Struct Transform2D 

pub struct Transform2D {
    pub a: f32,
    pub b: f32,
    pub c: f32,
    pub d: f32,
    pub tx: f32,
    pub ty: f32,
}

A 2D affine transform in logical pixels.

Matrix form (applied to column vectors):

| a  c  tx |
| b  d  ty |
| 0  0  1  |

So:

• x' = a*x + c*y + tx
• y' = b*x + d*y + ty

Fields

a: f32

b: f32

c: f32

d: f32

tx: f32

ty: f32

Implementations

impl Transform2D

pub const IDENTITY: Self

pub const fn translation(delta: Point) -> Self

pub const fn scale_uniform(s: f32) -> Self

pub fn rotation_radians(theta: f32) -> Self

pub fn rotation_degrees(degrees: f32) -> Self

pub fn rotation_about_radians(theta: f32, center: Point) -> Self

pub fn rotation_about_degrees(degrees: f32, center: Point) -> Self

pub fn compose(self, rhs: Self) -> Self

Matrix composition: self * rhs.

This means: apply rhs first, then self.

pub fn apply_point(self, p: Point) -> Point

pub fn inverse(self) -> Option<Self>

pub fn to_physical_px(self, scale_factor: f32) -> Self

Converts a logical-px transform to a physical-px transform.

If you already have coordinates multiplied by scale_factor, apply the returned transform directly in physical pixels.

pub fn as_translation_uniform_scale(self) -> Option<(f32, Point)>

Returns (scale, translation) if this is a translation + uniform scale transform.

Trait Implementations

impl Clone for Transform2D

fn clone(&self) -> Transform2D

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Transform2D

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

Formats the value using the given formatter.

impl Default for Transform2D

fn default() -> Self

Returns the “default value” for a type.

impl Mul for Transform2D

type Output = Transform2D

The resulting type after applying the * operator.

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

Performs the * operation.

impl MulAssign for Transform2D

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl PartialEq for Transform2D

fn eq(&self, other: &Transform2D) -> 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 Copy for Transform2D

impl StructuralPartialEq for Transform2D