Struct nannou::geom::graph::node::Transform

pub struct Transform<S = Default> where
    S: BaseFloat,  {
    pub scale: Vector3<S>,
    pub rot: Euler<Rad<S>>,
    pub disp: Vector3<S>,
}

A node's resulting rotation, displacement and scale relative to the graph's origin.

A transform is calculated and applied to a node's vertices in the following order:

1. scale: 1.0 * parent_scale * edge_scale
2. rotation: 0.0 + parent_position + edge_displacement
3. displacement: 0.0 + parent_orientation + edge_orientation`

Fields

scale: Vector3<S>

A scaling amount along each axis.

The scaling amount is multiplied onto each vertex of the node.

rot: Euler<Rad<S>>

A rotation amount along each axis, describing a relative orientation.

Rotates all vertices around the node origin when applied.

disp: Vector3<S>

A displacement amount along each axis.

This vector is added onto the position of each vertex of the node.

Methods

impl<S> Transform<S> where
    S: BaseFloat, 

pub fn apply_edge(&mut self, parent: &Self, edge: &Edge<S>)

Apply the given parent Edge to this transform.

pub fn prepare(self) -> PreparedTransform<S>

Prepare this transform for application.

pub fn vertices<I>(self, vertices: I) -> TransformedVertices<I::IntoIter, S> where
    I: IntoIterator,
    I::Item: ApplyTransform<S>, 

Transform the given vertices.

pub fn triangles<I, V>(
    self,
    triangles: I
) -> TransformedTriangles<I::IntoIter, V, S> where
    I: IntoIterator<Item = Tri<V>>,
    V: Vertex + ApplyTransform<S>, 

Transform the given vertices.

Trait Implementations

impl<S: Clone> Clone for Transform<S> where
    S: BaseFloat, 

fn clone(&self) -> Transform<S>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S: Debug> Debug for Transform<S> where
    S: BaseFloat, 

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

Formats the value using the given formatter.

impl<S> Default for Transform<S> where
    S: BaseFloat, 

fn default() -> Self

Returns the "default value" for a type.

impl<S: PartialEq> PartialEq<Transform<S>> for Transform<S> where
    S: BaseFloat, 

fn eq(&self, other: &Transform<S>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Transform<S>) -> bool

This method tests for !=.

impl<S> StructuralPartialEq for Transform<S> where
    S: BaseFloat, 

impl<S> Transform<Vector3<S>> for Transform<S> where
    S: BaseFloat, 

fn one() -> Self

Create an identity transformation. That is, a transformation which does nothing.

fn look_at(_eye: Point3<S>, _center: Point3<S>, _up: Vector3<S>) -> Self

Create a transformation that rotates a vector to look at center from eye, using up for orientation.

fn transform_vector(&self, _vec: Vector3<S>) -> Vector3<S>

Transform a vector using this transform.

fn inverse_transform_vector(&self, _vec: Vector3<S>) -> Option<Vector3<S>>

Inverse transform a vector using this transform

fn transform_point(&self, _point: Point3<S>) -> Point3<S>

Transform a point using this transform.

fn concat(&self, _other: &Self) -> Self

Combine this transform with another, yielding a new transformation which has the effects of both.

fn inverse_transform(&self) -> Option<Self>

Create a transform that "un-does" this one.

fn concat_self(&mut self, other: &Self)

Combine this transform with another, in-place.