Struct Transform 

pub struct Transform {
    pub translate_x: f32,
    pub translate_y: f32,
    pub scale_x: f32,
    pub scale_y: f32,
    pub rotate: f32,
    pub shear_x: f32,
    pub shear_y: f32,
    pub origin_x: f32,
    pub origin_y: f32,
}

Fields

translate_x: f32

translate_y: f32

scale_x: f32

scale_y: f32

rotate: f32

shear_x: f32

Horizontal shear factor (x += shear_x * y), e.g. ASS \fax.

shear_y: f32

Vertical shear factor (y += shear_y * x), e.g. ASS \fay.

origin_x: f32

origin_y: f32

Implementations

impl Transform

pub fn identity() -> Self

pub fn translate(x: f32, y: f32) -> Self

pub fn linear(&self) -> [f32; 4]

Forward 2x2 linear part (row-major [m00, m01, m10, m11]): M = R(rotate) * H(shear) * S(scale) applied before translation.

pub fn inverse_linear(&self) -> Option<[f32; 4]>

Inverse of linear, or None when singular.

pub fn linear_is_identity(&self) -> bool

Whether scale/rotation/shear are all identity (translation may apply).

pub fn apply_to_point(&self, p: Vec2) -> Vec2

pub fn apply_to_rect(&self, r: Rect) -> Rect

pub fn combine(&self, other: &Transform) -> Transform

Compose two transforms (self outer, other inner) for a transform stack: current.combine(pushed) where pushed is the newly pushed (inner) node.

Returns a transform such that combined.apply_to_point(p) == self.apply_to_point(other.apply_to_point(p)).

The linear part is composed exactly (via polar decomposition of the 2x2 product); origins are inherited from self, matching the previous behaviour for the shear-free cases.

Trait Implementations

impl Clone for Transform

fn clone(&self) -> Transform

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Transform

impl Debug for Transform

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

Formats the value using the given formatter.

impl Default for Transform

fn default() -> Transform

Returns the “default value” for a type.

impl PartialEq for Transform

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Transform