Struct bevy::prelude::Transform

pub struct Transform {
    pub translation: Vec3,
    pub rotation: Quat,
    pub scale: Vec3,
}

Describe the position of an entity. If the entity has a parent, the position is relative to its parent position.

• To place or move an entity, you should set its Transform.
• To get the global transform of an entity, you should get its GlobalTransform.
• To be displayed, an entity must have both a Transform and a GlobalTransform.
  • You may use the TransformBundle to guarantee this.

Transform and GlobalTransform

Transform is the position of an entity relative to its parent position, or the reference frame if it doesn’t have a Parent.

GlobalTransform is the position of an entity relative to the reference frame.

GlobalTransform is updated from Transform by systems in the system set TransformPropagate.

This system runs during PostUpdate. If you update the Transform of an entity during this set or after, you will notice a 1 frame lag before the GlobalTransform is updated.

Examples

• transform
• global_vs_local_translation

Fields

translation: Vec3

Position of the entity. In 2d, the last value of the Vec3 is used for z-ordering.

See the translations example for usage.

rotation: Quat

Rotation of the entity.

See the 3d_rotation example for usage.

scale: Vec3

Scale of the entity.

See the scale example for usage.

Implementations

impl Transform

pub const IDENTITY: Transform = _

An identity Transform with no translation, rotation, and a scale of 1 on all axes.

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

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

pub fn from_matrix(matrix: Mat4) -> Transform

Extracts the translation, rotation, and scale from matrix. It must be a 3d affine transformation matrix.

pub const fn from_translation(translation: Vec3) -> Transform

Creates a new Transform, with translation. Rotation will be 0 and scale 1 on all axes.

pub const fn from_rotation(rotation: Quat) -> Transform

Creates a new Transform, with rotation. Translation will be 0 and scale 1 on all axes.

pub const fn from_scale(scale: Vec3) -> Transform

Creates a new Transform, with scale. Translation will be 0 and rotation 0 on all axes.

pub fn looking_at(self, target: Vec3, up: Vec3) -> Transform

Returns this Transform with a new rotation so that Transform::forward points towards the target position and Transform::up points towards up.

In some cases it’s not possible to construct a rotation. Another axis will be picked in those cases:

• if target is the same as the transform translation, Vec3::Z is used instead
• if up is zero, Vec3::Y is used instead
• if the resulting forward direction is parallel with up, an orthogonal vector is used as the “right” direction

pub fn looking_to(self, direction: Vec3, up: Vec3) -> Transform

Returns this Transform with a new rotation so that Transform::forward points in the given direction and Transform::up points towards up.

In some cases it’s not possible to construct a rotation. Another axis will be picked in those cases:

• if direction is zero, Vec3::Z is used instead
• if up is zero, Vec3::Y is used instead
• if direction is parallel with up, an orthogonal vector is used as the “right” direction

pub const fn with_translation(self, translation: Vec3) -> Transform

Returns this Transform with a new translation.

pub const fn with_rotation(self, rotation: Quat) -> Transform

Returns this Transform with a new rotation.

pub const fn with_scale(self, scale: Vec3) -> Transform

Returns this Transform with a new scale.

pub fn compute_matrix(&self) -> Mat4

Returns the 3d affine transformation matrix from this transforms translation, rotation, and scale.

pub fn compute_affine(&self) -> Affine3A

Returns the 3d affine transformation matrix from this transforms translation, rotation, and scale.

pub fn local_x(&self) -> Direction3d

Get the unit vector in the local X direction.

pub fn left(&self) -> Direction3d

Equivalent to -local_x()

pub fn right(&self) -> Direction3d

Equivalent to local_x()

pub fn local_y(&self) -> Direction3d

Get the unit vector in the local Y direction.

pub fn up(&self) -> Direction3d

Equivalent to local_y()

pub fn down(&self) -> Direction3d

Equivalent to -local_y()

pub fn local_z(&self) -> Direction3d

Get the unit vector in the local Z direction.

pub fn forward(&self) -> Direction3d

Equivalent to -local_z()

pub fn back(&self) -> Direction3d

Equivalent to local_z()

pub fn rotate(&mut self, rotation: Quat)

Rotates this Transform by the given rotation.

If this Transform has a parent, the rotation is relative to the rotation of the parent.

Examples

• 3d_rotation

pub fn rotate_axis(&mut self, axis: Vec3, angle: f32)

Rotates this Transform around the given axis by angle (in radians).

If this Transform has a parent, the axis is relative to the rotation of the parent.

pub fn rotate_x(&mut self, angle: f32)

Rotates this Transform around the X axis by angle (in radians).

If this Transform has a parent, the axis is relative to the rotation of the parent.

pub fn rotate_y(&mut self, angle: f32)

Rotates this Transform around the Y axis by angle (in radians).

If this Transform has a parent, the axis is relative to the rotation of the parent.

pub fn rotate_z(&mut self, angle: f32)

Rotates this Transform around the Z axis by angle (in radians).

If this Transform has a parent, the axis is relative to the rotation of the parent.

pub fn rotate_local(&mut self, rotation: Quat)

Rotates this Transform by the given rotation.

The rotation is relative to this Transform’s current rotation.

pub fn rotate_local_axis(&mut self, axis: Vec3, angle: f32)

Rotates this Transform around its local axis by angle (in radians).

pub fn rotate_local_x(&mut self, angle: f32)

Rotates this Transform around its local X axis by angle (in radians).

pub fn rotate_local_y(&mut self, angle: f32)

