Struct nannou::prelude::DAffine2

pub struct DAffine2 {
    pub matrix2: DMat2,
    pub translation: DVec2,
}

A 2D affine transform, which can represent translation, rotation, scaling and shear.

Fields

matrix2: DMat2

translation: DVec2

Implementations

impl DAffine2

pub const ZERO: DAffine2 = _

The degenerate zero transform.

This transforms any finite vector and point to zero. The zero transform is non-invertible.

pub const IDENTITY: DAffine2 = _

The identity transform.

Multiplying a vector with this returns the same vector.

pub fn from_cols(x_axis: DVec2, y_axis: DVec2, z_axis: DVec2) -> DAffine2

Creates an affine transform from three column vectors.

pub fn from_cols_array(m: &[f64; 6]) -> DAffine2

Creates an affine transform from a [S; 6] array stored in column major order. If your data is stored in row major you will need to transpose the returned matrix.

pub fn to_cols_array(&self) -> [f64; 6]

Creates a [S; 6] array storing data in column major order. If you require data in row major order transpose the matrix first.

pub fn from_cols_array_2d(m: &[[f64; 2]; 3]) -> DAffine2

Creates an affine transform from a [[S; 2]; 3] 2D array stored in column major order. If your data is in row major order you will need to transpose the returned matrix.

pub fn to_cols_array_2d(&self) -> [[f64; 2]; 3]

Creates a [[S; 2]; 3] 2D array storing data in column major order. If you require data in row major order transpose the matrix first.

pub fn from_cols_slice(slice: &[f64]) -> DAffine2

Creates an affine transform from the first 6 values in slice.

Panics

Panics if slice is less than 6 elements long.

pub fn write_cols_to_slice(self, slice: &mut [f64])

Writes the columns of self to the first 12 elements in slice.

Panics

Panics if slice is less than 12 elements long.

pub fn from_scale(scale: DVec2) -> DAffine2

Creates an affine transform that changes scale. Note that if any scale is zero the transform will be non-invertible.

pub fn from_angle(angle: f64) -> DAffine2

Creates an affine transform from the given rotation angle.

pub fn from_translation(translation: DVec2) -> DAffine2

Creates an affine transformation from the given 2D translation.

pub fn from_mat2(matrix2: DMat2) -> DAffine2

Creates an affine transform from a 2x2 matrix (expressing scale, shear and rotation)

pub fn from_mat2_translation(matrix2: DMat2, translation: DVec2) -> DAffine2

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

Equivalent to Affine2::from_translation(translation) * Affine2::from_mat2(mat2)

pub fn from_scale_angle_translation( scale: DVec2, angle: f64, translation: DVec2 ) -> DAffine2

Creates an affine transform from the given 2D scale, rotation angle (in radians) and translation.

Equivalent to Affine2::from_translation(translation) * Affine2::from_angle(angle) * Affine2::from_scale(scale)

pub fn from_angle_translation(angle: f64, translation: DVec2) -> DAffine2

Creates an affine transform from the given 2D rotation angle (in radians) and translation.

Equivalent to Affine2::from_translation(translation) * Affine2::from_angle(angle)

pub fn from_mat3(m: DMat3) -> DAffine2

The given Mat3 must be an affine transform,

pub fn transform_point2(&self, other: DVec2) -> DVec2

Transforms the given 2D point, applying shear, scale, rotation and translation.

pub fn transform_vector2(&self, other: DVec2) -> DVec2

Transforms the given 2D vector, applying shear, scale and rotation (but NOT translation).

To also apply translation, use Self::transform_point2 instead.

pub fn is_finite(&self) -> bool

Returns true if, and only if, all elements are finite.

If any element is either NaN, positive or negative infinity, this will return false.

pub fn is_nan(&self) -> bool

Returns true if any elements are NaN.

pub fn abs_diff_eq(&self, other: DAffine2, max_abs_diff: f64) -> bool

Returns true if the absolute difference of all elements between self and other is less than or equal to max_abs_diff.

This can be used to compare if two 3x4 matrices contain similar elements. It works best when comparing with a known value. The max_abs_diff that should be used used depends on the values being compared against.

For more see comparing floating point numbers.

pub fn inverse(&self) -> DAffine2

Return the inverse of this transform.

Note that if the transform is not invertible the result will be invalid.

Trait Implementations

impl Add for DAffine2

type Output = DAffine2

The resulting type after applying the + operator.

fn add(self, other: DAffine2) -> <DAffine2 as Add>::Output

Performs the + operation.

impl Clone for DAffine2

fn clone(&self) -> DAffine2

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for DAffine2

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

Formats the value using the given formatter.

impl Default for DAffine2

fn default() -> DAffine2

Returns the “default value” for a type.

impl Deref for DAffine2

type Target = Columns3<DVec2>

The resulting type after dereferencing.

fn deref(&self) -> &<DAffine2 as Deref>::Target

Dereferences the value.

impl DerefMut for DAffine2

fn deref_mut(&mut self) -> &mut <DAffine2 as Deref>::Target

Mutably dereferences the value.

impl<'de> Deserialize<'de> for DAffine2

fn deserialize<D>( deserializer: D ) -> Result<DAffine2, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for DAffine2

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

Formats the value using the given formatter.

impl From<DAffine2> for DMat3

fn from(m: DAffine2) -> DMat3

Converts to this type from the input type.

impl Mul<DAffine2> for DMat3

type Output = DMat3

The resulting type after applying the * operator.

fn mul(self, other: DAffine2) -> <DMat3 as Mul<DAffine2>>::Output

Performs the * operation.

impl Mul<DMat3> for DAffine2

type Output = DMat3

The resulting type after applying the * operator.

fn mul(self, other: DMat3) -> <DAffine2 as Mul<DMat3>>::Output

Performs the * operation.

impl Mul<f64> for DAffine2

type Output = DAffine2

The resulting type after applying the * operator.

fn mul(self, other: f64) -> <DAffine2 as Mul<f64>>::Output

Performs the * operation.

impl Mul for DAffine2

type Output = DAffine2

The resulting type after applying the * operator.

fn mul(self, other: DAffine2) -> <DAffine2 as Mul>::Output

Performs the * operation.

impl PartialEq for DAffine2

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<'a> Product<&'a DAffine2> for DAffine2

fn product<I>(iter: I) -> DAffine2

where I: Iterator<Item = &'a DAffine2>,

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl Serialize for DAffine2

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Sub for DAffine2

type Output = DAffine2

The resulting type after applying the - operator.

fn sub(self, other: DAffine2) -> <DAffine2 as Sub>::Output

Performs the - operation.

impl Copy for DAffine2