Struct vek::transform::repr_c::Transform
[−]
[src]
pub struct Transform<P, O, S> { pub position: Vec3<P>, pub orientation: Quaternion<O>, pub scale: Vec3<S>, }
A convenient position + orientation + scale container, backed by two Vec3
and a Quaternion.
It can be easily interpolated and converted to a Mat4 of any layout.
let (p, rz, s) = (Vec3::unit_x(), 3.0_f32, 5.0_f32); let a = Mat4::scaling_3d(s).rotated_z(rz).translated_3d(p); let b = Mat4::from(Transform { position: p, orientation: Quaternion::rotation_z(rz), scale: Vec3::broadcast(s), }); assert_relative_eq!(a, b);
Fields
position: Vec3<P>
orientation: Quaternion<O>
scale: Vec3<S>
Trait Implementations
impl<P: Debug, O: Debug, S: Debug> Debug for Transform<P, O, S>
[src]
impl<P: Clone, O: Clone, S: Clone> Clone for Transform<P, O, S>
[src]
fn clone(&self) -> Transform<P, O, S>
[src]
Returns a copy of the value. Read more
fn clone_from(&mut self, source: &Self)
1.0.0[src]
Performs copy-assignment from source
. Read more
impl<P: Copy, O: Copy, S: Copy> Copy for Transform<P, O, S>
[src]
impl<P: Hash, O: Hash, S: Hash> Hash for Transform<P, O, S>
[src]
fn hash<__HPOS: Hasher>(&self, __arg_0: &mut __HPOS)
[src]
Feeds this value into the given [Hasher
]. Read more
fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
Feeds a slice of this type into the given [Hasher
]. Read more
impl<P: Eq, O: Eq, S: Eq> Eq for Transform<P, O, S>
[src]
impl<P: PartialEq, O: PartialEq, S: PartialEq> PartialEq for Transform<P, O, S>
[src]
fn eq(&self, __arg_0: &Transform<P, O, S>) -> bool
[src]
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, __arg_0: &Transform<P, O, S>) -> bool
[src]
This method tests for !=
.
impl<P: Zero, O: Zero + One, S: One> Default for Transform<P, O, S>
[src]
The default Transform
has a zero position, identity orientation and unit scale.
let a = Transform { position: Vec3::<f32>::zero(), orientation: Quaternion::<f32>::identity(), scale: Vec3::<f32>::one(), }; assert_eq!(a, Transform::default());
impl<P, O, S, Factor> Lerp<Factor> for Transform<P, O, S> where
Factor: Copy + Into<O>,
P: Lerp<Factor, Output = P>,
S: Lerp<Factor, Output = S>,
O: Lerp<O, Output = O> + Float + Sum,
[src]
Factor: Copy + Into<O>,
P: Lerp<Factor, Output = P>,
S: Lerp<Factor, Output = S>,
O: Lerp<O, Output = O> + Float + Sum,
LERP on a Transform
is defined as LERP-ing between the positions and scales,
and performing SLERP between the orientations.
type Output = Self
The resulting type after performing the LERP operation.
fn lerp_unclamped(a: Self, b: Self, t: Factor) -> Self
[src]
Returns the linear interpolation of from
to to
with factor
unconstrained, using the supposedly fastest but less precise implementation. Read more
fn lerp_unclamped_precise(a: Self, b: Self, t: Factor) -> Self
[src]
Returns the linear interpolation of from
to to
with factor
unconstrained, using a possibly slower but more precise operation. Read more
fn lerp(from: Self, to: Self, factor: Factor) -> Self::Output where
Factor: Clamp + Zero + One,
[src]
Factor: Clamp + Zero + One,
Alias to lerp_unclamped
which constrains factor
to be between 0 and 1 (inclusive). Read more
fn lerp_precise(from: Self, to: Self, factor: Factor) -> Self::Output where
Factor: Clamp + Zero + One,
[src]
Factor: Clamp + Zero + One,
Alias to lerp_unclamped_precise
which constrains factor
to be between 0 and 1 (inclusive). Read more
impl<'a, P, O, S, Factor> Lerp<Factor> for &'a Transform<P, O, S> where
Factor: Copy + Into<O>,
&'a P: Lerp<Factor, Output = P>,
&'a S: Lerp<Factor, Output = S>,
O: Lerp<O, Output = O> + Float + Sum,
[src]
Factor: Copy + Into<O>,
&'a P: Lerp<Factor, Output = P>,
&'a S: Lerp<Factor, Output = S>,
O: Lerp<O, Output = O> + Float + Sum,
LERP on a Transform
is defined as LERP-ing between the positions and scales,
and performing SLERP between the orientations.
type Output = Transform<P, O, S>
The resulting type after performing the LERP operation.
fn lerp_unclamped(a: Self, b: Self, t: Factor) -> Self::Output
[src]
Returns the linear interpolation of from
to to
with factor
unconstrained, using the supposedly fastest but less precise implementation. Read more
fn lerp_unclamped_precise(a: Self, b: Self, t: Factor) -> Self::Output
[src]
Returns the linear interpolation of from
to to
with factor
unconstrained, using a possibly slower but more precise operation. Read more
fn lerp(from: Self, to: Self, factor: Factor) -> Self::Output where
Factor: Clamp + Zero + One,
[src]
Factor: Clamp + Zero + One,
Alias to lerp_unclamped
which constrains factor
to be between 0 and 1 (inclusive). Read more
fn lerp_precise(from: Self, to: Self, factor: Factor) -> Self::Output where
Factor: Clamp + Zero + One,
[src]
Factor: Clamp + Zero + One,
Alias to lerp_unclamped_precise
which constrains factor
to be between 0 and 1 (inclusive). Read more