Rotates this Transform around its local Y axis by angle (in radians).

pub fn rotate_local_z(&mut self, angle: f32)

Rotates this Transform around its local Z axis by angle (in radians).

pub fn translate_around(&mut self, point: Vec3, rotation: Quat)

Translates this Transform around a point in space.

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

pub fn rotate_around(&mut self, point: Vec3, rotation: Quat)

Rotates this Transform around a point in space.

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

pub fn look_at(&mut self, target: Vec3, up: Vec3)

Rotates this Transform so that Transform::forward points towards the target position, and Transform::up points towards up.

In some cases it’s not possible to construct a rotation. Another axis will be picked in those cases:

• if target is the same as the transform translation, Vec3::Z is used instead
• if up is zero, Vec3::Y is used instead
• if the resulting forward direction is parallel with up, an orthogonal vector is used as the “right” direction

pub fn look_to(&mut self, direction: Vec3, up: Vec3)

Rotates this Transform so that Transform::forward points in the given direction and Transform::up points towards up.

In some cases it’s not possible to construct a rotation. Another axis will be picked in those cases:

• if direction is zero, Vec3::NEG_Z is used instead
• if up is zero, Vec3::Y is used instead
• if direction is parallel with up, an orthogonal vector is used as the “right” direction

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

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

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

Transforms the given point, applying scale, rotation and translation.

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

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

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

pub fn is_finite(&self) -> bool

Returns true if, and only if, translation, rotation and scale all are finite. If any of them contains a NaN, positive or negative infinity, this will return false.

Trait Implementations

impl Animatable for Transform

fn interpolate(a: &Transform, b: &Transform, t: f32) -> Transform

Interpolates between a and b with a interpolation factor of time.

fn blend(inputs: impl Iterator<Item = BlendInput<Transform>>) -> Transform

Blends one or more values together.

fn post_process(&mut self, _world: &World)

Post-processes the value using resources in the World. Most animatable types do not need to implement this.

impl Clone for Transform

fn clone(&self) -> Transform

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Component for Transform

where Transform: 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 Transform

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

Formats the value using the given formatter.

impl Default for Transform

fn default() -> Transform

Returns the “default value” for a type.

impl From<GlobalTransform> for Transform

The transform is expected to be non-degenerate and without shearing, or the output will be invalid.

fn from(transform: GlobalTransform) -> Transform

Converts to this type from the input type.

impl From<Transform> for GlobalTransform

fn from(transform: Transform) -> GlobalTransform

Converts to this type from the input type.

impl From<Transform> for SpatialBundle

fn from(transform: Transform) -> SpatialBundle

Converts to this type from the input type.

impl From<Transform> for TransformBundle

fn from(transform: Transform) -> TransformBundle

Converts to this type from the input type.

impl FromReflect for Transform

where Transform: Any + Send + Sync, Vec3: FromReflect + TypePath, Quat: FromReflect + TypePath,

fn from_reflect(reflect: &(dyn Reflect + 'static)) -> Option<Transform>

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 Transform

where Transform: Any + Send + Sync, Vec3: FromReflect + TypePath, Quat: FromReflect + TypePath,

fn get_type_registration() -> TypeRegistration

impl Mul<GlobalTransform> for Transform

type Output = GlobalTransform

The resulting type after applying the * operator.

fn mul( self, global_transform: GlobalTransform ) -> <Transform as Mul<GlobalTransform>>::Output

Performs the * operation.

impl Mul<Mesh> for Transform

type Output = Mesh

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Transform> for GlobalTransform

type Output = GlobalTransform

The resulting type after applying the * operator.

fn mul( self, transform: Transform ) -> <GlobalTransform as Mul<Transform>>::Output

Performs the * operation.

impl Mul<Vec3> for Transform

type Output = Vec3

The resulting type after applying the * operator.

fn mul(self, value: Vec3) -> <Transform as Mul<Vec3>>::Output

Performs the * operation.

impl Mul for Transform

type Output = Transform

The resulting type after applying the * operator.

fn mul(self, transform: Transform) -> <Transform as Mul>::Output

Performs the * operation.

impl PartialEq for Transform

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

where Transform: Any + Send + Sync, Vec3: FromReflect + TypePath, Quat: 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<Transform>) -> Box<dyn Any>

Returns the value as a Box<dyn Any>.

fn as_any(&self) -> &(dyn Any + 'static)

Returns the value as a &dyn Any.

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Returns the value as a &mut dyn Any.

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

Casts this type to a boxed reflected value.

fn as_reflect(&self) -> &(dyn Reflect + 'static)

Casts this type to a reflected value.

fn as_reflect_mut(&mut self) -> &mut (dyn Reflect + 'static)

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 + 'static))

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<Transform>) -> ReflectOwned

Returns an owned enumeration of “kinds” of type.

fn reflect_partial_eq(&self, value: &(dyn Reflect + 'static)) -> 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 Transform

where Transform: Any + Send + Sync, Vec3: FromReflect + TypePath, Quat: FromReflect + TypePath,

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

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 + 'static)>

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 + 'static)>

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 + 'static)>

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 TransformPoint for Transform

fn transform_point(&self, point: impl Into<Vec3>) -> Vec3

Transform a point.

impl TypePath for Transform

where Transform: 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 Transform

where Transform: Any + Send + Sync, Vec3: FromReflect + TypePath, Quat: FromReflect + TypePath,

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.

impl Copy for Transform

impl StructuralPartialEq for Transform