Struct web_glitz_buffer_vec::BufferVec

pub struct BufferVec<Rc, T> { /* fields omitted */ }

A growable GPU buffer for data that may be used to store GPU accessiable data that may be used in WebGlitz tasks.

Elements must implement Copy.

Example

use web_glitz_buffer_vec::BufferVec;
use web_glitz::buffer::UsageHint;

#[derive(web_glitz::derive::Vertex, Clone, Copy)]
struct Vertex {
    #[vertex_attribute(location = 0, format = "Float2_f32")]
    position: [f32; 2],
}

let mut vertices = BufferVec::new(context, UsageHint::StaticDraw);

vertices.update([
    Vertex { position: [-0.5, -0.5] },
    Vertex { position: [0.5, -0.5] },
    Vertex { position: [0.0, 0.5] },
]);

let vertices_view = vertices.as_buffer_view();

assert_eq!(vertices_view.len(), 3);

let render_pass = render_target.create_render_pass(|framebuffer| {
    framebuffer.pipeline_task(&graphics_pipeline, |active_pipeline| {
        active_pipeline.task_builder()
            .bind_vertex_buffers(vertices_view)
            .bind_resources(resources)
            .draw(3, 1)
            .finish()
    })
});

Here context is a WebGlitz RenderingContext. For details on rendering with WebGlitz, see the web_glitz::rendering module documentation.

Implementations

impl<Rc, T> BufferVec<Rc, T> where
    Rc: RenderingContext,
    T: Copy + 'static, 

pub fn new(context: Rc, usage: UsageHint) -> Self

Creates a new buffer-backed vector with 0 capacity for the given RenderingContext.

See UsageHint for details on GPU buffer performance hints.

Example

use web_glitz_buffer_vec::BufferVec;
use web_glitz::buffer::UsageHint;

let mut vec = BufferVec::new(context, UsageHint::StaticDraw);

assert_eq!(vec.capacity(), 0);

Here context is a RenderingContext.

pub fn with_capacity(context: Rc, usage: UsageHint, capacity: usize) -> Self

Creates a new buffer-backed vector with the specified capacity for the given RenderingContext.

See UsageHint for details on GPU buffer performance hints.

Example

use web_glitz_buffer_vec::BufferVec;
use web_glitz::buffer::UsageHint;

let mut vec = BufferVec::with_capacity(context, UsageHint::StaticDraw, 10);

assert_eq!(vec.capacity(), 10);

Here context is a RenderingContext.

pub fn update<D>(&mut self, data: D) -> bool where
    D: Borrow<[T]> + Send + Sync + 'static, 

Replaces the data in the buffer with the given data, resizing the buffer if necessary.

Returns true if a new buffer was allocated, false otherwise.

Guarantees

Any task submitted from the same thread that called update after the update will see the new data. Any task that does not fence submitted from the same thread that called update before the update will see the old data. No other guarantees are given.

Example

use web_glitz_buffer_vec::BufferVec;
use web_glitz::buffer::UsageHint;

let mut vec = BufferVec::new(context, UsageHint::StaticDraw);

vec.update([1, 2, 3]);

Here context is a WebGlitz RenderingContext.

pub fn capacity(&self) -> usize

The number of elements this vector can hold without allocating a new buffer.

pub fn as_buffer_view(&self) -> BufferView<'_, [T]> where
    T: Copy + 'static, 

Returns a view on the data in the buffer.

Example

use web_glitz_buffer_vec::BufferVec;
use web_glitz::buffer::UsageHint;

let mut vec = BufferVec::new(context, UsageHint::StaticDraw);

vec.update([1, 2, 3]);

let view = vec.as_buffer_view();

assert_eq!(view.len(), 3);

Here context is a WebGlitz RenderingContext.