Struct Array 

pub struct Array {
    storage: ArrayStorage,
    element_size: u64,
    max_dimension: Option<u32>,
}

A growable flat array of fixed-size elements, held in whichever resource the device can read.

This is the device-independent front end to the module: a caller sizes an array by its element count, uploads the same packed bytes on either path, and binds it through Self::handle without knowing which resource it landed in. Pass Some(max_texture_dimension_2d) to put it in a texture and None to put it in a storage buffer.

Fields

storage: ArrayStorage

The resource the elements live in.

element_size: u64

Bytes per element.

max_dimension: Option<u32>

The texture limit on the texel path, None on the buffer path.

Implementations

impl Array

pub fn new( device: &Device, label: Option<&str>, element_size: u64, capacity: u64, max_dimension: Option<u32>, ) -> Self

Allocate an array with room for capacity elements of element_size bytes.

max_dimension is Some of the device’s [wgpu::Limits::max_texture_dimension_2d] to hold the elements in a texture, or None to hold them in a storage buffer.

Panics

Under the conditions TexelArray::new panics, on the texel path.

pub fn element_size(&self) -> u64

Bytes per element.

pub fn capacity(&self) -> u64

How many elements fit without growing.

pub fn is_texel(&self) -> bool

Whether the elements are held in a texture rather than a buffer.

pub fn handle(&self) -> ArrayHandle

The bindable handle to the current resource.

Cloned rather than borrowed so a caller can move it into the resource graph, which is what makes a replaced array mark the bind groups built from it dirty.

pub fn grow_to( &mut self, device: &Device, label: Option<&str>, capacity: u64, ) -> bool

Grow to hold at least capacity elements, returning whether the resource was replaced.

A replacement is what a caller has to publish: every bind group built from the old handle is stale and has to be rebuilt. A no-op when the array already has the room.

Panics

Under the conditions TexelArray::new panics, on the texel path.

pub fn upload( &mut self, device: &Device, encoder: &mut CommandEncoder, elements: &[u8], )

Upload elements — whole elements, laid out as the storage buffer would have held them — recording the copy into encoder.

Panics

If elements is not a whole number of elements, or holds more than Self::capacity of them.

pub fn write(&mut self, queue: &Queue, elements: &[u8])

Upload elements immediately, for an array written once rather than every frame.

This mirrors [wgpu::Queue::write_buffer] and [wgpu::Queue::write_texture]: the bytes reach the resource through a temporary buffer wgpu allocates and submits for the caller, so there is no encoder to batch into. Prefer Self::upload for data that changes every frame, where a reused staging buffer costs nothing per frame.

Panics

If elements is not a whole number of elements, or holds more than Self::capacity of them.