Struct Affine2x3 

pub struct Affine2x3 {
    pub xx: Fixed,
    pub yx: Fixed,
    pub xy: Fixed,
    pub yy: Fixed,
    pub dx: Fixed,
    pub dy: Fixed,
}

A simple Fixed 2×3 affine transformation [xx, yx; xy, yy; dx, dy] $\left[\begin{array}{cc}\mathrm{xx}& \mathrm{yx}\\ \mathrm{xy}& \mathrm{yy}\\ \mathrm{dx}& \mathrm{dy}\end{array}\right]$.

Fields

xx: Fixed

X-component of transformed X-basis vector.

yx: Fixed

Y-component of transformed X-basis vector.

xy: Fixed

X-component of transformed Y-basis vector.

yy: Fixed

Y-component of transformed Y-basis vector.

dx: Fixed

Translation in X direction.

dy: Fixed

Translation in Y direction.

Implementations

impl Affine2x3

pub const IDENTITY: Self

The identity transform [1, 0; 0, 1; 0, 0] $\left[\begin{array}{cc}1& 0\\ 0& 1\\ 0& 0\end{array}\right]$.

assert_eq!(Affine2x3::IDENTITY.to_tuple_f64(), (1.0, 0.0, 0.0, 1.0, 0.0, 0.0));

pub const fn new( xx: Fixed, yx: Fixed, xy: Fixed, yy: Fixed, dx: Fixed, dy: Fixed, ) -> Self

Creates an Affine2x3 with [xx, yx; xy, yy; dx, dy] $\left[\begin{array}{cc}\mathrm{xx}& \mathrm{yx}\\ \mathrm{xy}& \mathrm{yy}\\ \mathrm{dx}& \mathrm{dy}\end{array}\right]$.

pub const fn transform(xx: Fixed, yx: Fixed, xy: Fixed, yy: Fixed) -> Self

Creates an Affine2x3 with [xx, yx; xy, yy; 0, 0] $\left[\begin{array}{cc}\mathrm{xx}& \mathrm{yx}\\ \mathrm{xy}& \mathrm{yy}\\ 0& 0\end{array}\right]$.

pub const fn translate(dx: Fixed, dy: Fixed) -> Self

Creates an Affine2x3 with [1, 0; 0, 1; dx, dy] $\left[\begin{array}{cc}1& 0\\ 0& 1\\ \mathrm{dx}& \mathrm{dy}\end{array}\right]$.

pub const fn scale(scale: Fixed) -> Self

Creates an Affine2x3 with [scale, 0; 0, scale; 0, 0] $\left[\begin{array}{cc}\mathrm{scale}& 0\\ 0& \mathrm{scale}\\ 0& 0\end{array}\right]$.

pub const fn scale_xy(x: Fixed, y: Fixed) -> Self

Creates an Affine2x3 with [x, 0; 0, y; 0, 0] $\left[\begin{array}{cc}x& 0\\ 0& y\\ 0& 0\end{array}\right]$.

pub fn rotation(radians: f64) -> Self

Creates an Affine2x3 with [cos(θ),-sin(θ);sin(θ),cos(θ); 0, 0] $\left[\begin{array}{cc}\mathrm{cos(\theta )}& \mathrm{-sin(\theta )}\\ \mathrm{sin(\theta )}& \mathrm{cos(\theta )}\\ 0& 0\end{array}\right]$, rotating the image counter-clockwise by specified angle.

pub fn rotation_degrees(degrees: f64) -> Self

Creates an Affine2x3 with [cos(θ),-sin(θ);sin(θ),cos(θ); 0, 0] $\left[\begin{array}{cc}\mathrm{cos(\theta )}& \mathrm{-sin(\theta )}\\ \mathrm{sin(\theta )}& \mathrm{cos(\theta )}\\ 0& 0\end{array}\right]$, rotating the image counter-clockwise by specified angle.

pub const fn map(&self, x: Fixed, y: Fixed) -> (Fixed, Fixed)

Applies this Affine2x3 transformation to the point [x, y, 1] $[xy1]$:

[x,y,1]×[xx,yx; xy,yy; dx,dy]=[xx*x+xy*y+dx, yx*x+yy*y+dy] $[xy1]\times \left[\begin{array}{cc}\mathrm{xx}& \mathrm{yx}\\ \mathrm{xy}& \mathrm{yy}\\ \mathrm{dx}& \mathrm{dy}\end{array}\right]=[\mathrm{xx}*x+\mathrm{xy}*y+\mathrm{dx},\mathrm{yx}*x+\mathrm{yy}*y+\mathrm{dy}]$

Examples

use ttf_view::types::Affine2x3;

assert_eq!(Affine2x3::IDENTITY.map_f64(10.0, -10.0), (10.0, -10.0));
assert_eq!(Affine2x3::IDENTITY.map_f64(-2583.2, 1842.2), (-2583.2, 1842.2));

let rot90 = Affine2x3::rotation_degrees(90.0);
assert_eq!(rot90.map_f64(23.5, 9.8), (9.8, -23.5));

pub const fn map_f64(&self, x: f64, y: f64) -> (f64, f64)

Applies this Affine2x3 transformation to the point [x, y, 1] $[xy1]$.

pub const fn wrapping_mul(self, other: Self) -> Self

Multiplies this Affine2x3 by another, wrapping and truncating at Fixed’s bounds.

pub const fn saturating_mul(self, other: Self) -> Self

Multiplies this Affine2x3 by another, saturating at Fixed’s bounds.

pub const fn checked_mul(self, other: Self) -> Option<Self>

Multiplies this Affine2x3 by another, returning None if overflow occurs.

pub const fn from_be_bytes(bytes: [u8; 24]) -> Self

Creates an Affine2x3 from big-endian bytes.

pub const fn to_be_bytes(self) -> [u8; 24]

Returns this Affine2x3 as big-endian bytes.

pub const fn to_tuple(self) -> (Fixed, Fixed, Fixed, Fixed, Fixed, Fixed)

Returns this Affine2x3’s (xx, yx, xy, yy, dx, dy) as a tuple.

pub const fn to_tuple_f64(self) -> (f64, f64, f64, f64, f64, f64)

Returns this Affine2x3’s (xx, yx, xy, yy, dx, dy) as a tuple of f64s.

pub const fn from_array([xx, yx, xy, yy, dx, dy]: [Fixed; 6]) -> Self

Creates an Affine2x3 from a [xx, yx, xy, yy, dx, dy] array.

pub const fn to_array(self) -> [Fixed; 6]

Returns this Affine2x3’s [xx, yx, xy, yy, dx, dy] as an array.

Trait Implementations

impl Clone for Affine2x3

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Affine2x3

impl Debug for Affine2x3

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

Formats the value using the given formatter.

impl Default for Affine2x3

fn default() -> Self

Returns the “default value” for a type.

impl Eq for Affine2x3

impl Hash for Affine2x3

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Mul for Affine2x3

Performs multiplication * (panics on overflow in debug configuration).

type Output = Affine2x3

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl PartialEq for Affine2x3

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Affine2x3