Struct rin::graphics::Node[−][src]

pub struct Node { /* fields omitted */ }

Position + Orientation + Scale of an object

Represents a model matrix decomposed into it’s components and caches this values so the matrix only is recalculated when any of the original values changes

Also calculates a global matrix from an optional parent

The update of the matrices happens whenever any of the update_* functions is called so don’t forget to call one of them before using the matrices after a change

A node that has just been created contains the correct updated matrices

Implementations

`impl Node`[src]

`pub fn new( pos: Point<f32, U3>, orientation: Unit<Quaternion<f32>>, scale: Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer> ) -> Node`[src]

`pub fn from_position(pos: Point<f32, U3>) -> Node`[src]

`pub fn with_parent( parent: &Node, pos: Point<f32, U3>, orientation: Unit<Quaternion<f32>>, scale: Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer> ) -> Node`[src]

`pub fn identity() -> Node`[src]

A node that applies no transformation

`pub fn has_changed(&self) -> bool`[src]

`pub fn reset_changed(&mut self)`[src]

`pub fn identity_with_parent(parent: &Node) -> Node`[src]

A node that applies no transformation but the global transformation contains the parent’s

`pub fn new_look_at( eye: Point<f32, U3>, at: Point<f32, U3>, up: Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer> ) -> Result<Node, Error>`[src]

A node that orients an object to look at a certain target

eye: position of the object
at: where the object will be looking at
up: up vector

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

`pub fn with_preparent( parent_inv: Matrix<f32, U4, U4, <DefaultAllocator as Allocator<f32, U4, U4>>::Buffer>, pos: Point<f32, U3>, orientation: Unit<Quaternion<f32>>, scale: Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer> ) -> Node`[src]

New node that stores the inverse of the current parent

When parenting a node at a certain position, orientation and scale allows for those to be absolute instead of relative to the parent.

This version of the method takes a Mat4 as preparent inverse global transformation

`pub fn with_preparent_node( preparent: &Node, pos: Point<f32, U3>, orientation: Unit<Quaternion<f32>>, scale: Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer> ) -> Node`[src]

New node that stores the inverse of the current parent

When parenting a node at a certain position, orientation and scale allows for those to be absolute instead of relative to the parent.

This version of the method takes another node as preparent global transformation

`pub fn identity_with_preparent( parent_inv: Matrix<f32, U4, U4, <DefaultAllocator as Allocator<f32, U4, U4>>::Buffer> ) -> Node`[src]

New node that stores the inverse of the current parent and applies no transformation itself

When parenting a node at a certain position, orientation and scale allows for those to be absolute instead of relative to the parent.

This version of the method takes another node as preparent global transformation

`pub fn identity_with_preparent_node(preparent: &Node) -> Node`[src]

New node that stores the inverse of the current parent and applies no transformation itself

When parenting a node at a certain position, orientation and scale allows for those to be absolute instead of relative to the parent.

This version of the method takes a Mat4 as preparent inverse global transformation

`pub fn clone_with_preparent(&self, preparent: &Node) -> Node`[src]

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>)`[src]

Sets the local position of this node

`pub fn position(&self) -> Point<f32, U3>`[src]

Returns the local position of this node

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

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>> )`[src]

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

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

Sets the orientation for this node from a quaternion

`pub fn orientation(&self) -> Unit<Quaternion<f32>>`[src]

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

`pub fn rotation(&self) -> Rotation<f32, U3>`[src]

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>`[src]

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>`[src]

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,` [src]

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>> )`[src]

Rotate this note a certain angle around the axis of rotation

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

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> )`[src]

Append a translation to the current local position

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

Returns the current local scale

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

Sets the local scale

`pub fn local_x_axis( &self ) -> Unit<Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer>>`[src]

The node orientation x axis

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

The node orientation y axis

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

The node orientation z axis

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

The node orientation x axis

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

The node orientation y axis

`pub fn global_z_axis( &self ) -> Unit<Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer>>`[src]

The node orientation z axis

`pub fn tilt(&mut self, angle: Rad<f32>)`[src]

rotate this node around it’s local x axis

`pub fn pan(&mut self, angle: Rad<f32>)`[src]

rotate this node around it’s local y axis

`pub fn roll(&mut self, angle: Rad<f32>)`[src]

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>`[src]

