Struct Transform2d

pub struct Transform2d {
    pub translation: Vec2,
    pub rotation: f32,
    pub scale: Vec2,
    pub z_translation: f32,
}

Describes the position of an Entity in 2d space.

This component acts as a proxy to the Transform component, and thus requires that both a Transform and GlobalTransform are present to function.

If this Transform2d has a Parent, then it’s relative to the Transform2d or Transform of the Parent.

Fields

translation: Vec2

The translation along the X and Y axes.

rotation: f32

The rotation in radians. Positive values rotate anti-clockwise.

scale: Vec2

The scale along the X and Y axes.

z_translation: f32

The translation along the Z axis.

You might be surprised that 2D entities have a translation along the Z axis, but this third dimension is used when rendering to decide what should appear in front or behind. A higher translation on the Z axis puts the entity closer to the camera, and thus in front of entities with a lower Z translation.

Keep in mind that this is relative to the Parent’s z_translation. The other fields on Transform2d don’t affect this because they are strictly 2D.

Implementations

impl Transform2d

pub const IDENTITY: Self

Creates a new identity Transform2d, with no translation, rotation, and a scale of 1 on all axes.

Translation is Vec2::ZERO, rotation is 0., scale is Vec2::ONE and z_translation is 0..

pub fn from_xy(x: f32, y: f32) -> Self

Creates a new Transform2d at the position (x, y).

Rotation will be 0., scale will be Vec2::ONE and z_translation will be 0..

pub fn from_xyz(x: f32, y: f32, z: f32) -> Self

Creates a new Transform2d at the position (x, y, z). The z component is used for z-ordering elements: higher z-value will be in front of lower z-value.

pub fn from_translation(translation: Vec2) -> Self

Creates a new Transform2d with translation.

Rotation will be 0., scale will be Vec2::ONE and z_translation will be 0..

pub fn from_translation_3d(_: Vec3) -> Self

Creates a new Transform2d with translation.

Rotation will be 0. and scale will be Vec2::ONE

pub fn from_rotation(rotation: f32) -> Self

Creates a new Transform2d with rotation.

Translation will be Vec2::ZERO, scale will be Vec2::ONE and z_translation will be 0..

pub fn from_scale(scale: impl IntoScale) -> Self

Creates a new Transform2d with scale.

Translation will be Vec2::ZERO, rotation will be 0. and z_translation will be 0.

pub fn with_translation(self, translation: Vec2) -> Self

Returns this Transform2d with a new translation.

pub fn with_rotation(self, rotation: f32) -> Self

Returns this Transform2d with a new rotation.

pub fn with_scale(self, scale: Vec2) -> Self

Returns this Transform2d with a new scale.

pub fn with_z_translation(self, z_translation: f32) -> Self

Returns this Transform2d with a new Z translation.

pub fn pointed_to(self, direction: Vec2, target_direction: Vec2) -> Self

Returns this Transform2d rotated so the local direction points in the given target_direction.

Example

// Create a transform rotated so that up/local_y points to the right.
let transform = Transform2d::IDENTITY.pointed_to(Vec2::Y, Vec2::X);

approx::assert_abs_diff_eq!(transform.up(), Vec2::X);

If this Transform2d has a parent, the point is relative to the Transform2d of the parent.

pub fn pointed_at(self, direction: Vec2, target_position: Vec2) -> Self

Returns this Transform2d rotated so the local direction points at the given target_position.

Example

// Create a transform that is translated to Vec2::ONE and then rotated so that up/local_y points to the origin.
let transform = Transform2d::from_translation(Vec2::ONE)
    .pointed_at(Vec2::Y, Vec2::ZERO);

approx::assert_abs_diff_eq!(transform.up(), Vec2::NEG_ONE.normalize());

If this Transform2d has a parent, the point is relative to the Transform2d of the parent.

pub fn point_to(&mut self, direction: Vec2, target_direction: Vec2)

Rotates this Transform2d so the local direction points in the given target_direction.

Example

