rscad_core/

dynamic.rs

//! Dynamically-typed CSG object tree.
//!
//! [`DynamicObject`] is a serializable, runtime-typed representation of a CSG
//! object tree.  It serves as the common intermediate representation for:
//!
//! - Serialized scene files (RON, JSON)
//! - OpenSCAD evaluation output
//!
//! Every variant maps to an rscad-core concept but uses runtime typing
//! instead of Rust generics, making it serializable and constructable at
//! runtime (e.g. from an OpenSCAD evaluator).
//!
//! The [`ToDynamic`] trait converts statically-typed rscad-core objects into
//! `DynamicObject`.  Types without a `DynamicObject` equivalent (e.g.
//! `Pattern`, `Offset`, `Projection`) intentionally do **not**
//! implement the trait — attempting to convert them is a compile-time error.

use std::collections::BTreeMap;

use crate::prelude_::*;

/// A dynamically-typed CSG object node.
///
/// Implements [`Object`] so it can be used anywhere a static rscad-core object
/// can, and can be serialized/deserialized when the `serde` feature is enabled.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum DynamicObject {
    // ── 3D Primitives ─────────────────────────────────────
    Cube {
        size: [f64; 3],
    },
    Sphere {
        radius: f64,
        #[cfg_attr(feature = "serde", serde(default = "default_segments"))]
        segments: usize,
        #[cfg_attr(feature = "serde", serde(default = "default_segments"))]
        stacks: usize,
    },
    Cylinder {
        radius: f64,
        height: f64,
        #[cfg_attr(feature = "serde", serde(default = "default_segments"))]
        segments: usize,
    },
    Cone {
        radius: f64,
        height: f64,
        #[cfg_attr(feature = "serde", serde(default = "default_segments"))]
        segments: usize,
    },

    // ── 2D Primitives (for extrusion) ─────────────────────
    Circle {
        radius: f64,
        #[cfg_attr(feature = "serde", serde(default = "default_segments"))]
        segments: usize,
    },
    Square {
        size: [f64; 2],
    },
    Polygon {
        points: Vec<[f64; 2]>,
    },
    /// Constraint-based 2D sketch (see [`crate::sketch`]). Lives in its local
    /// XZ plane like the other 2D primitives.
    Sketch {
        data: crate::sketch::SketchData,
    },

    // ── Boolean Operations ────────────────────────────────
    /// Implicit union of all children.
    Union {
        children: Vec<DynamicObject>,
    },
    /// First child minus all subsequent children.
    Difference {
        children: Vec<DynamicObject>,
    },
    /// Intersection of all children.
    Intersection {
        children: Vec<DynamicObject>,
    },

    // ── Transformations ───────────────────────────────────
    Translate {
        offset: [f64; 3],
        child: Box<DynamicObject>,
    },
    /// Rotation in degrees (OpenSCAD convention).
    Rotate {
        angles: [f64; 3],
        child: Box<DynamicObject>,
    },
    Scale {
        factors: [f64; 3],
        child: Box<DynamicObject>,
    },
    Mirror {
        axis: [f64; 3],
        child: Box<DynamicObject>,
    },
    /// RGBA color (0.0–1.0).
    Color {
        color: [f64; 4],
        child: Box<DynamicObject>,
    },
    /// PBR surface finish (metallic/roughness); albedo stays in [`Self::Color`].
    Material {
        material: crate::material::MaterialData,
        child: Box<DynamicObject>,
    },

    // ── Operations ────────────────────────────────────────
    LinearExtrude {
        height: f64,
        #[cfg_attr(feature = "serde", serde(default))]
        twist: f64,
        #[cfg_attr(feature = "serde", serde(default = "default_scale"))]
        scale: f64,
        #[cfg_attr(feature = "serde", serde(default = "default_slices"))]
        slices: usize,
        child: Box<DynamicObject>,
    },
    /// Revolve the child 2D profile about its local Y axis (OpenSCAD
    /// `rotate_extrude`). Profile-x is the radius (x ≥ 0 expected).
    Revolve {
        #[cfg_attr(feature = "serde", serde(default = "default_angle"))]
        angle_degrees: f64,
        #[cfg_attr(feature = "serde", serde(default = "default_segments"))]
        segments: usize,
        child: Box<DynamicObject>,
    },
    /// Grow/shrink the child 2D profile by `delta` (OpenSCAD `offset()`).
    Offset {
        delta: f64,
        /// Round corners (`offset(r=…)`); when set, `chamfer` is ignored.
        #[cfg_attr(feature = "serde", serde(default))]
        round: bool,
        /// Cut off miter spikes (`offset(delta=…, chamfer=true)`).
        #[cfg_attr(feature = "serde", serde(default))]
        chamfer: bool,
        /// Arc tessellation for round joins.
        #[cfg_attr(feature = "serde", serde(default = "default_segments"))]
        segments: usize,
        child: Box<DynamicObject>,
    },
    /// Chamfer/fillet the child's selected edges. Backends never see this
    /// variant directly — it lowers to plain CSG masks against the child
    /// ([`crate::feature::lower`]), re-resolved on every evaluation so the
    /// feature follows parameter edits.
    EdgeFeature {
        data: crate::feature::EdgeFeatureData,
        child: Box<DynamicObject>,
    },

    // ── Grouping ──────────────────────────────────────────
    /// Implicit union of children (convenience wrapper).
    Group {
        children: Vec<DynamicObject>,
    },
    /// Empty geometry — produces no polygons.
    Empty,
}

