rscad_csg_manifold/

lib.rs

//! Manifold CSG backend: converts `rscad-core` geometry types into
//! `manifold-csg` manifolds and cross-sections.

use glam::DVec3;
use manifold_csg::{CrossSection, JoinType, Manifold};
use std::collections::HashMap;

use rscad_core::Object;
use rscad_csg_traits::{CsgBackend, DynamicBackend, ToCsg, ToSketch};

/// Manifold C++ kernel CSG backend.
pub struct ManifoldBackend;

/// Generation-local provenance of one output triangle.
///
/// `original_id` identifies the input Manifold that contributed the surface;
/// `face_id` distinguishes its logical polygonal faces when Manifold provides
/// that optional array.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub struct TriangleSourceId {
    pub original_id: u32,
    pub face_id: Option<u32>,
}

/// Render metadata associated with one original input surface set.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct SurfaceMetadata {
    pub color: Option<[f32; 4]>,
}

/// A Manifold solid together with metadata keyed by Manifold `OriginalID`.
#[derive(Clone)]
pub struct ManifoldSolid {
    manifold: Manifold,
    metadata: HashMap<u32, SurfaceMetadata>,
}

impl ManifoldSolid {
    fn tracked(manifold: Manifold) -> Self {
        let mut metadata = HashMap::new();
        if let Ok(id) = u32::try_from(manifold.original_id()) {
            metadata.insert(id, SurfaceMetadata::default());
        }
        Self { manifold, metadata }
    }

    fn product(
        manifold: Manifold,
        mut left: HashMap<u32, SurfaceMetadata>,
        right: HashMap<u32, SurfaceMetadata>,
    ) -> Self {
        for (id, meta) in right {
            match left.entry(id) {
                std::collections::hash_map::Entry::Vacant(entry) => {
                    entry.insert(meta);
                }
                std::collections::hash_map::Entry::Occupied(entry) => {
                    debug_assert_eq!(
                        entry.get(),
                        &meta,
                        "one Manifold OriginalID carried conflicting surface metadata"
                    );
                }
            }
        }
        Self {
            manifold,
            metadata: left,
        }
    }

    pub fn manifold(&self) -> &Manifold {
        &self.manifold
    }

    pub fn into_manifold(self) -> Manifold {
        self.manifold
    }

    pub fn metadata(&self) -> &HashMap<u32, SurfaceMetadata> {
        &self.metadata
    }

    pub fn surface_metadata(&self, id: TriangleSourceId) -> Option<&SurfaceMetadata> {
        self.metadata.get(&id.original_id)
    }

    /// Expand Manifold's triangle runs into one provenance ID per triangle.
    pub fn triangle_source_ids(&self) -> Result<Vec<TriangleSourceId>, ProvenanceError> {
        let mesh = self.manifold.to_meshgl();
        triangle_source_ids_from_parts(
            mesh.tri_verts().len(),
            &mesh.face_id(),
            &mesh.run_index(),
            &mesh.run_original_id(),
            self.manifold.original_id(),
        )
    }
}

fn triangle_source_ids_from_parts(
    triangle_index_count: usize,
    face_ids: &[u32],
    run_starts: &[u32],
    original_ids: &[u32],
    fallback_original_id: i32,
) -> Result<Vec<TriangleSourceId>, ProvenanceError> {
    let triangle_count = triangle_index_count / 3;
    if !triangle_index_count.is_multiple_of(3) {
        return Err(ProvenanceError::TriangleIndexCount);
    }
    if triangle_count == 0 {
        return Ok(Vec::new());
    }
    if !face_ids.is_empty() && face_ids.len() != triangle_count {
        return Err(ProvenanceError::FaceIdCount {
            expected: triangle_count,
            actual: face_ids.len(),
        });
    }
    if run_starts.is_empty() && original_ids.is_empty() {
        let original_id =
            u32::try_from(fallback_original_id).map_err(|_| ProvenanceError::MissingRuns)?;
        return Ok((0..triangle_count)
            .map(|triangle| TriangleSourceId {
                original_id,
                face_id: face_ids.get(triangle).copied(),
            })
            .collect());
    }
    if original_ids.is_empty() || run_starts.len() < original_ids.len() {
        return Err(ProvenanceError::RunCount {
            starts: run_starts.len(),
            originals: original_ids.len(),
        });
    }

    let mut result = vec![None; triangle_count];
    for (run, &original_id) in original_ids.iter().enumerate() {
        let start = run_starts[run] as usize;
        let end = run_starts
            .get(run + 1)
            .map_or(triangle_index_count, |&end| end as usize);
        if !start.is_multiple_of(3)
            || !end.is_multiple_of(3)
            || start > end
            || end > triangle_index_count
        {
            return Err(ProvenanceError::RunBoundary { run, start, end });
        }
        for (triangle, slot) in result.iter_mut().enumerate().take(end / 3).skip(start / 3) {
            if slot.is_some() {
                return Err(ProvenanceError::OverlappingRun { triangle });
            }
            *slot = Some(TriangleSourceId {
                original_id,
                face_id: face_ids.get(triangle).copied(),
            });
        }
    }

    result
        .into_iter()
        .enumerate()
        .map(|(triangle, id)| id.ok_or(ProvenanceError::UncoveredTriangle { triangle }))
        .collect()
}

