Struct GlobalTransform

Source
pub struct GlobalTransform(/* private fields */);
Expand description

GlobalTransform is an affine transformation from entity-local coordinates to worldspace coordinates.

You cannot directly mutate GlobalTransform; instead, you change an entity’s transform by manipulating its Transform, which indirectly causes Bevy to update its GlobalTransform.

§Transform and GlobalTransform

Transform transforms an entity relative to its parent’s reference frame, or relative to world space coordinates, if it doesn’t have a Parent.

GlobalTransform is managed by Bevy; it is computed by successively applying the Transform of each ancestor entity which has a Transform. This is done automatically by Bevy-internal 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

Implementations§

Source§

impl GlobalTransform

Source

pub const IDENTITY: GlobalTransform

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

Source

pub fn compute_matrix(&self) -> Mat4

Returns the 3d affine transformation matrix as a Mat4.

Source

pub fn affine(&self) -> Affine3A

Returns the 3d affine transformation matrix as an Affine3A.

Examples found in repository?
examples/2d/mesh2d_manual.rs (line 343)
326pub fn extract_colored_mesh2d(
327    mut commands: Commands,
328    mut previous_len: Local<usize>,
329    // When extracting, you must use `Extract` to mark the `SystemParam`s
330    // which should be taken from the main world.
331    query: Extract<
332        Query<(Entity, &ViewVisibility, &GlobalTransform, &Mesh2d), With<ColoredMesh2d>>,
333    >,
334    mut render_mesh_instances: ResMut<RenderColoredMesh2dInstances>,
335) {
336    let mut values = Vec::with_capacity(*previous_len);
337    for (entity, view_visibility, transform, handle) in &query {
338        if !view_visibility.get() {
339            continue;
340        }
341
342        let transforms = Mesh2dTransforms {
343            world_from_local: (&transform.affine()).into(),
344            flags: MeshFlags::empty().bits(),
345        };
346
347        values.push((entity, ColoredMesh2d));
348        render_mesh_instances.insert(
349            entity.into(),
350            RenderMesh2dInstance {
351                mesh_asset_id: handle.0.id(),
352                transforms,
353                material_bind_group_id: Material2dBindGroupId::default(),
354                automatic_batching: false,
355            },
356        );
357    }
358    *previous_len = values.len();
359    commands.insert_or_spawn_batch(values);
360}
Source

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.

Source

pub fn to_isometry(&self) -> Isometry3d

Returns the isometric part of the transformation as an isometry. Any scaling done by the transformation will be ignored.

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

Source

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.

Source

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.

Examples found in repository?
examples/2d/mesh2d_arcs.rs (line 111)
106fn draw_bounds<Shape: Bounded2d + Send + Sync + 'static>(
107    q: Query<(&DrawBounds<Shape>, &GlobalTransform)>,
108    mut gizmos: Gizmos,
109) {
110    for (shape, transform) in &q {
111        let (_, rotation, translation) = transform.to_scale_rotation_translation();
112        let translation = translation.truncate();
113        let rotation = rotation.to_euler(EulerRot::XYZ).2;
114        let isometry = Isometry2d::new(translation, Rot2::radians(rotation));
115
116        let aabb = shape.0.aabb_2d(isometry);
117        gizmos.rect_2d(aabb.center(), aabb.half_size() * 2.0, RED);
118
119        let bounding_circle = shape.0.bounding_circle(isometry);
120        gizmos.circle_2d(bounding_circle.center, bounding_circle.radius(), BLUE);
121    }
122}
Source

pub fn right(&self) -> Dir3

Return the local right vector (X).

Source

pub fn left(&self) -> Dir3

Return the local left vector (-X).

Source

pub fn up(&self) -> Dir3

Return the local up vector (Y).

Examples found in repository?
examples/3d/3d_viewport_to_world.rs (line 32)
13fn draw_cursor(
14    camera_query: Single<(&Camera, &GlobalTransform)>,
15    ground: Single<&GlobalTransform, With<Ground>>,
16    windows: Single<&Window>,
17    mut gizmos: Gizmos,
18) {
19    let (camera, camera_transform) = *camera_query;
20
21    let Some(cursor_position) = windows.cursor_position() else {
22        return;
23    };
24
25    // Calculate a ray pointing from the camera into the world based on the cursor's position.
26    let Ok(ray) = camera.viewport_to_world(camera_transform, cursor_position) else {
27        return;
28    };
29
30    // Calculate if and where the ray is hitting the ground plane.
31    let Some(distance) =
32        ray.intersect_plane(ground.translation(), InfinitePlane3d::new(ground.up()))
33    else {
34        return;
35    };
36    let point = ray.get_point(distance);
37
38    // Draw a circle just above the ground plane at that position.
39    gizmos.circle(
40        Isometry3d::new(
41            point + ground.up() * 0.01,
42            Quat::from_rotation_arc(Vec3::Z, ground.up().as_vec3()),
43        ),
44        0.2,
45        Color::WHITE,
46    );
47}
Source

