Struct gdnative::core_types::Transform2D

#[repr(C)]
pub struct Transform2D {
    pub a: Vector2,
    pub b: Vector2,
    pub origin: Vector2,
}

Affine 2D transform (2x3 matrix).

Represents transformations such as translation, rotation, or scaling.

Expressed as a 2x3 matrix, this transform consists of 2 basis (column) vectors a and b, as well as an origin o; more information in Self::from_basis_origin():

[ a.x  b.x  o.x ]
[ a.y  b.y  o.y ]

Given linear independence, every point in the transformed coordinate system can be expressed as p = xa + yb + o, where x, y are the scaling factors and o is the origin.

See also Transform2D in the Godot API doc.

Fields

a: Vector2

The first basis vector of the transform.

When transforming the X unit vector (1, 0) under this transform, the resulting point is represented by a. Objects will move along a when moving on the X axis in the coordinate space of this transform.

(This field is called x in Godot, but was renamed to avoid confusion with the x vector component and less readable expressions such as x.y, y.x).

b: Vector2

The second basis vector of the transform.

When transforming the Y unit vector (0, 1) under this transform, the resulting point is represented by b. Objects will move along b when moving on the Y axis in the coordinate space of this transform.

(This field is called y in Godot, but was renamed to avoid confusion with the y vector component and less readable expressions such as x.y, y.x).

origin: Vector2

The origin of the transform. The coordinate space defined by this transform starts at this point.

Implementations

impl Transform2D

pub const IDENTITY: Transform2D = Self{ a: Vector2::new(1.0, 0.0), b: Vector2::new(0.0, 1.0), origin: Vector2::new(0.0, 0.0),}

Represents the identity transform.

pub const fn from_basis_origin(
    basis_vector_a: Vector2,
    basis_vector_b: Vector2,
    origin: Vector2
) -> Transform2D

Creates a new transform from three basis vectors and the coordinate system’s origin.

Each vector represents a basis vector in the transformed coordinate system. For example, a is the result of transforming the X unit vector (1, 0). The 2 vectors need to be linearly independent.

Basis vectors are stored as column vectors in the matrix. The construction Transform2D::from_basis_origin(a, b, o) will create the following 3x4 matrix:

[ a.x  b.x  o.x ]
[ a.y  b.y  o.y ]

pub fn from_scale_rotation_origin(
    scale: Vector2,
    rotation: f32,
    origin: Vector2
) -> Transform2D

Constructs the transform from a given scale, angle (in radians), and origin.

This is NOT equivalent to either of these two lines:

Transform2D::IDENTITY.scaled(scale).rotated(rotation).translated(origin)
Transform2D::IDENTITY.translated(origin).rotated(rotation).scaled(scale)

Those transformations do not preserve the given origin; see documentation for rotated, scaled, and translated.

pub fn affine_inverse(&self) -> Transform2D

Returns the inverse of the transform, under the assumption that the transformation is composed of rotation, scaling and translation.

pub fn basis_xform(&self, v: Vector2) -> Vector2

Returns a vector transformed (multiplied) by the basis matrix.

This method does not account for translation (the origin vector).

pub fn basis_xform_inv(&self, v: Vector2) -> Vector2

Returns a vector transformed (multiplied) by the inverse basis matrix.

This method does not account for translation (the origin vector).

pub fn xform(&self, v: Vector2) -> Vector2

Transforms the given Vector2, Rect2, or PoolVector2Array by this transform.

pub fn xform_inv(&self, v: Vector2) -> Vector2

Inverse-transforms the given Vector2, Rect2, or PoolVector2Array by this transform.

pub fn translated(&self, translation: Vector2) -> Transform2D

Translates the transform by the given offset, relative to the transform’s basis vectors.

Unlike rotated() and scaled(), this does not use matrix multiplication.

pub fn rotation(&self) -> f32

Returns the transform’s rotation (in radians).

pub fn set_rotation(&mut self, rotation: f32)

Sets the transform’s rotation (argument rotation in radians).

pub fn rotated(&self, rotation: f32) -> Transform2D

Rotates the transform by the given angle (in radians), using matrix multiplication. This will modify the transform’s origin.

pub fn scale(&self) -> Vector2

Returns the transform’s scale.

pub fn set_scale(&mut self, scale: Vector2)

Sets the transform’s scale.

pub fn scaled(&self, scale: Vector2) -> Transform2D

Scales the transform by the given scale factor, using matrix multiplication. This will modify the transform’s origin.

pub fn interpolate_with(&self, other: Transform2D, weight: f32) -> Transform2D

Returns a transform interpolated between this transform and another by a given weight (on the range of 0.0 to 1.0). NOTE: This method assumes both Transform2Ds are affine transformations.

pub fn is_equal_approx(&self, other: Transform2D) -> bool

Returns true if this transform and transform are approximately equal, by calling is_equal_approx on each component.

Trait Implementations

impl Clone for Transform2D

fn clone(&self) -> Transform2D

Returns a copy of the value.

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

Performs copy-assignment from source.

impl CoerceFromVariant for Transform2D

fn coerce_from_variant(v: &Variant) -> Transform2D

impl Debug for Transform2D

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Transform2D

fn deserialize<__D>(
    __deserializer: __D
) -> Result<Transform2D, <__D as Deserializer<'de>>::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Export for Transform2D

type Hint = NoHint

A type-specific hint type that is valid for the type being exported.

fn export_info(_hint: Option<<Transform2D as Export>::Hint>) -> ExportInfo

Returns ExportInfo given an optional typed hint.

impl FromVariant for Transform2D

fn from_variant(variant: &Variant) -> Result<Transform2D, FromVariantError>

impl Mul<Transform2D> for Transform2D

type Output = Transform2D

The resulting type after applying the * operator.

fn mul(self, rhs: Transform2D) -> <Transform2D as Mul<Transform2D>>::Output

Performs the * operation.

impl PartialEq<Transform2D> for Transform2D

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

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

Serialize this value into the given Serde serializer.

impl ToVariant for Transform2D

fn to_variant(&self) -> Variant

impl Copy for Transform2D

impl StructuralPartialEq for Transform2D