konjure_sdk/

procedural.rs

//! Bounded procedural triangle meshes and pure mesh transforms.
//!
//! These helpers operate on owned [`crate::Mesh`] values.  They deliberately do
//! not resolve assets or interact with a renderer, so the same mesh is usable by
//! native and WASM adapters.
use crate::{Diagnostic, MAX_COORDINATE_M, Mesh, Vec3};
use alloc::{format, vec, vec::Vec};

/// Largest number of vertices accepted by one procedural mesh.
pub const MAX_PROCEDURAL_VERTICES: usize = 262_144;
/// Largest number of triangle indices accepted by one procedural mesh.
pub const MAX_PROCEDURAL_INDICES: usize = 1_572_864;

/// Loads the bundled CC0 Suzanne test mesh in metres with its original normals.
///
/// Data is pinned to the Khronos sample asset credited to UX3D and Norbert
/// Nopper. `scripts/generate-suzanne.py` records source hashes and reproducibly
/// converts it into this allocation-bounded, platform-independent format.
///
/// # Errors
/// Returns a diagnostic if the bundled asset is corrupt or fails mesh validation.
pub fn suzanne() -> Result<Mesh, Diagnostic> {
    let data = include_bytes!("../assets/suzanne.mesh");
    let failure = || Diagnostic::plain("bundled Suzanne mesh is invalid");
    let read_u32 = |start| {
        data.get(start..start + 4)
            .and_then(|bytes| bytes.try_into().ok())
            .map(u32::from_le_bytes)
            .ok_or_else(failure)
    };
    let count = read_u32(0)? as usize;
    let index_count = read_u32(4)? as usize;
    if count > MAX_PROCEDURAL_VERTICES
        || index_count > MAX_PROCEDURAL_INDICES
        || data.len() != 8 + count * 48 + index_count * 4
    {
        return Err(failure());
    }
    let read_f64 = |start| {
        data.get(start..start + 8)
            .and_then(|bytes| bytes.try_into().ok())
            .map(f64::from_le_bytes)
            .ok_or_else(failure)
    };
    let mut mesh = Mesh {
        positions: Vec::with_capacity(count),
        normals: Vec::with_capacity(count),
        indices: Vec::with_capacity(index_count),
    };
    for i in 0..count {
        let offset = 8 + i * 48;
        mesh.positions.push(Vec3 {
            x: read_f64(offset)?,
            y: read_f64(offset + 8)?,
            z: read_f64(offset + 16)?,
        });
        mesh.normals.push(Vec3 {
            x: read_f64(offset + 24)?,
            y: read_f64(offset + 32)?,
            z: read_f64(offset + 40)?,
        });
    }
    for i in 0..index_count {
        mesh.indices.push(read_u32(8 + count * 48 + i * 4)?);
    }
    validate_mesh(&mesh)?;
    Ok(mesh)
}

/// A radius and vertical position used by [`lathe`].
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct ProfilePoint {
    /// Non-negative distance from the Y axis in metres.
    pub radius_m: f64,
    /// Vertical position in metres.
    pub y_m: f64,
}

/// Validates mesh buffer shape, finite coordinates, normals, and triangle indices.
///
/// # Errors
///
/// Returns a diagnostic when buffers have inconsistent lengths, exceed the
/// procedural allocation limit, or contain non-finite/out-of-range values,
/// degenerate normals, or invalid triangle indices.
pub fn validate_mesh(mesh: &Mesh) -> Result<(), Diagnostic> {
    if mesh.positions.is_empty() || mesh.positions.len() != mesh.normals.len() {
        return Err(Diagnostic::plain(
            "mesh positions and normals must be nonempty and have equal length",
        ));
    }
    if mesh.positions.len() > MAX_PROCEDURAL_VERTICES || mesh.indices.len() > MAX_PROCEDURAL_INDICES
    {
        return Err(Diagnostic::plain(
            "mesh exceeds procedural vertex or index budget",
        ));
    }
    if mesh.indices.is_empty() || !mesh.indices.len().is_multiple_of(3) {
        return Err(Diagnostic::plain(
            "mesh indices must contain nonempty triangle triples",
        ));
    }
    for position in &mesh.positions {
        valid_vector(*position, "mesh position")?;
    }
    for normal in &mesh.normals {
        valid_vector(*normal, "mesh normal")?;
        if length(*normal) <= 1e-12 {
            return Err(Diagnostic::plain("mesh normals must be nonzero"));
        }
    }
    if mesh
        .indices
        .iter()
        .any(|&index| index as usize >= mesh.positions.len())
    {
        return Err(Diagnostic::plain(
            "mesh indices must address an existing vertex",
        ));
    }
    Ok(())
}