#[cfg(feature = "serde")]
fn default_segments() -> usize {
    32
}

#[cfg(feature = "serde")]
fn default_scale() -> f64 {
    1.0
}

#[cfg(feature = "serde")]
fn default_slices() -> usize {
    1
}

#[cfg(feature = "serde")]
fn default_angle() -> f64 {
    360.0
}

// ── Top-level transform extraction ──────────────────────────────────────────

/// Result of peeling off top-level transforms from a [`DynamicObject`] tree.
///
/// Transforms above the first boolean/primitive/extrude/group/mirror node are
/// accumulated into a [`DAffine3`] matrix.  The outermost `Color` node (if any)
/// is extracted separately for use as a material `base_color`.
pub struct ExtractedTransforms<'a> {
    /// Accumulated spatial transform (translate × rotate × scale).
    pub transform: DAffine3,
    /// Extracted RGBA color (0.0–1.0), outermost `Color` node wins.
    pub color: Option<[f64; 4]>,
    /// Extracted surface finish, outermost `Material` node wins.
    pub material: Option<crate::material::MaterialData>,
    /// Reference to the remaining subtree below the peeled transforms.
    pub inner: &'a DynamicObject,
}

impl DynamicObject {
    /// Peel off top-level `Translate`/`Rotate`/`Scale`/`Color` nodes that are
    /// **not** under any boolean operation, producing an accumulated affine
    /// matrix, an optional color, and a reference to the remaining inner
    /// subtree.
    ///
    /// Extraction stops at booleans (`Union`, `Difference`, `Intersection`),
    /// `Mirror` (negative scale breaks face winding), `LinearExtrude`, `Group`,
    /// primitives, and `Empty`.
    pub fn extract_top_transforms(&self) -> ExtractedTransforms<'_> {
        let mut transform = DAffine3::IDENTITY;
        let mut color: Option<[f64; 4]> = None;
        let mut material: Option<crate::material::MaterialData> = None;
        let mut current = self;

        loop {
            match current {
                DynamicObject::Translate { offset, child } => {
                    transform *= DAffine3::from_translation(DVec3::from_array(*offset));
                    current = child;
                }
                DynamicObject::Rotate { angles, child } => {
                    // Rz·Ry·Rx — the OpenSCAD `rotate()` convention shared by
                    // every CSG backend and the SDF compiler.
                    let q = DQuat::from_euler(
                        EulerRot::ZYX,
                        angles[2].to_radians(),
                        angles[1].to_radians(),
                        angles[0].to_radians(),
                    );
                    transform *= DAffine3::from_quat(q);
                    current = child;
                }
                DynamicObject::Scale { factors, child } => {
                    transform *= DAffine3::from_scale(DVec3::from_array(*factors));
                    current = child;
                }
                DynamicObject::Color { color: c, child } => {
                    if color.is_none() {
                        color = Some(*c);
                    }
                    current = child;
                }
                DynamicObject::Material { material: m, child } => {
                    if material.is_none() {
                        material = Some(m.clone());
                    }
                    current = child;
                }
                _ => break,
            }
        }