Local transformation matrix

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

Global transformation matrix

`pub fn global_position(&self) -> Point<f32, U3>`[src]

Global position of this node

`pub fn global_orientation(&self) -> Unit<Quaternion<f32>>`[src]

Global orientation of this node

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

Global scale of this node

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

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>`[src]

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`[src]

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`[src]

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

Trait Implementations

`impl Clone for Node`[src]

`pub fn clone(&self) -> Node`[src]

`pub fn clone_from(&mut self, source: &Self)`1.0.0 [src]

`impl Component for Node`[src]

`type Storage = Changed<Forest<Node>, Node>`

`type MutStorageCacheGuard = ()`

`pub fn type_name() -> &'static str`[src]

`pub fn is_reference() -> bool`[src]

`pub fn id() -> TypeId`[src]

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

`impl Debug for Node`[src]

`pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<'a> DebugParameter for Node`[src]

`pub fn debug<S>( &self, serializer: S ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where S: Serializer,` [src]

`impl Default for Node`[src]

`pub fn default() -> Node`[src]

`impl<'de> Deserialize<'de> for Node`[src]

`pub fn deserialize<D>( deserializer: D ) -> Result<Node, <D as Deserializer<'de>>::Error> where __D: Deserializer<'de>,` [src]

`impl From<Isometry<f32, U3, Unit<Quaternion<f32>>>> for Node`[src]

`pub fn from(i: Isometry<f32, U3, Unit<Quaternion<f32>>>) -> Node`[src]

`impl From<Node> for Model`[src]

`pub fn from(node: Node) -> Model`[src]

`impl From<Point<f32, U3>> for Node`[src]

`pub fn from(pos: Point<f32, U3>) -> Node`[src]

`impl From<Rotation<f32, U3>> for Node`[src]

`pub fn from(r: Rotation<f32, U3>) -> Node`[src]

`impl From<Translation<f32, U3>> for Node`[src]

`pub fn from(t: Translation<f32, U3>) -> Node`[src]

`impl From<Unit<Quaternion<f32>>> for Node`[src]

`pub fn from(q: Unit<Quaternion<f32>>) -> Node`[src]

`impl Mul<Node> for Node`[src]

`type Output = Node`

The resulting type after applying the * operator.

`pub fn mul(self, right: Node) -> Node`[src]

`impl NodeMut for Node`[src]

`pub fn node_mut(&mut self) -> &mut Node`[src]

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

`pub fn update_with_parent_parts( &mut self, parent_loc: Option<&Node>, parent_orientation: Option<&Node>, parent_scale: Option<&Node> ) -> bool`[src]

`pub fn look_at( &mut self, at: &Point<f32, U3>, up: &Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer> ) -> Result<(), Error>`[src]

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

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

`pub fn tilt(&mut self, angle: Rad<f32>)`[src]

`pub fn pan(&mut self, angle: Rad<f32>)`[src]

`pub fn roll(&mut self, angle: Rad<f32>)`[src]

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

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

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

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

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

`impl NodeRef for Node`[src]

`pub fn node(&self) -> &Node`[src]

`pub fn position(&self) -> Point<f32, U3>`[src]

`pub fn orientation(&self) -> Unit<Quaternion<f32>>`[src]

`pub fn rotation(&self) -> Rotation<f32, U3>`[src]

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

`pub fn local_x_axis( &self ) -> Unit<Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer>>`[src]

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

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

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

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

`pub fn global_z_axis( &self ) -> Unit<Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer>>`[src]

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

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

`pub fn global_position(&self) -> Point<f32, U3>`[src]

`pub fn global_orientation(&self) -> Unit<Quaternion<f32>>`[src]

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

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

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

`impl One for Node`[src]

`pub fn one() -> Node`[src]

`pub fn set_one(&mut self)`[src]

