Struct RawBufferVec 

pub struct RawBufferVec<T: NoUninit> { /* private fields */ }

A structure for storing raw bytes that have already been properly formatted for use by the GPU.

“Properly formatted” means that item data already meets the alignment and padding requirements for how it will be used on the GPU. The item type must implement NoUninit for its data representation to be directly copyable.

Index, vertex, and instance-rate vertex buffers have no alignment nor padding requirements and so this helper type is a good choice for them.

The contained data is stored in system RAM. Calling reserve allocates VRAM from the RenderDevice. write_buffer queues copying of the data from system RAM to VRAM.

Other options for storing GPU-accessible data are:

• BufferVec
• DynamicStorageBuffer
• DynamicUniformBuffer
• GpuArrayBuffer
• StorageBuffer
• Texture
• UniformBuffer

Implementations

impl<T: NoUninit> RawBufferVec<T>

pub const fn new(buffer_usage: BufferUsages) -> Self

Creates a new RawBufferVec 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 append(&mut self, other: &mut RawBufferVec<T>)

pub fn get(&self, index: u32) -> Option<&T>

Returns the value at the given index.

pub fn set(&mut self, index: u32, value: T)

Sets the value at the given index.

The index must be less than RawBufferVec::len.

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

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

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

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

Changes the debugging label of the buffer.

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

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

Returns the label

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

Creates a Buffer on the RenderDevice with size at least size_of::<T>() * capacity, unless a 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 RawBufferVec 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.

pub fn pop(&mut self) -> Option<T>

Removes and returns the last element in the buffer.

pub fn values(&self) -> &Vec<T>

pub fn values_mut(&mut self) -> &mut Vec<T>

impl<T> RawBufferVec<T>

where T: NoUninit + Default,

pub fn grow_set(&mut self, index: u32, value: T)

Trait Implementations

impl<T: NoUninit> Extend<T> for RawBufferVec<T>

fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.