        ExtractedTransforms {
            transform,
            color,
            material,
            inner: current,
        }
    }
}

// ── Scene file types ────────────────────────────────────────────────────────

/// A scene file containing one or more named CSG trees.
///
/// Trees are stored as a [`BTreeMap`] keyed by label so that object names are
/// preserved in the serialized file and ordering is deterministic.
///
/// When loading, a bare [`DynamicObject`] is automatically promoted to a
/// single-tree `SceneFile` via [`SceneFile::from_single`].
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct SceneFile {
    pub trees: BTreeMap<String, DynamicObject>,
}

impl SceneFile {
    /// Wrap a single [`DynamicObject`] as a one-tree scene file.
    pub fn from_single(obj: DynamicObject) -> Self {
        Self {
            trees: BTreeMap::from([("Scene".into(), obj)]),
        }
    }
}

impl Object for DynamicObject {
    fn name(&self) -> Option<&'static str> {
        Some(match self {
            Self::Cube { .. } => "Cube",
            Self::Sphere { .. } => "Sphere",
            Self::Cylinder { .. } => "Cylinder",
            Self::Cone { .. } => "Cone",
            Self::Circle { .. } => "Circle",
            Self::Square { .. } => "Square",
            Self::Polygon { .. } => "Polygon",
            Self::Sketch { .. } => "Sketch",
            Self::Union { .. } => "Union",
            Self::Difference { .. } => "Difference",
            Self::Intersection { .. } => "Intersection",
            Self::Translate { .. } => "Translate",
            Self::Rotate { .. } => "Rotate",
            Self::Scale { .. } => "Scale",
            Self::Mirror { .. } => "Mirror",
            Self::Color { .. } => "Color",
            Self::Material { .. } => "Material",
            Self::LinearExtrude { .. } => "LinearExtrude",
            Self::Revolve { .. } => "Revolve",
            Self::Offset { .. } => "Offset",
            Self::EdgeFeature { data, .. } => data.kind.display_name(),
            Self::Group { .. } => "Group",
            Self::Empty => "Empty",
        })
    }
}

// ── ToDynamic trait + impls ──────────────────────────────────────────────────

/// Convert a statically-typed rscad-core object into a [`DynamicObject`].
pub trait ToDynamic {
    fn to_dynamic(&self) -> DynamicObject;
}

impl ToDynamic for Cube {
    fn to_dynamic(&self) -> DynamicObject {
        DynamicObject::Cube {
            size: [self.x, self.y, self.z],
        }
    }
}

impl ToDynamic for Sphere {
    fn to_dynamic(&self) -> DynamicObject {
        DynamicObject::Sphere {
            radius: self.radius,
            segments: self.fn_,
            stacks: self.stacks,
        }
    }
}

impl ToDynamic for Cylinder {
    fn to_dynamic(&self) -> DynamicObject {
        DynamicObject::Cylinder {
            radius: self.radius,
            height: self.height,
            segments: self.fn_,
        }
    }
}

impl ToDynamic for crate::Circle {
    fn to_dynamic(&self) -> DynamicObject {
        DynamicObject::Circle {
            radius: self.radius,
            segments: self.fn_,
        }
    }
}

impl ToDynamic for crate::Square {
    fn to_dynamic(&self) -> DynamicObject {
        DynamicObject::Square {
            size: [self.x, self.y],
        }
    }
}

impl<T: Object + ToDynamic> ToDynamic for Translate<T> {
    fn to_dynamic(&self) -> DynamicObject {
        DynamicObject::Translate {
            offset: self.translation.into(),
            child: Box::new(self.object.to_dynamic()),
        }
    }
}

impl<T: Object + ToDynamic> ToDynamic for Rotate<T> {
    fn to_dynamic(&self) -> DynamicObject {
        DynamicObject::Rotate {
            angles: self.rotation.into(),
            child: Box::new(self.object.to_dynamic()),
        }
    }
}