`pub fn is_one(&self) -> bool where Self: PartialEq<Self>,` [src]

`impl Serialize for Node`[src]

`pub fn serialize<S>( &self, serializer: S ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where S: Serializer,` [src]

`impl Copy for Node`[src]

Auto Trait Implementations

`impl RefUnwindSafe for Node`

`impl Send for Node`

`impl Sync for Node`

`impl Unpin for Node`

`impl UnwindSafe for Node`

Blanket Implementations

`impl<T> Any for T where T: 'static + ?Sized,` [src]

`pub fn type_id(&self) -> TypeId`[src]

`impl<T> Any for T where T: Any,` [src]

`pub fn get_type_id(&self) -> TypeId`[src]

`impl<T> Borrow<T> for T where T: ?Sized,` [src]

`pub fn borrow(&self) -> &T`[src]

`impl<T> BorrowMut<T> for T where T: ?Sized,` [src]

`pub fn borrow_mut(&mut self) -> &mut T`[src]

`impl<T> Downcast for T where T: Any,` [src]

`pub fn into_any(self: Box<T, Global>) -> Box<dyn Any + 'static, Global>`[src]

`pub fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>`[src]

`pub fn as_any(&self) -> &(dyn Any + 'static)`[src]

`pub fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)`[src]

`impl<T> DowncastSync for T where T: Any + Send + Sync,` [src]

`pub fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + 'static + Send + Sync>`[src]

`impl<T> From<T> for T`[src]

`pub fn from(t: T) -> T`[src]

`impl<T, U> Into for T where U: From<T>,` [src]

`pub fn into(self) -> U`[src]

`impl<V> IntoPnt<V> for V`[src]

`pub fn into_pnt(self) -> V`[src]

`impl<V> IntoVec<V> for V`[src]

`pub fn into_vec(self) -> V`[src]

`impl<T> Pointable for T`[src]

`pub const ALIGN: usize`[src]

`type Init = T`

The type for initializers.

`pub unsafe fn init(init: <T as Pointable>::Init) -> usize`[src]

`pub unsafe fn deref<'a>(ptr: usize) -> &'a T`[src]

`pub unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T`[src]

`pub unsafe fn drop(ptr: usize)`[src]

`impl<T> Same<T> for T`[src]

`type Output = T`

Should always be Self

`impl<T> Serialize for T where T: Serialize + ?Sized,` [src]

`pub fn erased_serialize( &self, serializer: &mut dyn Serializer ) -> Result<Ok, Error>`[src]

`impl<SS, SP> SupersetOf<SS> for SP where SS: SubsetOf<SP>,` [src]

`pub fn to_subset(&self) -> Option<SS>`[src]

`pub fn is_in_subset(&self) -> bool`[src]

`pub fn to_subset_unchecked(&self) -> SS`[src]

`pub fn from_subset(element: &SS) -> SP`[src]

`impl<SS, SP> SupersetOf<SS> for SP where SS: SubsetOf<SP>,` [src]

`pub fn to_subset(&self) -> Option<SS>`[src]

`pub fn is_in_subset(&self) -> bool`[src]

`pub fn to_subset_unchecked(&self) -> SS`[src]

`pub fn from_subset(element: &SS) -> SP`[src]

`impl<T> ToOwned for T where T: Clone,` [src]

`type Owned = T`

The resulting type after obtaining ownership.

`pub fn to_owned(&self) -> T`[src]

`pub fn clone_into(&self, target: &mut T)`[src]

`impl<T, U> TryFrom for T where U: Into<T>,` [src]

`type Error = Infallible`

The type returned in the event of a conversion error.

`pub fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>`[src]

`impl<T, U> TryInto for T where U: TryFrom<T>,` [src]

`type Error = >::Error`

The type returned in the event of a conversion error.

Struct rin::graphics::Node⎘[−][src]

Implementations

impl Node[src]

pub fn new( pos: Point<f32, U3>, orientation: Unit<Quaternion<f32>>, scale: Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer>) -> Node[src]

