Struct solstice::mesh::VertexMesh

pub struct VertexMesh<V> { /* fields omitted */ }

The Mesh represents a set of vertices to be drawn by a shader program and how to draw them. A well-formed Vertex implementation will provide information to the mesh about it’s layout in order to properly sync the data to the GPU. A derive macro exists in Vertex that will derive this implementation for you.

use solstice::vertex::{VertexFormat, AttributeType};
#[repr(C)]
#[derive(Copy, Clone, bytemuck::Zeroable, bytemuck::Pod)]
struct TestVertex {
    position: [f32; 2],
    color: [f32; 4],
}

impl solstice::vertex::Vertex for TestVertex {
    fn build_bindings() -> &'static [VertexFormat] {
        &[VertexFormat {
            name: "position",
            offset: 0,
            atype: AttributeType::F32F32,
            normalize: false,
        }, VertexFormat {
            name: "color",
            offset: std::mem::size_of::<[f32; 2]>(),
            atype: AttributeType::F32F32F32F32,
            normalize: false
        }]
    }
}

let vertex_data = vec![
    TestVertex {
        position: [0.5, 0.],
        color: [1., 0., 0., 1.]
    },
    TestVertex {
        position: [0., 1.0],
        color: [0., 1., 0., 1.]
    },
    TestVertex {
        position: [1., 0.],
        color: [0., 0., 1., 1.]
    },
];

Vertex data is then copied into the mesh.

let mut mesh = solstice::mesh::Mesh::new(&mut ctx, 3);
mesh.set_vertices(&vertex_data, 0);

Once constructed, a Mesh is of an immutable size but the draw range can be modified to effectively change it’s size without changing the underlying memory’s size.

let mut mesh = solstice::mesh::Mesh::new(&mut ctx, 3000).unwrap();
mesh.set_draw_range(Some(0..3)); // draws only the first three vertices of the 3000 allocated

Implementations

impl<V> VertexMesh<V> where
    V: Vertex, 

pub fn new(ctx: &mut Context, size: usize) -> Result<Self, GraphicsError>

Construct a Mesh with a given number of vertices.

pub fn with_data(
    ctx: &mut Context,
    vertices: &[V]
) -> Result<Self, GraphicsError>

pub fn with_buffer(buffer: Buffer) -> Self

pub fn set_vertices(&self, ctx: &mut Context, vertices: &[V], offset: usize)

Write new data into a range of the Mesh’s vertex data.

pub fn set_draw_range(&mut self, draw_range: Option<Range<usize>>)

Sets the range of vertices to be drawn. Passing None will draw the entire mesh.

pub fn set_draw_mode(&mut self, draw_mode: DrawMode)

Sets how the vertex data should be tesselated.

pub fn draw_range(&self) -> Range<usize>

pub fn draw_mode(&self) -> DrawMode

pub fn len(&self) -> usize

Trait Implementations

impl<V: Clone> Clone for VertexMesh<V>

fn clone(&self) -> VertexMesh<V>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<V: Debug> Debug for VertexMesh<V>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<V: Vertex> Mesh for VertexMesh<V>

fn attachments(&self) -> Vec<AttachedAttributes<'_>>

fn draw(
    &self,
    ctx: &mut Context,
    draw_range: Range<usize>,
    draw_mode: DrawMode,
    instance_count: usize
)

impl<V: Vertex> Mesh for &VertexMesh<V>

fn attachments(&self) -> Vec<AttachedAttributes<'_>>

fn draw(
    &self,
    ctx: &mut Context,
    draw_range: Range<usize>,
    draw_mode: DrawMode,
    instance_count: usize
)

impl<V: Vertex> MeshAttacher for VertexMesh<V>

fn attach_with_step<'a, T: Mesh>(
    &'a self,
    other: &'a T,
    step: u32
) -> MultiMesh<'a>

fn attach<'a, T: Mesh>(&'a self, other: &'a T) -> MultiMesh<'a>

impl<V: PartialEq> PartialEq<VertexMesh<V>> for VertexMesh<V>

fn eq(&self, other: &VertexMesh<V>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &VertexMesh<V>) -> bool

This method tests for !=.

impl<V> StructuralPartialEq for VertexMesh<V>