impl<T: Object + ToDynamic> ToDynamic for Scale<T> {
    fn to_dynamic(&self) -> DynamicObject {
        DynamicObject::Scale {
            factors: self.scale.into(),
            child: Box::new(self.object.to_dynamic()),
        }
    }
}

impl<T: Object + ToDynamic> ToDynamic for Mirror<T> {
    fn to_dynamic(&self) -> DynamicObject {
        DynamicObject::Mirror {
            axis: self.mirror.into(),
            child: Box::new(self.object.to_dynamic()),
        }
    }
}

impl<T: Object + ToDynamic> ToDynamic for Colored<T> {
    fn to_dynamic(&self) -> DynamicObject {
        DynamicObject::Color {
            color: [
                self.color.r as f64 / 255.0,
                self.color.g as f64 / 255.0,
                self.color.b as f64 / 255.0,
                self.color.a as f64 / 255.0,
            ],
            child: Box::new(self.object.to_dynamic()),
        }
    }
}

impl<A: Object + ToDynamic, B: Object + ToDynamic> ToDynamic for Union<A, B> {
    fn to_dynamic(&self) -> DynamicObject {
        let mut children = Vec::new();
        flatten_union(&self.this.to_dynamic(), &mut children);
        flatten_union(&self.other.to_dynamic(), &mut children);
        DynamicObject::Union { children }
    }
}

impl<A: Object + ToDynamic, B: Object + ToDynamic> ToDynamic for Difference<A, B> {
    fn to_dynamic(&self) -> DynamicObject {
        DynamicObject::Difference {
            children: vec![self.this.to_dynamic(), self.other.to_dynamic()],
        }
    }
}

impl<A: Object + ToDynamic, B: Object + ToDynamic> ToDynamic for Intersection<A, B> {
    fn to_dynamic(&self) -> DynamicObject {
        DynamicObject::Intersection {
            children: vec![self.this.to_dynamic(), self.other.to_dynamic()],
        }
    }
}

/// Flatten nested `Union` DynamicObjects into a single children vec.
fn flatten_union(node: &DynamicObject, out: &mut Vec<DynamicObject>) {
    match node {
        DynamicObject::Union { children } => {
            for child in children {
                flatten_union(child, out);
            }
        }
        other => out.push(other.clone()),
    }
}

impl<O: Object + ToDynamic> ToDynamic for crate::extrude::LinearExtrude<O> {
    fn to_dynamic(&self) -> DynamicObject {
        DynamicObject::LinearExtrude {
            height: self.height,
            twist: self.twist,
            scale: self.scale,
            slices: self.slices,
            child: Box::new(self.object.to_dynamic()),
        }
    }
}

impl<O: Object + ToDynamic> ToDynamic for crate::extrude::RotateExtrude<O> {
    fn to_dynamic(&self) -> DynamicObject {
        DynamicObject::Revolve {
            angle_degrees: self.angle_degrees,
            segments: self.fn_,
            child: Box::new(self.object.to_dynamic()),
        }
    }
}

impl<A: Object + ToDynamic, B: Object + ToDynamic> ToDynamic for TwoContainer<A, B> {
    fn to_dynamic(&self) -> DynamicObject {
        DynamicObject::Group {
            children: vec![self.a.to_dynamic(), self.b.to_dynamic()],
        }
    }
}

impl ToDynamic for Empty {
    fn to_dynamic(&self) -> DynamicObject {
        DynamicObject::Empty
    }
}

impl ToDynamic for DynamicObject {
    fn to_dynamic(&self) -> DynamicObject {
        self.clone()
    }
}

impl<T: ToDynamic> ToDynamic for Box<T> {
    fn to_dynamic(&self) -> DynamicObject {
        (**self).to_dynamic()
    }
}

impl<T: ToDynamic> ToDynamic for Option<T> {
    fn to_dynamic(&self) -> DynamicObject {
        match self {
            Some(inner) => inner.to_dynamic(),
            None => DynamicObject::Empty,
        }
    }
}