let mut transform = Transform2d::IDENTITY;

// Rotate the transform so that up/local_y points to the right.
transform.point_to(Vec2::Y, Vec2::X);

approx::assert_abs_diff_eq!(transform.up(), Vec2::X);

If this Transform2d has a parent, the point is relative to the Transform2d of the parent.

pub fn point_at(&mut self, direction: Vec2, target_position: Vec2)

Rotates this Transform2d so the local direction points at the given target_position.

Example

let mut transform = Transform2d::from_translation(Vec2::ONE);

// Rotate the transform so that up/local_y points to the origin.
transform.point_at(Vec2::Y, Vec2::ZERO);

approx::assert_abs_diff_eq!(transform.up(), Vec2::NEG_ONE.normalize());

If this Transform2d has a parent, the point is relative to the Transform2d of the parent.

pub fn local_x(&self) -> Vec2

Get the unit vector in the local X direction.

pub fn left(&self) -> Vec2

Equivalent to -local_x()

pub fn right(&self) -> Vec2

Equivalent to local_x()

pub fn local_y(&self) -> Vec2

Get the unit vector in the local Y direction.

pub fn up(&self) -> Vec2

Equivalent to local_y()

pub fn down(&self) -> Vec2

Equivalent to -local_y()

pub fn rotation_matrix(&self) -> Mat2

Returns the rotation matrix from this transforms rotation.

pub fn compute_matrix(&self) -> Mat3

Computes the affine transformation matrix of this transform.

pub fn compute_affine(&self) -> Affine2

Computes the affine transform of this transform.

pub fn translate_around(&mut self, point: Vec2, angle: f32)

Translates this Transform2d around a point in space.

If this Transform2d has a parent, the point is relative to the Transform2d or Transform of the parent.

pub fn rotate_around(&mut self, point: Vec2, angle: f32)

Rotates this Transform2d around a point in space.

If this Transform2d has a parent, the point is relative to the Transform2d or Transform of the parent.

pub fn transform_point(&self, point: Vec2) -> Vec2

Transforms the given point, applying scale, rotation and translation. z_translation is ignored.

If this Transform2d has a parent, this will transform a point that is relative to the parent’s Transform2d into one relative to this Transform2d.

If this Transform2d does not have a parent, this will transform a point that is in global space into one relative to this Transform2d.

If you want to transform a point in global space to the local space of this Transform2d, consider using GlobalTransform2d::transform_point() instead.

pub fn mul_transform(&self, transform: Transform2d) -> Self

Multiplies self with transform component by component, returning the resulting Transform2d

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 Component for Transform2d

where Self: Send + Sync + 'static,

type Storage = TableStorage

A marker type indicating the storage type used for this component. This must be either TableStorage or SparseStorage.

impl Debug for Transform2d

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

Formats the value using the given formatter.

impl Default for Transform2d

fn default() -> Self

Returns the “default value” for a type.

impl From<Transform> for Transform2d

fn from(transform_3d: Transform) -> Self

Converts to this type from the input type.

impl From<Transform2d> for Spatial2dBundle

fn from(transform: Transform2d) -> Self

Converts to this type from the input type.

impl From<Transform2d> for Transform

fn from(transform2d: Transform2d) -> Self

Converts to this type from the input type.

impl From<Transform2d> for Transform2dBundle

fn from(transform: Transform2d) -> Self

Converts to this type from the input type.

impl FromReflect for Transform2d

where Self: Any + Send + Sync, Vec2: FromReflect + TypePath, f32: FromReflect + TypePath,

fn from_reflect(reflect: &dyn Reflect) -> Option<Self>

Constructs a concrete instance of Self from a reflected value.

fn take_from_reflect( reflect: Box<dyn Reflect>, ) -> Result<Self, Box<dyn Reflect>>

Attempts to downcast the given value to Self using, constructing the value using from_reflect if that fails.

impl GetTypeRegistration for Transform2d

where Self: Any + Send + Sync, Vec2: FromReflect + TypePath, f32: FromReflect + TypePath,