pub fn down(&self) -> Dir3

Return the local down vector (-Y).

Source

pub fn back(&self) -> Dir3

Return the local back vector (Z).

Source

pub fn forward(&self) -> Dir3

Return the local forward vector (-Z).

Source

pub fn translation(&self) -> Vec3

Get the translation as a Vec3.

Examples found in repository?
examples/ecs/iter_combinations.rs (line 127)
122fn interact_bodies(mut query: Query<(&Mass, &GlobalTransform, &mut Acceleration)>) {
123    let mut iter = query.iter_combinations_mut();
124    while let Some([(Mass(m1), transform1, mut acc1), (Mass(m2), transform2, mut acc2)]) =
125        iter.fetch_next()
126    {
127        let delta = transform2.translation() - transform1.translation();
128        let distance_sq: f32 = delta.length_squared();
129
130        let f = GRAVITY_CONSTANT / distance_sq;
131        let force_unit_mass = delta * f;
132        acc1.0 += force_unit_mass * *m2;
133        acc2.0 -= force_unit_mass * *m1;
134    }
135}
More examples
Hide additional examples
examples/animation/animated_fox.rs (line 46)
40fn observe_on_step(
41    trigger: Trigger<OnStep>,
42    particle: Res<ParticleAssets>,
43    mut commands: Commands,
44    transforms: Query<&GlobalTransform>,
45) {
46    let translation = transforms.get(trigger.entity()).unwrap().translation();
47    let mut rng = thread_rng();
48    // Spawn a bunch of particles.
49    for _ in 0..14 {
50        let horizontal = rng.gen::<Dir2>() * rng.gen_range(8.0..12.0);
51        let vertical = rng.gen_range(0.0..4.0);
52        let size = rng.gen_range(0.2..1.0);
53        commands.queue(spawn_particle(
54            particle.mesh.clone(),
55            particle.material.clone(),
56            translation.reject_from_normalized(Vec3::Y),
57            rng.gen_range(0.2..0.6),
58            size,
59            Vec3::new(horizontal.x, vertical, horizontal.y) * 10.0,
60        ));
61    }
62}
examples/3d/3d_viewport_to_world.rs (line 32)
13fn draw_cursor(
14    camera_query: Single<(&Camera, &GlobalTransform)>,
15    ground: Single<&GlobalTransform, With<Ground>>,
16    windows: Single<&Window>,
17    mut gizmos: Gizmos,
18) {
19    let (camera, camera_transform) = *camera_query;
20
21    let Some(cursor_position) = windows.cursor_position() else {
22        return;
23    };
24
25    // Calculate a ray pointing from the camera into the world based on the cursor's position.
26    let Ok(ray) = camera.viewport_to_world(camera_transform, cursor_position) else {
27        return;
28    };
29
30    // Calculate if and where the ray is hitting the ground plane.
31    let Some(distance) =
32        ray.intersect_plane(ground.translation(), InfinitePlane3d::new(ground.up()))
33    else {
34        return;
35    };
36    let point = ray.get_point(distance);
37
38    // Draw a circle just above the ground plane at that position.
39    gizmos.circle(
40        Isometry3d::new(
41            point + ground.up() * 0.01,
42            Quat::from_rotation_arc(Vec3::Z, ground.up().as_vec3()),
43        ),
44        0.2,
45        Color::WHITE,
46    );
47}
examples/3d/blend_modes.rs (line 310)
250fn example_control_system(
251    mut materials: ResMut<Assets<StandardMaterial>>,
252    controllable: Query<(&MeshMaterial3d<StandardMaterial>, &ExampleControls)>,
253    camera: Single<(&mut Camera, &mut Transform, &GlobalTransform), With<Camera3d>>,
254    mut labels: Query<(&mut Node, &ExampleLabel)>,
255    mut display: Single<&mut Text, With<ExampleDisplay>>,
256    labeled: Query<&GlobalTransform>,
257    mut state: Local<ExampleState>,
258    time: Res<Time>,
259    input: Res<ButtonInput<KeyCode>>,
260) {
261    if input.pressed(KeyCode::ArrowUp) {
262        state.alpha = (state.alpha + time.delta_secs()).min(1.0);
263    } else if input.pressed(KeyCode::ArrowDown) {
264        state.alpha = (state.alpha - time.delta_secs()).max(0.0);
265    }
266
267    if input.just_pressed(KeyCode::Space) {
268        state.unlit = !state.unlit;
269    }
270
271    let randomize_colors = input.just_pressed(KeyCode::KeyC);
272
273    for (material_handle, controls) in &controllable {
274        let material = materials.get_mut(material_handle).unwrap();
275
276        if controls.color && randomize_colors {
277            material.base_color = Srgba {
278                red: random(),
279                green: random(),
280                blue: random(),
281                alpha: state.alpha,
282            }
283            .into();
284        } else {
285            material.base_color.set_alpha(state.alpha);
286        }
287
288        if controls.unlit {
289            material.unlit = state.unlit;
290        }
291    }
292
293    let (mut camera, mut camera_transform, camera_global_transform) = camera.into_inner();
294
295    if input.just_pressed(KeyCode::KeyH) {
296        camera.hdr = !camera.hdr;
297    }
298
299    let rotation = if input.pressed(KeyCode::ArrowLeft) {
300        time.delta_secs()
301    } else if input.pressed(KeyCode::ArrowRight) {
302        -time.delta_secs()
303    } else {
304        0.0
305    };
306
307    camera_transform.rotate_around(Vec3::ZERO, Quat::from_rotation_y(rotation));
308
309    for (mut node, label) in &mut labels {
310        let world_position = labeled.get(label.entity).unwrap().translation() + Vec3::Y;
311
312        let viewport_position = camera
313            .world_to_viewport(camera_global_transform, world_position)
314            .unwrap();
315
316        node.top = Val::Px(viewport_position.y);
317        node.left = Val::Px(viewport_position.x);
318    }
319
320    display.0 = format!(
321        "  HDR: {}\nAlpha: {:.2}",
322        if camera.hdr { "ON " } else { "OFF" },
323        state.alpha
324    );
325}
Source