pub fn from_position(pos: Point<f32, U3>) -> Node[src]

pub fn with_parent( parent: &Node, pos: Point<f32, U3>, orientation: Unit<Quaternion<f32>>, scale: Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer>) -> Node[src]

pub fn identity() -> Node[src]

pub fn has_changed(&self) -> bool[src]

pub fn reset_changed(&mut self)[src]

pub fn identity_with_parent(parent: &Node) -> Node[src]

pub fn new_look_at( eye: Point<f32, U3>, at: Point<f32, U3>, up: Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer>) -> Result<Node, Error>[src]

pub fn with_preparent( parent_inv: Matrix<f32, U4, U4, <DefaultAllocator as Allocator<f32, U4, U4>>::Buffer>, pos: Point<f32, U3>, orientation: Unit<Quaternion<f32>>, scale: Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer>) -> Node[src]

pub fn with_preparent_node( preparent: &Node, pos: Point<f32, U3>, orientation: Unit<Quaternion<f32>>, scale: Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer>) -> Node[src]

pub fn identity_with_preparent( parent_inv: Matrix<f32, U4, U4, <DefaultAllocator as Allocator<f32, U4, U4>>::Buffer>) -> Node[src]

pub fn identity_with_preparent_node(preparent: &Node) -> Node[src]

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

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

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

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

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

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

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

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

pub fn look_at( &mut self, at: &Point<f32, U3>, up: &Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer>) -> Result<(), Error>[src]

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>[src]

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, [src]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub fn update_with_parent_parts( &mut self, parent_loc: Option<&Node>, parent_orientation: Option<&Node>, parent_scale: Option<&Node>) -> bool[src]

Trait Implementations

impl Clone for Node[src]

pub fn clone(&self) -> Node[src]

pub fn clone_from(&mut self, source: &Self)1.0.0[src]

impl Component for Node[src]

type Storage = Changed<Forest<Node>, Node>

type MutStorageCacheGuard = ()

pub fn type_name() -> &'static str[src]

pub fn is_reference() -> bool[src]

pub fn id() -> TypeId[src]

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

impl Debug for Node[src]

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>[src]

impl<'a> DebugParameter for Node[src]

pub fn debug<S>( &self, serializer: S) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where S: Serializer, [src]

impl Default for Node[src]

pub fn default() -> Node[src]

impl<'de> Deserialize<'de> for Node[src]

pub fn deserialize<__D>( __deserializer: __D) -> Result<Node, <__D as Deserializer<'de>>::Error> where __D: Deserializer<'de>, [src]

impl From<Isometry<f32, U3, Unit<Quaternion<f32>>>> for Node[src]

pub fn from(i: Isometry<f32, U3, Unit<Quaternion<f32>>>) -> Node[src]

impl From<Node> for Model[src]

pub fn from(node: Node) -> Model[src]

impl From<Point<f32, U3>> for Node[src]

pub fn from(pos: Point<f32, U3>) -> Node[src]

impl From<Rotation<f32, U3>> for Node[src]

pub fn from(r: Rotation<f32, U3>) -> Node[src]

impl From<Translation<f32, U3>> for Node[src]

pub fn from(t: Translation<f32, U3>) -> Node[src]

impl From<Unit<Quaternion<f32>>> for Node[src]

pub fn from(q: Unit<Quaternion<f32>>) -> Node[src]

Struct rin::graphics::Node[−][src]

`impl Node`[src]

`pub fn new( pos: Point<f32, U3>, orientation: Unit<Quaternion<f32>>, scale: Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer> ) -> Node`[src]

`pub fn from_position(pos: Point<f32, U3>) -> Node`[src]

`pub fn with_parent( parent: &Node, pos: Point<f32, U3>, orientation: Unit<Quaternion<f32>>, scale: Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer> ) -> Node`[src]

`pub fn identity() -> Node`[src]

`pub fn has_changed(&self) -> bool`[src]

`pub fn reset_changed(&mut self)`[src]

`pub fn identity_with_parent(parent: &Node) -> Node`[src]

