Struct BufferVec 

pub struct BufferVec<T>
where
    T: ShaderType + WriteInto,
{ /* private fields */ }

Available on crate feature bevy_render only.

Like RawBufferVec, but doesn’t require that the data type T be NoUninit.

This is a high-performance data structure that you should use whenever possible if your data is more complex than is suitable for RawBufferVec. The ShaderType trait from the encase library is used to ensure that the data is correctly aligned for use by the GPU.

For performance reasons, unlike RawBufferVec, this type doesn’t allow CPU access to the data after it’s been added via BufferVec::push. If you need CPU access to the data, consider another type, such as StorageBuffer.

Other options for storing GPU-accessible data are:

• DynamicStorageBuffer
• DynamicUniformBuffer
• GpuArrayBuffer
• RawBufferVec
• StorageBuffer
• Texture
• UniformBuffer

Implementations

impl<T> BufferVec<T>

where T: ShaderType + WriteInto,

pub const fn new(buffer_usage: BufferUsages) -> BufferVec<T>

Creates a new BufferVec with the given BufferUsages.

pub fn buffer(&self) -> Option<&Buffer>

Returns a handle to the buffer, if the data has been uploaded.

pub fn binding(&self) -> Option<BindingResource<'_>>

Returns the binding for the buffer if the data has been uploaded.

pub fn capacity(&self) -> usize

Returns the amount of space that the GPU will use before reallocating.

pub fn len(&self) -> usize

Returns the number of items that have been pushed to this buffer.

pub fn is_empty(&self) -> bool

Returns true if the buffer is empty.

pub fn push(&mut self, value: T) -> usize

Adds a new value and returns its index.

pub fn set_label(&mut self, label: Option<&str>)

Changes the debugging label of the buffer.

The next time the buffer is updated (via Self::reserve), Bevy will inform the driver of the new label.

pub fn get_label(&self) -> Option<&str>

Returns the label

pub fn reserve_internal(&mut self, count: usize)

Preallocates space for count elements in the internal CPU-side buffer.

Unlike Self::reserve, this doesn’t have any effect on the GPU buffer.

pub fn reserve(&mut self, capacity: usize, device: &RenderDevice)

Creates a Buffer on the RenderDevice with size at least size_of::<T>() * capacity, unless such a buffer already exists.

If a Buffer exists, but is too small, references to it will be discarded, and a new Buffer will be created. Any previously created Buffers that are no longer referenced will be deleted by the RenderDevice once it is done using them (typically 1-2 frames).

In addition to any BufferUsages provided when the BufferVec was created, the buffer on the RenderDevice is marked as BufferUsages::COPY_DST.

pub fn write_buffer(&mut self, device: &RenderDevice, queue: &RenderQueue)

Queues writing of data from system RAM to VRAM using the RenderDevice and the provided RenderQueue.

Before queuing the write, a reserve operation is executed.

pub fn write_buffer_range( &mut self, render_queue: &RenderQueue, range: Range<usize>, ) -> Result<(), WriteBufferRangeError>

Queues writing of data from system RAM to VRAM using the RenderDevice and the provided RenderQueue.

If the buffer is not initialized on the GPU or the range is bigger than the capacity it will return an error. You’ll need to either reserve a new buffer which will lose data on the GPU or create a new buffer and copy the old data to it.

This will only write the data contained in the given range. It is useful if you only want to update a part of the buffer.

pub fn truncate(&mut self, len: usize)

Reduces the length of the buffer.

pub fn clear(&mut self)

Removes all elements from the buffer.