[−][src]Struct quicksilver::geom::Transform

`pub struct Transform(_);`

A 2D transformation represented by a matrix

Transforms can be composed together through matrix multiplication, and are applied to Vectors through multiplication, meaning the notation used is the '*' operator. A property of matrix multiplication is that for some matrices A, B, C and vector V is

``````Transform = A * B * C
Transform * V = A * (B * (C * V))
``````

This property allows encoding multiple transformations in a single matrix. A transformation that involves rotating a shape 30 degrees and then moving it six units up could be written as

```use quicksilver::geom::{Transform, Vector};
let transform = Transform::rotate(30) * Transform::translate(Vector::new(0, -6));```

and then applied to a Vector

`transform * Vector::new(5, 5)`

Methods

`impl Transform`[src]

`pub const IDENTITY: Transform`[src]

The identity transformation

`pub fn from_array(array: [[f32; 3]; 3]) -> Transform`[src]

Create a Transform from an arbitrary matrix in a column-major matrix

`pub fn rotate<T: Scalar>(angle: T) -> Transform`[src]

Create a rotation transformation

`pub fn translate(    vec: impl Into<Vector>) -> Transform`[src]

Create a translation transformation

`pub fn scale(    vec: impl Into<Vector>) -> Transform`[src]

Create a scale transformation

`pub fn into_matrix(self) -> Matrix3<f32>`[src]

Convert the Transform into an nalgebra Matrix3

```#[must_use] pub fn inverse(&self) -> Transform```[src]

Find the inverse of a Transform

A transform's inverse will cancel it out when multplied with it, as seen below:

```let transform = Transform::translate(Vector::new(4, 5));
let inverse = transform.inverse();
let vector = Vector::new(10, 10);
assert_eq!(vector, transform * inverse * vector);
assert_eq!(vector, inverse * transform * vector);```

Trait Implementations

`impl PartialEq<Transform> for Transform`[src]

```#[must_use] fn ne(&self, other: &Rhs) -> bool```1.0.0[src]

This method tests for `!=`.

`impl Clone for Transform`[src]

`fn clone_from(&mut self, source: &Self)`1.0.0[src]

Performs copy-assignment from `source`. Read more

`impl Mul<Transform> for Transform`[src]

Concat two transforms A and B such that A * B * v = A * (B * v)

`type Output = Transform`

The resulting type after applying the `*` operator.

`impl Mul<Vector> for Transform`[src]

Transform a vector

`type Output = Vector`

The resulting type after applying the `*` operator.

`impl<T: Scalar> Mul<T> for Transform`[src]

Scale all of the internal values of the Transform matrix

Note this will NOT scale vectors multiplied by this transform, and generally you shouldn't need to use this.

`type Output = Transform`

The resulting type after applying the `*` operator.

Blanket Implementations

`impl<T, U> TryFrom for T where    T: From<U>, `[src]

`type Error = !`

🔬 This is a nightly-only experimental API. (`try_from`)

The type returned in the event of a conversion error.

`impl<T, U> TryInto for T where    U: TryFrom<T>, `[src]

`type Error = <U as TryFrom<T>>::Error`

🔬 This is a nightly-only experimental API. (`try_from`)

The type returned in the event of a conversion error.

`impl<T> SetParameter for T`

`fn set<T>(&mut self, value: T) -> <T as Parameter<Self>>::Result where    T: Parameter<Self>, `

Sets `value` as a parameter of `self`.

`impl<T> Scalar for T where    T: Copy + PartialEq<T> + Any + Debug, `[src]

`fn is<T>() -> bool where    T: Scalar, `[src]

Tests if `Self` the same as the type `T` Read more

`impl<T> Same for T`

`type Output = T`

Should always be `Self`