impl Mesh {
    /// Validates this owned mesh for use with the procedural helpers.
    pub fn validate(&self) -> Result<(), Diagnostic> {
        validate_mesh(self)
    }

    /// Returns a copy translated by `offset_m` metres.
    pub fn translated(&self, offset_m: Vec3) -> Result<Self, Diagnostic> {
        self.validate()?;
        valid_vector(offset_m, "translation")?;
        let mut result = self.clone();
        for point in &mut result.positions {
            *point = add(*point, offset_m);
            valid_vector(*point, "translated position")?;
        }
        Ok(result)
    }

    /// Returns a copy rotated by XYZ Euler angles in radians.
    pub fn rotated_xyz(&self, radians: Vec3) -> Result<Self, Diagnostic> {
        self.validate()?;
        valid_vector(radians, "rotation")?;
        let mut result = self.clone();
        for point in &mut result.positions {
            *point = rotate_xyz(*point, radians);
            valid_vector(*point, "rotated position")?;
        }
        for normal in &mut result.normals {
            *normal = normalized(rotate_xyz(*normal, radians))?;
        }
        Ok(result)
    }

    /// Returns a copy scaled per axis. Negative determinant scales reverse
    /// winding once so triangles remain outward-facing relative to their normals.
    pub fn scaled(&self, scale: Vec3) -> Result<Self, Diagnostic> {
        self.validate()?;
        valid_vector(scale, "scale")?;
        if scale.x.abs() <= 1e-12 || scale.y.abs() <= 1e-12 || scale.z.abs() <= 1e-12 {
            return Err(Diagnostic::plain("mesh scale axes must be nonzero"));
        }
        let mut result = self.clone();
        for point in &mut result.positions {
            *point = mul(*point, scale);
            valid_vector(*point, "scaled position")?;
        }
        for normal in &mut result.normals {
            *normal = normalized(Vec3 {
                x: normal.x / scale.x,
                y: normal.y / scale.y,
                z: normal.z / scale.z,
            })?;
        }
        if scale.x * scale.y * scale.z < 0.0 {
            // The inverse-transpose operation above already transforms normals
            // into their outward reflected direction. Reflection only reverses
            // face orientation, so do not negate those corrected normals.
            result.reverse_indices();
        }
        Ok(result)
    }

    /// Reverses all triangle winding and negates each normal.
    pub fn reversed_winding(mut self) -> Self {
        self.reverse_winding();
        self
    }

    fn reverse_winding(&mut self) {
        self.reverse_indices();
        for normal in &mut self.normals {
            *normal = Vec3 {
                x: -normal.x,
                y: -normal.y,
                z: -normal.z,
            };
        }
    }

    fn reverse_indices(&mut self) {
        for triangle in self.indices.as_chunks_mut::<3>().0 {
            triangle.swap(1, 2);
        }
    }

    /// Maps positions through a pure caller-supplied function and recalculates
    /// smooth normals from the resulting triangles.
    pub fn map_positions<F>(&self, map: F) -> Result<Self, Diagnostic>
    where
        F: Fn(Vec3) -> Vec3,
    {
        self.validate()?;
        let mut result = self.clone();
        for point in &mut result.positions {
            *point = map(*point);
            valid_vector(*point, "mapped position")?;
        }
        result.normals = smooth_normals(&result.positions, &result.indices)?;
        Ok(result)
    }
}

