Struct glamour::Transform2

#[repr(transparent)]
pub struct Transform2<Src: Unit, Dst: Unit> {
    pub matrix: Matrix3<Src::Scalar>,
    /* private fields */
}

2D transform represented as a 3x3 column-major matrix.

This is a strongly typed wrapper around a Matrix3, where that matrix describes how to map between units.

Fields

matrix: Matrix3<Src::Scalar>

Underlying matrix.

Implementations

impl<Src, Dst> Transform2<Src, Dst>

where Src: Unit, Src::Scalar: FloatScalar, Dst: Unit<Scalar = Src::Scalar>,

pub const IDENTITY: Self = _

Identity matrix.

pub const fn from_matrix_unchecked(matrix: Matrix3<Src::Scalar>) -> Self

Create from matrix.

pub fn from_matrix(matrix: Matrix3<Src::Scalar>) -> Option<Self>

Create from matrix, checking if the matrix is invertible.

pub fn from_angle(angle: Angle<Src::Scalar>) -> Self

Create rotation transform.

Example

struct A;
impl Unit for A { type Scalar = f64; }
struct B;
impl Unit for B { type Scalar = f64; }

type Transform = Transform2<A, B>;

let translate = Transform::from_angle(Angle::FRAG_PI_2);
let a: Vector2<A> = Vector2 { x: 10.0, y: 20.0 };
let b: Vector2<B> = translate.map(a);
assert_abs_diff_eq!(b, vec2!(-20.0, 10.0), epsilon = 0.000001);

pub fn from_scale(scale: Vector2<Src>) -> Self

Create scaling transform.

Example

struct A;
impl Unit for A { type Scalar = f32; }
struct B;
impl Unit for B { type Scalar = f32; }

type Transform = Transform2<A, B>;

let translate = Transform::from_scale(Vector2 { x: 2.0, y: 3.0 });
let a: Vector2<A> = Vector2 { x: 10.0, y: 20.0 };
let b: Vector2<B> = translate.map(a);
assert_abs_diff_eq!(b, vec2!(20.0, 60.0));

pub fn from_translation(translation: Vector2<Src>) -> Self

Create translation transform.

Example

struct A;
impl Unit for A { type Scalar = f32; }
struct B;
impl Unit for B { type Scalar = f32; }

type Transform = Transform2<A, B>;

let translate = Transform::from_translation(Vector2 { x: 10.0, y: 20.0 });
let a: Point2<A> = Point2 { x: 1.0, y: 2.0 };
let b: Point2<B> = translate.map(a);
assert_abs_diff_eq!(b, point!(11.0, 22.0));

pub fn from_scale_angle_translation( scale: Vector2<Src>, angle: Angle<Src::Scalar>, translation: Vector2<Src> ) -> Self

Create scaling, rotation, and translation matrix.

Example

type Transform = Transform2<f32, f32>;

let a = Transform::from_scale_angle_translation(
    (2.0, 3.0).into(),
    Angle::from_degrees(90.0),
    (10.0, 20.0).into(),
);

let b = Transform::from_scale((2.0, 3.0).into())
    .then_rotate(Angle::from_degrees(90.0))
    .then_translate((10.0, 20.0).into());

assert_abs_diff_eq!(a, b);

impl<Src, Dst> Transform2<Src, Dst>

where Src: Unit, Src::Scalar: FloatScalar, Dst: Unit<Scalar = Src::Scalar>,

pub fn then<Dst2>(self, other: Transform2<Dst, Dst2>) -> Transform2<Src, Dst2>

where Dst2: Unit<Scalar = Dst::Scalar>,

Perform matrix multiplication such that other’s transformation applies after self.

This may change the target coordinate space - that is, the resulting transform takes points and vectors from Src to Dst2.

This operation is equivalent to other.matrix * self.matrix - that is, the multiplication order is the reverse of the order of the effects of the transformation.

pub fn then_rotate(self, angle: Angle<Src::Scalar>) -> Self

Shorthand for .then(Transform2::from_angle(angle)).

This does not change the target coordinate space.

pub fn then_scale(self, scale: Vector2<Dst>) -> Self

Shorthand for .then(Transform2::from_scale(scale)).

This does not change the target coordinate space.

Example

let a = Transform2::<f32, f32>::IDENTITY
    .then_scale((2.0, 3.0).into());
let b = Transform2::<f32, f32>::from_scale((2.0, 3.0).into());
assert_eq!(a, b);

pub fn then_translate(self, translation: Vector2<Dst>) -> Self

Shorthand for .then(Transform2::from_scale(scale)).

This does not change the target coordinate space.

pub fn inverse(&self) -> Transform2<Dst, Src>

Invert the matrix.

See glam::Mat3::inverse() and glam::DMat3::inverse().

Trait Implementations

impl<Src, Dst> AbsDiffEq for Transform2<Src, Dst>

where Src: Unit, Src::Scalar: FloatScalar, Dst: Unit<Scalar = Src::Scalar>,

type Epsilon = <Matrix3<<Src as Unit>::Scalar> as AbsDiffEq>::Epsilon

Used for specifying relative comparisons.

fn default_epsilon() -> Self::Epsilon

The default tolerance to use when testing values that are close together.

