Enum Combine 

pub enum Combine {
    NewBody,
    With {
        op: BooleanOp,
        target: SolidRef,
    },
}

What an extrude or revolve does with the solid it builds: keep it as a new body, or combine it by op with the solid named target — which that consumes, as a boolean step does. A BooleanOp::Difference cuts the new solid out of the target: an extruded pocket, a drilled hole.

A step may build its solid in several parts, each combined in turn — the two sides of an extrude, one of which goes up to the next face of the target (see Tool).

Either way the step’s result is named after the step — extrude(E) — so what comes after refers to “what step E left” however it was made. Combined, the built solid is only a tool, gone once the step is done, and what the combination creates is named combine(E,...), as a boolean step names its own.

Variants

NewBody

With

Fields

op: BooleanOp

target: SolidRef

Implementations

impl Combine

pub fn cut(target: impl Into<String>) -> Self

Cutting the tools out of the solid named target.

pub fn join(target: impl Into<String>) -> Self

Joining the tools onto the solid named target.

pub fn intersect(target: impl Into<String>) -> Self

Keeping what the tools and the solid named target have in common.

pub fn target(&self) -> Option<&str>

The solid it combines with, if any.

pub fn new_for(before: &NamedModel) -> Self

The default for a step after before: joining the newest solid, if there is one — building onto what is there is the common case.

pub fn follow_sign(&mut self, from: f64, value: f64)

A join for a positive value, a cut for a negative one — what an extrude up out of a face, or down into it, means — when value crosses to the other side of zero from from. On the same side, a join or a cut stays what was chosen: an extrude may cut upwards into a solid above its sketch. A new body and an intersection stay what they are.

pub fn target_field<'a, A, T>( f: &mut EditForm<'a, A, T>, reader: &Reader<'a>, label: &str, target: Option<&SolidRef>, set: impl Fn(Edit<'_, A, T>, SolidRef) + 'a, )

The field that picks the solid to combine with — or to go as far as — labelled label, holding target, in the part reader reads; set gets the solid picked.

pub fn fields<'a, A, T>( &self, f: &mut EditForm<'a, A, T>, reader: &Reader<'a>, set: impl Fn(&mut A, Combine) + Clone + 'a, )

Its fields in f: the mode — chosen without a target, it takes the newest solid of the part reader reads — and the target to pick. set puts the combination set where the arguments keep it.

pub fn built_name(&self, namer: &Namer) -> String

The name the built solid gets: the step’s own as a new body, or a name within the step for a tool the combination consumes.

Trait Implementations

impl Clone for Combine

fn clone(&self) -> Combine

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Combine

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

Formats the value using the given formatter.

impl Default for Combine

fn default() -> Combine

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Combine

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Combine

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Combine

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 Combine