Struct ComputedTransform3D 

#[repr(C)]
pub struct ComputedTransform3D {
    pub m: [[f32; 4]; 4],
}

A computed 4x4 transformation matrix in pixel space.

Represents the final transformation matrix for a DOM element after applying all CSS transform functions (translate, rotate, scale, etc.) and accounting for transform-origin.

Memory Layout

Matrix is stored in row-major format:

m[0] = [m11, m12, m13, m14]
m[1] = [m21, m22, m23, m24]
m[2] = [m31, m32, m33, m34]
m[3] = [m41, m42, m43, m44]

Fields

m: [[f32; 4]; 4]

The 4x4 matrix in row-major format

Implementations

impl ComputedTransform3D

pub const IDENTITY: Self

The identity matrix (no transformation).

pub const fn new( m11: f32, m12: f32, m13: f32, m14: f32, m21: f32, m22: f32, m23: f32, m24: f32, m31: f32, m32: f32, m33: f32, m34: f32, m41: f32, m42: f32, m43: f32, m44: f32, ) -> Self

Creates a new 4x4 transformation matrix with the given elements.

Elements are specified in row-major order (m11, m12, …, m44).

pub const fn new_2d( m11: f32, m12: f32, m21: f32, m22: f32, m41: f32, m42: f32, ) -> Self

Creates a 2D transformation matrix (3D matrix with Z = 0).

This is equivalent to the CSS matrix() function. The transformation only affects the X and Y axes.

Corresponds to matrix(m11, m12, m21, m22, m41, m42) in CSS.

pub fn inverse(&self) -> Self

Computes the inverse of this transformation matrix.

This function uses a standard matrix inversion algorithm. Returns the identity matrix if the determinant is zero (singular matrix).

NOTE: This is a relatively expensive operation.

pub fn from_style_transform_vec( t_vec: &[StyleTransform], transform_origin: &StyleTransformOrigin, percent_resolve_x: f32, percent_resolve_y: f32, rotation_mode: RotationMode, ) -> Self

pub fn from_style_transform( t: &StyleTransform, transform_origin: &StyleTransformOrigin, percent_resolve_x: f32, percent_resolve_y: f32, rotation_mode: RotationMode, ) -> Self

Creates a new transform from a style transform using the parent width as a way to resolve for percentages

pub const fn new_scale(x: f32, y: f32, z: f32) -> Self

pub const fn new_translation(x: f32, y: f32, z: f32) -> Self

pub fn new_perspective(d: f32) -> Self

pub fn new_rotation(x: f32, y: f32, z: f32, theta_radians: f32) -> Self

Create a 3d rotation transform from an angle / axis. The supplied axis must be normalized.

pub fn new_skew(alpha: f32, beta: f32) -> Self

pub fn get_column_major(&self) -> Self

pub fn transform_point2d(&self, p: LogicalPosition) -> Option<LogicalPosition>

pub fn scale_for_dpi(&mut self, scale_factor: f32)

pub fn then(&self, other: &Self) -> Self

Computes the sum of two matrices while applying other AFTER the current matrix.

pub unsafe fn then_sse(&self, other: &Self) -> Self

pub unsafe fn linear_combine_avx8( a01: __m256, b: &ComputedTransform3D, ) -> __m256

pub unsafe fn then_avx8(&self, other: &Self) -> Self

pub fn make_rotation( rotation_origin: (f32, f32), degrees: f32, axis_x: f32, axis_y: f32, axis_z: f32, rotation_mode: RotationMode, ) -> Self

Trait Implementations

impl Clone for ComputedTransform3D

fn clone(&self) -> ComputedTransform3D

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ComputedTransform3D

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

Formats the value using the given formatter.

impl PartialEq for ComputedTransform3D

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

fn partial_cmp(&self, other: &ComputedTransform3D) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Copy for ComputedTransform3D

impl StructuralPartialEq for ComputedTransform3D