Struct MeshData 

pub struct MeshData<P: Part = NoParts, C: Clip = NoClips> { /* private fields */ }

A mesh’s vertices and indices, in the slots the parts P select, posed by the clips C name.

The indices define counter-clockwise triangles; the draw’s transform places and scales the mesh.

Implementations

impl MeshData

pub fn new(vertices: Vec<Vertex>, indices: Vec<u32>) -> Self

A mesh of one slot, drawn with Material::default.

Every index must point to a vertex; one past them is an error the catalog run reports. Every triangle’s three indices run counter-clockwise seen from outside the mesh: a triangle seen from behind is not drawn.

Examples found in repository

examples/sound-lab.rs (line 185)

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/stress-preview.rs (line 551)

fn build_rock(seed: u32) -> MeshData {
    let height = ROCK_HEIGHT * (1.0 + hash_signed(seed, ROCK_SIDES) * ROCK_HEIGHT_DISPLACEMENT);
    let apex = Vec3::Y * height;
    let base: Vec<Vec3> = (0..ROCK_SIDES)
        .map(|corner| {
            let angle = core::f32::consts::TAU * corner as f32 / ROCK_SIDES as f32;
            let radius =
                ROCK_BASE_RADIUS * (1.0 + hash_signed(seed, corner) * ROCK_RADIAL_DISPLACEMENT);
            Vec3::new(angle.cos() * radius, 0.0, angle.sin() * radius)
        })
        .collect();

    let mut vertices = Vec::with_capacity(base.len() * 6);
    let mut indices = Vec::with_capacity(base.len() * 6);
    for corner in 0..base.len() {
        let next = (corner + 1) % base.len();
        push_face(&mut vertices, &mut indices, base[corner], apex, base[next]);
        push_face(
            &mut vertices,
            &mut indices,
            base[corner],
            base[next],
            Vec3::ZERO,
        );
    }

    MeshData::new(vertices, indices).with_material(Material::lit(ROCK_COLOR))
}

examples/material-playground.rs (line 403)

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 759)

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)
}

impl<P: Part, C: Clip> MeshData<P, C>

pub fn with_material(self, material: Material) -> Self

Sets the material of every slot.

Examples found in repository

examples/material-playground.rs (line 284)

fn sphere_with_material(assets: &Assets, material: Material) -> MeshData {
    Sphere {
        subdivisions: SPHERE_SUBDIVISIONS,
    }
    .build(assets)
    .with_material(material)
}

fn cube_with_material(assets: &Assets, material: Material) -> MeshData {
    Cube.build(assets).with_material(material)
}

examples/sprite-adventure.rs (line 586)

    fn build(&self, assets: &Assets) -> MeshData {
        Plane
            .build(assets)
            .with_texture(assets.texture(POND_SHEET).pixelated())
            .with_material(Material::lit(Color::WHITE).cutout())
    }
}

/// A crate prop, its texture drawn over a cube.
#[derive(Catalog, Clone, PartialEq, Eq, Hash)]
struct Crate;

impl Mesh for Crate {
    fn build(&self, assets: &Assets) -> MeshData {
        Cube.build(assets)
            .with_texture(assets.texture(CRATE_TEXTURE).pixelated())
    }
}

/// The well's rim.
#[derive(Catalog, Clone, PartialEq, Eq, Hash)]
struct Well;

impl Mesh for Well {
    fn build(&self, assets: &Assets) -> MeshData {
        Cube.build(assets)
            .with_texture(assets.texture(WELL_SHEET).pixelated())
    }
}

/// The well's mouth, laid flat over the rim's top face.
#[derive(Catalog, Clone, PartialEq, Eq, Hash)]
struct WellMouth;

impl Mesh for WellMouth {
    fn build(&self, assets: &Assets) -> MeshData {
        Plane
            .build(assets)
            .with_texture(assets.texture(WELL_SHEET).pixelated())
    }
}

/// A stone box: the mouth's pillars and lintel.
#[derive(Catalog, Clone, PartialEq, Eq, Hash)]
struct Stone;

impl Mesh for Stone {
    fn build(&self, assets: &Assets) -> MeshData {
        Cube.build(assets)
            .with_texture(assets.texture(STONE_SHEET).pixelated())
    }
}

/// A bush sprite, cutout with its own relief.
#[derive(Catalog, Clone, PartialEq, Eq, Hash)]
struct Bush;

