Struct TransformationUniform 

pub struct TransformationUniform<F, Q>
where
    F: Float,
    Q: Quaternion<F>,
    FArray<F, 3>: Vector3<F>,
{ /* private fields */ }

A transformation that is a translation . rotation . scaling (i.e. it applies a scaling to an object, then the rotation then translates it)

This supports only a uniform scaling

Trait Implementations

impl<F, Q> Clone for TransformationUniform<F, Q>

where F: Float + Clone, Q: Quaternion<F> + Clone, FArray<F, 3>: Vector3<F>,

fn clone(&self) -> TransformationUniform<F, Q>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<F, Q> Copy for TransformationUniform<F, Q>

where F: Float + Copy, Q: Quaternion<F> + Copy, FArray<F, 3>: Vector3<F>,

impl<F, Q> Debug for TransformationUniform<F, Q>

where F: Float + Debug, Q: Quaternion<F> + Debug, FArray<F, 3>: Vector3<F>,

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

Formats the value using the given formatter.

impl<F, Q> Default for TransformationUniform<F, Q>

where F: Float, Q: Quaternion<F>, FArray<F, 3>: Vector3<F>, FArray<F, 4>: Vector4<F>,

fn default() -> Self

Returns the “default value” for a type.

impl<'de, F, Q> Deserialize<'de> for TransformationUniform<F, Q>

where F: Float + Deserialize<'de> + Serialize, Q: Quaternion<F> + Deserialize<'de> + Serialize, FArray<F, 3>: Vector3<F> + DeserializeOwned + Serialize, FArray<F, 4>: Vector4<F>,

Available on crate feature serde only.

fn deserialize<DE>(deserializer: DE) -> Result<Self, DE::Error>

where DE: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<F, Q> Display for TransformationUniform<F, Q>

where F: Float, Q: Quaternion<F>, FArray<F, 3>: Vector3<F>, FArray<F, 4>: Vector4<F>,

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

Formats the value using the given formatter.

impl<F, Q> Div<F> for TransformationUniform<F, Q>

where F: Float, Q: Quaternion<F>, FArray<F, 3>: Vector3<F>,

type Output = TransformationUniform<F, Q>

The resulting type after applying the / operator.

fn div(self, f: F) -> Self::Output

Performs the / operation.

impl<F, Q> DivAssign<F> for TransformationUniform<F, Q>

where F: Float, Q: Quaternion<F>, FArray<F, 3>: Vector3<F>,

fn div_assign(&mut self, f: F)

Performs the /= operation.

impl<F, Q> Mul<F> for TransformationUniform<F, Q>

where F: Float, Q: Quaternion<F>, FArray<F, 3>: Vector3<F>,

type Output = TransformationUniform<F, Q>

The resulting type after applying the * operator.

fn mul(self, f: F) -> Self::Output

Performs the * operation.

impl<F, Q> Mul<FArray<F, 4>> for TransformationUniform<F, Q>

where F: Float, Q: Quaternion<F>, FArray<F, 3>: Vector3<F>, FArray<F, 4>: Vector4<F>,

type Output = FArray<F, 4>

The resulting type after applying the * operator.

fn mul(self, v: FArray<F, 4>) -> Self::Output

Performs the * operation.

impl<F, Q> MulAssign<F> for TransformationUniform<F, Q>

where F: Float, Q: Quaternion<F>, FArray<F, 3>: Vector3<F>,

fn mul_assign(&mut self, f: F)

Performs the *= operation.

impl<F, Q> PartialEq for TransformationUniform<F, Q>

where F: Float + PartialEq, Q: Quaternion<F> + PartialEq, FArray<F, 3>: Vector3<F>,

