Struct bevy::render::render_resource::BufferVec

pub struct BufferVec<T>
where
    T: Pod,
{ /* 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 Pod 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:

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

Implementations

impl<T> BufferVec<T>

where T: Pod,

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

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

pub fn capacity(&self) -> usize

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

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

pub fn append(&mut self, other: &mut BufferVec<T>)

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

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

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

Creates a Buffer on the RenderDevice with size at least std::mem::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 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 truncate(&mut self, len: usize)

pub fn clear(&mut self)

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

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

Trait Implementations

impl<T> Extend<T> for BufferVec<T>

where T: Pod,

fn extend<I>(&mut self, iter: I)

where I: IntoIterator<Item = T>,

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.