fn get_type_registration() -> TypeRegistration

impl PartialEq for Transform2d

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Reflect for Transform2d

where Self: Any + Send + Sync, Vec2: FromReflect + TypePath, f32: FromReflect + TypePath,

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

Returns the TypeInfo of the type represented by this value.

fn into_any(self: Box<Self>) -> Box<dyn Any>

Returns the value as a Box<dyn Any>.

fn as_any(&self) -> &dyn Any

Returns the value as a &dyn Any.

fn as_any_mut(&mut self) -> &mut dyn Any

Returns the value as a &mut dyn Any.

fn into_reflect(self: Box<Self>) -> Box<dyn Reflect>

Casts this type to a boxed reflected value.

fn as_reflect(&self) -> &dyn Reflect

Casts this type to a reflected value.

fn as_reflect_mut(&mut self) -> &mut dyn Reflect

Casts this type to a mutable reflected value.

fn clone_value(&self) -> Box<dyn Reflect>

Clones the value as a Reflect trait object.

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

Performs a type-checked assignment of a reflected value to this value.

fn apply(&mut self, value: &dyn Reflect)

Applies a reflected value to this value.

fn reflect_kind(&self) -> ReflectKind

Returns a zero-sized enumeration of “kinds” of type.

fn reflect_ref(&self) -> ReflectRef<'_>

Returns an immutable enumeration of “kinds” of type.

fn reflect_mut(&mut self) -> ReflectMut<'_>

Returns a mutable enumeration of “kinds” of type.

fn reflect_owned(self: Box<Self>) -> ReflectOwned

Returns an owned enumeration of “kinds” of type.

fn reflect_partial_eq(&self, value: &dyn Reflect) -> Option<bool>

Returns a “partial equality” comparison result.

fn reflect_hash(&self) -> Option<u64>

Returns a hash of the value (which includes the type).

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

Debug formatter for the value.

fn serializable(&self) -> Option<Serializable<'_>>

Returns a serializable version of the value.

fn is_dynamic(&self) -> bool

Indicates whether or not this type is a dynamic type.

impl Struct for Transform2d

where Self: Any + Send + Sync, Vec2: FromReflect + TypePath, f32: FromReflect + TypePath,

fn field(&self, name: &str) -> Option<&dyn Reflect>

Returns a reference to the value of the field named name as a &dyn Reflect.

fn field_mut(&mut self, name: &str) -> Option<&mut dyn Reflect>

Returns a mutable reference to the value of the field named name as a &mut dyn Reflect.

fn field_at(&self, index: usize) -> Option<&dyn Reflect>

Returns a reference to the value of the field with index index as a &dyn Reflect.

fn field_at_mut(&mut self, index: usize) -> Option<&mut dyn Reflect>

Returns a mutable reference to the value of the field with index index as a &mut dyn Reflect.

fn name_at(&self, index: usize) -> Option<&str>

Returns the name of the field with index index.

fn field_len(&self) -> usize

Returns the number of fields in the struct.

fn iter_fields(&self) -> FieldIter<'_>

Returns an iterator over the values of the reflectable fields for this struct.

fn clone_dynamic(&self) -> DynamicStruct

Clones the struct into a DynamicStruct.

impl TypePath for Transform2d

where Self: Any + Send + Sync,

fn type_path() -> &'static str

Returns the fully qualified path of the underlying type.

fn short_type_path() -> &'static str

Returns a short, pretty-print enabled path to the type.

fn type_ident() -> Option<&'static str>

Returns the name of the type, or None if it is anonymous.

fn crate_name() -> Option<&'static str>

Returns the name of the crate the type is in, or None if it is anonymous.

fn module_path() -> Option<&'static str>

Returns the path to the module the type is in, or None if it is anonymous.

impl Typed for Transform2d

where Self: Any + Send + Sync, Vec2: FromReflect + TypePath, f32: FromReflect + TypePath,

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.

impl Copy for Transform2d

impl StructuralPartialEq for Transform2d