impl Mesh for Bush {
    fn build(&self, assets: &Assets) -> MeshData {
        Quad.build(assets)
            .with_texture(assets.texture(BUSH_SPRITE).pixelated())
            .with_relief(assets.relief(BUSH_RELIEF))
            .with_material(Material::lit(Color::WHITE).cutout())
    }
}

/// A rock sprite, cutout with its own relief.
#[derive(Catalog, Clone, PartialEq, Eq, Hash)]
struct Rock;

impl Mesh for Rock {
    fn build(&self, assets: &Assets) -> MeshData {
        Quad.build(assets)
            .with_texture(assets.texture(ROCK_SPRITE).pixelated())
            .with_relief(assets.relief(ROCK_RELIEF))
            .with_material(Material::lit(Color::WHITE).cutout())
    }
}

/// A torch's post sprite, cutout with its own relief.
#[derive(Catalog, Clone, PartialEq, Eq, Hash)]
struct Torch;

impl Mesh for Torch {
    fn build(&self, assets: &Assets) -> MeshData {
        Quad.build(assets)
            .with_texture(assets.texture(TORCH_SPRITE).pixelated())
            .with_relief(assets.relief(TORCH_RELIEF))
            .with_material(Material::lit(Color::WHITE).cutout())
    }
}

/// A torch's flame sprite, added over the dark rather than lit.
#[derive(Catalog, Clone, PartialEq, Eq, Hash)]
struct Flame;

impl Mesh for Flame {
    fn build(&self, assets: &Assets) -> MeshData {
        Quad.build(assets)
            .with_texture(assets.texture(FLAME_SHEET).pixelated())
            .with_material(Material::color(FLAME_TINT).additive())
    }
}

/// The player's sprite, cutout with its own relief, its sheet shared
/// with `examples/isometric-board.rs`.
#[derive(Catalog, Clone, PartialEq, Eq, Hash)]
struct Walker;

impl Mesh for Walker {
    fn build(&self, assets: &Assets) -> MeshData {
        Quad.build(assets)
            .with_texture(assets.texture(WALKER_SHEET).pixelated())
            .with_relief(assets.relief(WALKER_RELIEF))
            .with_material(Material::lit(Color::WHITE).cutout())
    }

examples/stress-preview.rs (line 551)

fn build_rock(seed: u32) -> MeshData {
    let height = ROCK_HEIGHT * (1.0 + hash_signed(seed, ROCK_SIDES) * ROCK_HEIGHT_DISPLACEMENT);
    let apex = Vec3::Y * height;
    let base: Vec<Vec3> = (0..ROCK_SIDES)
        .map(|corner| {
            let angle = core::f32::consts::TAU * corner as f32 / ROCK_SIDES as f32;
            let radius =
                ROCK_BASE_RADIUS * (1.0 + hash_signed(seed, corner) * ROCK_RADIAL_DISPLACEMENT);
            Vec3::new(angle.cos() * radius, 0.0, angle.sin() * radius)
        })
        .collect();

    let mut vertices = Vec::with_capacity(base.len() * 6);
    let mut indices = Vec::with_capacity(base.len() * 6);
    for corner in 0..base.len() {
        let next = (corner + 1) % base.len();
        push_face(&mut vertices, &mut indices, base[corner], apex, base[next]);
        push_face(
            &mut vertices,
            &mut indices,
            base[corner],
            base[next],
            Vec3::ZERO,
        );
    }

    MeshData::new(vertices, indices).with_material(Material::lit(ROCK_COLOR))
}

pub fn with_texture(self, texture: TextureData) -> Self

Samples every slot from texture, in place of a white default.

Examples found in repository

examples/isometric-board.rs (line 198)

    fn build(&self, assets: &Assets) -> MeshData {
        Quad.build(assets)
            .with_texture(assets.texture(SPRITE_TEXTURE).pixelated())
    }

examples/sprite-adventure.rs (line 572)

    fn build(&self, assets: &Assets) -> MeshData {
        Plane
            .build(assets)
            .with_texture(assets.texture(GROUND_SHEET).pixelated())
    }
}

/// The shoreline sprite laid over the pond's styled water, cutout so the
/// water shows through its cleared middle.
#[derive(Catalog, Clone, PartialEq, Eq, Hash)]
struct Shore;

impl Mesh for Shore {
    fn build(&self, assets: &Assets) -> MeshData {
        Plane
            .build(assets)
            .with_texture(assets.texture(POND_SHEET).pixelated())
            .with_material(Material::lit(Color::WHITE).cutout())
    }
}

/// A crate prop, its texture drawn over a cube.
#[derive(Catalog, Clone, PartialEq, Eq, Hash)]
struct Crate;