impl std::ops::Deref for ManifoldSolid {
    type Target = Manifold;

    fn deref(&self) -> &Self::Target {
        &self.manifold
    }
}

impl AsRef<Manifold> for ManifoldSolid {
    fn as_ref(&self) -> &Manifold {
        &self.manifold
    }
}

/// Invalid or incomplete provenance arrays returned by `MeshGL`.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum ProvenanceError {
    TriangleIndexCount,
    FaceIdCount {
        expected: usize,
        actual: usize,
    },
    MissingRuns,
    RunCount {
        starts: usize,
        originals: usize,
    },
    RunBoundary {
        run: usize,
        start: usize,
        end: usize,
    },
    OverlappingRun {
        triangle: usize,
    },
    UncoveredTriangle {
        triangle: usize,
    },
}

impl std::fmt::Display for ProvenanceError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "invalid Manifold triangle provenance: {self:?}")
    }
}

impl std::error::Error for ProvenanceError {}

impl CsgBackend for ManifoldBackend {
    type CsgType = ManifoldSolid;
    type SketchType = CrossSection;

    fn empty_csg() -> ManifoldSolid {
        ManifoldSolid::tracked(Manifold::batch_union(&[]))
    }
    fn empty_sketch() -> CrossSection {
        CrossSection::batch_union(&[])
    }

    fn union(a: ManifoldSolid, b: ManifoldSolid) -> ManifoldSolid {
        let manifold = a.manifold.union(&b.manifold);
        ManifoldSolid::product(manifold, a.metadata, b.metadata)
    }
    fn difference(a: ManifoldSolid, b: ManifoldSolid) -> ManifoldSolid {
        let manifold = a.manifold.difference(&b.manifold);
        ManifoldSolid::product(manifold, a.metadata, b.metadata)
    }
    fn intersection(a: ManifoldSolid, b: ManifoldSolid) -> ManifoldSolid {
        let manifold = a.manifold.intersection(&b.manifold);
        ManifoldSolid::product(manifold, a.metadata, b.metadata)
    }
    fn xor(a: ManifoldSolid, b: ManifoldSolid) -> ManifoldSolid {
        let ab = a.manifold.union(&b.manifold);
        let inter = a.manifold.intersection(&b.manifold);
        ManifoldSolid::product(ab.difference(&inter), a.metadata, b.metadata)
    }

    fn union_2d(a: CrossSection, b: CrossSection) -> CrossSection {
        a.union(&b)
    }
    fn difference_2d(a: CrossSection, b: CrossSection) -> CrossSection {
        a.difference(&b)
    }
    fn intersection_2d(a: CrossSection, b: CrossSection) -> CrossSection {
        a.intersection(&b)
    }
    fn xor_2d(a: CrossSection, b: CrossSection) -> CrossSection {
        let ab = a.union(&b);
        let inter = a.intersection(&b);
        ab.difference(&inter)
    }