/// Creates an XZ grid centered at the origin with upward normals.
pub fn grid(width_m: f64, depth_m: f64, columns: usize, rows: usize) -> Result<Mesh, Diagnostic> {
    positive(width_m, "grid width")?;
    positive(depth_m, "grid depth")?;
    if columns == 0 || rows == 0 {
        return Err(Diagnostic::plain("grid columns and rows must be positive"));
    }
    let vertices = (columns + 1)
        .checked_mul(rows + 1)
        .ok_or_else(|| Diagnostic::plain("grid vertex count overflow"))?;
    let indices = columns
        .checked_mul(rows)
        .and_then(|n| n.checked_mul(6))
        .ok_or_else(|| Diagnostic::plain("grid index count overflow"))?;
    budget(vertices, indices)?;
    let mut positions = Vec::with_capacity(vertices);
    let mut normals = Vec::with_capacity(vertices);
    let mut out = Vec::with_capacity(indices);
    for row in 0..=rows {
        for column in 0..=columns {
            positions.push(Vec3 {
                x: (column as f64 / columns as f64 - 0.5) * width_m,
                y: 0.,
                z: (row as f64 / rows as f64 - 0.5) * depth_m,
            });
            normals.push(Vec3 {
                x: 0.,
                y: 1.,
                z: 0.,
            });
        }
    }
    for row in 0..rows {
        for column in 0..columns {
            let a = (row * (columns + 1) + column) as u32;
            let b = a + columns as u32 + 1;
            out.extend_from_slice(&[a, b, a + 1, a + 1, b, b + 1]);
        }
    }
    Ok(Mesh {
        positions,
        normals,
        indices: out,
    })
}

/// Creates a capped cone centered at the origin and aligned with Y.
pub fn cone(radius_m: f64, height_m: f64, segments: usize) -> Result<Mesh, Diagnostic> {
    positive(radius_m, "cone radius")?;
    positive(height_m, "cone height")?;
    if segments < 3 {
        return Err(Diagnostic::plain("cone requires at least three segments"));
    }
    budget(
        segments + 2,
        segments
            .checked_mul(6)
            .ok_or_else(|| Diagnostic::plain("cone index count overflow"))?,
    )?;
    let mut positions = Vec::with_capacity(segments + 2);
    let mut normals = Vec::with_capacity(segments + 2);
    let mut indices = Vec::with_capacity(segments * 6);
    let slope = radius_m / height_m;
    for index in 0..segments {
        let angle = index as f64 / segments as f64 * core::f64::consts::TAU;
        let (c, s) = (libm::cos(angle), libm::sin(angle));
        positions.push(Vec3 {
            x: radius_m * c,
            y: -height_m / 2.,
            z: radius_m * s,
        });
        normals.push(normalized(Vec3 {
            x: c,
            y: slope,
            z: s,
        })?);
    }
    let apex = segments as u32;
    positions.push(Vec3 {
        x: 0.,
        y: height_m / 2.,
        z: 0.,
    });
    normals.push(Vec3 {
        x: 0.,
        y: 1.,
        z: 0.,
    });
    let center = apex + 1;
    positions.push(Vec3 {
        x: 0.,
        y: -height_m / 2.,
        z: 0.,
    });
    normals.push(Vec3 {
        x: 0.,
        y: -1.,
        z: 0.,
    });
    for index in 0..segments {
        let next = ((index + 1) % segments) as u32;
        let index = index as u32;
        indices.extend_from_slice(&[index, next, apex, center, next, index]);
    }
    Ok(Mesh {
        positions,
        normals,
        indices,
    })
}

/// Creates a UV sphere centred at the origin with caller-selected resolution.
pub fn uv_sphere(radius_m: f64, rings: usize, segments: usize) -> Result<Mesh, Diagnostic> {
    positive(radius_m, "sphere radius")?;
    if rings < 2 || segments < 3 {
        return Err(Diagnostic::plain(
            "sphere requires at least two rings and three segments",
        ));
    }
    let vertices = (rings + 1)
        .checked_mul(segments + 1)
        .ok_or_else(|| Diagnostic::plain("sphere vertex count overflow"))?;
    let indices = rings
        .checked_mul(segments)
        .and_then(|n| n.checked_mul(6))
        .ok_or_else(|| Diagnostic::plain("sphere index count overflow"))?;
    budget(vertices, indices)?;
    let mut positions = Vec::with_capacity(vertices);
    let mut normals = Vec::with_capacity(vertices);
    let mut out = Vec::with_capacity(indices);
    for ring in 0..=rings {
        let phi = ring as f64 / rings as f64 * core::f64::consts::PI;
        for segment in 0..=segments {
            let theta = segment as f64 / segments as f64 * core::f64::consts::TAU;
            let normal = Vec3 {
                x: libm::sin(phi) * libm::cos(theta),
                y: libm::cos(phi),
                z: libm::sin(phi) * libm::sin(theta),
            };
            positions.push(Vec3 {
                x: normal.x * radius_m,
                y: normal.y * radius_m,
                z: normal.z * radius_m,
            });
            normals.push(normal);
        }
    }
    for ring in 0..rings {
        for segment in 0..segments {
            let a = (ring * (segments + 1) + segment) as u32;
            let b = a + segments as u32 + 1;
            out.extend_from_slice(&[a, a + 1, b, a + 1, b + 1, b]);
        }
    }
    Ok(Mesh {
        positions,
        normals,
        indices: out,
    })
}