impl<T: ToDynamic> ToDynamic for Vec<T> {
    fn to_dynamic(&self) -> DynamicObject {
        DynamicObject::Group {
            children: self.iter().map(ToDynamic::to_dynamic).collect(),
        }
    }
}

impl<T: ToDynamic, const N: usize> ToDynamic for [T; N] {
    fn to_dynamic(&self) -> DynamicObject {
        DynamicObject::Group {
            children: self.iter().map(ToDynamic::to_dynamic).collect(),
        }
    }
}

impl ToDynamic for () {
    fn to_dynamic(&self) -> DynamicObject {
        DynamicObject::Empty
    }
}

macro_rules! impl_to_dynamic_tuple {
    ($($name:ident),+) => {
        impl<$($name: ToDynamic),+> ToDynamic for ($($name,)+) {
            fn to_dynamic(&self) -> DynamicObject {
                #[allow(non_snake_case)]
                let ($($name,)+) = self;
                DynamicObject::Group {
                    children: vec![$($name.to_dynamic()),+],
                }
            }
        }
    };
}

impl_to_dynamic_tuple!(A);
impl_to_dynamic_tuple!(A, B);
impl_to_dynamic_tuple!(A, B, C);
impl_to_dynamic_tuple!(A, B, C, D);
impl_to_dynamic_tuple!(A, B, C, D, E);
impl_to_dynamic_tuple!(A, B, C, D, E, F);

#[cfg(test)]
mod tests {
    use super::*;
    use crate::extrude::LinearExtrudeObject;

    #[test]
    fn cube_converts() {
        let cube = Cube {
            x: 10.0,
            y: 20.0,
            z: 30.0,
        };
        let node = cube.to_dynamic();
        assert!(matches!(
            node,
            DynamicObject::Cube {
                size: [10.0, 20.0, 30.0]
            }
        ));
    }

    #[test]
    fn translated_cube_converts() {
        let obj = Cube {
            x: 1.0,
            y: 1.0,
            z: 1.0,
        }
        .translate(5.0, 0.0, 0.0);
        let node = obj.to_dynamic();
        assert!(matches!(node, DynamicObject::Translate { .. }));
    }

    #[test]
    fn union_flattens() {
        let a = Cube {
            x: 1.0,
            y: 1.0,
            z: 1.0,
        };
        let b = Cube {
            x: 2.0,
            y: 2.0,
            z: 2.0,
        };
        let c = Cube {
            x: 3.0,
            y: 3.0,
            z: 3.0,
        };
        let obj = a.union(b).union(c);
        let node = obj.to_dynamic();
        match node {
            DynamicObject::Union { children } => assert_eq!(children.len(), 3),
            other => panic!("expected Union, got {other:?}"),
        }
    }

    #[test]
    fn colored_converts_u8_to_f64() {
        let obj = Cube {
            x: 1.0,
            y: 1.0,
            z: 1.0,
        }
        .colored(Color::RED);
        let node = obj.to_dynamic();
        match node {
            DynamicObject::Color { color, .. } => {
                assert!((color[0] - 1.0).abs() < f64::EPSILON);
                assert!((color[1]).abs() < f64::EPSILON);
                assert!((color[2]).abs() < f64::EPSILON);
                assert!((color[3] - 1.0).abs() < f64::EPSILON);
            }
            other => panic!("expected Color, got {other:?}"),
        }
    }

    #[test]
    fn linear_extrude_converts() {
        let obj = crate::Circle {
            radius: 5.0,
            fa: 0.0,
            fs: 0.0,
            fn_: 32,
        }
        .linear_extrude(10.0);
        let node = obj.to_dynamic();
        match node {
            DynamicObject::LinearExtrude { height, child, .. } => {
                assert!((height - 10.0).abs() < f64::EPSILON);
                assert!(matches!(*child, DynamicObject::Circle { .. }));
            }
            other => panic!("expected LinearExtrude, got {other:?}"),
        }
    }

