Struct Transform2 

pub struct Transform2<WFrom = Generic, WTo = WFrom> {
    pub m: [f64; 6],
    /* private fields */
}

A 2D affine transform between two phantom coordinate spaces.

Fields

m: [f64; 6]

Affine matrix coefficients in kurbo-compatible [a, b, c, d, e, f] order.

Implementations

impl<WFrom, WTo> Transform2<WFrom, WTo>

where WFrom: Space, WTo: Space,

pub fn new(m: [f64; 6]) -> Transform2<WFrom, WTo>

Constructs a transform from raw affine coefficients.

pub fn identity() -> Transform2<WFrom, WTo>

Returns the identity transform.

pub fn scale(s: f64) -> Transform2<WFrom, WTo>

Constructs a uniform scale transform.

pub fn scale_sep(s: Vector2<WTo>) -> Transform2<WFrom, WTo>

Constructs a non-uniform scale transform.

pub fn skew(k: Vector2<WTo>) -> Transform2<WFrom, WTo>

Constructs a skew transform.

pub fn rotate(th: f64) -> Transform2<WFrom, WTo>

Constructs a rotation transform, in radians.

pub fn translate(p: Vector2<WTo>) -> Transform2<WFrom, WTo>

Constructs a translation transform.

pub fn determinant(self) -> f64

Returns the affine determinant.

pub fn coeffs(&self) -> [f64; 6]

Returns raw affine coefficients in kurbo-compatible [a, b, c, d, e, f] order.

pub fn get_translation(self) -> Vector2<WFrom>

Extracts the translation component as a vector.

pub fn get_scale(self) -> Vector2<WTo>

Returns the transformed unit scale vector.

pub fn cast_spaces<W, T>(self) -> Transform2<W, T>

where W: Space, T: Space,

Casts the phantom coordinate spaces without changing coefficients.

pub fn inverse(self) -> Transform2<WTo, WFrom>

Produces NaN values when the determinant is zero.

pub fn compose( p: Point2<WTo>, vx: Vector2<WTo>, vy: Vector2<WTo>, ) -> Transform2<WFrom, WTo>

Composes a transform from origin and basis vectors.

pub fn decompose(&self) -> (Point2<WTo>, Vector2<WTo>, Vector2<WTo>)

Decomposes the transform into origin and transformed basis vectors.

pub fn contains_point(&self, point: Point2<WTo>) -> bool

Returns true when point lands inside the transformed unit square.

Trait Implementations

impl<F, T> Clone for Transform2<F, T>

fn clone(&self) -> Transform2<F, T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl CoercionRules for Transform2

fn try_coerce(value: PaxValue) -> Result<Transform2, String>

Attempts to coerce value into Self.

fn allows_singleton_stack() -> bool

Opts appearance layers into scalar-to-singleton stack conversion. Ordinary vector values remain list-only.

fn is_identity_roundtrip() -> bool

Whether cloning Self preserves the semantics of converting that clone through ToPaxValue and back with try_coerce.

impl<F, T> Copy for Transform2<F, T>

impl<F, T> Debug for Transform2<F, T>

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

Formats the value using the given formatter.

impl<F, T> Default for Transform2<F, T>

where F: Space, T: Space,

fn default() -> Transform2<F, T>

Returns the “default value” for a type.

impl<T, F> From<Transform2<T, F>> for Affine

where T: Space, F: Space,

fn from(value: Transform2<T, F>) -> Affine

Converts to this type from the input type.

impl HelperFunctions for Transform2

fn register_all_functions()

Registers all helper functions for this type.

impl<F, T> ImplToFromPaxAny for Transform2<F, T>

where F: Space, T: Space,

impl<W, T> Interpolatable for Transform2<W, T>

where W: Space, T: Space,

fn interpolate(&self, other: &Transform2<W, T>, t: f64) -> Transform2<W, T>

Interpolates this value toward other at time t on the unit interval.

impl<F, W> Into<Transform2<F, W>> for TransformParts

where F: Space, W: Space,

fn into(self) -> Transform2<F, W>

Converts this type into the (usually inferred) input type.

impl<F, T> Into<TransformParts> for Transform2<F, T>

where F: Space, T: Space,

NOTE: the returned parts.skew.y will always be equal to 0,

fn into(self) -> TransformParts

Converts this type into the (usually inferred) input type.

impl<F, T> Mul<Point2<F>> for Transform2<F, T>

where F: Space, T: Space,

type Output = Point2<T>

The resulting type after applying the * operator.

fn mul(self, other: Point2<F>) -> <Transform2<F, T> as Mul<Point2<F>>>::Output

Performs the * operation.

impl<W1, W2, W3> Mul<Transform2<W1, W2>> for Transform2<W2, W3>

where W1: Space, W2: Space, W3: Space,

type Output = Transform2<W1, W3>

The resulting type after applying the * operator.

fn mul( self, rhs: Transform2<W1, W2>, ) -> <Transform2<W2, W3> as Mul<Transform2<W1, W2>>>::Output

Performs the * operation.

impl<F, T> Mul<Vector2<F>> for Transform2<F, T>

where F: Space, T: Space,

type Output = Vector2<T>

The resulting type after applying the * operator.

fn mul(self, other: Vector2<F>) -> <Transform2<F, T> as Mul<Vector2<F>>>::Output

Performs the * operation.

impl<F, T> PartialEq for Transform2<F, T>

fn eq(&self, other: &Transform2<F, T>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl ToPaxValue for Transform2

fn to_pax_value(self) -> PaxValue

Converts this value into a PaxValue.

fn nested_properties(&self) -> Vec<UntypedProperty>

Live properties read when snapshotting a compound value for PAXEL. Adapters observe these as well as the containing property.

fn to_pax_value_in_graph(self) -> PaxValue

where Self: Sized,

Converts against owner-thread graph views, including nested generated property fields. Requires an entered property graph for shared fields. Ordinary Self::to_pax_value reads published value snapshots.