    fn translate(csg: ManifoldSolid, offset: DVec3) -> ManifoldSolid {
        ManifoldSolid {
            manifold: csg.manifold.translate(offset.x, offset.y, offset.z),
            metadata: csg.metadata,
        }
    }
    fn rotate(csg: ManifoldSolid, angles: DVec3) -> ManifoldSolid {
        ManifoldSolid {
            manifold: csg.manifold.rotate(angles.x, angles.y, angles.z),
            metadata: csg.metadata,
        }
    }
    fn scale(csg: ManifoldSolid, factors: DVec3) -> ManifoldSolid {
        ManifoldSolid {
            manifold: csg.manifold.scale(factors.x, factors.y, factors.z),
            metadata: csg.metadata,
        }
    }
    fn mirror(csg: ManifoldSolid, axes: DVec3) -> ManifoldSolid {
        ManifoldSolid {
            manifold: csg.manifold.mirror([axes.x, axes.y, axes.z]),
            metadata: csg.metadata,
        }
    }

    fn translate_2d(sketch: CrossSection, offset: DVec3) -> CrossSection {
        sketch.translate(offset.x, offset.y)
    }
    fn rotate_2d(sketch: CrossSection, angles: DVec3) -> CrossSection {
        sketch.rotate(angles.z)
    }
    fn scale_2d(sketch: CrossSection, factors: DVec3) -> CrossSection {
        sketch.scale(factors.x, factors.y)
    }
    fn mirror_2d(sketch: CrossSection, axes: DVec3) -> CrossSection {
        sketch.mirror(axes.x, axes.y)
    }

    fn color(mut csg: ManifoldSolid, color: [f32; 4]) -> ManifoldSolid {
        if csg.metadata.is_empty()
            && let Ok(id) = u32::try_from(csg.manifold.original_id())
        {
            csg.metadata.insert(id, SurfaceMetadata::default());
        }
        for metadata in csg.metadata.values_mut() {
            metadata.color.get_or_insert(color);
        }
        csg
    }
    fn color_2d(sketch: CrossSection, _color: [f32; 4]) -> CrossSection {
        sketch
    }

    fn extrude(
        sketch: CrossSection,
        height: f64,
        twist: f64,
        scale: f64,
        slices: usize,
    ) -> ManifoldSolid {
        ManifoldSolid::tracked(z_to_y_up(Manifold::extrude_with_options(
            &sketch,
            height,
            slices as i32,
            twist,
            scale,
            scale,
        )))
    }

    fn revolve(sketch: CrossSection, angle_degrees: f64, segments: usize) -> ManifoldSolid {
        ManifoldSolid::tracked(z_to_y_up(Manifold::revolve(
            &sketch,
            segments as i32,
            angle_degrees,
        )))
    }
}

/// Convert a Z-up Manifold primitive to Y-up (Bevy convention).
fn z_to_y_up(m: Manifold) -> Manifold {
    m.rotate(-90.0, 0.0, 0.0).mirror([0.0, 0.0, 1.0])
}

// ── 3D Primitives ──────────────────────────────────────────

impl ToCsg<ManifoldBackend> for rscad_core::Cube {
    fn to_csg(&self) -> ManifoldSolid {
        ManifoldSolid::tracked(Manifold::cube(self.x, self.y, self.z, false))
    }
}

impl ToCsg<ManifoldBackend> for rscad_core::Sphere {
    fn to_csg(&self) -> ManifoldSolid {
        ManifoldSolid::tracked(Manifold::sphere(self.radius, self.fn_ as i32))
    }
}

impl ToCsg<ManifoldBackend> for rscad_core::Cylinder {
    fn to_csg(&self) -> ManifoldSolid {
        ManifoldSolid::tracked(z_to_y_up(Manifold::cylinder(
            self.height,
            self.radius,
            self.radius,
            self.fn_ as i32,
            false,
        )))
    }
}

// ── 2D Primitives ──────────────────────────────────────────

impl ToSketch<ManifoldBackend> for rscad_core::Circle {
    fn to_sketch(&self) -> CrossSection {
        CrossSection::circle(self.radius, self.fn_ as i32)
    }
}

impl ToSketch<ManifoldBackend> for rscad_core::Square {
    fn to_sketch(&self) -> CrossSection {
        CrossSection::square(self.x, self.y, false)
    }
}