fn eq(&self, other: &TransformationUniform<F, Q>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<F, Q> Serialize for TransformationUniform<F, Q>

where F: Float + for<'de> Deserialize<'de> + Serialize, Q: Quaternion<F> + for<'de> Deserialize<'de> + Serialize, FArray<F, 3>: Vector3<F> + DeserializeOwned + Serialize, FArray<F, 4>: Vector4<F> + Serialize,

Available on crate feature serde only.

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<F, Q> StructuralPartialEq for TransformationUniform<F, Q>

where F: Float, Q: Quaternion<F>, FArray<F, 3>: Vector3<F>,

impl<F, Q> Transform<F> for TransformationUniform<F, Q>

where F: Float, Q: Quaternion<F>, FArray<F, 3>: Vector3<F>, FArray<F, 4>: Vector4<F>,

const UNIFORM_SCALING: bool = true

Set to true if the transformation can only perform uniform scaling

type Vec3 = FArray<F, 3>

Type of vector comprehended as the translation/scaling for this transform

type Vec4 = FArray<F, 4>

Type of vector comprehended as the translation/scaling for this transform

type Quat = Q

Type of quaternion comprehended as the rotation for this transform

fn of_trs<A: AsRef<[F; 3]>>(t: A, r: Q, s: A) -> Option<Self>

Create a transformation that is a translation, rotation and scaling

fn of_trsu<A: AsRef<[F; 3]>>(t: A, r: Q, s: F) -> Self

Create a transformation that is a translation, rotation and uniform scaling

fn is_uniform_scale(&self) -> bool

Returns true if the scaling is uniform in each axis

fn scale(&self) -> Option<Self::Vec3>

Get the scale of the transform in each of the axes

fn uniform_scale(&self) -> Option<F>

Get the scale of the transform in each of the axes, if possible

fn translation(&self) -> Self::Vec3

Get a translation by a vector

fn rotation(&self) -> Option<Q>

Get the rotation of the transformation, if possible

fn set_identity(&mut self)

Set to an identity transformation

fn set_scale<A: AsRef<[F; 3]>>(&mut self, scale: A) -> bool

Set the scale of the transformation

fn set_uniform_scale(&mut self, scale: F)

Set the scale of the transformation

fn set_translation<A: AsRef<[F; 3]>>(&mut self, translation: A)

Set the translation of the transformation

fn set_rotation(&mut self, rotation: Q)

Set the rotation of a transformation

fn scale_uniform_by(&mut self, scale: F)

Pre-apply a uniform scaling

fn scale_by<A: AsRef<[F; 3]>>(&mut self, scale: A) -> bool

Pre-apply a nonuniform scaling

fn translate_by<A: AsRef<[F; 3]>>(&mut self, translation: A, scale: F)

Pre-apply a scaled translation to the transformation

fn rotate_by(&mut self, quaternion: &Q)

Rotate the transformation by a quaternion

fn transform_by<T: Transform<F, Quat = Self::Quat>>( &mut self, transformer: &T, ) -> bool

Transform this transformation by another UNIFORM scale transformation; if is not uniform scaling then return false

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

Get the inverse transformation

fn apply3_arr(&self, other: &[F; 3]) -> [F; 3]

Apply the transformation to a [F; 4]

fn apply4_arr(&self, other: &[F; 4]) -> [F; 4]

Apply the transformation to a [F; 4]

fn as_mat3<M: SqMatrix3<F>>(&self) -> M

Convert the non-translation to a 3-by-3 matrix

fn as_mat4<M: SqMatrix4<F>>(&self) -> M

Convert it to a 4-by-4 matrix

fn set_inverse(&mut self) -> bool

Invert the transformation

fn set_mat4<M: SqMatrix4<F>>(&self, mat4: &mut M)

Convert it to a 4-by-4 matrix and set it

fn set_mat3<M: SqMatrix3<F>>(&self, mat3: &mut M)

Convert it to a 4-by-4 matrix and set it

fn apply3<T>(&self, other: T) -> T

where T: Deref<Target = [F; 3]> + From<[F; 3]>,

Apply the quaternion to a vector or similar

fn apply4<T>(&self, other: T) -> T

where T: Deref<Target = [F; 4]> + From<[F; 4]>,

Apply the transformation to a vector or similar