Struct Vertex 

#[repr(C)]
pub struct Vertex {
    pub position: Vec3,
    pub normal: Vec3,
    pub uv: Vec2,
}

One corner of a mesh.

Fields

position: Vec3

Corner position, in mesh space, in meters.

normal: Vec3

The corner’s outward direction, used for lighting.

uv: Vec2

The texture coordinate, (0, 0) at the texture’s top left.

Implementations

impl Vertex

pub const fn new(position: Vec3, normal: Vec3, uv: Vec2) -> Self

A vertex at position, with normal and uv.

Examples found in repository

examples/stress-preview.rs (line 566)

fn push_face(vertices: &mut Vec<Vertex>, indices: &mut Vec<u32>, a: Vec3, b: Vec3, c: Vec3) {
    let normal = (b - a).cross(c - a).normalize();
    let uvs = [
        Vec2::new(0.0, 1.0),
        Vec2::new(0.5, 0.0),
        Vec2::new(1.0, 1.0),
    ];
    let base = vertices.len() as u32;
    for (point, uv) in [a, b, c].into_iter().zip(uvs) {
        vertices.push(Vertex::new(point, normal, uv));
    }
    indices.extend([base, base + 1, base + 2]);
}

examples/sound-lab.rs (line 178)

fn ring_outline() -> MeshData {
    const SEGMENTS: u32 = 48;
    const OUTER: f32 = 1.0;
    const INNER: f32 = 0.94;

    let mut vertices = Vec::with_capacity(SEGMENTS as usize * 4);
    let mut indices = Vec::with_capacity(SEGMENTS as usize * 6);
    for segment in 0..SEGMENTS {
        let a0 = segment as f32 / SEGMENTS as f32 * TAU;
        let a1 = (segment + 1) as f32 / SEGMENTS as f32 * TAU;
        let (u0, v0) = (a0.cos(), a0.sin());
        let (u1, v1) = (a1.cos(), a1.sin());
        let base = vertices.len() as u32;
        vertices.extend([
            Vertex::new(Vec3::new(INNER * u0, 0.0, -INNER * v0), Vec3::Y, Vec2::ZERO),
            Vertex::new(Vec3::new(OUTER * u0, 0.0, -OUTER * v0), Vec3::Y, Vec2::ZERO),
            Vertex::new(Vec3::new(OUTER * u1, 0.0, -OUTER * v1), Vec3::Y, Vec2::ZERO),
            Vertex::new(Vec3::new(INNER * u1, 0.0, -INNER * v1), Vec3::Y, Vec2::ZERO),
        ]);
        indices.extend([base, base + 1, base + 2, base, base + 2, base + 3]);
    }
    MeshData::new(vertices, indices)
}

fn facing_marker() -> MeshData {
    const TIP: Vec3 = Vec3::new(0.0, 0.0, -0.5);
    const BACK: [Vec3; 4] = [
        Vec3::new(-0.5, -0.5, 0.5),
        Vec3::new(0.5, -0.5, 0.5),
        Vec3::new(0.5, 0.5, 0.5),
        Vec3::new(-0.5, 0.5, 0.5),
    ];

    let mut vertices = Vec::with_capacity(BACK.len() * 3);
    for (corner, next) in BACK.iter().zip(BACK.iter().cycle().skip(1)) {
        let normal = (next - corner).cross(TIP - corner).normalize();
        vertices.extend([
            Vertex::new(*corner, normal, Vec2::new(0.0, 1.0)),
            Vertex::new(*next, normal, Vec2::new(1.0, 1.0)),
            Vertex::new(TIP, normal, Vec2::new(0.5, 0.0)),
        ]);
    }
    let indices = (0..vertices.len() as u32).collect();
    MeshData::new(vertices, indices)
}

examples/material-playground.rs (lines 367-371)

fn banner_mesh() -> MeshData {
    let mut vertices = Vec::with_capacity(((BANNER_COLUMNS + 1) * 4) as usize);
    for normal in [Vec3::Z, Vec3::NEG_Z] {
        for column in 0..=BANNER_COLUMNS {
            let u = column as f32 / BANNER_COLUMNS as f32;
            let x = u * BANNER_WIDTH;
            for v in [0.0, 1.0] {
                vertices.push(Vertex::new(
                    Vec3::new(x, -v * BANNER_HEIGHT, 0.0),
                    normal,
                    Vec2::new(u, v),
                ));
            }
        }
    }

    let side = BANNER_COLUMNS + 1;
    let mut indices = Vec::with_capacity((BANNER_COLUMNS * 12) as usize);
    for column in 0..BANNER_COLUMNS {
        let top_left = column * 2;
        let bottom_left = top_left + 1;
        let top_right = top_left + 2;
        let bottom_right = top_left + 3;
        indices.extend([
            bottom_left,
            bottom_right,
            top_right,
            bottom_left,
            top_right,
            top_left,
        ]);

        let back = side * 2;
        indices.extend([
            back + top_right,
            back + bottom_right,
            back + bottom_left,
            back + top_left,
            back + top_right,
            back + bottom_left,
        ]);
    }

    MeshData::new(vertices, indices)
}

examples/isometric-board.rs (line 754)

fn build_rock(seed: u32) -> MeshData {
    let corners: [Vec3; 8] = core::array::from_fn(|index| {
        let sign = Vec3::new(
            if index & 1 == 0 { -0.5 } else { 0.5 },
            if index & 2 == 0 { -0.5 } else { 0.5 },
            if index & 4 == 0 { -0.5 } else { 0.5 },
        );
        sign + corner_offset(seed, index as u32)
    });
    let corner_at = |sign: Vec3| corners[corner_index(sign)];

    let mut vertices = Vec::with_capacity(ROCK_FACES.len() * 4);
    let mut indices = Vec::with_capacity(ROCK_FACES.len() * 6);
    for (face, &(normal, right, up)) in ROCK_FACES.iter().enumerate() {
        let quad = [
            corner_at(normal - right - up),
            corner_at(normal + right - up),
            corner_at(normal + right + up),
            corner_at(normal - right + up),
        ];
        let normal = (quad[1] - quad[0]).cross(quad[3] - quad[0]).normalize();
        let uvs = [
            Vec2::new(0.0, 1.0),
            Vec2::new(1.0, 1.0),
            Vec2::new(1.0, 0.0),
            Vec2::new(0.0, 0.0),
        ];
        vertices.extend(
            quad.into_iter()
                .zip(uvs)
                .map(|(corner, uv)| Vertex::new(corner, normal, uv)),
        );
        let base = face as u32 * 4;
        indices.extend(ROCK_TRIANGLES.map(|index| base + index));
    }
    MeshData::new(vertices, indices)
}

Trait Implementations

impl Clone for Vertex

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Vertex

impl Debug for Vertex

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

Formats the value using the given formatter.

impl PartialEq for Vertex

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Pod for Vertex

impl StructuralPartialEq for Vertex

impl Zeroable for Vertex

fn zeroed() -> Self

Calls zeroed.