Enum TreeOp 

pub enum TreeOp {
    Input(Var),
    Const(f32),
    Binary(BinaryOpcode, Arc<TreeOp>, Arc<TreeOp>),
    Unary(UnaryOpcode, Arc<TreeOp>),
    RemapAxes {
        target: Arc<TreeOp>,
        x: Arc<TreeOp>,
        y: Arc<TreeOp>,
        z: Arc<TreeOp>,
    },
    RemapAffine {
        target: Arc<TreeOp>,
        mat: Affine3<f32>,
    },
}

Opcode type for trees

This is equivalent to Op, but also includes the RemapAxes and TreeOp::RemapAffine operations for lazy remapping.

Variants

Input(Var)

Input (an arbitrary Var)

Const(f32)

Binary(BinaryOpcode, Arc<TreeOp>, Arc<TreeOp>)

Unary(UnaryOpcode, Arc<TreeOp>)

RemapAxes

Lazy remapping of trees

When imported into a Context, all x/y/z clauses within target will be replaced with the provided x/y/z trees.

If the transform is affine, then RemapAffine should be preferred, because it flattens sequences of affine transformations.

Fields

target: Arc<TreeOp>

x: Arc<TreeOp>

y: Arc<TreeOp>

z: Arc<TreeOp>

RemapAffine

Lazy affine transforms

When imported into a Context, the x/y/z clauses within target will be transformed with the provided affine matrix.

Fields

target: Arc<TreeOp>

mat: Affine3<f32>

Trait Implementations

impl Debug for TreeOp

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

Formats the value using the given formatter.

impl Drop for TreeOp

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl Eq for TreeOp

impl From<TreeOp> for Tree

fn from(t: TreeOp) -> Tree

Converts to this type from the input type.

impl Hash for TreeOp

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for TreeOp

TreeOp equality uses OrderedFloat semantics for comparisons

This is subtle, but it ensures consistent behavior while using pointer equality for short-circuiting recursive checks. If we instead used standard floating-point semantics, two NAN trees would be considered equal if one is a clone of the other (due to pointer equality) but unequal if they were constructed separately (due to float semantics).

In addition, this makes equality reflexive, allowing us to implement Eq (and to store values in hashmaps).

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

Equality operator ==.

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

Inequality operator !=.