Enum SolidOperation

#[non_exhaustive]
pub enum SolidOperation {
    Extrusion {
        profile: NodeId,
        direction: DVec3,
        depth: f64,
    },
    TaperedExtrusion {
        start_profile: NodeId,
        end_profile: NodeId,
        direction: DVec3,
        depth: f64,
    },
    Revolution {
        profile: NodeId,
        axis_origin: DVec3,
        axis_direction: DVec3,
        angle: f64,
    },
    TaperedRevolution {
        start_profile: NodeId,
        end_profile: NodeId,
        axis_origin: DVec3,
        axis_direction: DVec3,
        angle: f64,
    },
    SweptDisk {
        directrix: NodeId,
        radius: f64,
        inner_radius: Option<f64>,
        parameter_range: Option<(f64, f64)>,
        fillet_radius: Option<f64>,
    },
    FixedReferenceSweep {
        profile: NodeId,
        directrix: NodeId,
        reference_direction: DVec3,
        parameter_range: Option<(f64, f64)>,
    },
    SurfaceCurveSweep {
        profile: NodeId,
        directrix: NodeId,
        reference_surface: NodeId,
        parameter_range: Option<(f64, f64)>,
    },
    SectionedSpine {
        spine: NodeId,
        sections: Vec<Section>,
    },
    Boolean {
        left: NodeId,
        right: NodeId,
        operator: BooleanOperator,
    },
    BoundedHalfSpace {
        half_space: NodeId,
        boundary: NodeId,
        placement: DAffine3,
    },
}

Relationship that constructs a solid from lower-level geometry.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Extrusion

Linear extrusion of a profile.

Fields

profile: NodeId

direction: DVec3

depth: f64

TaperedExtrusion

Tapered linear extrusion between two profiles.

Fields

start_profile: NodeId

end_profile: NodeId

direction: DVec3

depth: f64

Revolution

Revolution of a profile.

Fields

profile: NodeId

axis_origin: DVec3

axis_direction: DVec3

angle: f64

TaperedRevolution

Tapered revolution between two profiles.

Fields

start_profile: NodeId

end_profile: NodeId

axis_origin: DVec3

axis_direction: DVec3

angle: f64

SweptDisk

Disk swept along a directrix curve.

fillet_radius rounds the corners where consecutive directrix segments meet, and is meaningful only on a piecewise-linear directrix: a smooth curve has no corners to round. None means sharp corners, which is also the correct reading for any directrix that is already smooth.

It is a property of the SWEEP, not of the disk: the disk stays circular and it is the swept path whose corners are filleted. A consumer that cannot round corners must refuse a Some rather than drop it, because silently sharpening a pipe run produces geometry that builds, renders, and is wrong.

Fields

directrix: NodeId

radius: f64

inner_radius: Option<f64>

parameter_range: Option<(f64, f64)>

fillet_radius: Option<f64>

Corner rounding radius; None means sharp corners.

FixedReferenceSweep

Profile swept along a directrix using a fixed reference direction.

Fields

profile: NodeId

directrix: NodeId

reference_direction: DVec3

parameter_range: Option<(f64, f64)>

SurfaceCurveSweep

Profile swept along a directrix constrained by a reference surface.

Fields

profile: NodeId

directrix: NodeId

reference_surface: NodeId

parameter_range: Option<(f64, f64)>

SectionedSpine

Sections interpolated along a spine.

Fields

spine: NodeId

sections: Vec<Section>

Boolean

General CSG binary operation.

Fields

left: NodeId

right: NodeId

operator: BooleanOperator

BoundedHalfSpace

Unbounded half-space clipped by a finite boundary geometry.

Fields

half_space: NodeId

boundary: NodeId

A closed 2D curve in placement’s XY plane. A 3D curve is refused when the graph is built.

placement: DAffine3

The boundary’s own frame, independent of the clip plane.

The boundary profile is authored in this frame, so its rotation orients the profile itself rather than the finished solid. A source format may place the boundary independently of the base surface, and only the rotation about the clip normal is meaningful: the compiler projects this frame’s axes into the plane, so a component along the normal is dropped rather than tilting the profile out of its own plane.

Trait Implementations

impl Clone for SolidOperation

fn clone(&self) -> SolidOperation

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SolidOperation

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

Formats the value using the given formatter.

impl From<SolidOperation> for GeometryNode

fn from(value: SolidOperation) -> GeometryNode

Converts to this type from the input type.

impl PartialEq for SolidOperation

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

impl StructuralPartialEq for SolidOperation