impl<const N: usize> ToSketch<ManifoldBackend> for rscad_core::Polygon<N> {
    fn to_sketch(&self) -> CrossSection {
        let points = self.points_array().map(|p| p.to_array());
        CrossSection::from_simple_polygon(&points)
    }
}

impl ToSketch<ManifoldBackend> for rscad_core::PolygonDynamic {
    fn to_sketch(&self) -> CrossSection {
        let points: Vec<[f64; 2]> = self.points().map(|p| p.to_array()).collect();
        CrossSection::from_simple_polygon(&points)
    }
}

// ── Offset (2D-only) ──────────────────────────────────────

impl<T: Object + ToSketch<ManifoldBackend>> ToSketch<ManifoldBackend> for rscad_core::Offset<T> {
    fn to_sketch(&self) -> CrossSection {
        use rscad_core::transformations::OffsetType;
        let join_type = match self.offset_type {
            OffsetType::Normal => JoinType::Square,
            OffsetType::Rounded => JoinType::Round,
        };
        self.object
            .to_sketch()
            .offset(self.offset, join_type, 2.0, 0)
    }
}

// ── DynamicObject (generic dispatch via DynamicBackend) ────

impl DynamicBackend for ManifoldBackend {
    // SKETCH_IS_CSG stays false: 2D nodes in 3D context (and vice versa)
    // evaluate to empty.

    fn cube(size: [f64; 3]) -> ManifoldSolid {
        ManifoldSolid::tracked(Manifold::cube(size[0], size[1], size[2], false))
    }
    fn sphere(radius: f64, segments: usize, _stacks: usize) -> ManifoldSolid {
        ManifoldSolid::tracked(Manifold::sphere(radius, segments as i32))
    }
    fn cylinder(radius: f64, height: f64, segments: usize) -> ManifoldSolid {
        ManifoldSolid::tracked(z_to_y_up(Manifold::cylinder(
            height,
            radius,
            radius,
            segments as i32,
            false,
        )))
    }
    fn cone(radius: f64, height: f64, segments: usize) -> ManifoldSolid {
        ManifoldSolid::tracked(z_to_y_up(Manifold::cylinder(
            height,
            radius,
            0.0,
            segments as i32,
            false,
        )))
    }

    fn circle(radius: f64, segments: usize) -> CrossSection {
        CrossSection::circle(radius, segments as i32)
    }
    fn square(size: [f64; 2]) -> CrossSection {
        CrossSection::square(size[0], size[1], false)
    }
    fn polygon(points: &[[f64; 2]]) -> CrossSection {
        CrossSection::from_simple_polygon(points)
    }
    fn sketch(loops: &[Vec<glam::DVec2>]) -> CrossSection {
        let loops: Vec<Vec<[f64; 2]>> = loops
            .iter()
            .map(|l| l.iter().map(|p| p.to_array()).collect())
            .collect();
        // Positive fill: CCW outers fill, CW holes subtract.
        CrossSection::from_polygons(&loops)
    }

    fn offset(
        sketch: CrossSection,
        delta: f64,
        round: bool,
        chamfer: bool,
        segments: usize,
    ) -> CrossSection {
        let join = match (round, chamfer) {
            (true, _) => JoinType::Round,
            (false, true) => JoinType::Square,
            (false, false) => JoinType::Miter,
        };
        sketch.offset(delta, join, 2.0, segments as i32)
    }

    fn union_all(items: Vec<ManifoldSolid>) -> ManifoldSolid {
        let manifolds: Vec<Manifold> = items.iter().map(|item| item.manifold.clone()).collect();
        let mut metadata = HashMap::new();
        for item in items {
            for (id, meta) in item.metadata {
                match metadata.entry(id) {
                    std::collections::hash_map::Entry::Vacant(entry) => {
                        entry.insert(meta);
                    }
                    std::collections::hash_map::Entry::Occupied(entry) => {
                        debug_assert_eq!(entry.get(), &meta);
                    }
                }
            }
        }
        ManifoldSolid {
            manifold: Manifold::batch_union(&manifolds),
            metadata,
        }
    }
    fn union_all_2d(items: Vec<CrossSection>) -> CrossSection {
        CrossSection::batch_union(&items)
    }
}

// ── Bevy mesh conversion ───────────────────────────────────