    #[test]
    fn rotate_extrude_converts() {
        use crate::extrude::RotateExtrudeObject;
        let obj = crate::Circle {
            radius: 5.0,
            fa: 0.0,
            fs: 0.0,
            fn_: 32,
        }
        .rotate_extrude()
        .with_angle(180.0);
        let node = obj.to_dynamic();
        match node {
            DynamicObject::Revolve {
                angle_degrees,
                child,
                ..
            } => {
                assert!((angle_degrees - 180.0).abs() < f64::EPSILON);
                assert!(matches!(*child, DynamicObject::Circle { .. }));
            }
            other => panic!("expected Revolve, got {other:?}"),
        }
    }

    #[test]
    fn empty_converts() {
        assert!(matches!(Empty.to_dynamic(), DynamicObject::Empty));
    }

    #[test]
    fn option_none_is_empty() {
        let obj: Option<Cube> = None;
        assert!(matches!(obj.to_dynamic(), DynamicObject::Empty));
    }

    #[test]
    fn two_container_becomes_group() {
        let obj = Cube {
            x: 1.0,
            y: 1.0,
            z: 1.0,
        }
        .and(Sphere {
            radius: 2.0,
            stacks: 16,
            fn_: 16,
        });
        let node = obj.to_dynamic();
        match node {
            DynamicObject::Group { children } => assert_eq!(children.len(), 2),
            other => panic!("expected Group, got {other:?}"),
        }
    }

    #[test]
    fn dynamic_object_implements_object() {
        let obj = DynamicObject::Cube {
            size: [1.0, 2.0, 3.0],
        };
        assert_eq!(obj.name(), Some("Cube"));
    }

    // ── extract_top_transforms tests ─────────────────────────────

    #[test]
    fn extract_identity_from_primitive() {
        let obj = DynamicObject::Cube {
            size: [1.0, 2.0, 3.0],
        };
        let ext = obj.extract_top_transforms();
        assert_eq!(ext.transform, DAffine3::IDENTITY);
        assert!(ext.color.is_none());
        assert!(matches!(ext.inner, DynamicObject::Cube { .. }));
    }

    #[test]
    fn extract_single_translate() {
        let obj = DynamicObject::Translate {
            offset: [1.0, 2.0, 3.0],
            child: Box::new(DynamicObject::Cube {
                size: [1.0, 1.0, 1.0],
            }),
        };
        let ext = obj.extract_top_transforms();
        let expected = DAffine3::from_translation(DVec3::new(1.0, 2.0, 3.0));
        assert!((ext.transform.translation - expected.translation).length() < 1e-10);
        assert!(matches!(ext.inner, DynamicObject::Cube { .. }));
    }

    #[test]
    fn extract_nested_transforms() {
        // Translate(Rotate(Scale(Cube)))
        let obj = DynamicObject::Translate {
            offset: [10.0, 0.0, 0.0],
            child: Box::new(DynamicObject::Rotate {
                angles: [0.0, 0.0, 90.0],
                child: Box::new(DynamicObject::Scale {
                    factors: [2.0, 2.0, 2.0],
                    child: Box::new(DynamicObject::Cube {
                        size: [1.0, 1.0, 1.0],
                    }),
                }),
            }),
        };
        let ext = obj.extract_top_transforms();
        assert!(matches!(ext.inner, DynamicObject::Cube { .. }));
        // Translation should be [10, 0, 0]
        assert!((ext.transform.translation.x - 10.0).abs() < 1e-10);
    }

    #[test]
    fn extract_stops_at_boolean() {
        let obj = DynamicObject::Translate {
            offset: [5.0, 0.0, 0.0],
            child: Box::new(DynamicObject::Union {
                children: vec![
                    DynamicObject::Cube {
                        size: [1.0, 1.0, 1.0],
                    },
                    DynamicObject::Sphere {
                        radius: 1.0,
                        segments: 16,
                        stacks: 8,
                    },
                ],
            }),
        };
        let ext = obj.extract_top_transforms();
        assert!((ext.transform.translation.x - 5.0).abs() < 1e-10);
        assert!(matches!(ext.inner, DynamicObject::Union { .. }));
    }

