Struct Transform 

#[repr(C)]
pub struct Transform {
    pub angle: f32,
    pub scale: f32,
    pub tx: f32,
    pub ty: f32,
}

A similarity transform — a turn and a uniform scale about the origin, then a move: p' = R(angle) · scale · p + t, y down, so a positive angle turns clockwise on screen. What a node’s rotate, scale and pivot compose to (ADR 0043), carried by the clip entry its quads name (display::Clip::transform) in the same units as the entry’s rect.

#[repr(C)]: four floats, which is how KuiClip and the Node clips() buffer read it.

use kui_core::{Rect, Transform, Vec2};
// A quarter turn about the centre of a 100 × 50 box at (10, 10).
let t = Transform::about(Vec2::new(60.0, 35.0), 0.25, 1.0);
let p = t.apply(Vec2::new(10.0, 10.0));
assert!((p.x - 85.0).abs() < 1e-4 && (p.y - (-15.0)).abs() < 1e-4);
let back = t.unapply(p);
assert!((back.x - 10.0).abs() < 1e-4 && (back.y - 10.0).abs() < 1e-4);
// Its bounding box is the box turned: 50 wide, 100 tall, same centre.
let b = t.bounds(Rect::new(10.0, 10.0, 100.0, 50.0));
assert!((b.w - 50.0).abs() < 1e-3 && (b.h - 100.0).abs() < 1e-3);

Fields

angle: f32

Radians, clockwise with y down.

scale: f32

The uniform factor; 1 for none.

tx: f32

The move after the turn and the scale.

ty: f32

Implementations

impl Transform

pub const IDENTITY: Transform

No turn, no scale, no move.

pub fn about(pivot: Vec2, turns: f32, scale: f32) -> Transform

A turn of turns (clockwise, y down) and a scale of scale about pivot, which stays where it is.

pub fn is_identity(&self) -> bool

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

p through this transform.

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

The point that maps to p: the inverse. A scale of zero has no inverse; the answer is then NaN, which no rect contains, so nothing is hit, as nothing is drawn.

pub fn then(&self, outer: &Transform) -> Transform

This transform, then outer: the composition a nested turn is (inner.then(outer) maps a point as outer.apply(inner.apply(p))).

pub fn scaled(&self, s: f32) -> Transform

Logical to physical pixels: the move scales, the turn and the factor do not.

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

The smallest axis-aligned rect holding r put through this transform: what an access rect and a cull read.

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

The bounding box of r pulled back through this transform: the rect in this transform’s source space that covers everything of r in its target space — how a clip from outside a turn is approximated inside it (ADR 0043, decision 4).

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<(), Error>

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