/// Creates a torus around the Y axis with caller-selected ring and tube resolution.
pub fn torus_mesh(
    major_radius_m: f64,
    minor_radius_m: f64,
    rings: usize,
    sides: usize,
) -> Result<Mesh, Diagnostic> {
    positive(major_radius_m, "torus major radius")?;
    positive(minor_radius_m, "torus minor radius")?;
    if minor_radius_m >= major_radius_m {
        return Err(Diagnostic::plain(
            "torus minor radius must be less than major radius",
        ));
    }
    if rings < 3 || sides < 3 {
        return Err(Diagnostic::plain(
            "torus requires at least three rings and sides",
        ));
    }
    let vertices = (rings + 1)
        .checked_mul(sides + 1)
        .ok_or_else(|| Diagnostic::plain("torus vertex count overflow"))?;
    let indices = rings
        .checked_mul(sides)
        .and_then(|n| n.checked_mul(6))
        .ok_or_else(|| Diagnostic::plain("torus index count overflow"))?;
    budget(vertices, indices)?;
    let mut positions = Vec::with_capacity(vertices);
    let mut normals = Vec::with_capacity(vertices);
    let mut out = Vec::with_capacity(indices);
    for ring in 0..=rings {
        let u = ring as f64 / rings as f64 * core::f64::consts::TAU;
        let (cu, su) = (libm::cos(u), libm::sin(u));
        for side in 0..=sides {
            let v = side as f64 / sides as f64 * core::f64::consts::TAU;
            let (cv, sv) = (libm::cos(v), libm::sin(v));
            let normal = Vec3 {
                x: cu * cv,
                y: sv,
                z: su * cv,
            };
            positions.push(Vec3 {
                x: (major_radius_m + minor_radius_m * cv) * cu,
                y: minor_radius_m * sv,
                z: (major_radius_m + minor_radius_m * cv) * su,
            });
            normals.push(normal);
        }
    }
    for ring in 0..rings {
        for side in 0..sides {
            let a = (ring * (sides + 1) + side) as u32;
            let b = a + sides as u32 + 1;
            out.extend_from_slice(&[a, a + 1, b, a + 1, b + 1, b]);
        }
    }
    Ok(Mesh {
        positions,
        normals,
        indices: out,
    })
}

/// Revolves a radius-height profile around Y. The profile must contain at least
/// two finite points with non-negative radii.
pub fn lathe(profile: &[ProfilePoint], segments: usize) -> Result<Mesh, Diagnostic> {
    if profile.len() < 2 || segments < 3 {
        return Err(Diagnostic::plain(
            "lathe requires at least two profile points and three segments",
        ));
    }
    for point in profile {
        if !point.radius_m.is_finite()
            || point.radius_m < 0.
            || point.radius_m > MAX_COORDINATE_M
            || !point.y_m.is_finite()
            || point.y_m.abs() > MAX_COORDINATE_M
        {
            return Err(Diagnostic::plain(
                "lathe profile must be finite, bounded, and have nonnegative radii",
            ));
        }
    }
    let columns = segments
        .checked_add(1)
        .ok_or_else(|| Diagnostic::plain("lathe segment overflow"))?;
    let vertices = profile
        .len()
        .checked_mul(columns)
        .ok_or_else(|| Diagnostic::plain("lathe vertex count overflow"))?;
    let indices = (profile.len() - 1)
        .checked_mul(segments)
        .and_then(|n| n.checked_mul(6))
        .ok_or_else(|| Diagnostic::plain("lathe index count overflow"))?;
    budget(vertices, indices)?;
    let mut positions = Vec::with_capacity(vertices);
    let mut out = Vec::with_capacity(indices);
    for point in profile {
        for segment in 0..=segments {
            let angle = segment as f64 / segments as f64 * core::f64::consts::TAU;
            positions.push(Vec3 {
                x: point.radius_m * libm::cos(angle),
                y: point.y_m,
                z: point.radius_m * libm::sin(angle),
            });
        }
    }
    for row in 0..profile.len() - 1 {
        for column in 0..segments {
            let a = (row * columns + column) as u32;
            let b = a + columns as u32;
            out.extend_from_slice(&[a, a + 1, b, a + 1, b + 1, b]);
        }
    }
    let normals = smooth_normals(&positions, &out)?;
    Ok(Mesh {
        positions,
        normals,
        indices: out,
    })
}