/// Per-vertex `(OriginalID, faceID)` emitted by the Manifold backend.
///
/// Manifold's optional/missing `faceID` is encoded as [`UNKNOWN_FACE_ID`].
#[cfg(feature = "bevy")]
pub const ATTRIBUTE_SURFACE_ID: bevy_mesh::MeshVertexAttribute =
    bevy_mesh::MeshVertexAttribute::new(
        "Rscad_SurfaceId",
        0x5253_0001,
        wgpu::VertexFormat::Uint32x2,
    );

#[cfg(feature = "bevy")]
pub const UNKNOWN_FACE_ID: u32 = u32::MAX;

#[cfg(feature = "bevy")]
impl rscad_csg_traits::CsgToMesh for ManifoldBackend {
    fn to_bevy_mesh(solid: &ManifoldSolid) -> bevy_mesh::Mesh {
        use bevy_asset::RenderAssetUsages;
        use bevy_mesh::{Indices, Mesh as BevyMesh, PrimitiveTopology};

        let manifold_mesh = solid.manifold.to_meshgl();
        let props = manifold_mesh.vert_properties();
        let n_props = manifold_mesh.num_prop();
        let indices = manifold_mesh.tri_verts();

        if n_props < 3 {
            return BevyMesh::new(
                PrimitiveTopology::TriangleList,
                RenderAssetUsages::default(),
            );
        }

        let n_verts = props.len().checked_div(n_props).unwrap_or(0);

        let positions: Vec<[f32; 3]> = (0..n_verts)
            .map(|i| {
                let b = i * n_props;
                [props[b], props[b + 1], props[b + 2]]
            })
            .collect();

        let mut mesh = BevyMesh::new(
            PrimitiveTopology::TriangleList,
            RenderAssetUsages::default(),
        );
        mesh.insert_attribute(BevyMesh::ATTRIBUTE_POSITION, positions);
        mesh.insert_indices(Indices::U32(indices));
        mesh.duplicate_vertices();
        mesh.compute_flat_normals();

        match triangle_source_ids_from_parts(
            manifold_mesh.tri_verts().len(),
            &manifold_mesh.face_id(),
            &manifold_mesh.run_index(),
            &manifold_mesh.run_original_id(),
            solid.manifold.original_id(),
        ) {
            Ok(source_ids) => {
                let surface_ids: Vec<[u32; 2]> = source_ids
                    .iter()
                    .flat_map(|id| {
                        std::iter::repeat_n(
                            [id.original_id, id.face_id.unwrap_or(UNKNOWN_FACE_ID)],
                            3,
                        )
                    })
                    .collect();
                mesh.insert_attribute(ATTRIBUTE_SURFACE_ID, surface_ids);

                let has_colors = source_ids.iter().any(|id| {
                    solid
                        .surface_metadata(*id)
                        .and_then(|metadata| metadata.color)
                        .is_some()
                });
                if has_colors {
                    let colors: Vec<[f32; 4]> = source_ids
                        .iter()
                        .flat_map(|id| {
                            let color = solid
                                .surface_metadata(*id)
                                .and_then(|metadata| metadata.color)
                                .unwrap_or([1.0; 4]);
                            std::iter::repeat_n(color, 3)
                        })
                        .collect();
                    mesh.insert_attribute(BevyMesh::ATTRIBUTE_COLOR, colors);
                }
            }
            Err(error) => {
                tracing::warn!(%error, "Manifold mesh omitted invalid surface provenance");
            }
        }
        mesh
    }
}

// ── CsgToStl ───────────────────────────────────────────────

impl rscad_csg_traits::CsgToStl for ManifoldBackend {
    fn write_stl_binary(
        solid: &ManifoldSolid,
        writer: &mut dyn std::io::Write,
    ) -> std::io::Result<()> {
        rscad_csg_traits::stl::write_stl_binary(writer, stl_triangles(&solid.manifold).into_iter())
    }

    fn write_stl_ascii(
        solid: &ManifoldSolid,
        writer: &mut dyn std::io::Write,
    ) -> std::io::Result<()> {
        rscad_csg_traits::stl::write_stl_ascii(writer, stl_triangles(&solid.manifold).into_iter())
    }
}

