Enum DynamicObject 

pub enum DynamicObject {
    Cube {
        size: [f64; 3],
    },
    Sphere {
        radius: f64,
        segments: usize,
        stacks: usize,
    },
    Cylinder {
        radius: f64,
        height: f64,
        segments: usize,
    },
    Cone {
        radius: f64,
        height: f64,
        segments: usize,
    },
    Circle {
        radius: f64,
        segments: usize,
    },
    Square {
        size: [f64; 2],
    },
    Polygon {
        points: Vec<[f64; 2]>,
    },
    Sketch {
        data: SketchData,
    },
    Union {
        children: Vec<DynamicObject>,
    },
    Difference {
        children: Vec<DynamicObject>,
    },
    Intersection {
        children: Vec<DynamicObject>,
    },
    Translate {
        offset: [f64; 3],
        child: Box<DynamicObject>,
    },
    Rotate {
        angles: [f64; 3],
        child: Box<DynamicObject>,
    },
    Scale {
        factors: [f64; 3],
        child: Box<DynamicObject>,
    },
    Mirror {
        axis: [f64; 3],
        child: Box<DynamicObject>,
    },
    Color {
        color: [f64; 4],
        child: Box<DynamicObject>,
    },
    Material {
        material: MaterialData,
        child: Box<DynamicObject>,
    },
    LinearExtrude {
        height: f64,
        twist: f64,
        scale: f64,
        slices: usize,
        child: Box<DynamicObject>,
    },
    Revolve {
        angle_degrees: f64,
        segments: usize,
        child: Box<DynamicObject>,
    },
    Offset {
        delta: f64,
        round: bool,
        chamfer: bool,
        segments: usize,
        child: Box<DynamicObject>,
    },
    EdgeFeature {
        data: EdgeFeatureData,
        child: Box<DynamicObject>,
    },
    Group {
        children: Vec<DynamicObject>,
    },
    Empty,
}

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.

Variants

Cube

Fields

size: [f64; 3]

Sphere

Fields

radius: f64

segments: usize

stacks: usize

Cylinder

Fields

radius: f64

height: f64

segments: usize

Cone

Fields

radius: f64

height: f64

segments: usize

Circle

Fields

radius: f64

segments: usize

Square

Fields

size: [f64; 2]

Polygon

Fields

points: Vec<[f64; 2]>

Sketch

Constraint-based 2D sketch (see crate::sketch). Lives in its local XZ plane like the other 2D primitives.

Fields

data: SketchData

Union

Implicit union of all children.

Fields

children: Vec<DynamicObject>

Difference

First child minus all subsequent children.

Fields

children: Vec<DynamicObject>

Intersection

Intersection of all children.

Fields

children: Vec<DynamicObject>

Translate

Fields

offset: [f64; 3]

child: Box<DynamicObject>

Rotate

Rotation in degrees (OpenSCAD convention).

Fields

angles: [f64; 3]

child: Box<DynamicObject>

Scale

Fields

factors: [f64; 3]

child: Box<DynamicObject>

Mirror

Fields

axis: [f64; 3]

child: Box<DynamicObject>

Color

RGBA color (0.0–1.0).

Fields

color: [f64; 4]

child: Box<DynamicObject>

Material

PBR surface finish (metallic/roughness); albedo stays in Self::Color.

Fields

material: MaterialData

child: Box<DynamicObject>

LinearExtrude

Fields

height: f64

twist: f64

scale: f64

slices: usize

child: Box<DynamicObject>

Revolve

Revolve the child 2D profile about its local Y axis (OpenSCAD rotate_extrude). Profile-x is the radius (x ≥ 0 expected).

Fields

angle_degrees: f64

segments: usize

child: Box<DynamicObject>

Offset

Grow/shrink the child 2D profile by delta (OpenSCAD offset()).

Fields

delta: f64

round: bool

Round corners (offset(r=…)); when set, chamfer is ignored.

chamfer: bool

Cut off miter spikes (offset(delta=…, chamfer=true)).

segments: usize

Arc tessellation for round joins.

child: Box<DynamicObject>

EdgeFeature

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.

Fields

data: EdgeFeatureData

child: Box<DynamicObject>

Group

Implicit union of children (convenience wrapper).

Fields

children: Vec<DynamicObject>

Empty

Empty geometry — produces no polygons.

Implementations

impl DynamicObject

pub fn extract_top_transforms(&self) -> ExtractedTransforms<'_>

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.

Trait Implementations

impl Clone for DynamicObject

fn clone(&self) -> DynamicObject

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DynamicObject

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for DynamicObject

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Object for DynamicObject

fn name(&self) -> Option<&'static str>

impl PartialEq for DynamicObject

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for DynamicObject

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl ToDynamic for DynamicObject

fn to_dynamic(&self) -> DynamicObject

impl StructuralPartialEq for DynamicObject