/// Samples a pure parameterization over `[0, 1] × [0, 1]` and derives smooth normals.
pub fn parametric_surface<F>(
    u_segments: usize,
    v_segments: usize,
    sample: F,
) -> Result<Mesh, Diagnostic>
where
    F: Fn(f64, f64) -> Vec3,
{
    if u_segments == 0 || v_segments == 0 {
        return Err(Diagnostic::plain(
            "parametric surface segments must be positive",
        ));
    }
    let vertices = (u_segments + 1)
        .checked_mul(v_segments + 1)
        .ok_or_else(|| Diagnostic::plain("parametric surface vertex count overflow"))?;
    let indices = u_segments
        .checked_mul(v_segments)
        .and_then(|n| n.checked_mul(6))
        .ok_or_else(|| Diagnostic::plain("parametric surface index count overflow"))?;
    budget(vertices, indices)?;
    let mut positions = Vec::with_capacity(vertices);
    let mut out = Vec::with_capacity(indices);
    for v in 0..=v_segments {
        for u in 0..=u_segments {
            let point = sample(u as f64 / u_segments as f64, v as f64 / v_segments as f64);
            valid_vector(point, "parametric sample")?;
            positions.push(point);
        }
    }
    for v in 0..v_segments {
        for u in 0..u_segments {
            let a = (v * (u_segments + 1) + u) as u32;
            let b = a + u_segments as u32 + 1;
            out.extend_from_slice(&[a, a + 1, b, a + 1, b + 1, b]);
        }
    }
    let normals = smooth_normals(&positions, &out)?;
    Ok(Mesh {
        positions,
        normals,
        indices: out,
    })
}

fn budget(vertices: usize, indices: usize) -> Result<(), Diagnostic> {
    if vertices > MAX_PROCEDURAL_VERTICES
        || indices > MAX_PROCEDURAL_INDICES
        || vertices > u32::MAX as usize
    {
        Err(Diagnostic::plain(
            "procedural mesh exceeds vertex or index budget",
        ))
    } else {
        Ok(())
    }
}
fn positive(value: f64, name: &str) -> Result<(), Diagnostic> {
    if value.is_finite() && value > 0. && value <= MAX_COORDINATE_M {
        Ok(())
    } else {
        Err(Diagnostic::plain(format!(
            "{name} must be finite and in 0..={MAX_COORDINATE_M}"
        )))
    }
}
fn valid_vector(value: Vec3, name: &str) -> Result<(), Diagnostic> {
    if [value.x, value.y, value.z]
        .into_iter()
        .all(|v| v.is_finite() && v.abs() <= MAX_COORDINATE_M)
    {
        Ok(())
    } else {
        Err(Diagnostic::plain(format!(
            "{name} must be finite and within coordinate bounds"
        )))
    }
}
fn add(a: Vec3, b: Vec3) -> Vec3 {
    Vec3 {
        x: a.x + b.x,
        y: a.y + b.y,
        z: a.z + b.z,
    }
}
fn mul(a: Vec3, b: Vec3) -> Vec3 {
    Vec3 {
        x: a.x * b.x,
        y: a.y * b.y,
        z: a.z * b.z,
    }
}
fn length(v: Vec3) -> f64 {
    libm::hypot(libm::hypot(v.x, v.y), v.z)
}
fn normalized(v: Vec3) -> Result<Vec3, Diagnostic> {
    let l = length(v);
    if l <= 1e-12 || !l.is_finite() {
        Err(Diagnostic::plain("normal must be finite and nonzero"))
    } else {
        Ok(Vec3 {
            x: v.x / l,
            y: v.y / l,
            z: v.z / l,
        })
    }
}
fn rotate_xyz(v: Vec3, r: Vec3) -> Vec3 {
    let (sx, cx) = (libm::sin(r.x), libm::cos(r.x));
    let (sy, cy) = (libm::sin(r.y), libm::cos(r.y));
    let (sz, cz) = (libm::sin(r.z), libm::cos(r.z));
    let y = v.y * cx - v.z * sx;
    let z = v.y * sx + v.z * cx;
    let x = v.x * cy + z * sy;
    let z = -v.x * sy + z * cy;
    Vec3 {
        x: x * cz - y * sz,
        y: x * sz + y * cz,
        z,
    }
}
fn smooth_normals(positions: &[Vec3], indices: &[u32]) -> Result<Vec<Vec3>, Diagnostic> {
    let mut normals = vec![Vec3::ZERO; positions.len()];
    for triangle in indices.as_chunks::<3>().0 {
        let a = positions[triangle[0] as usize];
        let b = positions[triangle[1] as usize];
        let c = positions[triangle[2] as usize];
        let ab = Vec3 {
            x: b.x - a.x,
            y: b.y - a.y,
            z: b.z - a.z,
        };
        let ac = Vec3 {
            x: c.x - a.x,
            y: c.y - a.y,
            z: c.z - a.z,
        };
        let n = Vec3 {
            x: ab.y * ac.z - ab.z * ac.y,
            y: ab.z * ac.x - ab.x * ac.z,
            z: ab.x * ac.y - ab.y * ac.x,
        };
        if length(n) <= 1e-18 {
            return Err(Diagnostic::plain(
                "procedural mesh contains a degenerate triangle",
            ));
        }
        for &i in triangle {
            normals[i as usize] = add(normals[i as usize], n);
        }
    }
    normals.into_iter().map(normalized).collect()
}

