Struct emath::ts_transform::TSTransform

#[repr(C)]
pub struct TSTransform {
    pub scaling: f32,
    pub translation: Vec2,
}

Linearly transforms positions via a translation, then a scaling.

TSTransform first scales points with the scaling origin at 0, 0 (the top left corner), then translates them.

Fields

scaling: f32

Scaling applied first, scaled around (0, 0).

translation: Vec2

Translation amount, applied after scaling.

Implementations

impl TSTransform

pub const IDENTITY: Self = _

pub fn new(translation: Vec2, scaling: f32) -> Self

Creates a new translation that first scales points around (0, 0), then translates them.

pub fn from_translation(translation: Vec2) -> Self

pub fn from_scaling(scaling: f32) -> Self

pub fn inverse(&self) -> Self

Inverts the transform.

let p1 = pos2(2.0, 3.0);
let p2 = pos2(12.0, 5.0);
let ts = TSTransform::new(vec2(2.0, 3.0), 2.0);
let inv = ts.inverse();
assert_eq!(inv.mul_pos(p1), pos2(0.0, 0.0));
assert_eq!(inv.mul_pos(p2), pos2(5.0, 1.0));

assert_eq!(ts.inverse().inverse(), ts);

pub fn mul_pos(&self, pos: Pos2) -> Pos2

Transforms the given coordinate.

let p1 = pos2(0.0, 0.0);
let p2 = pos2(5.0, 1.0);
let ts = TSTransform::new(vec2(2.0, 3.0), 2.0);
assert_eq!(ts.mul_pos(p1), pos2(2.0, 3.0));
assert_eq!(ts.mul_pos(p2), pos2(12.0, 5.0));

pub fn mul_rect(&self, rect: Rect) -> Rect

Transforms the given rectangle.

let rect = Rect::from_min_max(pos2(5.0, 5.0), pos2(15.0, 10.0));
let ts = TSTransform::new(vec2(1.0, 0.0), 3.0);
let transformed = ts.mul_rect(rect);
assert_eq!(transformed.min, pos2(16.0, 15.0));
assert_eq!(transformed.max, pos2(46.0, 30.0));

Trait Implementations

impl Clone for TSTransform

fn clone(&self) -> TSTransform

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for TSTransform

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

Formats the value using the given formatter.

impl Default for TSTransform

fn default() -> Self

Returns the “default value” for a type.

impl Mul<Pos2> for TSTransform

Transforms the position.

type Output = Pos2

The resulting type after applying the * operator.

fn mul(self, pos: Pos2) -> Pos2

Performs the * operation.

impl Mul<Rect> for TSTransform

Transforms the rectangle.

type Output = Rect

The resulting type after applying the * operator.

fn mul(self, rect: Rect) -> Rect

Performs the * operation.

impl Mul for TSTransform

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

Applies the right hand side transform, then the left hand side.

let ts1 = TSTransform::new(vec2(1.0, 0.0), 2.0);
let ts2 = TSTransform::new(vec2(-1.0, -1.0), 3.0);
let ts_combined = TSTransform::new(vec2(2.0, -1.0), 6.0);
assert_eq!(ts_combined, ts2 * ts1);

type Output = TSTransform

The resulting type after applying the * operator.

impl PartialEq for TSTransform

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

fn zeroed() -> Self

Calls zeroed.

impl Copy for TSTransform

impl Eq for TSTransform

impl Pod for TSTransform

impl StructuralPartialEq for TSTransform