Struct bevy::transform::components::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 be displayed, an entity must have both a Transform and a GlobalTransform.
• To get the global position of an entity, you should get its GlobalTransform.

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 in the system transform_propagate_system.

In pseudo code:

for entity in entities_without_parent:
    set entity.global_transform to entity.transform
    recursively:
        set parent to current entity
        for child in parent.children:
            set child.global_transform to parent.global_transform * child.transform

This system runs in stage CoreStage::PostUpdate. If you update theTransform of an entity in this stage or after, you will notice a 1 frame lag before the GlobalTransform is updated.

Fields

translation: Vec3

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

rotation: Quat

Rotation of the entity.

scale: Vec3

Scale of the entity.

Implementations

impl Transform

pub 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 const fn identity() -> Transform

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

pub fn from_matrix(matrix: Mat4) -> Transform

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

pub fn from_translation(translation: Vec3) -> Transform

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

pub fn from_rotation(rotation: Quat) -> Transform

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

pub 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

Updates and returns this Transform by rotating it so that its unit vector in the local z direction is toward target and its unit vector in the local y direction is toward up.

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

Returns this Transform with a new translation.

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

Returns this Transform with a new rotation.

pub 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 local_x(&self) -> Vec3

Get the unit vector in the local x direction.

pub fn left(&self) -> Vec3

Equivalent to -local_x()

pub fn right(&self) -> Vec3

Equivalent to local_x()

pub fn local_y(&self) -> Vec3

Get the unit vector in the local y direction.

pub fn up(&self) -> Vec3

Equivalent to local_y()

pub fn down(&self) -> Vec3

Equivalent to -local_y()

pub fn local_z(&self) -> Vec3

Get the unit vector in the local z direction.

pub fn forward(&self) -> Vec3

Equivalent to -local_z()

pub fn back(&self) -> Vec3

Equivalent to local_z()

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

Rotates the transform by the given rotation.

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

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

pub fn mul_vec3(&self, value: Vec3) -> Vec3

Returns a Vec3 of this Transform applied to value.

pub fn apply_non_uniform_scale(&mut self, scale_factor: Vec3)

Changes the scale of this Transform, multiplying the current scale by scale_factor.

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

Rotates this Transform so that its unit vector in the local z direction is toward target and its unit vector in the local y direction is toward up.

Trait Implementations

impl Clone for Transform

pub 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: 'static,
    Transform: Send,
    Transform: Sync, 

type Storage = TableStorage

impl Debug for Transform

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

Formats the value using the given formatter.

impl Default for Transform

pub fn default() -> Transform

Returns the “default value” for a type.

impl From<GlobalTransform> for Transform

pub fn from(transform: GlobalTransform) -> Transform

Performs the conversion.

impl From<Transform> for GlobalTransform

pub fn from(transform: Transform) -> GlobalTransform

Performs the conversion.

impl GetTypeRegistration for Transform

pub fn get_type_registration() -> TypeRegistration

impl Mul<Transform> for Transform

type Output = Transform

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Transform> for GlobalTransform

type Output = GlobalTransform

The resulting type after applying the * operator.

pub 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.

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

Performs the * operation.

impl PartialEq<Transform> for Transform

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl Reflect for Transform

pub fn type_name(&self) -> &str

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

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

pub fn clone_value(&self) -> Box<dyn Reflect + 'static, Global>

pub fn set(
    &mut self,
    value: Box<dyn Reflect + 'static, Global>
) -> Result<(), Box<dyn Reflect + 'static, Global>>

pub fn apply(&mut self, value: &(dyn Reflect + 'static))

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

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

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

Returns a serializable value, if serialization is supported. Otherwise None will be returned.

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

Returns a hash of the value (which includes the type) if hashing is supported. Otherwise None will be returned.

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

Returns a “partial equal” comparison result if comparison is supported. Otherwise None will be returned.

impl Struct for Transform

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

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

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

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

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

pub fn field_len(&self) -> usize

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

pub fn clone_dynamic(&self) -> DynamicStruct

impl Copy for Transform

impl StructuralPartialEq for Transform