Struct mutiny::transformation::PreviousTransformation

pub struct PreviousTransformation(pub Node);

Methods

impl PreviousTransformation

pub fn new(pos: Pnt3, rot: UnitQuat, scale: Vec3) -> PreviousTransformation

pub fn from_position(pos: Pnt3) -> PreviousTransformation

Methods from Deref<Target = Node>

pub fn clone_with_preparent(&self, preparent: &Node) -> Node

Clones this node but applies a preparent transformation

Allows to parent this node with it's current position, orientation and scale as absolute instead of relative to the parent.

pub fn set_position(&mut self, pos: Point<f32, U3>)

Sets the local position of this node

pub fn position(&self) -> Point<f32, U3>

Returns the local position of this node

pub fn preparent(     &self ) -> Option<Matrix<f32, U4, U4, <DefaultAllocator as Allocator<f32, U4, U4>>::Buffer>>

Returns the initial parent inverse transformation if there's one

pub fn set_angle_axis(     &mut self,     angle: Rad<f32>,     axis: &Unit<Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer>> )

Sets the orientation for this node from an angle and axis of rotation

pub fn set_orientation(&mut self, q: Unit<Quaternion<f32>>)

Sets the orientation for this node from a quaternion

pub fn orientation(&self) -> Unit<Quaternion<f32>>

Returns the orientation of this node as a quaternion which is how it's stored internally

pub fn rotation(&self) -> Rotation<f32, U3>

Returns the orientation of this node as a Rotation3.

This method converts the internal quaternion into a Rotation3

pub fn look_at(     &mut self,     at: &Point<f32, U3>,     up: &Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer> )

Changes the orientation of the node to look at the passed position using the up vector

pub fn look_at_node<N>(     &mut self,     node: &N,     up: &Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer> ) where     N: NodeRef,

Changes the orientation of the node to look at the passed node global position using the up vector

pub fn rotate(     &mut self,     angle: Rad<f32>,     axis: &Unit<Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer>> )

Rotate this note a certain angle around the axis of rotation

pub fn append_orientation(&mut self, rot: &Unit<Quaternion<f32>>)

Append the passed quaternion to the current local orientation

pub fn translate(     &mut self,     t: &Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer> )

Append a translation to the current local position

pub fn scale(     &self ) -> Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer>

Returns the current local scale

pub fn set_scale(     &mut self,     s: Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer> )

Sets the local scale

pub fn x_axis(     &self ) -> Unit<Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer>>

The node orientation x axis

pub fn y_axis(     &self ) -> Unit<Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer>>

The node orientation y axis

pub fn z_axis(     &self ) -> Unit<Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer>>

The node orientation z axis

pub fn tilt(&mut self, angle: Rad<f32>)

rotate this node around it's local x axis

pub fn pan(&mut self, angle: Rad<f32>)

rotate this node around it's local y axis

pub fn roll(&mut self, angle: Rad<f32>)

rotate this node around it's local z axis

pub fn local_transformation(     &self ) -> Matrix<f32, U4, U4, <DefaultAllocator as Allocator<f32, U4, U4>>::Buffer>

Local transformation matrix

pub fn global_transformation(     &self ) -> Matrix<f32, U4, U4, <DefaultAllocator as Allocator<f32, U4, U4>>::Buffer>

Global transformation matrix

pub fn global_position(&self) -> Point<f32, U3>

Global position of this node

pub fn global_orientation(&self) -> Unit<Quaternion<f32>>

Global orientation of this node

pub fn global_scale(     &self ) -> Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer>

Global scale of this node

pub fn inv_local_transformation(     &self ) -> Matrix<f32, U4, U4, <DefaultAllocator as Allocator<f32, U4, U4>>::Buffer>

Inverse local transformation of this node

This is cacheed internally and uses the fastest version posible to calculate the inverse so it's usually faster than calling local_transformation().try_inverse()

pub fn inv_global_transformation(     &self ) -> Matrix<f32, U4, U4, <DefaultAllocator as Allocator<f32, U4, U4>>::Buffer>

Inverse global transformation of this node

This is cacheed internally and uses the fastest version posible to calculate the inverse so it's usually faster than calling global_transformation().try_inverse()

pub fn update_with_parent(&mut self, parent: Option<&Node>) -> bool

Updates the internal matrices including the glonal matrices using the optional parent passed as argument

pub fn update_with_parent_flags(     &mut self,     parent: Option<&Node>,     flags: Flags ) -> bool

Updates the internal matrices including the glonal matrices using the optional parent passed as argument and flags

Trait Implementations

impl Default for PreviousTransformation

fn default() -> PreviousTransformation

Returns the "default value" for a type.

impl<'a> From<&'a Transformations> for PreviousTransformation

fn from(trafo: &'a Transformations) -> PreviousTransformation

Performs the conversion.

impl Clone for PreviousTransformation

fn clone(&self) -> PreviousTransformation

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for PreviousTransformation

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

Formats the value using the given formatter.

impl Deref for PreviousTransformation

type Target = Node

The resulting type after dereferencing.

fn deref(&self) -> &Node

Dereferences the value.

impl DerefMut for PreviousTransformation

fn deref_mut(&mut self) -> &mut Node

Mutably dereferences the value.

impl Component for PreviousTransformation

type Storage = DenseVec<PreviousTransformation>

fn type_name() -> &'static str

fn id() -> TypeId

impl<'a> DebugParameter for PreviousTransformation

fn debug<S: Serializer>(     &self,     serializer: S ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

impl Serialize for PreviousTransformation

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

Serialize this value into the given Serde serializer.

impl<'de> Deserialize<'de> for PreviousTransformation

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where     __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.