Struct VertexBuffer

pub struct VertexBuffer<K: BufferLayout> {
    pub unprocessed: Vec<Vec<OrderedIndex>>,
    pub buffers: Vec<Vec<ClippedIndexDetails>>,
    pub vertex_buffer: Buffer<K>,
    pub index_buffer: Buffer<K>,
    pub layer_size: usize,
    /* private fields */
}

VertexBuffer holds all the Details to render with Verticies and indicies. This stores and handles the orders of all rendered objects to try and reduce the amount of GPU uploads we make.

Fields

unprocessed: Vec<Vec<OrderedIndex>>

Unprocessed Buffer Data.

buffers: Vec<Vec<ClippedIndexDetails>>

Buffers ready to Render

vertex_buffer: Buffer<K>

The main Vertex Buffer within GPU memory.

index_buffer: Buffer<K>

The main Index Buffer within GPU memory.

layer_size: usize

Size each Buffer Layer gets allocated to for Future buffers.

Implementations

impl<K: BufferLayout> VertexBuffer<K>

pub fn create_buffer( gpu_device: &GpuDevice, buffers: &BufferData, layer_size: usize, ) -> Self

Used to create a VertexBuffer. Only use this for creating a reusable buffer.

Arguments

• buffers: The (Vertex:Vec, Indices:Vec) to Create the Buffer with.
• layer_size: The capacity allocated for any future elements per new Buffer Layer.

pub fn add_buffer_store( &mut self, renderer: &GpuRenderer, index: OrderedIndex, buffer_layer: usize, )

Adds the Buffer to the unprocessed list so it can be processed in VertexBuffer::finalize This must be called in order to Render the Object.

Arguments

• index: The Order Index of the Object we want to render.
• buffer_layer: The Buffer Layer we want to add this Object too.

pub fn finalize(&mut self, renderer: &mut GpuRenderer)

Processes all unprocessed listed buffers and uploads any changes to the gpu This must be called after VertexBuffer::add_buffer_store in order to Render the Objects.

pub fn index_count(&self) -> usize

Returns the index count.

pub fn index_max(&self) -> usize

Returns the index maximum size.

pub fn indices(&self, bounds: Option<Range<u64>>) -> BufferSlice<'_>

Returns wgpu::BufferSlice of indices. bounds is used to set a specific Range if needed. If bounds is None then range is 0..index_count.

pub fn new(device: &GpuDevice, layer_size: usize) -> Self

Creates an VertexBuffer with a default buffer size. Buffer size is based on the initial crate::BufferLayout::default_buffer length.

Arguments

• layer_size: The capacity allocated for any future elements per new Buffer Layer.

pub fn set_index_count(&mut self, count: usize)

Set the Index based on how many Vertex’s Exist

pub fn vertex_count(&self) -> usize

Returns the Vertex elements count.

pub fn is_empty(&self) -> bool

Returns if the vertex buffer is empty

pub fn is_clipped(&self) -> bool

Returns if the buffer is clipped or not to deturmine if you should use buffers or clipped_buffers.

pub fn set_as_clipped(&mut self)

Sets the Buffer into Clipping mode. This will Produce a clipped_buffers instead of the buffers which will still be layered but a Vector of individual objects will Exist rather than a grouped object per layer. Will make it less Efficient but allows Bounds Clipping.

pub fn vertex_max(&self) -> usize

Returns vertex_buffer’s max size in bytes.

pub fn vertex_stride(&self) -> usize

Returns vertex_buffer’s vertex_stride.

pub fn vertices(&self, bounds: Option<Range<u64>>) -> BufferSlice<'_>

Returns wgpu::BufferSlice of vertices. bounds is used to set a specific Range if needed. If bounds is None then range is 0..vertex_count.

pub fn with_capacity( gpu_device: &GpuDevice, capacity: usize, layer_size: usize, ) -> Self

Creates an VertexBuffer with a buffer capacity. Buffer size is based on the initial crate::BufferLayout::default_buffer length.

Arguments

• capacity: The capacity of the Buffers instances for future allocation * 2.
• layer_size: The capacity allocated for any future elements per new Buffer Layer.

Trait Implementations

impl<'a, K: BufferLayout> AsBufferPass<'a> for VertexBuffer<K>

fn as_buffer_pass(&'a self) -> BufferPass<'a>

Creates a BufferPass from the Holding Object.