Struct RingBuffer 

pub struct RingBuffer {
    pub buffer: Buffer,
    /* private fields */
}

A streaming GPU vertex/index ring buffer.

Holds a single VERTEX | INDEX | COPY_DST GPU buffer; sub-ranges are handed out sequentially and the cursor wraps back to zero at the end of each frame (or when the remaining space is insufficient for an allocation).

Fields

buffer: Buffer

The underlying GPU buffer.

Implementations

impl RingBuffer

pub fn new(device: &Device, initial_bytes: usize, alignment: u64) -> Self

Create a new ring buffer with an initial capacity of max(initial_bytes, MIN_CAPACITY) bytes.

alignment is the byte alignment applied to every allocation. For vertex buffers 4 is typical; for uniform buffers use device.limits().min_uniform_buffer_offset_alignment.

pub fn reset(&mut self)

Reset the write cursor to zero.

Must be called once per frame before any allocations for that frame. Does NOT wait for the GPU — the caller must ensure the previous frame’s GPU work has completed before calling reset().

pub fn upload( &mut self, device: &Device, queue: &Queue, data: &[u8], ) -> Result<RingAllocation, UiError>

Allocate size bytes from the ring buffer and upload data into the allocation via queue.write_buffer.

Returns a RingAllocation describing the offset and size within self.buffer.

Wrapping

If the remaining capacity after the cursor is insufficient, the cursor wraps to zero (one wrap per frame is normal; multiple wraps in a single frame indicate the buffer is undersized — consider calling grow).

Growing

If even a fresh buffer at offset 0 cannot fit the requested size the buffer is automatically grown to max(capacity * 2, align_up(size)) and grow_count is incremented.

Errors

Returns UiError::Render only if the allocation remains impossible after an attempted grow (e.g. device OOM). In practice this should not occur for reasonable data sizes.

pub fn grow(&mut self, device: &Device, min_size: usize) -> Result<(), UiError>

Explicitly grow the ring buffer to at least min_size bytes.

The new capacity is max(capacity * 2, next_power_of_two(min_size)). The cursor is reset to zero after a grow.

Errors

Returns UiError::Render on failure (typically OOM).

pub fn stats(&self) -> RingBufferStats

Return a snapshot of the ring buffer’s lifetime statistics.

pub fn capacity(&self) -> usize

Current byte capacity of the underlying GPU buffer.

pub fn cursor(&self) -> usize

Current write cursor offset in bytes.