Struct bevy::render::render_resource::encase::StorageBuffer

pub struct StorageBuffer<B> { /* private fields */ }

Storage buffer wrapper facilitating RW operations

Implementations

impl<B> StorageBuffer<B>

pub const fn new(buffer: B) -> StorageBuffer<B>

Examples found in repository

examples/shader/gpu_readback.rs (line 106)

    fn from_world(world: &mut World) -> Self {
        let render_device = world.resource::<RenderDevice>();
        let mut init_data = encase::StorageBuffer::new(Vec::new());
        // Init the buffer with 0
        let data = vec![0; BUFFER_LEN];
        init_data.write(&data).expect("Failed to write buffer");
        // The buffer that will be accessed by the gpu
        let gpu_buffer = render_device.create_buffer_with_data(&BufferInitDescriptor {
            label: Some("gpu_buffer"),
            contents: init_data.as_ref(),
            usage: BufferUsages::STORAGE | BufferUsages::COPY_SRC,
        });
        // For portability reasons, WebGPU draws a distinction between memory that is
        // accessible by the CPU and memory that is accessible by the GPU. Only
        // buffers accessible by the CPU can be mapped and accessed by the CPU and
        // only buffers visible to the GPU can be used in shaders. In order to get
        // data from the GPU, we need to use `CommandEncoder::copy_buffer_to_buffer` to
        // copy the buffer modified by the GPU into a mappable, CPU-accessible buffer
        let cpu_buffer = render_device.create_buffer(&BufferDescriptor {
            label: Some("readback_buffer"),
            size: (BUFFER_LEN * std::mem::size_of::<u32>()) as u64,
            usage: BufferUsages::MAP_READ | BufferUsages::COPY_DST,
            mapped_at_creation: false,
        });

        Self {
            gpu_buffer,
            cpu_buffer,
        }
    }

pub fn into_inner(self) -> B

impl<B> StorageBuffer<B>

where B: BufferMut,

pub fn write<T>(&mut self, value: &T) -> Result<(), Error>

where T: ShaderType + WriteInto + ?Sized,

Examples found in repository

examples/shader/gpu_readback.rs (line 109)

    fn from_world(world: &mut World) -> Self {
        let render_device = world.resource::<RenderDevice>();
        let mut init_data = encase::StorageBuffer::new(Vec::new());
        // Init the buffer with 0
        let data = vec![0; BUFFER_LEN];
        init_data.write(&data).expect("Failed to write buffer");
        // The buffer that will be accessed by the gpu
        let gpu_buffer = render_device.create_buffer_with_data(&BufferInitDescriptor {
            label: Some("gpu_buffer"),
            contents: init_data.as_ref(),
            usage: BufferUsages::STORAGE | BufferUsages::COPY_SRC,
        });
        // For portability reasons, WebGPU draws a distinction between memory that is
        // accessible by the CPU and memory that is accessible by the GPU. Only
        // buffers accessible by the CPU can be mapped and accessed by the CPU and
        // only buffers visible to the GPU can be used in shaders. In order to get
        // data from the GPU, we need to use `CommandEncoder::copy_buffer_to_buffer` to
        // copy the buffer modified by the GPU into a mappable, CPU-accessible buffer
        let cpu_buffer = render_device.create_buffer(&BufferDescriptor {
            label: Some("readback_buffer"),
            size: (BUFFER_LEN * std::mem::size_of::<u32>()) as u64,
            usage: BufferUsages::MAP_READ | BufferUsages::COPY_DST,
            mapped_at_creation: false,
        });

        Self {
            gpu_buffer,
            cpu_buffer,
        }
    }

impl<B> StorageBuffer<B>

where B: BufferRef,

pub fn read<T>(&self, value: &mut T) -> Result<(), Error>

where T: ShaderType + ReadFrom + ?Sized,

pub fn create<T>(&self) -> Result<T, Error>

where T: ShaderType + CreateFrom,

Trait Implementations

impl<B> AsMut<B> for StorageBuffer<B>

fn as_mut(&mut self) -> &mut B

Converts this type into a mutable reference of the (usually inferred) input type.

impl<B> AsRef<B> for StorageBuffer<B>

fn as_ref(&self) -> &B

Converts this type into a shared reference of the (usually inferred) input type.

impl<B> From<B> for StorageBuffer<B>

fn from(buffer: B) -> StorageBuffer<B>

Converts to this type from the input type.