#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn procedural_meshes_are_valid_and_negative_scale_preserves_faces() {
        let mesh = grid(2., 2., 2, 2).unwrap();
        assert!(mesh.validate().is_ok());
        let mirrored = mesh
            .scaled(Vec3 {
                x: -1.,
                y: 1.,
                z: 1.,
            })
            .unwrap();
        assert_eq!(mirrored.indices[0..3], [0, 1, 3]);
        for triangle in mirrored.indices.as_chunks::<3>().0 {
            let a = mirrored.positions[triangle[0] as usize];
            let b = mirrored.positions[triangle[1] as usize];
            let c = mirrored.positions[triangle[2] as usize];
            let cross = Vec3 {
                x: (b.y - a.y) * (c.z - a.z) - (b.z - a.z) * (c.y - a.y),
                y: (b.z - a.z) * (c.x - a.x) - (b.x - a.x) * (c.z - a.z),
                z: (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x),
            };
            let normal = mirrored.normals[triangle[0] as usize];
            assert!(
                cross.x * normal.x + cross.y * normal.y + cross.z * normal.z > 0.0,
                "mirrored face winding must agree with transformed normals"
            );
        }
        assert!(cone(1., 2., 16).unwrap().validate().is_ok());
        assert!(
            lathe(
                &[
                    ProfilePoint {
                        radius_m: 0.2,
                        y_m: -1.
                    },
                    ProfilePoint {
                        radius_m: 0.8,
                        y_m: 0.
                    },
                    ProfilePoint {
                        radius_m: 0.3,
                        y_m: 1.
                    }
                ],
                16
            )
            .unwrap()
            .validate()
            .is_ok()
        );
    }
    #[test]
    fn parametric_surface_rejects_degenerate_or_nonfinite() {
        assert!(parametric_surface(1, 1, |_, _| Vec3::ZERO).is_err());
        assert!(
            parametric_surface(1, 1, |_, _| Vec3 {
                x: f64::NAN,
                y: 0.,
                z: 0.
            })
            .is_err()
        );
    }
    #[test]
    fn bundled_suzanne_is_a_valid_bounded_mesh() {
        let mesh = suzanne().expect("bundled Suzanne");
        assert_eq!(mesh.positions.len(), 2_012);
        assert_eq!(mesh.normals.len(), mesh.positions.len());
        assert_eq!(mesh.indices.len(), 3_936 * 3);
        mesh.validate().expect("valid bundled mesh");
    }
}