    #[test]
    fn extract_stops_at_mirror() {
        let obj = DynamicObject::Translate {
            offset: [5.0, 0.0, 0.0],
            child: Box::new(DynamicObject::Mirror {
                axis: [1.0, 0.0, 0.0],
                child: Box::new(DynamicObject::Cube {
                    size: [1.0, 1.0, 1.0],
                }),
            }),
        };
        let ext = obj.extract_top_transforms();
        assert!((ext.transform.translation.x - 5.0).abs() < 1e-10);
        assert!(matches!(ext.inner, DynamicObject::Mirror { .. }));
    }

    #[test]
    fn extract_color() {
        let obj = DynamicObject::Color {
            color: [1.0, 0.0, 0.0, 1.0],
            child: Box::new(DynamicObject::Cube {
                size: [1.0, 1.0, 1.0],
            }),
        };
        let ext = obj.extract_top_transforms();
        assert_eq!(ext.color, Some([1.0, 0.0, 0.0, 1.0]));
        assert!(matches!(ext.inner, DynamicObject::Cube { .. }));
    }

    #[test]
    fn extract_color_interleaved_with_transform() {
        // Translate(Color(Rotate(Cube)))
        let obj = DynamicObject::Translate {
            offset: [5.0, 0.0, 0.0],
            child: Box::new(DynamicObject::Color {
                color: [0.0, 1.0, 0.0, 1.0],
                child: Box::new(DynamicObject::Rotate {
                    angles: [90.0, 0.0, 0.0],
                    child: Box::new(DynamicObject::Cube {
                        size: [1.0, 1.0, 1.0],
                    }),
                }),
            }),
        };
        let ext = obj.extract_top_transforms();
        assert!((ext.transform.translation.x - 5.0).abs() < 1e-10);
        assert_eq!(ext.color, Some([0.0, 1.0, 0.0, 1.0]));
        assert!(matches!(ext.inner, DynamicObject::Cube { .. }));
    }

    #[test]
    fn extract_boolean_at_root() {
        let obj = DynamicObject::Union {
            children: vec![DynamicObject::Cube {
                size: [1.0, 1.0, 1.0],
            }],
        };
        let ext = obj.extract_top_transforms();
        assert_eq!(ext.transform, DAffine3::IDENTITY);
        assert!(ext.color.is_none());
        assert!(matches!(ext.inner, DynamicObject::Union { .. }));
    }

    fn gold() -> crate::material::MaterialData {
        crate::material::MaterialData {
            metallic: 1.0,
            roughness: 0.25,
            preset: Some("Gold".into()),
        }
    }

    #[test]
    fn extract_material() {
        let obj = DynamicObject::Material {
            material: gold(),
            child: Box::new(DynamicObject::Cube {
                size: [1.0, 1.0, 1.0],
            }),
        };
        let ext = obj.extract_top_transforms();
        assert_eq!(ext.material, Some(gold()));
        assert!(ext.color.is_none());
        assert!(matches!(ext.inner, DynamicObject::Cube { .. }));
    }

    #[test]
    fn extract_material_interleaved_with_transform_and_color() {
        // Translate(Material(Color(Cube))) — all three captured, peeling continues.
        let obj = DynamicObject::Translate {
            offset: [5.0, 0.0, 0.0],
            child: Box::new(DynamicObject::Material {
                material: gold(),
                child: Box::new(DynamicObject::Color {
                    color: [0.0, 1.0, 0.0, 1.0],
                    child: Box::new(DynamicObject::Cube {
                        size: [1.0, 1.0, 1.0],
                    }),
                }),
            }),
        };
        let ext = obj.extract_top_transforms();
        assert!((ext.transform.translation.x - 5.0).abs() < 1e-10);
        assert_eq!(ext.color, Some([0.0, 1.0, 0.0, 1.0]));
        assert_eq!(ext.material, Some(gold()));
        assert!(matches!(ext.inner, DynamicObject::Cube { .. }));
    }

    #[test]
    fn extract_outermost_material_wins() {
        let obj = DynamicObject::Material {
            material: gold(),
            child: Box::new(DynamicObject::Material {
                material: crate::material::MaterialData::default(),
                child: Box::new(DynamicObject::Cube {
                    size: [1.0, 1.0, 1.0],
                }),
            }),
        };
        let ext = obj.extract_top_transforms();
        assert_eq!(ext.material, Some(gold()));
    }
}