Struct rin_scene::transformation::PreviousTransformation

pub struct PreviousTransformation(pub Node);

Implementations

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 has_changed(&self) -> bool

pub fn reset_changed(&mut self)

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>
) -> Result<(), Error>

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

Returns an error if the look at direction and the up vector are parallel

pub fn face_towards(
    &mut self,
    dir: &Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer>,
    up: &Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer>
) -> Result<(), Error>

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

Returns an error if the look at direction and the up vector are parallel

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

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

Returns an error if the look at direction and the up vector are parallel

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 local_x_axis(
    &self
) -> Unit<Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer>>

The node orientation x axis

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

The node orientation y axis

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

The node orientation z axis

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

The node orientation x axis

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

The node orientation y axis

pub fn global_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_parts(
    &mut self,
    parent_loc: Option<&Node>,
    parent_orientation: Option<&Node>,
    parent_scale: Option<&Node>
) -> bool

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

Trait Implementations

impl Clone for PreviousTransformation

fn clone(&self) -> PreviousTransformation

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Component for PreviousTransformation

type Storage = DenseVec<PreviousTransformation>

type MutStorageCacheGuard = ()

fn type_name() -> &'static str

fn is_reference() -> bool

pub fn id() -> TypeId

pub fn references_other(
) -> Option<Box<dyn Fn(&Storages, &Entity) + 'static, Global>>

impl Debug for PreviousTransformation

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

Formats the value using the given formatter.

impl<'a> DebugParameter for PreviousTransformation

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

impl Default for PreviousTransformation

fn default() -> PreviousTransformation

Returns the “default value” for a type.

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<'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.

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.