fn abs_diff_eq(&self, other: &Self, epsilon: Self::Epsilon) -> bool

A test for equality that uses the absolute difference to compute the approximate equality of two numbers.

fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool

The inverse of AbsDiffEq::abs_diff_eq.

impl<Src: Unit, Dst: Unit> Clone for Transform2<Src, Dst>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Src, Dst> Debug for Transform2<Src, Dst>

where Src: Unit, Src::Scalar: FloatScalar, Dst: Unit,

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

Formats the value using the given formatter.

impl<Src, Dst> Default for Transform2<Src, Dst>

where Src: Unit, Src::Scalar: FloatScalar, Dst: Unit,

fn default() -> Self

Returns the “default value” for a type.

impl<Src, Dst, Dst2> Mul<Transform2<Dst, Dst2>> for Transform2<Src, Dst>

where Src: Unit, Src::Scalar: FloatScalar, Dst: Unit<Scalar = Src::Scalar>, Dst2: Unit<Scalar = Src::Scalar>,

type Output = Transform2<Src, Dst2>

The resulting type after applying the * operator.

fn mul(self, rhs: Transform2<Dst, Dst2>) -> Self::Output

Performs the * operation.

impl<Src, Dst> PartialEq for Transform2<Src, Dst>

where Src: Unit, Dst: Unit,

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Src, Dst> RelativeEq for Transform2<Src, Dst>

where Src: Unit, Src::Scalar: FloatScalar, Dst: Unit<Scalar = Src::Scalar>,

fn default_max_relative() -> Self::Epsilon

The default relative tolerance for testing values that are far-apart.

fn relative_eq( &self, other: &Self, epsilon: Self::Epsilon, max_relative: Self::Epsilon ) -> bool

A test for equality that uses a relative comparison if the values are far apart.

fn relative_ne( &self, other: &Rhs, epsilon: Self::Epsilon, max_relative: Self::Epsilon ) -> bool

The inverse of RelativeEq::relative_eq.

impl<Src, Dst> TransformMap<Point2<Src>> for Transform2<Src, Dst>

where Src: Unit, Src::Scalar: FloatScalar, Dst: Unit<Scalar = Src::Scalar>,

type Output = Point2<Dst>

Result type of the transformation.

fn map(&self, value: Point2<Src>) -> Self::Output

Map T to Self::Output.

impl<Src, Dst> TransformMap<Vector2<Src>> for Transform2<Src, Dst>

where Src: Unit, Src::Scalar: FloatScalar, Dst: Unit<Scalar = Src::Scalar>,

type Output = Vector2<Dst>

Result type of the transformation.

fn map(&self, value: Vector2<Src>) -> Self::Output

Map T to Self::Output.

impl<Src: Unit, Dst: Unit> TransparentWrapper<Matrix3<<Src as Unit>::Scalar>> for Transform2<Src, Dst>

fn wrap(s: Inner) -> Self

where Self: Sized,

Convert the inner type into the wrapper type.

fn wrap_ref(s: &Inner) -> &Self

Convert a reference to the inner type into a reference to the wrapper type.

fn wrap_mut(s: &mut Inner) -> &mut Self

Convert a mutable reference to the inner type into a mutable reference to the wrapper type.

fn wrap_slice(s: &[Inner]) -> &[Self]

where Self: Sized,

Convert a slice to the inner type into a slice to the wrapper type.

fn wrap_slice_mut(s: &mut [Inner]) -> &mut [Self]

where Self: Sized,

Convert a mutable slice to the inner type into a mutable slice to the wrapper type.

fn peel(s: Self) -> Inner

where Self: Sized,

Convert the wrapper type into the inner type.

fn peel_ref(s: &Self) -> &Inner

Convert a reference to the wrapper type into a reference to the inner type.

fn peel_mut(s: &mut Self) -> &mut Inner

Convert a mutable reference to the wrapper type into a mutable reference to the inner type.

fn peel_slice(s: &[Self]) -> &[Inner]

where Self: Sized,

Convert a slice to the wrapped type into a slice to the inner type.

fn peel_slice_mut(s: &mut [Self]) -> &mut [Inner]

where Self: Sized,

Convert a mutable slice to the wrapped type into a mutable slice to the inner type.

impl<Src, Dst> UlpsEq for Transform2<Src, Dst>

where Src: Unit, Src::Scalar: FloatScalar, Dst: Unit<Scalar = Src::Scalar>,

fn default_max_ulps() -> u32

The default ULPs to tolerate when testing values that are far-apart.

fn ulps_eq(&self, other: &Self, epsilon: Self::Epsilon, max_ulps: u32) -> bool

A test for equality that uses units in the last place (ULP) if the values are far apart.

fn ulps_ne(&self, other: &Rhs, epsilon: Self::Epsilon, max_ulps: u32) -> bool

The inverse of UlpsEq::ulps_eq.

impl<Src: Unit, Dst: Unit> Zeroable for Transform2<Src, Dst>

fn zeroed() -> Self

Calls zeroed.

impl<Src: Unit, Dst: Unit> Copy for Transform2<Src, Dst>

impl<Src: Unit, Dst: Unit> Pod for Transform2<Src, Dst>