pub fn translation_vec3a(&self) -> Vec3A

Get the translation as a Vec3A.

Source

pub fn rotation(&self) -> Quat

Get the rotation as a Quat.

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

§Warning

This is calculated using to_scale_rotation_translation, meaning that you should probably use it directly if you also need translation or scale.

Source

pub fn scale(&self) -> Vec3

Get the scale as a Vec3.

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

Some of the computations overlap with to_scale_rotation_translation, which means you should use it instead if you also need rotation.

Source

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

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

Source

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

Transforms the given point from local space to global space, applying shear, scale, rotation and translation.

It can be used like this:

let global_transform = GlobalTransform::from_xyz(1., 2., 3.);
let local_point = Vec3::new(1., 2., 3.);
let global_point = global_transform.transform_point(local_point);
assert_eq!(global_point, Vec3::new(2., 4., 6.));
let global_point = Vec3::new(2., 4., 6.);
let global_transform = GlobalTransform::from_xyz(1., 2., 3.);
let local_point = global_transform.affine().inverse().transform_point3(global_point);
assert_eq!(local_point, Vec3::new(1., 2., 3.))

To apply shear, scale, and rotation without applying translation, different functions are available:

let global_transform = GlobalTransform::from_xyz(1., 2., 3.);
let local_direction = Vec3::new(1., 2., 3.);
let global_direction = global_transform.affine().transform_vector3(local_direction);
assert_eq!(global_direction, Vec3::new(1., 2., 3.));
let roundtripped_local_direction = global_transform.affine().inverse().transform_vector3(global_direction);
assert_eq!(roundtripped_local_direction, local_direction);
Examples found in repository?
examples/3d/irradiance_volumes.rs (line 575)
523fn create_cubes(
524    image_assets: Res<Assets<Image>>,
525    mut commands: Commands,
526    irradiance_volumes: Query<(&IrradianceVolume, &GlobalTransform)>,
527    voxel_cube_parents: Query<Entity, With<VoxelCubeParent>>,
528    voxel_cubes: Query<Entity, With<VoxelCube>>,
529    example_assets: Res<ExampleAssets>,
530    mut voxel_visualization_material_assets: ResMut<Assets<VoxelVisualizationMaterial>>,
531) {
532    // If voxel cubes have already been spawned, don't do anything.
533    if !voxel_cubes.is_empty() {
534        return;
535    }
536
537    let Some(voxel_cube_parent) = voxel_cube_parents.iter().next() else {
538        return;
539    };
540
541    for (irradiance_volume, global_transform) in irradiance_volumes.iter() {
542        let Some(image) = image_assets.get(&irradiance_volume.voxels) else {
543            continue;
544        };
545
546        let resolution = image.texture_descriptor.size;
547
548        let voxel_cube_material = voxel_visualization_material_assets.add(ExtendedMaterial {
549            base: StandardMaterial::from(Color::from(RED)),
550            extension: VoxelVisualizationExtension {
551                irradiance_volume_info: VoxelVisualizationIrradianceVolumeInfo {
552                    world_from_voxel: VOXEL_FROM_WORLD.inverse(),
553                    voxel_from_world: VOXEL_FROM_WORLD,
554                    resolution: uvec3(
555                        resolution.width,
556                        resolution.height,
557                        resolution.depth_or_array_layers,
558                    ),
559                    intensity: IRRADIANCE_VOLUME_INTENSITY,
560                },
561            },
562        });
563
564        let scale = vec3(
565            1.0 / resolution.width as f32,
566            1.0 / resolution.height as f32,
567            1.0 / resolution.depth_or_array_layers as f32,
568        );
569
570        // Spawn a cube for each voxel.
571        for z in 0..resolution.depth_or_array_layers {
572            for y in 0..resolution.height {
573                for x in 0..resolution.width {
574                    let uvw = (uvec3(x, y, z).as_vec3() + 0.5) * scale - 0.5;
575                    let pos = global_transform.transform_point(uvw);
576                    let voxel_cube = commands
577                        .spawn((
578                            Mesh3d(example_assets.voxel_cube.clone()),
579                            MeshMaterial3d(voxel_cube_material.clone()),
580                            Transform::from_scale(Vec3::splat(VOXEL_CUBE_SCALE))
581                                .with_translation(pos),
582                        ))
583                        .insert(VoxelCube)
584                        .insert(NotShadowCaster)
585                        .id();
586
587                    commands.entity(voxel_cube_parent).add_child(voxel_cube);
588                }
589            }
590        }
591    }
592}
Source

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

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

