Struct solstice::mesh::VertexMesh

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

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: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<V> StructuralPartialEq for VertexMesh<V>