impl Mesh for Crate {
    fn build(&self, assets: &Assets) -> MeshData {
        Cube.build(assets)
            .with_texture(assets.texture(CRATE_TEXTURE).pixelated())
    }
}

/// The well's rim.
#[derive(Catalog, Clone, PartialEq, Eq, Hash)]
struct Well;

impl Mesh for Well {
    fn build(&self, assets: &Assets) -> MeshData {
        Cube.build(assets)
            .with_texture(assets.texture(WELL_SHEET).pixelated())
    }
}

/// The well's mouth, laid flat over the rim's top face.
#[derive(Catalog, Clone, PartialEq, Eq, Hash)]
struct WellMouth;

impl Mesh for WellMouth {
    fn build(&self, assets: &Assets) -> MeshData {
        Plane
            .build(assets)
            .with_texture(assets.texture(WELL_SHEET).pixelated())
    }
}

/// A stone box: the mouth's pillars and lintel.
#[derive(Catalog, Clone, PartialEq, Eq, Hash)]
struct Stone;

impl Mesh for Stone {
    fn build(&self, assets: &Assets) -> MeshData {
        Cube.build(assets)
            .with_texture(assets.texture(STONE_SHEET).pixelated())
    }
}

/// A bush sprite, cutout with its own relief.
#[derive(Catalog, Clone, PartialEq, Eq, Hash)]
struct Bush;

impl Mesh for Bush {
    fn build(&self, assets: &Assets) -> MeshData {
        Quad.build(assets)
            .with_texture(assets.texture(BUSH_SPRITE).pixelated())
            .with_relief(assets.relief(BUSH_RELIEF))
            .with_material(Material::lit(Color::WHITE).cutout())
    }
}

/// A rock sprite, cutout with its own relief.
#[derive(Catalog, Clone, PartialEq, Eq, Hash)]
struct Rock;

impl Mesh for Rock {
    fn build(&self, assets: &Assets) -> MeshData {
        Quad.build(assets)
            .with_texture(assets.texture(ROCK_SPRITE).pixelated())
            .with_relief(assets.relief(ROCK_RELIEF))
            .with_material(Material::lit(Color::WHITE).cutout())
    }
}

/// A torch's post sprite, cutout with its own relief.
#[derive(Catalog, Clone, PartialEq, Eq, Hash)]
struct Torch;

impl Mesh for Torch {
    fn build(&self, assets: &Assets) -> MeshData {
        Quad.build(assets)
            .with_texture(assets.texture(TORCH_SPRITE).pixelated())
            .with_relief(assets.relief(TORCH_RELIEF))
            .with_material(Material::lit(Color::WHITE).cutout())
    }
}

/// A torch's flame sprite, added over the dark rather than lit.
#[derive(Catalog, Clone, PartialEq, Eq, Hash)]
struct Flame;

impl Mesh for Flame {
    fn build(&self, assets: &Assets) -> MeshData {
        Quad.build(assets)
            .with_texture(assets.texture(FLAME_SHEET).pixelated())
            .with_material(Material::color(FLAME_TINT).additive())
    }
}

/// The player's sprite, cutout with its own relief, its sheet shared
/// with `examples/isometric-board.rs`.
#[derive(Catalog, Clone, PartialEq, Eq, Hash)]
struct Walker;

impl Mesh for Walker {
    fn build(&self, assets: &Assets) -> MeshData {
        Quad.build(assets)
            .with_texture(assets.texture(WALKER_SHEET).pixelated())
            .with_relief(assets.relief(WALKER_RELIEF))
            .with_material(Material::lit(Color::WHITE).cutout())
    }
}

/// The cave floor tile.
#[derive(Catalog, Clone, PartialEq, Eq, Hash)]
struct CaveFloor;

impl Mesh for CaveFloor {
    fn build(&self, assets: &Assets) -> MeshData {
        Plane
            .build(assets)
            .with_texture(assets.texture(CAVE_SHEET).pixelated())
    }
}

/// The cave wall face.
#[derive(Catalog, Clone, PartialEq, Eq, Hash)]
struct CaveWall;

impl Mesh for CaveWall {
    fn build(&self, assets: &Assets) -> MeshData {
        Cube.build(assets)
            .with_texture(assets.texture(CAVE_SHEET).pixelated())
    }

examples/flock-parallelism.rs (line 162)

