Struct VertexStreamPool 

pub struct VertexStreamPool {
    label: &'static str,
    usage: BufferUsages,
    allocator: Allocator,
    streams: HashMap<VertexBufferLayoutDesc, Stream>,
}

One large buffer per vertex layout, sub-allocated into element ranges.

See the module documentation for why every layout shares one allocator, and for what a pool is for.

Fields

label: &'static str

The label every buffer is created with, reused when one is replaced.

usage: BufferUsages

The usages every buffer is created with.

allocator: Allocator

Where the free element indices are, shared by every layout.

streams: HashMap<VertexBufferLayoutDesc, Stream>

The buffer of each layout the pool has been asked for.

Implementations

impl VertexStreamPool

pub fn new( _device: &Device, label: &'static str, usage: BufferUsages, initial_element_capacity: u32, ) -> Self

Creates a pool whose buffers hold initial_element_capacity elements each.

No buffer exists until a layout is asked for; the capacity is only what the allocator starts with, and it grows on demand.

pub fn element_capacity(&self) -> u32

How many elements the pool can hold.

pub fn byte_offset(layout: &VertexBufferLayoutDesc, index: u32) -> u64

The byte offset of element index in a layout’s buffer.

This is index times the layout’s stride, which is always a multiple of [wgpu::VERTEX_ALIGNMENT], so the result satisfies the alignment [wgpu::Queue::write_buffer] asks for.

pub fn buffer(&self, layout: &VertexBufferLayoutDesc) -> Option<&Buffer>

The buffer of layout, if the pool has been asked for it.

This changes when the pool grows, so read it again instead of holding one.

pub fn allocate( &mut self, device: &Device, queue: &Queue, layouts: &[VertexBufferLayoutDesc], count: u32, ) -> Option<VertexAllocation>

Makes sure every layout in layouts has a buffer, then reserves count elements in all of them at once.

A layout with no attributes and no stride declares nothing to read, so it is skipped: it gets no buffer and no part in the allocation.

Returns None only if the pool cannot grow any further (its element count would overflow a u32, or it has run out of node slots for its allocations).

Growing allocates new buffers and copies the old contents into them; existing allocations keep their element indices, but the buffers they name change, so a caller holding one must re-read Self::buffer.

pub fn release(&mut self, allocation: Allocation)

Hands an allocation back to the pool.

Panics

Panics if the allocation was already released.

fn reserve( &mut self, device: &Device, queue: &Queue, layouts: &[VertexBufferLayoutDesc], end: u32, )

Grows every layout’s buffer until it covers end elements.

A layout that already covers them is left alone, so a pool shared by meshes of wildly different strides only pays for each layout as far as that layout goes.

fn grow(&mut self, count: u32) -> Option<()>

Grows the allocator until count elements fit.

Returns None if it cannot grow, leaving the pool unchanged.