Enum ShapeOp 

pub enum ShapeOp {
    Extrude(f64),
    Taper(f64),
    Rotate(Quat),
    Translate(Vec3),
    Scale(Vec3),
    Split {
        axis: Axis,
        slots: Vec<SplitSlot>,
    },
    Repeat {
        axis: Axis,
        tile_size: f64,
        rule: String,
    },
    Comp(CompTarget),
    I(String),
    Mat(String),
    Rule(String),
    Align {
        local_axis: Axis,
        target: Vec3,
    },
    Offset {
        distance: f64,
        cases: Vec<OffsetCase>,
    },
    Roof {
        config: RoofConfig,
        cases: Vec<RoofCase>,
    },
    Attach {
        world_axis: Vec3,
        cases: Vec<AttachCase>,
    },
}

The atomic CGA operations that the interpreter executes.

Every operation transforms the current Scope into zero or more child scopes, each tagged with a rule name that will be recursively evaluated.

Variants

Extrude(f64)

Lifts a 2-D footprint (XZ plane) into a 3-D volume by setting the Y size.

Taper(f64)

Pyramidal taper: scales the top face toward the centroid. amount ∈ [0, 1]: 0 = no taper, 1 = full pyramid (top collapses to a point).

Rotate(Quat)

Applies an additional rotation to the scope (cumulative with existing rotation).

Translate(Vec3)

Translates the scope origin in local space.

Scale(Vec3)

Scales the scope size along each axis (multiplicative).

Split

Divides the scope along axis into ordered slots.

Fields

axis: Axis

slots: Vec<SplitSlot>

Repeat

Tiles the scope along axis with child scopes of approximate size tile_size. The tile count is floor(total / tile_size); the actual tile size is then stretched to total / count so the tiles fill the scope exactly with no gap.

Fields

axis: Axis

tile_size: f64

rule: String

Comp(CompTarget)

Decomposes the scope into its geometric components (faces, edges, vertices).

I(String)

Terminal: replace the scope with the named mesh asset. This is the “terminal symbol” — produces a Terminal node in the output model.

Mat(String)

Sets the material identifier on the current work item. The material is propagated to the final Terminal, allowing downstream renderers to apply textures/shaders without changing the scope. Syntax: Mat("Brick") or Mat(Brick).

Rule(String)

Calls a named sub-rule on the current scope unchanged. Used for grammar rule references that don’t transform the scope themselves.

Align

Rotates the scope so that the specified local axis points in the given world direction.

Applies the shortest-arc rotation from the current world direction of local_axis to target. Useful for recovering from accumulated rotations. Syntax: Align(Y, Up), Align(Z, Forward), etc. Named targets: Up=(0,1,0), Down=(0,-1,0), Right=(1,0,0), Left=(-1,0,0), Forward=(0,0,-1), Back=(0,0,1).

Fields

local_axis: Axis

target: Vec3

Offset

Creates an inset (distance < 0) frame on a 2D face scope.

Produces up to two kinds of child scopes:

• Inside: the inset rectangle.
• Border: four surrounding strips (bottom, top, left, right), each invoking the same rule.

Syntax: Offset(-0.2) { Inside: Glass | Border: Frame }

Fields

distance: f64

cases: Vec<OffsetCase>

Roof

Generates a roof structure above the current scope using rich parametric configuration.

Operates on a volume scope. The config contains the roof type, primary pitch angle, optional secondary pitch, overhang, ridge offset, fascia depth, and tier height.

Syntax examples:

• Roof(Gable, 30) { Slope: Tiles | GableEnd: Bricks } — basic Gable
• Roof(Hip, 30, 0.5) { Slope: Tiles } — Hip with overhang
• Roof(Gambrel, 45, 20) { LowerSlope: Shingles | UpperSlope: Tiles } — Gambrel
• Roof(Saltbox, 45, offset=0.3) { Slope: Tiles | GableEnd: Bricks } — Saltbox
• Roof(DutchGable, 45, tier=0.7) { Slope: Tiles | GableEnd: Bricks } — Dutch Gable

Fields

config: RoofConfig

cases: Vec<RoofCase>

Attach

Projects a new horizontal scope out of a sloped face for attaching dormers or details.

world_axis defines the “up” direction for the attached scope (usually world Y). The resulting scope sits on the face’s surface with its Y axis aligned to world_axis, inheriting the face’s width and height but with depth = 0.

Syntax: Attach(Up) { Surface: DormerMass }

Fields

world_axis: Vec3

cases: Vec<AttachCase>

Trait Implementations

impl Clone for ShapeOp

fn clone(&self) -> ShapeOp

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ShapeOp

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ShapeOp

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ShapeOp

fn eq(&self, other: &ShapeOp) -> 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 ShapeOp

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ShapeOp