Trait Implementations§

Source§

impl Clone for GlobalTransform

Source§

fn clone(&self) -> GlobalTransform

Returns a copy of the value. Read more
1.0.0 · Source§

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

Performs copy-assignment from source. Read more
Source§

impl Component for GlobalTransform
where GlobalTransform: Send + Sync + 'static,

Source§

const STORAGE_TYPE: StorageType = bevy_ecs::component::StorageType::Table

A constant indicating the storage type used for this component.
Source§

fn register_required_components( requiree: ComponentId, components: &mut Components, storages: &mut Storages, required_components: &mut RequiredComponents, inheritance_depth: u16, )

Registers required components.
Source§

fn register_component_hooks(hooks: &mut ComponentHooks)

Called when registering this component, allowing mutable access to its ComponentHooks.
Source§

impl Debug for GlobalTransform

Source§

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

Formats the value using the given formatter. Read more
Source§

impl Default for GlobalTransform

Source§

fn default() -> GlobalTransform

Returns the “default value” for a type. Read more
Source§

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

Source§

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

Deserialize this value from the given Serde deserializer. Read more
Source§

impl From<Affine3A> for GlobalTransform

Source§

fn from(value: Affine3A) -> GlobalTransform

Converts to this type from the input type.
Source§

impl From<GlobalTransform> for Transform

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

Source§

fn from(transform: GlobalTransform) -> Transform

Converts to this type from the input type.
Source§

impl From<Mat4> for GlobalTransform

Source§

fn from(world_from_local: Mat4) -> GlobalTransform

Converts to this type from the input type.
Source§

impl From<Transform> for GlobalTransform

Source§

fn from(transform: Transform) -> GlobalTransform

Converts to this type from the input type.
Source§

impl FromArg for &'static GlobalTransform
where GlobalTransform: Any + Send + Sync, Affine3A: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

type This<'from_arg> = &'from_arg GlobalTransform

The type to convert into. Read more
Source§

