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-page level and uploads only the pages that changed if the number of such pages is small. It uses a compute shader to scatter the changed pages.

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, page_size_log2: u32, label: Arc<str>, ) -> Self

Creates a new AtomicSparseBufferVec with the given set of buffer usages, page size, 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.

The page_size_log2 parameter is the base-2 logarithm of the page size. That is, the page size is 1 << page_size_log2.

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.

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

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

Truncates the buffer to the given length.

If the buffer is already that length or shorter, 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.