Struct bevy::transform::components::GlobalTransform

pub struct GlobalTransform(/* private fields */);

Describe the position of an entity relative to the reference frame.

• To place or move an entity, you should set its Transform.
• GlobalTransform is fully managed by bevy, you cannot mutate it, use Transform instead.
• To get the global transform of an entity, you should get its GlobalTransform.
• For transform hierarchies to work correctly, you 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 in this schedule or after, you will notice a 1 frame lag before the GlobalTransform is updated.

Examples

• transform

Implementations

impl GlobalTransform

pub const IDENTITY: GlobalTransform = _

An identity GlobalTransform that maps all points in space to themselves.

pub fn compute_matrix(&self) -> Mat4

Returns the 3d affine transformation matrix as a Mat4.

pub fn affine(&self) -> Affine3A

Returns the 3d affine transformation matrix as an Affine3A.

pub fn compute_transform(&self) -> Transform

Returns the transformation as a Transform.

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

pub fn reparented_to(&self, parent: &GlobalTransform) -> Transform

Returns the Transform self would have if it was a child of an entity with the parent GlobalTransform.

This is useful if you want to “reparent” an Entity. Say you have an entity e1 that you want to turn into a child of e2, but you want e1 to keep the same global transform, even after re-parenting. You would use:

#[derive(Component)]
struct ToReparent {
    new_parent: Entity,
}
fn reparent_system(
    mut commands: Commands,
    mut targets: Query<(&mut Transform, Entity, &GlobalTransform, &ToReparent)>,
    transforms: Query<&GlobalTransform>,
) {
    for (mut transform, entity, initial, to_reparent) in targets.iter_mut() {
        if let Ok(parent_transform) = transforms.get(to_reparent.new_parent) {
            *transform = initial.reparented_to(parent_transform);
            commands.entity(entity)
                .remove::<ToReparent>()
                .set_parent(to_reparent.new_parent);
        }
    }
}

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

pub fn to_scale_rotation_translation(&self) -> (Vec3, Quat, Vec3)

Extracts scale, rotation and translation from self.

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

pub fn right(&self) -> Vec3

Return the local right vector (X).

pub fn left(&self) -> Vec3

Return the local left vector (-X).

pub fn up(&self) -> Vec3

Return the local up vector (Y).

pub fn down(&self) -> Vec3

Return the local down vector (-Y).

pub fn back(&self) -> Vec3

Return the local back vector (Z).

pub fn forward(&self) -> Vec3

Return the local forward vector (-Z).

pub fn translation(&self) -> Vec3

Get the translation as a Vec3.

pub fn translation_vec3a(&self) -> Vec3A

Get the translation as a Vec3A.

pub fn radius_vec3a(&self, extents: Vec3A) -> f32

Get an upper bound of the radius from the given extents.

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

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

This moves point into the local space of this GlobalTransform.

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

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

Trait Implementations

impl Clone for GlobalTransform

fn clone(&self) -> GlobalTransform

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Component for GlobalTransformwhere GlobalTransform: 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 GlobalTransform

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

Formats the value using the given formatter.

impl Default for GlobalTransform

fn default() -> GlobalTransform

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for GlobalTransform

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

Deserialize this value from the given Serde deserializer.

impl From<Affine3A> for GlobalTransform

fn from(affine: Affine3A) -> GlobalTransform

Converts to this type from the input 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<Mat4> for GlobalTransform

fn from(matrix: Mat4) -> GlobalTransform

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 FromReflect for GlobalTransformwhere Affine3A: FromReflect + TypePath,

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

Constructs a concrete instance of Self from a reflected value.

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

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

impl GetTypeRegistration for GlobalTransformwhere Affine3A: FromReflect + TypePath,

fn get_type_registration() -> TypeRegistration

impl Mul<GlobalTransform> for GlobalTransform

type Output = GlobalTransform

The resulting type after applying the * operator.

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

Performs the * operation.

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<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 GlobalTransform

type Output = Vec3

The resulting type after applying the * operator.

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

Performs the * operation.

impl PartialEq<GlobalTransform> for GlobalTransform

fn eq(&self, other: &GlobalTransform) -> 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 GlobalTransformwhere Affine3A: 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<GlobalTransform, Global>) -> Box<dyn Any, Global>

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<GlobalTransform, Global>) -> Box<dyn Reflect, Global>

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, Global>

Clones the value as a Reflect trait object.

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

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_ref(&self) -> ReflectRef<'_>

Returns an enumeration of “kinds” of type.

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

Returns a mutable enumeration of “kinds” of type.

fn reflect_owned(self: Box<GlobalTransform, Global>) -> 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 Serialize for GlobalTransform

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

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

Transform a point.

impl TupleStruct for GlobalTransformwhere Affine3A: FromReflect + TypePath,

fn field(&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_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 field_len(&self) -> usize

Returns the number of fields in the tuple struct.

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

Returns an iterator over the values of the tuple struct’s fields.

fn clone_dynamic(&self) -> DynamicTupleStruct

Clones the struct into a DynamicTupleStruct.

impl TypePath for GlobalTransformwhere Affine3A: FromReflect + TypePath,

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 GlobalTransformwhere Affine3A: FromReflect + TypePath,

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.

impl Copy for GlobalTransform

impl StructuralPartialEq for GlobalTransform