fn from_arg( arg: Arg<'_>, ) -> Result<<&'static GlobalTransform as FromArg>::This<'_>, ArgError>

Creates an item from an argument. Read more
Source§

impl FromArg for &'static mut GlobalTransform
where GlobalTransform: Any + Send + Sync, Affine3A: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

type This<'from_arg> = &'from_arg mut GlobalTransform

The type to convert into. Read more
Source§

fn from_arg( arg: Arg<'_>, ) -> Result<<&'static mut GlobalTransform as FromArg>::This<'_>, ArgError>

Creates an item from an argument. Read more
Source§

impl FromArg for GlobalTransform
where GlobalTransform: Any + Send + Sync, Affine3A: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

type This<'from_arg> = GlobalTransform

The type to convert into. Read more
Source§

fn from_arg( arg: Arg<'_>, ) -> Result<<GlobalTransform as FromArg>::This<'_>, ArgError>

Creates an item from an argument. Read more
Source§

impl FromReflect for GlobalTransform
where GlobalTransform: Any + Send + Sync, Affine3A: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

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

Constructs a concrete instance of Self from a reflected value.
Source§

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

Attempts to downcast the given value to Self using, constructing the value using from_reflect if that fails. Read more
Source§

impl GetOwnership for &GlobalTransform
where GlobalTransform: Any + Send + Sync, Affine3A: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

fn ownership() -> Ownership

Returns the ownership of Self.
Source§

impl GetOwnership for &mut GlobalTransform
where GlobalTransform: Any + Send + Sync, Affine3A: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

fn ownership() -> Ownership

Returns the ownership of Self.
Source§

impl GetOwnership for GlobalTransform
where GlobalTransform: Any + Send + Sync, Affine3A: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

fn ownership() -> Ownership

Returns the ownership of Self.
Source§

impl GetTypeRegistration for GlobalTransform
where GlobalTransform: Any + Send + Sync, Affine3A: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

fn get_type_registration() -> TypeRegistration

Returns the default TypeRegistration for this type.
Source§

fn register_type_dependencies(registry: &mut TypeRegistry)

Registers other types needed by this type. Read more
Source§

impl IntoReturn for &GlobalTransform
where GlobalTransform: Any + Send + Sync, Affine3A: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

fn into_return<'into_return>(self) -> Return<'into_return>
where &GlobalTransform: 'into_return,

Converts Self into a Return value.
Source§

impl IntoReturn for &mut GlobalTransform
where GlobalTransform: Any + Send + Sync, Affine3A: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

fn into_return<'into_return>(self) -> Return<'into_return>
where &mut GlobalTransform: 'into_return,

Converts Self into a Return value.
Source§

impl IntoReturn for GlobalTransform
where GlobalTransform: Any + Send + Sync, Affine3A: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

fn into_return<'into_return>(self) -> Return<'into_return>
where GlobalTransform: 'into_return,

Converts Self into a Return value.
Source§

impl Mul<GlobalTransform> for Transform

Source§

type Output = GlobalTransform

The resulting type after applying the * operator.
Source§

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

Performs the * operation. Read more
Source§

impl Mul<Transform> for GlobalTransform

Source§

type Output = GlobalTransform

The resulting type after applying the * operator.
Source§

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

Performs the * operation. Read more
Source§

impl Mul<Vec3> for GlobalTransform

Source§

type Output = Vec3

The resulting type after applying the * operator.
Source§

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

Performs the * operation. Read more
Source§

impl Mul for GlobalTransform

Source§

type Output = GlobalTransform

The resulting type after applying the * operator.
Source§

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

Performs the * operation. Read more
Source§

impl PartialEq for GlobalTransform

Source§

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

Tests for self and other values to be equal, and is used by ==.
1.0.0 · Source§

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

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

impl PartialReflect for GlobalTransform
where GlobalTransform: Any + Send + Sync, Affine3A: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

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

Returns the TypeInfo of the type represented by this value. Read more
Source§

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

Clones the value as a Reflect trait object. Read more
Source§

fn try_apply( &mut self, value: &(dyn PartialReflect + 'static), ) -> Result<(), ApplyError>

Tries to apply a reflected value to this value. Read more
Source§

fn reflect_kind(&self) -> ReflectKind

Returns a zero-sized enumeration of “kinds” of type. Read more
Source§

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

Returns an immutable enumeration of “kinds” of type. Read more
Source§

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

Returns a mutable enumeration of “kinds” of type. Read more
Source§

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

Returns an owned enumeration of “kinds” of type. Read more
Source§

fn try_into_reflect( self: Box<GlobalTransform>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

Attempts to cast this type to a boxed, fully-reflected value.
Source§

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

Attempts to cast this type to a fully-reflected value.
Source§

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

Attempts to cast this type to a mutable, fully-reflected value.
Source§

fn into_partial_reflect(self: Box<GlobalTransform>) -> Box<dyn PartialReflect>

Casts this type to a boxed, reflected value. Read more
Source§

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

Casts this type to a reflected value. Read more
Source§

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

Casts this type to a mutable, reflected value. Read more
Source§

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

Returns a “partial equality” comparison result. Read more
Source§

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

Debug formatter for the value. Read more
Source§

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

Applies a reflected value to this value. Read more
Source§

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

Returns a hash of the value (which includes the type). Read more
Source§

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

Returns a serializable version of the value. Read more
Source§

fn is_dynamic(&self) -> bool

Indicates whether or not this type is a dynamic type. Read more
Source§

impl Reflect for GlobalTransform
where GlobalTransform: Any + Send + Sync, Affine3A: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

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

Returns the value as a Box<dyn Any>. Read more
Source§

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

Returns the value as a &dyn Any. Read more
Source§

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

Returns the value as a &mut dyn Any. Read more
Source§

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

Casts this type to a boxed, fully-reflected value.
Source§

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

Casts this type to a fully-reflected value.
Source§

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

Casts this type to a mutable, fully-reflected value.
Source§

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

Performs a type-checked assignment of a reflected value to this value. Read more
Source§

impl Serialize for GlobalTransform

Source§

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. Read more
Source§

impl TransformPoint for GlobalTransform

Source§

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

Transform a point.
Source§

impl TupleStruct for GlobalTransform
where GlobalTransform: Any + Send + Sync, Affine3A: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

fn field(&self, index: usize) -> Option<&(dyn PartialReflect + 'static)>

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

fn field_mut( &mut self, index: usize, ) -> Option<&mut (dyn PartialReflect + 'static)>

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

fn field_len(&self) -> usize

Returns the number of fields in the tuple struct.
Source§

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

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

fn clone_dynamic(&self) -> DynamicTupleStruct

Clones the struct into a DynamicTupleStruct.
Source§

fn get_represented_tuple_struct_info(&self) -> Option<&'static TupleStructInfo>

Will return None if TypeInfo is not available.
Source§

impl TypePath for GlobalTransform

Source§

fn type_path() -> &'static str

Returns the fully qualified path of the underlying type. Read more
Source§

fn short_type_path() -> &'static str

Returns a short, pretty-print enabled path to the type. Read more
Source§

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

Returns the name of the type, or None if it is anonymous. Read more
Source§

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

Returns the name of the crate the type is in, or None if it is anonymous. Read more
Source§

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

Returns the path to the module the type is in, or None if it is anonymous. Read more
Source§

impl Typed for GlobalTransform
where GlobalTransform: Any + Send + Sync, Affine3A: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.
Source§

impl Copy for GlobalTransform

Source§

impl StructuralPartialEq for GlobalTransform

Auto Trait Implementations§

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T, U> AsBindGroupShaderType<U> for T
where U: ShaderType, &'a T: for<'a> Into<U>,

Source§

fn as_bind_group_shader_type(&self, _images: &RenderAssets<GpuImage>) -> U

Return the T ShaderType for self. When used in AsBindGroup derives, it is safe to assume that all images in self exist.
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<C> Bundle for C
where C: Component,

Source§

fn component_ids( components: &mut Components, storages: &mut Storages, ids: &mut impl FnMut(ComponentId), )

Source§

unsafe fn from_components<T, F>(ctx: &mut T, func: &mut F) -> C
where F: for<'a> FnMut(&'a mut T) -> OwningPtr<'a>,

Source§

fn register_required_components( components: &mut Components, storages: &mut Storages, required_components: &mut RequiredComponents, )

Registers components that are required by the components in this Bundle.
Source§

fn get_component_ids( components: &Components, ids: &mut impl FnMut(Option<ComponentId>), )

Gets this Bundle’s component ids. This will be None if the component has not been registered.
Source§

impl<T> CloneToUninit for T
where T: Clone,

Source§

unsafe fn clone_to_uninit(&self, dst: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
Source§

impl<T> Conv for T

Source§

fn conv<T>(self) -> T
where Self: Into<T>,

Converts self into T using Into<T>. Read more
Source§

impl<T> Downcast<T> for T

Source§

fn downcast(&self) -> &T

Source§

impl<T> Downcast for T
where T: Any,

Source§

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

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
Source§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
Source§

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

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &Any’s vtable from &Trait’s.
Source§

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

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
Source§

impl<T> DowncastSync for T
where T: Any + Send + Sync,

Source§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
Source§

impl<C> DynamicBundle for C
where C: Component,

Source§

fn get_components(self, func: &mut impl FnMut(StorageType, OwningPtr<'_>))

Source§

impl<T> DynamicTypePath for T
where T: TypePath,

Source§

impl<T> DynamicTyped for T
where T: Typed,

Source§

impl<T> FmtForward for T

Source§

fn fmt_binary(self) -> FmtBinary<Self>
where Self: Binary,

Causes self to use its Binary implementation when Debug-formatted.
Source§

fn fmt_display(self) -> FmtDisplay<Self>
where Self: Display,

Causes self to use its Display implementation when Debug-formatted.
Source§

fn fmt_lower_exp(self) -> FmtLowerExp<Self>
where Self: LowerExp,

Causes self to use its LowerExp implementation when Debug-formatted.
Source§

fn fmt_lower_hex(self) -> FmtLowerHex<Self>
where Self: LowerHex,

Causes self to use its LowerHex implementation when Debug-formatted.
Source§

fn fmt_octal(self) -> FmtOctal<Self>
where Self: Octal,

Causes self to use its Octal implementation when Debug-formatted.
Source§

fn fmt_pointer(self) -> FmtPointer<Self>
where Self: Pointer,

Causes self to use its Pointer implementation when Debug-formatted.
Source§

fn fmt_upper_exp(self) -> FmtUpperExp<Self>
where Self: UpperExp,

Causes self to use its UpperExp implementation when Debug-formatted.
Source§

fn fmt_upper_hex(self) -> FmtUpperHex<Self>
where Self: UpperHex,

Causes self to use its UpperHex implementation when Debug-formatted.
Source§

fn fmt_list(self) -> FmtList<Self>
where &'a Self: for<'a> IntoIterator,

Formats each item in a sequence. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<S> FromSample<S> for S

Source§

fn from_sample_(s: S) -> S

Source§

impl<T> FromWorld for T
where T: Default,

Source§

fn from_world(_world: &mut World) -> T

Creates Self using default().

Source§

impl<T> GetPath for T
where T: Reflect + ?Sized,

Source§

fn reflect_path<'p>( &self, path: impl ReflectPath<'p>, ) -> Result<&(dyn PartialReflect + 'static), ReflectPathError<'p>>

Returns a reference to the value specified by path. Read more
Source§

fn reflect_path_mut<'p>( &mut self, path: impl ReflectPath<'p>, ) -> Result<&mut (dyn PartialReflect + 'static), ReflectPathError<'p>>

Returns a mutable reference to the value specified by path. Read more
Source§

fn path<'p, T>( &self, path: impl ReflectPath<'p>, ) -> Result<&T, ReflectPathError<'p>>
where T: Reflect,

Returns a statically typed reference to the value specified by path. Read more
Source§

fn path_mut<'p, T>( &mut self, path: impl ReflectPath<'p>, ) -> Result<&mut T, ReflectPathError<'p>>
where T: Reflect,

Returns a statically typed mutable reference to the value specified by path. Read more
Source§

impl<S> GetTupleStructField for S
where S: TupleStruct,

Source§

fn get_field<T>(&self, index: usize) -> Option<&T>
where T: Reflect,

Returns a reference to the value of the field with index index, downcast to T.
Source§

fn get_field_mut<T>(&mut self, index: usize) -> Option<&mut T>
where T: Reflect,

Returns a mutable reference to the value of the field with index index, downcast to T.
Source§

impl<T> Instrument for T

Source§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more
Source§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> IntoEither for T

Source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

impl<F, T> IntoSample<T> for F
where T: FromSample<F>,

Source§

fn into_sample(self) -> T

Source§

impl<T> NoneValue for T
where T: Default,

Source§

type NoneType = T

Source§

fn null_value() -> T

The none-equivalent value.
Source§

impl<T> Pipe for T
where T: ?Sized,

Source§

fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
where Self: Sized,

Pipes by value. This is generally the method you want to use. Read more
Source§

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R
where R: 'a,

Borrows self and passes that borrow into the pipe function. Read more
Source§

fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R
where R: 'a,

Mutably borrows self and passes that borrow into the pipe function. Read more
Source§

fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
where Self: Borrow<B>, B: 'a + ?Sized, R: 'a,

Borrows self, then passes self.borrow() into the pipe function. Read more
Source§

fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R, ) -> R
where Self: BorrowMut<B>, B: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more
Source§

fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
where Self: AsRef<U>, U: 'a + ?Sized, R: 'a,

Borrows self, then passes self.as_ref() into the pipe function.
Source§

fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
where Self: AsMut<U>, U: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.as_mut() into the pipe function.
Source§

fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
where Self: Deref<Target = T>, T: 'a + ?Sized, R: 'a,

Borrows self, then passes self.deref() into the pipe function.
Source§

fn pipe_deref_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R, ) -> R
where Self: DerefMut<Target = T> + Deref, T: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.deref_mut() into the pipe function.
Source§

impl<T> Pointable for T

Source§

const ALIGN: usize

The alignment of pointer.
Source§

type Init = T

The type for initializers.
Source§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
Source§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
Source§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
Source§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
Source§

impl<R, P> ReadPrimitive<R> for P
where R: Read + ReadEndian<P>, P: Default,

Source§

fn read_from_little_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_little_endian().
Source§

fn read_from_big_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_big_endian().
Source§

fn read_from_native_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_native_endian().
Source§

impl<T> Same for T

Source§

type Output = T

Should always be Self
Source§

impl<T> Serialize for T
where T: Serialize + ?Sized,

Source§

fn erased_serialize(&self, serializer: &mut dyn Serializer) -> Result<(), Error>

Source§

fn do_erased_serialize( &self, serializer: &mut dyn Serializer, ) -> Result<(), ErrorImpl>

Source§

impl<T> Tap for T

Source§

fn tap(self, func: impl FnOnce(&Self)) -> Self

Immutable access to a value. Read more
Source§

fn tap_mut(self, func: impl FnOnce(&mut Self)) -> Self

Mutable access to a value. Read more
Source§

fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

Immutable access to the Borrow<B> of a value. Read more
Source§

fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut<B>, B: ?Sized,

Mutable access to the BorrowMut<B> of a value. Read more
Source§

fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

Immutable access to the AsRef<R> view of a value. Read more
Source§

fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

Mutable access to the AsMut<R> view of a value. Read more
Source§

fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

Immutable access to the Deref::Target of a value. Read more
Source§

fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

Mutable access to the Deref::Target of a value. Read more
Source§

fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self

Calls .tap() only in debug builds, and is erased in release builds.
Source§

fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self

Calls .tap_mut() only in debug builds, and is erased in release builds.
Source§

fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

Calls .tap_borrow() only in debug builds, and is erased in release builds.
Source§

fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut<B>, B: ?Sized,

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds.
Source§

fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

Calls .tap_ref() only in debug builds, and is erased in release builds.
Source§

fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

Calls .tap_ref_mut() only in debug builds, and is erased in release builds.
Source§

fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

Calls .tap_deref() only in debug builds, and is erased in release builds.
Source§

fn tap_deref_mut_dbg<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

Calls .tap_deref_mut() only in debug builds, and is erased in release builds.
Source§

impl<T> ToOwned for T
where T: Clone,

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
Source§

impl<T, U> ToSample<U> for T
where U: FromSample<T>,

Source§

fn to_sample_(self) -> U

Source§

impl<T> TryConv for T

Source§

fn try_conv<T>(self) -> Result<T, Self::Error>
where Self: TryInto<T>,

Attempts to convert self into T using TryInto<T>. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
Source§

impl<T> TypeData for T
where T: 'static + Send + Sync + Clone,

Source§

impl<T> Upcast<T> for T

Source§

fn upcast(&self) -> Option<&T>

Source§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

Source§

fn vzip(self) -> V

Source§

impl<T> WithSubscriber for T

Source§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more
Source§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more
Source§

impl<T> ConditionalSend for T
where T: Send,

Source§

impl<T> DeserializeOwned for T
where T: for<'de> Deserialize<'de>,

Source§

impl<S, T> Duplex<S> for T
where T: FromSample<S> + ToSample<S>,

Source§

impl<T> Reflectable for T

Source§

impl<T> Settings for T
where T: 'static + Send + Sync,

Source§

impl<T> WasmNotSend for T
where T: Send,

Source§

impl<T> WasmNotSendSync for T

Source§

impl<T> WasmNotSync for T
where T: Sync,