fn stl_triangles(solid: &Manifold) -> Vec<rscad_csg_traits::stl::StlTriangle> {
    let (props, n_props, indices) = solid.to_mesh_f32();
    if n_props < 3 {
        return vec![];
    }
    let get_pos = |i: usize| -> [f32; 3] {
        let b = i * n_props;
        [props[b], props[b + 1], props[b + 2]]
    };
    indices
        .chunks_exact(3)
        .map(|tri| {
            let v0 = get_pos(tri[0] as usize);
            let v1 = get_pos(tri[1] as usize);
            let v2 = get_pos(tri[2] as usize);
            // Face normal from the edge cross product; degenerate → zero.
            let e1 = [v1[0] - v0[0], v1[1] - v0[1], v1[2] - v0[2]];
            let e2 = [v2[0] - v0[0], v2[1] - v0[1], v2[2] - v0[2]];
            let n = [
                e1[1] * e2[2] - e1[2] * e2[1],
                e1[2] * e2[0] - e1[0] * e2[2],
                e1[0] * e2[1] - e1[1] * e2[0],
            ];
            let len = (n[0] * n[0] + n[1] * n[1] + n[2] * n[2]).sqrt();
            let normal = if len > 0.0 {
                [n[0] / len, n[1] / len, n[2] / len]
            } else {
                [0.0, 0.0, 0.0]
            };
            (normal, [v0, v1, v2])
        })
        .collect()
}

// ── Tests ──────────────────────────────────────────────────

#[cfg(test)]
mod tests {
    use super::*;
    use rscad_core::{Cube, DynamicObject};

    fn colored(color: [f64; 4], child: DynamicObject) -> DynamicObject {
        DynamicObject::Color {
            color,
            child: Box::new(child),
        }
    }

    #[test]
    fn run_boundaries_expand_to_triangle_sources() {
        let sources = triangle_source_ids_from_parts(
            18,
            &[100, 101, 102, 103, 104, 105],
            &[0, 6, 18],
            &[10, 20],
            -1,
        )
        .unwrap();
        assert_eq!(sources.len(), 6);
        assert!(sources[..2].iter().all(|source| source.original_id == 10));
        assert!(sources[2..].iter().all(|source| source.original_id == 20));
        assert_eq!(sources[3].face_id, Some(103));
    }

    #[test]
    fn malformed_run_boundaries_are_rejected() {
        assert!(matches!(
            triangle_source_ids_from_parts(6, &[], &[0, 4], &[10], -1),
            Err(ProvenanceError::RunBoundary { .. })
        ));
        assert!(matches!(
            triangle_source_ids_from_parts(6, &[], &[3], &[10], -1),
            Err(ProvenanceError::UncoveredTriangle { triangle: 0 })
        ));
    }

    #[test]
    fn cube_to_manifold_produces_mesh() {
        let cube = Cube::new([10]);
        let m = ToCsg::<ManifoldBackend>::to_csg(&cube);
        let (props, n_props, indices) = m.to_mesh_f32_with_normals(3);
        assert!(n_props > 0, "should have vertex properties");
        assert!(!props.is_empty(), "should have vertex data");
        assert!(!indices.is_empty(), "should have triangle indices");
    }

    #[test]
    fn cube_has_triangle_provenance_for_six_faces() {
        let solid = ToCsg::<ManifoldBackend>::to_csg(&Cube::new([10]));
        let (_, _, indices) = solid.to_mesh_f32();
        let sources = solid.triangle_source_ids().unwrap();
        assert_eq!(sources.len(), indices.len() / 3);
        assert!(
            sources
                .iter()
                .all(|id| id.original_id == sources[0].original_id)
        );
        let faces: std::collections::HashSet<_> =
            sources.iter().filter_map(|id| id.face_id).collect();
        assert_eq!(faces.len(), 6);
    }

    #[test]
    fn translate_preserves_mesh() {
        let shape = rscad_core::Translate::new(Cube::new([5]), 1.0, 2.0, 3.0);
        let m = ToCsg::<ManifoldBackend>::to_csg(&shape);
        let (_, _, indices) = m.to_mesh_f32_with_normals(3);
        assert!(!indices.is_empty());
    }

