Struct AtomicSparseBufferVec 

pub struct AtomicSparseBufferVec<T>
where
    T: AtomicPod,
{ /* private fields */ }

A GPU buffer that can grow, can be updated atomically from multiple threads on the CPU, and is sparsely updated on the GPU if only a small number of elements have changed.

This type is similar to crate::render_resource::buffer_vec::AtomicRawBufferVec, but instead of reuploading the entire buffer to the GPU when it’s changed, it tracks changes on a per-element level and uploads only the elements that changed if the number of such elements is small. It uses a compute shader to scatter those changed elements.

As the stored data is AtomicPod, multiple threads may update the buffer simultaneously. Note that, like crate::render_resource::buffer_vec::AtomicRawBufferVec, only existing elements may be updated from multiple threads; new data still requires exclusive access.

T must have a size that’s a multiple of 4.

Implementations

impl<T> AtomicSparseBufferVec<T>

where T: AtomicPod,

pub fn new( buffer_usages: BufferUsages, label: Arc<str>, ) -> AtomicSparseBufferVec<T>

Creates a new AtomicSparseBufferVec with the given set of buffer usages and label.

buffer_usages specifies the set of allowed wgpu buffer usages for the buffer that AtomicSparseBufferVec manages. BufferUsages::COPY_DST is automatically added to this set.

pub fn len(&self) -> u32

Returns the number of elements in the CPU side copy of the buffer.

pub fn is_empty(&self) -> bool

Returns true if there are no elements in the CPU side copy of the buffer.

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

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

pub fn clear(&mut self)

Removes all elements from the buffer.

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

Copies a value out of the buffer.

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

Sets the value at the given index.

If the index isn’t in range of the buffer, this method panics.

Internally, the value is converted to its blob representation.

Note that this method is thread-safe and doesn’t require &mut self. It’s your responsibility, however, to ensure synchronization; though this method is memory-safe, it’s possible for other threads to observe partially-overwritten values if Self::get or similar methods are called while the write operation is occurring.

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

Adds a new value and returns its index.

pub fn reserve(&mut self, new_capacity: usize, render_device: &RenderDevice)

Ensures that the backing buffer for this buffer vector is present and appropriately sized on the GPU.

pub fn grow(&mut self, new_len: u32)

Grows the buffer by adding default values so that it’s at least the given size.

This method sets all the newly-added values to dirty.

If the buffer is already large enough, this method does nothing.

pub fn write_buffers( &mut self, render_device: &RenderDevice, render_queue: &RenderQueue, )

Writes the data to the GPU, either via a sparse upload or a bulk data upload.

pub fn prepare_to_populate_buffers( &mut self, render_device: &RenderDevice, pipeline_cache: &PipelineCache, sparse_buffer_update_jobs: &mut SparseBufferUpdateJobs, sparse_buffer_update_bind_groups: &mut SparseBufferUpdateBindGroups, sparse_buffer_update_pipelines: &SparseBufferUpdatePipelines, )

If a sparse update has been scheduled, prepares all GPU resources necessary to perform a sparse buffer update, other than updating the metadata uniform.

impl<T> AtomicSparseBufferVec<T>

where T: AtomicPod + PartialEq,

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

Sets the value at the given index, growing the buffer if the index isn’t in range.

If the buffer already holds value there, this does nothing, leaving the element’s dirty bit clear so that a sparse update skips it.

Requires &mut self because growing reallocates.

Use Self::set_if_changed when the index is known to be in range and only a shared reference is available.

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

Sets the value at an index that’s already in range, without growing the buffer.

If the buffer already holds value there, this does nothing, leaving the element’s dirty bit clear so that a sparse update skips it.

Like Self::set, this is thread-safe, doesn’t require &mut self, and panics if the index isn’t in range.