`pub fn new_look_at( eye: Point<f32, U3>, at: Point<f32, U3>, up: Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer> ) -> Result<Node, Error>`[src]

`pub fn with_preparent( parent_inv: Matrix<f32, U4, U4, <DefaultAllocator as Allocator<f32, U4, U4>>::Buffer>, pos: Point<f32, U3>, orientation: Unit<Quaternion<f32>>, scale: Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer> ) -> Node`[src]

`pub fn with_preparent_node( preparent: &Node, pos: Point<f32, U3>, orientation: Unit<Quaternion<f32>>, scale: Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer> ) -> Node`[src]

`pub fn identity_with_preparent( parent_inv: Matrix<f32, U4, U4, <DefaultAllocator as Allocator<f32, U4, U4>>::Buffer> ) -> Node`[src]

`pub fn identity_with_preparent_node(preparent: &Node) -> Node`[src]

`pub fn clone_with_preparent(&self, preparent: &Node) -> Node`[src]

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

`pub fn position(&self) -> Point<f32, U3>`[src]

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

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

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

`pub fn orientation(&self) -> Unit<Quaternion<f32>>`[src]

`pub fn rotation(&self) -> Rotation<f32, U3>`[src]

`pub fn look_at( &mut self, at: &Point<f32, U3>, up: &Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer> ) -> Result<(), Error>`[src]

`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>`[src]

`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,` [src]

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

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

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

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

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

`pub fn local_x_axis( &self ) -> Unit<Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer>>`[src]

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

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

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

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

`pub fn global_z_axis( &self ) -> Unit<Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer>>`[src]

`pub fn tilt(&mut self, angle: Rad<f32>)`[src]

`pub fn pan(&mut self, angle: Rad<f32>)`[src]

`pub fn roll(&mut self, angle: Rad<f32>)`[src]

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

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

`pub fn global_position(&self) -> Point<f32, U3>`[src]

`pub fn global_orientation(&self) -> Unit<Quaternion<f32>>`[src]

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

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

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

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

`pub fn update_with_parent_parts( &mut self, parent_loc: Option<&Node>, parent_orientation: Option<&Node>, parent_scale: Option<&Node> ) -> bool`[src]

`impl Clone for Node`[src]

`pub fn clone(&self) -> Node`[src]

`pub fn clone_from(&mut self, source: &Self)`1.0.0 [src]

`impl Component for Node`[src]

`type Storage = Changed<Forest<Node>, Node>`

`type MutStorageCacheGuard = ()`

`pub fn type_name() -> &'static str`[src]

`pub fn is_reference() -> bool`[src]

`pub fn id() -> TypeId`[src]

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

`impl Debug for Node`[src]

`pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<'a> DebugParameter for Node`[src]

`pub fn debug<S>( &self, serializer: S ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where S: Serializer,` [src]

`impl Default for Node`[src]

`pub fn default() -> Node`[src]

`impl<'de> Deserialize<'de> for Node`[src]

`pub fn deserialize<D>( deserializer: D ) -> Result<Node, <D as Deserializer<'de>>::Error> where __D: Deserializer<'de>,` [src]

`impl From<Isometry<f32, U3, Unit<Quaternion<f32>>>> for Node`[src]

`pub fn from(i: Isometry<f32, U3, Unit<Quaternion<f32>>>) -> Node`[src]

`impl From<Node> for Model`[src]

`pub fn from(node: Node) -> Model`[src]

`impl From<Point<f32, U3>> for Node`[src]

`pub fn from(pos: Point<f32, U3>) -> Node`[src]

`impl From<Rotation<f32, U3>> for Node`[src]

`pub fn from(r: Rotation<f32, U3>) -> Node`[src]

`impl From<Translation<f32, U3>> for Node`[src]

`pub fn from(t: Translation<f32, U3>) -> Node`[src]

`impl From<Unit<Quaternion<f32>>> for Node`[src]

`pub fn from(q: Unit<Quaternion<f32>>) -> Node`[src]

`impl Mul<Node> for Node`[src]

`type Output = Node`