    #[test]
    fn union_combines_two_cubes() {
        let a = Cube::new([5]);
        let b = rscad_core::Translate::new(Cube::new([5]), 3.0, 0.0, 0.0);
        let shape = rscad_core::Union { this: a, other: b };
        let m = ToCsg::<ManifoldBackend>::to_csg(&shape);
        let (_, _, indices) = m.to_mesh_f32_with_normals(3);
        assert!(!indices.is_empty());
    }

    #[test]
    fn difference_subtracts() {
        let a = Cube::new([10]);
        let b = rscad_core::Translate::new(Cube::new([5]), 2.5, 2.5, 2.5);
        let shape = rscad_core::Difference { this: a, other: b };
        let m = ToCsg::<ManifoldBackend>::to_csg(&shape);
        let (_, _, indices) = m.to_mesh_f32_with_normals(3);
        assert!(!indices.is_empty());
    }

    #[test]
    fn difference_retains_both_operand_colors() {
        let scene = DynamicObject::Difference {
            children: vec![
                colored(
                    [1.0, 0.0, 0.0, 1.0],
                    DynamicObject::Cube {
                        size: [10.0, 10.0, 10.0],
                    },
                ),
                colored(
                    [0.0, 0.0, 1.0, 1.0],
                    DynamicObject::Translate {
                        offset: [2.5, 2.5, 2.5],
                        child: Box::new(DynamicObject::Cube {
                            size: [5.0, 5.0, 5.0],
                        }),
                    },
                ),
            ],
        };
        let solid = ToCsg::<ManifoldBackend>::to_csg(&scene);
        let sources = solid.triangle_source_ids().unwrap();
        let colors: std::collections::HashSet<[u32; 4]> = sources
            .iter()
            .filter_map(|id| solid.surface_metadata(*id)?.color)
            .map(|color| color.map(f32::to_bits))
            .collect();
        assert_eq!(colors.len(), 2);
        assert!(colors.contains(&[1.0f32.to_bits(), 0, 0, 1.0f32.to_bits()]));
        assert!(colors.contains(&[0, 0, 1.0f32.to_bits(), 1.0f32.to_bits()]));
    }

    #[test]
    fn transforms_preserve_original_id_and_color() {
        let scene = DynamicObject::Translate {
            offset: [10.0, 20.0, 30.0],
            child: Box::new(colored(
                [0.25, 0.5, 0.75, 1.0],
                DynamicObject::Cube {
                    size: [1.0, 1.0, 1.0],
                },
            )),
        };
        let solid = ToCsg::<ManifoldBackend>::to_csg(&scene);
        let sources = solid.triangle_source_ids().unwrap();
        assert!(sources.iter().all(|id| {
            solid.surface_metadata(*id).and_then(|meta| meta.color) == Some([0.25, 0.5, 0.75, 1.0])
        }));
    }

    #[test]
    fn inner_color_wins_like_bsp_metadata() {
        let scene = colored(
            [0.0, 0.0, 1.0, 1.0],
            colored(
                [1.0, 0.0, 0.0, 1.0],
                DynamicObject::Cube {
                    size: [1.0, 1.0, 1.0],
                },
            ),
        );
        let solid = ToCsg::<ManifoldBackend>::to_csg(&scene);
        assert!(
            solid
                .metadata()
                .values()
                .all(|metadata| { metadata.color == Some([1.0, 0.0, 0.0, 1.0]) })
        );
    }

    #[test]
    fn empty_produces_no_mesh() {
        let m = ToCsg::<ManifoldBackend>::to_csg(&rscad_core::Empty);
        let (props, _, indices) = m.to_mesh_f32_with_normals(3);
        assert!(props.is_empty());
        assert!(indices.is_empty());
    }

    #[test]
    fn linear_extrude_circle() {
        let circle = rscad_core::Circle::new(5.0, 0.0, 0.0, 32);
        let extruded = rscad_core::extrude::LinearExtrude::new(circle).with_height(10.0);
        let m = ToCsg::<ManifoldBackend>::to_csg(&extruded);
        let (_, _, indices) = m.to_mesh_f32_with_normals(3);
        assert!(!indices.is_empty());
    }