    fn build(&self, assets: &Assets) -> MeshData<NoParts, ButterflyClip> {
        assets
            .model(BUTTERFLY_ROOT)
            .with_texture(greyed(&assets.texture(BUTTERFLY_SKIN)))
    }

pub fn with_relief(self, relief: ReliefData) -> Self

Reads the relief of every slot from relief.

See Slot::relief for what the channels hold and which draws read them.

Examples found in repository

examples/material-playground.rs (line 206)

    fn build(&self, assets: &Assets) -> MeshData {
        sphere_with_material(assets, relief_material()).with_relief(relief_bumps())
    }

examples/sprite-adventure.rs (line 643)

    fn build(&self, assets: &Assets) -> MeshData {
        Quad.build(assets)
            .with_texture(assets.texture(BUSH_SPRITE).pixelated())
            .with_relief(assets.relief(BUSH_RELIEF))
            .with_material(Material::lit(Color::WHITE).cutout())
    }
}

/// A rock sprite, cutout with its own relief.
#[derive(Catalog, Clone, PartialEq, Eq, Hash)]
struct Rock;

impl Mesh for Rock {
    fn build(&self, assets: &Assets) -> MeshData {
        Quad.build(assets)
            .with_texture(assets.texture(ROCK_SPRITE).pixelated())
            .with_relief(assets.relief(ROCK_RELIEF))
            .with_material(Material::lit(Color::WHITE).cutout())
    }
}

/// A torch's post sprite, cutout with its own relief.
#[derive(Catalog, Clone, PartialEq, Eq, Hash)]
struct Torch;

impl Mesh for Torch {
    fn build(&self, assets: &Assets) -> MeshData {
        Quad.build(assets)
            .with_texture(assets.texture(TORCH_SPRITE).pixelated())
            .with_relief(assets.relief(TORCH_RELIEF))
            .with_material(Material::lit(Color::WHITE).cutout())
    }
}

/// A torch's flame sprite, added over the dark rather than lit.
#[derive(Catalog, Clone, PartialEq, Eq, Hash)]
struct Flame;

impl Mesh for Flame {
    fn build(&self, assets: &Assets) -> MeshData {
        Quad.build(assets)
            .with_texture(assets.texture(FLAME_SHEET).pixelated())
            .with_material(Material::color(FLAME_TINT).additive())
    }
}

/// The player's sprite, cutout with its own relief, its sheet shared
/// with `examples/isometric-board.rs`.
#[derive(Catalog, Clone, PartialEq, Eq, Hash)]
struct Walker;

impl Mesh for Walker {
    fn build(&self, assets: &Assets) -> MeshData {
        Quad.build(assets)
            .with_texture(assets.texture(WALKER_SHEET).pixelated())
            .with_relief(assets.relief(WALKER_RELIEF))
            .with_material(Material::lit(Color::WHITE).cutout())
    }

pub fn with_shading(self, shading: ShadingData) -> Self

Reads the shading of every slot from shading.

See Slot::shading for what the channels hold and what each one scales.

Examples found in repository

examples/material-playground.rs (line 185)

    fn build(&self, assets: &Assets) -> MeshData {
        sphere_with_material(assets, shading_material()).with_shading(shading_checker())
    }

pub fn with_emissive_map(self, emissive: TextureData) -> Self

Reads the light every slot casts per texel from emissive.

See Slot::emissive_map for what scales it.

Examples found in repository

examples/material-playground.rs (line 227)

    fn build(&self, assets: &Assets) -> MeshData {
        cube_with_material(assets, emissive_material()).with_emissive_map(emissive_checker())
    }

impl<P: Part> MeshData<P, NoClips>

pub fn in_parts( vertices: Vec<Vertex>, indices: Vec<u32>, slot: impl FnMut(P) -> Slot, ) -> Self

A mesh of one slot per part, in the order the parts count themselves, each slot taking the next indices.

Required if you want a generated mesh with parts a draw repaints one at a time. slot runs once per part, so every part has a slot. The slot lengths must cover the indices exactly; otherwise that is an error the catalog run reports. Every triangle’s three indices run counter-clockwise seen from outside the mesh: a triangle seen from behind is not drawn.

impl<P: Part, C: Clip> MeshData<P, C>

pub fn vertices(&self) -> &[Vertex]

The mesh’s vertices, in the order the vertex buffer takes them.

pub fn indices(&self) -> &[u32]

The triangle indices, three per triangle, counter-clockwise.

pub fn slots(&self) -> &[Slot]

The mesh’s slots, in index order.

Trait Implementations

impl<P: Clone + Part, C: Clone + Clip> Clone for MeshData<P, C>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<P: Debug + Part, C: Debug + Clip> Debug for MeshData<P, C>

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

Formats the value using the given formatter.