Struct TransformInstance 

#[repr(C)]
pub struct TransformInstance {
    pub col0: [f32; 4],
    pub col1: [f32; 4],
    pub col2: [f32; 4],
    pub col3: [f32; 4],
}

Fields

col0: [f32; 4]

col1: [f32; 4]

col2: [f32; 4]

col3: [f32; 4]

Implementations

impl InstanceTransform

pub fn identity() -> Self

pub fn translation(tx: f32, ty: f32) -> Self

Create a 2D translation transform (tx, ty) in pixels.

Each field (col0..col3) stores one column of the GPU mat4x4. Translation lives in col3.

pub fn translation3d(tx: f32, ty: f32, tz: f32) -> Self

Create a 3D translation transform (tx, ty, tz).

Translation is stored in col3.

pub fn scale(sx: f32, sy: f32) -> Self

Create a 2D scale transform with factors (sx, sy).

pub fn scale3d(sx: f32, sy: f32, sz: f32) -> Self

Create a 3D scale transform with factors (sx, sy, sz).

pub fn rotation_z(radians: f32) -> Self

Create a rotation around the Z axis by radians. Positive angles rotate counter-clockwise in screen space.

pub fn rotation_z_deg(degrees: f32) -> Self

Create a rotation around the Z axis by degrees.

pub fn affine_2d(a: f32, b: f32, c: f32, d: f32, tx: f32, ty: f32) -> Self

Create a 2D affine transform from matrix components: [ a c tx ] [ b d ty ] [ 0 0 1 ]

Stored so that col0..col3 map to GPU columns 0..3: col0=[a,b,0,0] col1=[c,d,0,0] col2=[0,0,1,0] col3=[tx,ty,0,1]

pub fn multiply(&self, rhs: &Self) -> Self

Compose two transforms so that self is applied first, then rhs.

This uses left-to-right application order (like CSS/SVG/euclid’s .then()): a.multiply(&b) means “apply a first, then b”.

Note: mathematically this computes rhs × self (not self × rhs), which is what gives us the intuitive left-to-right ordering.

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

Compose two transforms so that self is applied first, then next.

Alias for multiply that mirrors euclid’s Transform3D::then().

let composed = rotation.then(&translation); // rotate first, translate second

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

Return the 4 columns as an array.

pub fn from_cols(cols: [[f32; 4]; 4]) -> Self

Build from 4 columns.

pub fn desc<'a>() -> VertexBufferLayout<'a>

Trait Implementations

impl Clone for InstanceTransform

fn clone(&self) -> InstanceTransform

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for InstanceTransform

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

Formats the value using the given formatter.

impl Zeroable for InstanceTransform

fn zeroed() -> Self

Calls zeroed.

impl Copy for InstanceTransform

impl Pod for InstanceTransform