Struct TransformAndBounds 

pub struct TransformAndBounds<F, T = F> {
    pub transform: Transform2<F, T>,
    pub bounds: (f64, f64),
}

Pax’s canonical representation of position, size, and transform, encoded as a transform (translation, rotation, scale, skew) and a separate width/height (bounds) value. Bounds are expressed as the (x1, y1) values of the axis-aligned pre-transform bounding box, where (x0, y0) are the origin.

In this model, position is a derived property, calculated by applying the transform to the bounding box.

Fields

transform: Transform2<F, T>

bounds: (f64, f64)

Implementations

impl<F, T> TransformAndBounds<F, T>

where F: Space, T: Space,

pub fn center(&self) -> Point2<T>

Center point of this transformed box.

pub fn corners(&self) -> [Point2<T>; 4]

Corners of this transformed box, starting at origin and proceeding around the rectangle.

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

Test whether a point falls inside this transformed box.

pub fn as_pure_size(self) -> TransformAndBounds<F, T>

Move scale from the transform into the bounds field.

pub fn as_pure_scale(self) -> TransformAndBounds<F, T>

Move bounds into the transform as scale, leaving unit bounds.

pub fn cast_spaces<A, B>(self) -> TransformAndBounds<A, B>

where A: Space, B: Space,

Retype coordinate-space markers without changing numeric values.

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

Convert this split representation into a single affine transform.

impl<F, T> TransformAndBounds<F, T>

where F: Space, T: Space,

pub fn inverse(&self) -> TransformAndBounds<T, F>

Invert the transform-and-bounds mapping.

pub fn intersects(&self, other: &TransformAndBounds<F, T>) -> bool

Test transformed-box intersection using the separating axis theorem.

Trait Implementations

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

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

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

where F: Space, T: Space,

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

Formats the value using the given formatter.

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

where F: Space, T: Space,

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

Returns the “default value” for a type.

impl<F, T> Interpolatable for TransformAndBounds<F, T>

where F: Space, T: Space,

fn interpolate( &self, other: &TransformAndBounds<F, T>, t: f64, ) -> TransformAndBounds<F, T>

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

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

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

type Output = TransformAndBounds<W1, W3>

The resulting type after applying the * operator.

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

Performs the * operation.

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

where F: PartialEq, T: PartialEq,

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

Equality operator ==.

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

Inequality operator !=.

impl PartialEq for TransformAndBounds<NodeLocal, Window>

fn eq(&self, other: &TransformAndBounds<NodeLocal, Window>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<F, T> StructuralPartialEq for TransformAndBounds<F, T>

where F: PartialEq, T: PartialEq,