Struct Affine 

pub struct Affine<const N: usize, T, A: Alignment>(/* private fields */)
where
    Length<N>: SupportedLength,
    T: Scalar;

An affine transform, which can represent translation, rotation, scaling and shear.

Affine is the generic form of:

• Affine2<T>
• Affine3<T>
• Affine2U<T>
• Affine3U<T>

Affine is generic over:

• N: Length (2, 3, or 4)
• T: Scalar type (see Scalar)
• A: Alignment (see Alignment)

Guarantees

Affine<N, T, A> represents Matrix<N, T, A> followed by Vector<N, T, A> followed by optional padding due to alignment.

Padding bytes are initialized and accept any bit-pattern. It is sound to store any bit-pattern in padding, and it is unsound to assume that padding contains valid values of T unless T accepts all bit-patterns.

• Affine<N, T, Unaligned>: has no padding, has no additional alignment.

• Affine<2, T, Aligned>: may have one padding vector, may have additional alignment.

• Affine<3, T, Aligned>: may have four padding elements if both Matrix<3, T, Aligned> and Vector<3, T, Aligned> don’t have padding, may have additional alignment.

• Affine<4, T, Aligned>: has no padding, has the alignment of Matrix<4, T, Aligned>.

Affines of scalar types with the same Scalar::Repr are guaranteed to have compatible memory layouts, unless Repr = (). They are guaranteed to have the same size and element positions, but their alignment may differ.

Types containing compatible Affine types are not guaranteed to have the same memory layout. For example, even though Affine2<f32> and Affine2<i32> have the same memory layout, Option<Affine2<f32>> and Option<Affine2<i32>> may not.

Implementations

impl<const N: usize, T, A: Alignment> Affine<N, T, A>

where Length<N>: SupportedLength, T: Scalar,

pub const fn from_mat(mat: Matrix<N, T, A>) -> Self

where T: Zero,

Creates an affine transform from a matrix, expressing scale, rotation and shear.

pub const fn from_translation(translation: Vector<N, T, A>) -> Self

where T: Zero + One,

Creates an affine transform from a translation vector.

pub const fn from_mat_translation( mat: Matrix<N, T, A>, translation: Vector<N, T, A>, ) -> Self

Creates an affine transform from a translation vector and a matrix, expressing scale, rotation and shear.

pub const fn to_alignment<A2: Alignment>(&self) -> Affine<N, T, A2>

Converts the affine to the specified alignment.

See Alignment for more information.

pub const fn align(&self) -> Affine<N, T, Aligned>

Converts the affine to Aligned alignment.

See Alignment for more information.

pub const fn unalign(&self) -> Affine<N, T, Unaligned>

Converts the affine to Unaligned alignment.

See Alignment for more information.

impl<T, A: Alignment> Affine<2, T, A>

where T: Scalar,

pub const fn from_cols( x_axis: Vector<2, T, A>, y_axis: Vector<2, T, A>, z_axis: Vector<2, T, A>, ) -> Self

Creates a 2D affine transform from three column vectors.

pub const fn from_col_array(array: &[Vector<2, T, A>; 3]) -> Self

Creates a 2D affine transform from three column vectors.

pub const fn to_col_array(&self) -> [Vector<2, T, A>; 3]

Converts the affine transform to three column vectors.

pub const fn as_col_array_ref(&self) -> &[Vector<2, T, A>; 3]

Returns a reference to the affine transform’s columns.

pub const fn as_col_array_mut(&mut self) -> &mut [Vector<2, T, A>; 3]

Returns a mutable reference to the affine transform’s columns.

impl<T, A: Alignment> Affine<3, T, A>

where T: Scalar,

pub const fn from_cols( x_axis: Vector<3, T, A>, y_axis: Vector<3, T, A>, z_axis: Vector<3, T, A>, w_axis: Vector<3, T, A>, ) -> Self

Creates a 3D affine transform from four column vectors.

pub const fn from_col_array(array: &[Vector<3, T, A>; 4]) -> Self

Creates a 3D affine transform from four column vectors.