    #[test]
    fn cross_section_square() {
        let sq = rscad_core::Square::new(5.0, 3.0);
        let cs = ToSketch::<ManifoldBackend>::to_sketch(&sq);
        let area = cs.area();
        assert!((area - 15.0).abs() < 0.01, "square area should be ~15.0");
    }

    #[test]
    fn sketch_profile_with_hole() {
        use rscad_core::sketch::SketchData;
        let mut data = SketchData::default();
        data.add_rect(glam::DVec2::ZERO, glam::DVec2::new(2.0, 1.0));
        data.add_circle(glam::DVec2::new(1.0, 0.5), 0.25);
        let cs = ToSketch::<ManifoldBackend>::to_sketch(&DynamicObject::Sketch { data });
        let area = cs.area();
        let expected = 2.0 - core::f64::consts::PI * 0.25 * 0.25;
        // Tessellated circle comes in slightly under the exact π r².
        assert!((area - expected).abs() < 0.02, "area {area} vs {expected}");
    }

    /// Crossing outers stay CCW after winding normalization, so positive fill
    /// resolves their overlap as a union.
    #[test]
    fn sketch_crossing_outers_union_area() {
        use rscad_core::sketch::SketchData;
        let mut data = SketchData::default();
        data.add_rect(glam::DVec2::ZERO, glam::DVec2::new(2.0, 2.0));
        data.add_rect(glam::DVec2::new(1.0, 1.0), glam::DVec2::new(3.0, 3.0));
        let cs = ToSketch::<ManifoldBackend>::to_sketch(&DynamicObject::Sketch { data });
        let area = cs.area();
        let expected = 4.0 + 4.0 - 1.0;
        assert!((area - expected).abs() < 0.01, "area {area} vs {expected}");
    }

    #[cfg(feature = "bevy")]
    #[test]
    fn bevy_mesh_carries_surface_ids_and_mixed_colors() {
        use bevy_mesh::{Mesh as BevyMesh, VertexAttributeValues};
        use rscad_csg_traits::CsgToMesh;

        let scene = DynamicObject::Union {
            children: vec![
                colored(
                    [1.0, 0.0, 0.0, 1.0],
                    DynamicObject::Cube {
                        size: [1.0, 1.0, 1.0],
                    },
                ),
                DynamicObject::Translate {
                    offset: [2.0, 0.0, 0.0],
                    child: Box::new(DynamicObject::Cube {
                        size: [1.0, 1.0, 1.0],
                    }),
                },
            ],
        };
        let solid = ToCsg::<ManifoldBackend>::to_csg(&scene);
        let mesh = ManifoldBackend::to_bevy_mesh(&solid);
        assert!(
            mesh.indices().is_none(),
            "triangle vertices must be separated"
        );

        let surface_ids = match mesh.attribute(ATTRIBUTE_SURFACE_ID).unwrap() {
            VertexAttributeValues::Uint32x2(values) => values,
            other => panic!("unexpected surface ID format: {other:?}"),
        };
        let colors = match mesh.attribute(BevyMesh::ATTRIBUTE_COLOR).unwrap() {
            VertexAttributeValues::Float32x4(values) => values,
            other => panic!("unexpected color format: {other:?}"),
        };
        assert_eq!(surface_ids.len(), mesh.count_vertices());
        assert_eq!(colors.len(), mesh.count_vertices());
        assert!(
            surface_ids
                .chunks_exact(3)
                .all(|tri| tri[0] == tri[1] && tri[1] == tri[2])
        );
        assert!(colors.contains(&[1.0, 0.0, 0.0, 1.0]));
        assert!(colors.contains(&[1.0; 4]));
    }

    #[cfg(feature = "bevy")]
    #[test]
    fn uncolored_bevy_mesh_omits_color_attribute() {
        use bevy_mesh::Mesh as BevyMesh;
        use rscad_csg_traits::CsgToMesh;

        let solid = ToCsg::<ManifoldBackend>::to_csg(&Cube::new([1]));
        let mesh = ManifoldBackend::to_bevy_mesh(&solid);
        assert!(mesh.attribute(ATTRIBUTE_SURFACE_ID).is_some());
        assert!(mesh.attribute(BevyMesh::ATTRIBUTE_COLOR).is_none());
    }
}