pub const fn to_col_array(&self) -> [Vector<3, T, A>; 4]

Converts the affine transform to four column vectors.

pub const fn as_col_array_ref(&self) -> &[Vector<3, T, A>; 4]

Returns a reference to the affine transform’s columns.

pub const fn as_col_array_mut(&mut self) -> &mut [Vector<3, T, A>; 4]

Returns a mutable reference to the affine transform’s columns.

impl<T, A: Alignment> Affine<4, T, A>

where T: Scalar,

pub const fn from_cols( x_axis: Vector<4, T, A>, y_axis: Vector<4, T, A>, z_axis: Vector<4, T, A>, w_axis: Vector<4, T, A>, fifth_axis: Vector<4, T, A>, ) -> Self

Creates a 4D affine transform from five column vectors.

pub const fn from_col_array(array: &[Vector<4, T, A>; 5]) -> Self

Creates a 4D affine transform from five column vectors.

pub const fn to_col_array(&self) -> [Vector<4, T, A>; 5]

Converts the affine transform to five column vectors.

pub const fn as_col_array_ref(&self) -> &[Vector<4, T, A>; 5]

Returns a reference to the affine transform’s columns.

pub const fn as_col_array_mut(&mut self) -> &mut [Vector<4, T, A>; 5]

Returns a mutable reference to the affine transform’s columns.

impl<const N: usize, T, A: Alignment> Affine<N, T, A>

where Length<N>: SupportedLength, T: Scalar + Zero,

pub const ZERO: Self

All zeros.

Transforms any finite vector to zero.

impl<const N: usize, T, A: Alignment> Affine<N, T, A>

where Length<N>: SupportedLength, T: Scalar + Zero + One,

pub const IDENTITY: Self

The identity transform.

Corresponds to no transformation.

impl<const N: usize, T, A: Alignment> Affine<N, T, A>

where Length<N>: SupportedLength, T: Scalar + Nan,

pub const NAN: Self

All NaN (Not a Number).

Trait Implementations

impl<const N: usize, T, A: Alignment> Clone for Affine<N, T, A>

where Length<N>: SupportedLength, T: Scalar,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const N: usize, T, A: Alignment> Debug for Affine<N, T, A>

where Length<N>: SupportedLength, T: Scalar + Debug,

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

Formats the value using the given formatter.

impl<const N: usize, T, A: Alignment> Deref for Affine<N, T, A>

where Length<N>: SupportedLength, T: Scalar,

type Target = AffineDeref<N, T, A>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<const N: usize, T, A: Alignment> DerefMut for Affine<N, T, A>

where Length<N>: SupportedLength, T: Scalar,

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<const N: usize, T, A: Alignment> Display for Affine<N, T, A>

where Length<N>: SupportedLength, T: Scalar + Display,

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

Formats the value using the given formatter.

impl<const N: usize, T, A: Alignment> PartialEq for Affine<N, T, A>

where Length<N>: SupportedLength, T: Scalar + PartialEq,

fn eq(&self, other: &Self) -> bool

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

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

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

impl<const N: usize, T, A: Alignment> Copy for Affine<N, T, A>

where Length<N>: SupportedLength, T: Scalar,

impl<const N: usize, T, A: Alignment> Eq for Affine<N, T, A>

where Length<N>: SupportedLength, T: Scalar + Eq,

impl<const N: usize, T, A: Alignment> RefUnwindSafe for Affine<N, T, A>

where Length<N>: SupportedLength, T: Scalar + RefUnwindSafe,

impl<const N: usize, T, A: Alignment> Send for Affine<N, T, A>

where Length<N>: SupportedLength, T: Scalar + Send,

impl<const N: usize, T, A: Alignment> Sync for Affine<N, T, A>

where Length<N>: SupportedLength, T: Scalar + Sync,

impl<const N: usize, T, A: Alignment> Unpin for Affine<N, T, A>

where Length<N>: SupportedLength, T: Scalar + Unpin,

impl<const N: usize, T, A: Alignment> UnwindSafe for Affine<N, T, A>

where Length<N>: SupportedLength, T: Scalar + UnwindSafe,