Struct Transform

Source

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

Expand description

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. GlobalTransform is automatically inserted whenever Transform is inserted.

§`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 ChildOf component.

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

GlobalTransform is updated from Transform in the TransformSystems::Propagate system set.

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

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§

Source §

Rotates this Transform so that the main_axis vector, reinterpreted in local coordinates, points in the given main_direction, while secondary_axis points towards secondary_direction. For example, if a spaceship model has its nose pointing in the X-direction in its own local coordinates and its dorsal fin pointing in the Y-direction, then align(Dir3::X, v, Dir3::Y, w) will make the spaceship’s nose point in the direction of v, while the dorsal fin does its best to point in the direction w.

In some cases a rotation cannot be constructed. Another axis will be picked in those cases:

if main_axis or main_direction fail converting to Dir3 (e.g are zero), Dir3::X takes their place
if secondary_axis or secondary_direction fail converting, Dir3::Y takes their place
if main_axis is parallel with secondary_axis or main_direction is parallel with secondary_direction, a rotation is constructed which takes main_axis to main_direction along a great circle, ignoring the secondary counterparts

See Transform::align for additional details.

Examples found in repository ?

examples/transforms/align.rs (line 226)

224fn random_axes_target_alignment(random_axes: &RandomAxes) -> Transform {
225    let RandomAxes(first, second) = random_axes;
226    Transform::IDENTITY.aligned_by(Vec3::NEG_Z, *first, Vec3::X, *second)
227}

Source

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

Returns this Transform with a new translation.

Examples found in repository ?

examples/ecs/parallel_query.rs (line 21)

10fn spawn_system(mut commands: Commands, asset_server: Res<AssetServer>) {
11    commands.spawn(Camera2d);
12    let texture = asset_server.load("branding/icon.png");
13
14    // We're seeding the PRNG here to make this example deterministic for testing purposes.
15    // This isn't strictly required in practical use unless you need your app to be deterministic.
16    let mut rng = ChaCha8Rng::seed_from_u64(19878367467713);
17    for z in 0..128 {
18        commands.spawn((
19            Sprite::from_image(texture.clone()),
20            Transform::from_scale(Vec3::splat(0.1))
21                .with_translation(Vec2::splat(0.0).extend(z as f32)),
22            Velocity(20.0 * Vec2::new(rng.random::<f32>() - 0.5, rng.random::<f32>() - 0.5)),
23        ));
24    }
25}

More examples

Hide additional examples

examples/3d/pcss.rs (line 192)

179fn spawn_light(commands: &mut Commands, app_status: &AppStatus) {
180    // Because this light can become a directional light, point light, or spot
181    // light depending on the settings, we add the union of the components
182    // necessary for this light to behave as all three of those.
183    commands
184        .spawn((
185            create_directional_light(app_status),
186            Transform::from_rotation(Quat::from_array([
187                0.6539259,
188                -0.34646285,
189                0.36505926,
190                -0.5648683,
191            ]))
192            .with_translation(vec3(57.693, 34.334, -6.422)),
193        ))
194        // These two are needed for point lights.
195        .insert(CubemapVisibleEntities::default())
196        .insert(CubemapFrusta::default())
197        // These two are needed for spot lights.
198        .insert(VisibleMeshEntities::default())
199        .insert(Frustum::default());
200}

examples/3d/fog.rs (line 87)

56fn setup_pyramid_scene(
57    mut commands: Commands,
58    mut meshes: ResMut<Assets<Mesh>>,
59    mut materials: ResMut<Assets<StandardMaterial>>,
60) {
61    let stone = materials.add(StandardMaterial {
62        base_color: Srgba::hex("28221B").unwrap().into(),
63        perceptual_roughness: 1.0,
64        ..default()
65    });
66
67    // pillars
68    for (x, z) in &[(-1.5, -1.5), (1.5, -1.5), (1.5, 1.5), (-1.5, 1.5)] {
69        commands.spawn((
70            Mesh3d(meshes.add(Cuboid::new(1.0, 3.0, 1.0))),
71            MeshMaterial3d(stone.clone()),
72            Transform::from_xyz(*x, 1.5, *z),
73        ));
74    }
75
76    // orb
77    commands.spawn((
78        Mesh3d(meshes.add(Sphere::default())),
79        MeshMaterial3d(materials.add(StandardMaterial {
80            base_color: Srgba::hex("126212CC").unwrap().into(),
81            reflectance: 1.0,
82            perceptual_roughness: 0.0,
83            metallic: 0.5,
84            alpha_mode: AlphaMode::Blend,
85            ..default()
86        })),
87        Transform::from_scale(Vec3::splat(1.75)).with_translation(Vec3::new(0.0, 4.0, 0.0)),
88        NotShadowCaster,
89        NotShadowReceiver,
90    ));
91
92    // steps
93    for i in 0..50 {
94        let half_size = i as f32 / 2.0 + 3.0;
95        let y = -i as f32 / 2.0;
96        commands.spawn((
97            Mesh3d(meshes.add(Cuboid::new(2.0 * half_size, 0.5, 2.0 * half_size))),
98            MeshMaterial3d(stone.clone()),
99            Transform::from_xyz(0.0, y + 0.25, 0.0),
100        ));
101    }
102
103    // sky
104    commands.spawn((
105        Mesh3d(meshes.add(Cuboid::new(2.0, 1.0, 1.0))),
106        MeshMaterial3d(materials.add(StandardMaterial {
107            base_color: Srgba::hex("888888").unwrap().into(),
108            unlit: true,
109            cull_mode: None,
110            ..default()
111        })),
112        Transform::from_scale(Vec3::splat(1_000_000.0)),
113    ));
114
115    // light
116    commands.spawn((
117        PointLight {
118            shadows_enabled: true,
119            ..default()
120        },
121        Transform::from_xyz(0.0, 1.0, 0.0),
122    ));
123}

examples/2d/sprite_animation.rs (line 123)

85fn setup(
86    mut commands: Commands,
87    asset_server: Res<AssetServer>,
88    mut texture_atlas_layouts: ResMut<Assets<TextureAtlasLayout>>,
89) {
90    commands.spawn(Camera2d);
91
92    // Create a minimal UI explaining how to interact with the example
93    commands.spawn((
94        Text::new("Left Arrow: Animate Left Sprite\nRight Arrow: Animate Right Sprite"),
95        Node {
96            position_type: PositionType::Absolute,
97            top: px(12),
98            left: px(12),
99            ..default()
100        },
101    ));
102
103    // Load the sprite sheet using the `AssetServer`
104    let texture = asset_server.load("textures/rpg/chars/gabe/gabe-idle-run.png");
105
106    // The sprite sheet has 7 sprites arranged in a row, and they are all 24px x 24px
107    let layout = TextureAtlasLayout::from_grid(UVec2::splat(24), 7, 1, None, None);
108    let texture_atlas_layout = texture_atlas_layouts.add(layout);
109
110    // The first (left-hand) sprite runs at 10 FPS
111    let animation_config_1 = AnimationConfig::new(1, 6, 10);
112
113    // Create the first (left-hand) sprite
114    commands.spawn((
115        Sprite {
116            image: texture.clone(),
117            texture_atlas: Some(TextureAtlas {
118                layout: texture_atlas_layout.clone(),
119                index: animation_config_1.first_sprite_index,
120            }),
121            ..default()
122        },
123        Transform::from_scale(Vec3::splat(6.0)).with_translation(Vec3::new(-70.0, 0.0, 0.0)),
124        LeftSprite,
125        animation_config_1,
126    ));
127
128    // The second (right-hand) sprite runs at 20 FPS
129    let animation_config_2 = AnimationConfig::new(1, 6, 20);
130
131    // Create the second (right-hand) sprite
132    commands.spawn((
133        Sprite {
134            image: texture.clone(),
135            texture_atlas: Some(TextureAtlas {
136                layout: texture_atlas_layout.clone(),
137                index: animation_config_2.first_sprite_index,
138            }),
139            ..Default::default()
140        },
141        Transform::from_scale(Vec3::splat(6.0)).with_translation(Vec3::new(70.0, 0.0, 0.0)),
142        RightSprite,
143        animation_config_2,
144    ));
145}

examples/3d/irradiance_volumes.rs (line 583)

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

examples/3d/meshlet.rs (line 94)

35fn setup(
36    mut commands: Commands,
37    asset_server: Res<AssetServer>,
38    mut standard_materials: ResMut<Assets<StandardMaterial>>,
39    mut debug_materials: ResMut<Assets<MeshletDebugMaterial>>,
40    mut meshes: ResMut<Assets<Mesh>>,
41) {
42    commands.spawn((
43        Camera3d::default(),
44        Transform::from_translation(Vec3::new(1.8, 0.4, -0.1)).looking_at(Vec3::ZERO, Vec3::Y),
45        Msaa::Off,
46        EnvironmentMapLight {
47            diffuse_map: asset_server.load("environment_maps/pisa_diffuse_rgb9e5_zstd.ktx2"),
48            specular_map: asset_server.load("environment_maps/pisa_specular_rgb9e5_zstd.ktx2"),
49            intensity: 150.0,
50            ..default()
51        },
52        CameraController::default(),
53    ));
54
55    commands.spawn((
56        DirectionalLight {
57            illuminance: light_consts::lux::FULL_DAYLIGHT,
58            shadows_enabled: true,
59            ..default()
60        },
61        CascadeShadowConfigBuilder {
62            num_cascades: 1,
63            maximum_distance: 15.0,
64            ..default()
65        }
66        .build(),
67        Transform::from_rotation(Quat::from_euler(EulerRot::ZYX, 0.0, PI * -0.15, PI * -0.15)),
68    ));
69
70    // A custom file format storing a [`bevy_mesh::Mesh`]
71    // that has been converted to a [`bevy_pbr::meshlet::MeshletMesh`]
72    // using [`bevy_pbr::meshlet::MeshletMesh::from_mesh`], which is
73    // a function only available when the `meshlet_processor` cargo feature is enabled.
74    let meshlet_mesh_handle = asset_server.load(ASSET_URL);
75    let debug_material = debug_materials.add(MeshletDebugMaterial::default());
76
77    for x in -2..=2 {
78        commands.spawn((
79            MeshletMesh3d(meshlet_mesh_handle.clone()),
80            MeshMaterial3d(standard_materials.add(StandardMaterial {
81                base_color: match x {
82                    -2 => Srgba::hex("#dc2626").unwrap().into(),
83                    -1 => Srgba::hex("#ea580c").unwrap().into(),
84                    0 => Srgba::hex("#facc15").unwrap().into(),
85                    1 => Srgba::hex("#16a34a").unwrap().into(),
86                    2 => Srgba::hex("#0284c7").unwrap().into(),
87                    _ => unreachable!(),
88                },
89                perceptual_roughness: (x + 2) as f32 / 4.0,
90                ..default()
91            })),
92            Transform::default()
93                .with_scale(Vec3::splat(0.2))
94                .with_translation(Vec3::new(x as f32 / 2.0, 0.0, -0.3)),
95        ));
96    }
97    for x in -2..=2 {
98        commands.spawn((
99            MeshletMesh3d(meshlet_mesh_handle.clone()),
100            MeshMaterial3d(debug_material.clone()),
101            Transform::default()
102                .with_scale(Vec3::splat(0.2))
103                .with_rotation(Quat::from_rotation_y(PI))
104                .with_translation(Vec3::new(x as f32 / 2.0, 0.0, 0.3)),
105        ));
106    }
107
108    commands.spawn((
109        Mesh3d(meshes.add(Plane3d::default().mesh().size(5.0, 5.0))),
110        MeshMaterial3d(standard_materials.add(StandardMaterial {
111            base_color: Color::WHITE,
112            perceptual_roughness: 1.0,
113            ..default()
114        })),
115    ));
116}

Additional examples can be found in:

Source

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

Returns this Transform with a new rotation.

Examples found in repository ?

examples/3d/post_processing.rs (line 101)

89fn spawn_scene(commands: &mut Commands, asset_server: &AssetServer) {
90    // Spawn the main scene.
91    commands.spawn(SceneRoot(asset_server.load(
92        GltfAssetLabel::Scene(0).from_asset("models/TonemappingTest/TonemappingTest.gltf"),
93    )));
94
95    // Spawn the flight helmet.
96    commands.spawn((
97        SceneRoot(
98            asset_server
99                .load(GltfAssetLabel::Scene(0).from_asset("models/FlightHelmet/FlightHelmet.gltf")),
100        ),
101        Transform::from_xyz(0.5, 0.0, -0.5).with_rotation(Quat::from_rotation_y(-0.15 * PI)),
102    ));
103
104    // Spawn the light.
105    commands.spawn((
106        DirectionalLight {
107            illuminance: 15000.0,
108            shadows_enabled: true,
109            ..default()
110        },
111        Transform::from_rotation(Quat::from_euler(EulerRot::ZYX, 0.0, PI * -0.15, PI * -0.15)),
112        CascadeShadowConfigBuilder {
113            maximum_distance: 3.0,
114            first_cascade_far_bound: 0.9,
115            ..default()
116        }
117        .build(),
118    ));
119}

More examples

Hide additional examples

examples/3d/pcss.rs (lines 156-158)

152fn spawn_camera(commands: &mut Commands, asset_server: &AssetServer) {
153    commands
154        .spawn((
155            Camera3d::default(),
156            Transform::from_xyz(-12.912 * 0.7, 4.466 * 0.7, -10.624 * 0.7).with_rotation(
157                Quat::from_euler(EulerRot::YXZ, -134.76 / 180.0 * PI, -0.175, 0.0),
158            ),
159        ))
160        .insert(ShadowFilteringMethod::Gaussian)
161        // `TemporalJitter` is needed for TAA. Note that it does nothing without
162        // `TemporalAntiAliasSettings`.
163        .insert(TemporalJitter::default())
164        // We want MSAA off for TAA to work properly.
165        .insert(Msaa::Off)
166        // The depth prepass is needed for TAA.
167        .insert(DepthPrepass)
168        // The motion vector prepass is needed for TAA.
169        .insert(MotionVectorPrepass)
170        // Add a nice skybox.
171        .insert(Skybox {
172            image: asset_server.load("environment_maps/sky_skybox.ktx2"),
173            brightness: 500.0,
174            rotation: Quat::IDENTITY,
175        });
176}

examples/3d/color_grading.rs (line 356)

344fn add_basic_scene(commands: &mut Commands, asset_server: &AssetServer) {
345    // Spawn the main scene.
346    commands.spawn(SceneRoot(asset_server.load(
347        GltfAssetLabel::Scene(0).from_asset("models/TonemappingTest/TonemappingTest.gltf"),
348    )));
349
350    // Spawn the flight helmet.
351    commands.spawn((
352        SceneRoot(
353            asset_server
354                .load(GltfAssetLabel::Scene(0).from_asset("models/FlightHelmet/FlightHelmet.gltf")),
355        ),
356        Transform::from_xyz(0.5, 0.0, -0.5).with_rotation(Quat::from_rotation_y(-0.15 * PI)),
357    ));
358
359    // Spawn the light.
360    commands.spawn((
361        DirectionalLight {
362            illuminance: 15000.0,
363            shadows_enabled: true,
364            ..default()
365        },
366        Transform::from_rotation(Quat::from_euler(EulerRot::ZYX, 0.0, PI * -0.15, PI * -0.15)),
367        CascadeShadowConfigBuilder {
368            maximum_distance: 3.0,
369            first_cascade_far_bound: 0.9,
370            ..default()
371        }
372        .build(),
373    ));
374}

examples/3d/tonemapping.rs (line 114)

99fn setup_basic_scene(mut commands: Commands, asset_server: Res<AssetServer>) {
100    // Main scene
101    commands.spawn((
102        SceneRoot(asset_server.load(
103            GltfAssetLabel::Scene(0).from_asset("models/TonemappingTest/TonemappingTest.gltf"),
104        )),
105        SceneNumber(1),
106    ));
107
108    // Flight Helmet
109    commands.spawn((
110        SceneRoot(
111            asset_server
112                .load(GltfAssetLabel::Scene(0).from_asset("models/FlightHelmet/FlightHelmet.gltf")),
113        ),
114        Transform::from_xyz(0.5, 0.0, -0.5).with_rotation(Quat::from_rotation_y(-0.15 * PI)),
115        SceneNumber(1),
116    ));
117
118    // light
119    commands.spawn((
120        DirectionalLight {
121            illuminance: 15_000.,
122            shadows_enabled: true,
123            ..default()
124        },
125        Transform::from_rotation(Quat::from_euler(EulerRot::ZYX, 0.0, PI * -0.15, PI * -0.15)),
126        CascadeShadowConfigBuilder {
127            maximum_distance: 3.0,
128            first_cascade_far_bound: 0.9,
129            ..default()
130        }
131        .build(),
132        SceneNumber(1),
133    ));
134}

examples/3d/skybox.rs (line 69)

62fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
63    // directional 'sun' light
64    commands.spawn((
65        DirectionalLight {
66            illuminance: 32000.0,
67            ..default()
68        },
69        Transform::from_xyz(0.0, 2.0, 0.0).with_rotation(Quat::from_rotation_x(-PI / 4.)),
70    ));
71
72    let skybox_handle = asset_server.load(CUBEMAPS[0].0);
73    // camera
74    commands.spawn((
75        Camera3d::default(),
76        Msaa::Off,
77        TemporalAntiAliasing::default(),
78        ScreenSpaceAmbientOcclusion::default(),
79        Transform::from_xyz(0.0, 0.0, 8.0).looking_at(Vec3::ZERO, Vec3::Y),
80        CameraController::default(),
81        Skybox {
82            image: skybox_handle.clone(),
83            brightness: 1000.0,
84            ..default()
85        },
86    ));
87
88    // ambient light
89    // NOTE: The ambient light is used to scale how bright the environment map is so with a bright
90    // environment map, use an appropriate color and brightness to match
91    commands.insert_resource(AmbientLight {
92        color: Color::srgb_u8(210, 220, 240),
93        brightness: 1.0,
94        ..default()
95    });
96
97    commands.insert_resource(Cubemap {
98        is_loaded: false,
99        index: 0,
100        image_handle: skybox_handle,
101    });
102}

examples/3d/mesh_ray_cast.rs (line 82)

71fn setup(
72    mut commands: Commands,
73    mut meshes: ResMut<Assets<Mesh>>,
74    mut materials: ResMut<Assets<StandardMaterial>>,
75) {
76    // Make a box of planes facing inward so the laser gets trapped inside
77    let plane_mesh = meshes.add(Plane3d::default());
78    let plane_material = materials.add(Color::from(css::GRAY).with_alpha(0.01));
79    let create_plane = move |translation, rotation| {
80        (
81            Transform::from_translation(translation)
82                .with_rotation(Quat::from_scaled_axis(rotation)),
83            Mesh3d(plane_mesh.clone()),
84            MeshMaterial3d(plane_material.clone()),
85        )
86    };
87
88    commands.spawn(create_plane(vec3(0.0, 0.5, 0.0), Vec3::X * PI));
89    commands.spawn(create_plane(vec3(0.0, -0.5, 0.0), Vec3::ZERO));
90    commands.spawn(create_plane(vec3(0.5, 0.0, 0.0), Vec3::Z * FRAC_PI_2));
91    commands.spawn(create_plane(vec3(-0.5, 0.0, 0.0), Vec3::Z * -FRAC_PI_2));
92    commands.spawn(create_plane(vec3(0.0, 0.0, 0.5), Vec3::X * -FRAC_PI_2));
93    commands.spawn(create_plane(vec3(0.0, 0.0, -0.5), Vec3::X * FRAC_PI_2));
94
95    // Light
96    commands.spawn((
97        DirectionalLight::default(),
98        Transform::from_rotation(Quat::from_euler(EulerRot::XYZ, -0.1, 0.2, 0.0)),
99    ));
100
101    // Camera
102    commands.spawn((
103        Camera3d::default(),
104        Transform::from_xyz(1.5, 1.5, 1.5).looking_at(Vec3::ZERO, Vec3::Y),
105        Tonemapping::TonyMcMapface,
106        Bloom::default(),
107    ));
108}

Additional examples can be found in:

Source

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

Returns this Transform with a new scale.

Examples found in repository ?

examples/3d/clustered_decals.rs (line 340)

336fn calculate_initial_decal_transform(start: Vec3, looking_at: Vec3, size: Vec2) -> Transform {
337    let direction = looking_at - start;
338    let center = start + direction * 0.5;
339    Transform::from_translation(center)
340        .with_scale((size * 0.5).extend(direction.length()))
341        .looking_to(direction, Vec3::Y)
342}

More examples

Hide additional examples

examples/3d/irradiance_volumes.rs (line 273)

268fn spawn_sphere(commands: &mut Commands, assets: &ExampleAssets) {
269    commands
270        .spawn((
271            Mesh3d(assets.main_sphere.clone()),
272            MeshMaterial3d(assets.main_sphere_material.clone()),
273            Transform::from_xyz(0.0, SPHERE_SCALE, 0.0).with_scale(Vec3::splat(SPHERE_SCALE)),
274        ))
275        .insert(MainObject);
276}

examples/2d/mesh2d.rs (line 22)

12fn setup(
13    mut commands: Commands,
14    mut meshes: ResMut<Assets<Mesh>>,
15    mut materials: ResMut<Assets<ColorMaterial>>,
16) {
17    commands.spawn(Camera2d);
18
19    commands.spawn((
20        Mesh2d(meshes.add(Rectangle::default())),
21        MeshMaterial2d(materials.add(Color::from(PURPLE))),
22        Transform::default().with_scale(Vec3::splat(128.)),
23    ));
24}

examples/2d/pixel_grid_snap.rs (line 78)

70fn setup_mesh(
71    mut commands: Commands,
72    mut meshes: ResMut<Assets<Mesh>>,
73    mut materials: ResMut<Assets<ColorMaterial>>,
74) {
75    commands.spawn((
76        Mesh2d(meshes.add(Capsule2d::default())),
77        MeshMaterial2d(materials.add(Color::BLACK)),
78        Transform::from_xyz(25., 0., 2.).with_scale(Vec3::splat(32.)),
79        Rotate,
80        PIXEL_PERFECT_LAYERS,
81    ));
82}

examples/shader/shader_material_2d.rs (line 41)

25fn setup(
26    mut commands: Commands,
27    mut meshes: ResMut<Assets<Mesh>>,
28    mut materials: ResMut<Assets<CustomMaterial>>,
29    asset_server: Res<AssetServer>,
30) {
31    // camera
32    commands.spawn(Camera2d);
33
34    // quad
35    commands.spawn((
36        Mesh2d(meshes.add(Rectangle::default())),
37        MeshMaterial2d(materials.add(CustomMaterial {
38            color: LinearRgba::BLUE,
39            color_texture: Some(asset_server.load("branding/icon.png")),
40        })),
41        Transform::default().with_scale(Vec3::splat(128.)),
42    ));
43}

examples/shader_advanced/render_depth_to_texture.rs (line 209)

196fn spawn_plane(
197    commands: &mut Commands,
198    meshes: &mut Assets<Mesh>,
199    show_depth_texture_materials: &mut Assets<ShowDepthTextureMaterial>,
200    demo_depth_texture: &DemoDepthTexture,
201) {
202    let plane_handle = meshes.add(Plane3d::new(Vec3::Z, Vec2::splat(2.0)));
203    let show_depth_texture_material = show_depth_texture_materials.add(ShowDepthTextureMaterial {
204        depth_texture: Some(demo_depth_texture.0.clone()),
205    });
206    commands.spawn((
207        Mesh3d(plane_handle),
208        MeshMaterial3d(show_depth_texture_material),
209        Transform::from_xyz(10.0, 4.0, 0.0).with_scale(Vec3::splat(2.5)),
210    ));
211}

Source

pub fn to_matrix(&self) -> Mat4

Computes the 3d affine transformation matrix from this transform’s translation, rotation, and scale.

Source

pub fn compute_affine(&self) -> Affine3A

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

Source

pub fn local_x(&self) -> Dir3

Get the unit vector in the local X direction.

Examples found in repository ?

examples/transforms/translation.rs (line 68)

62fn move_cube(mut cubes: Query<(&mut Transform, &mut Movable)>, timer: Res<Time>) {
63    for (mut transform, mut cube) in &mut cubes {
64        // Check if the entity moved too far from its spawn, if so invert the moving direction.
65        if (cube.spawn - transform.translation).length() > cube.max_distance {
66            cube.speed *= -1.0;
67        }
68        let direction = transform.local_x();
69        transform.translation += direction * cube.speed * timer.delta_secs();
70    }
71}

Source

pub fn left(&self) -> Dir3

Equivalent to -local_x()

Source

pub fn right(&self) -> Dir3

Equivalent to local_x()

Examples found in repository ?

examples/ecs/fallible_params.rs (line 128)

124fn move_targets(mut enemies: Populated<(&mut Transform, &mut Enemy)>, time: Res<Time>) {
125    for (mut transform, mut target) in &mut *enemies {
126        target.rotation += target.rotation_speed * time.delta_secs();
127        transform.rotation = Quat::from_rotation_z(target.rotation);
128        let offset = transform.right() * target.radius;
129        transform.translation = target.origin.extend(0.0) + offset;
130    }
131}

More examples

Hide additional examples

examples/3d/../helpers/camera_controller.rs (line 220)

127fn run_camera_controller(
128    time: Res<Time<Real>>,
129    mut windows: Query<(&Window, &mut CursorOptions)>,
130    accumulated_mouse_motion: Res<AccumulatedMouseMotion>,
131    accumulated_mouse_scroll: Res<AccumulatedMouseScroll>,
132    mouse_button_input: Res<ButtonInput<MouseButton>>,
133    key_input: Res<ButtonInput<KeyCode>>,
134    mut toggle_cursor_grab: Local<bool>,
135    mut mouse_cursor_grab: Local<bool>,
136    mut query: Query<(&mut Transform, &mut CameraController), With<Camera>>,
137) {
138    let dt = time.delta_secs();
139
140    let Ok((mut transform, mut controller)) = query.single_mut() else {
141        return;
142    };
143
144    if !controller.initialized {
145        let (yaw, pitch, _roll) = transform.rotation.to_euler(EulerRot::YXZ);
146        controller.yaw = yaw;
147        controller.pitch = pitch;
148        controller.initialized = true;
149        info!("{}", *controller);
150    }
151    if !controller.enabled {
152        return;
153    }
154
155    let mut scroll = 0.0;
156
157    let amount = match accumulated_mouse_scroll.unit {
158        MouseScrollUnit::Line => accumulated_mouse_scroll.delta.y,
159        MouseScrollUnit::Pixel => accumulated_mouse_scroll.delta.y / 16.0,
160    };
161    scroll += amount;
162    controller.walk_speed += scroll * controller.scroll_factor * controller.walk_speed;
163    controller.run_speed = controller.walk_speed * 3.0;
164
165    // Handle key input
166    let mut axis_input = Vec3::ZERO;
167    if key_input.pressed(controller.key_forward) {
168        axis_input.z += 1.0;
169    }
170    if key_input.pressed(controller.key_back) {
171        axis_input.z -= 1.0;
172    }
173    if key_input.pressed(controller.key_right) {
174        axis_input.x += 1.0;
175    }
176    if key_input.pressed(controller.key_left) {
177        axis_input.x -= 1.0;
178    }
179    if key_input.pressed(controller.key_up) {
180        axis_input.y += 1.0;
181    }
182    if key_input.pressed(controller.key_down) {
183        axis_input.y -= 1.0;
184    }
185
186    let mut cursor_grab_change = false;
187    if key_input.just_pressed(controller.keyboard_key_toggle_cursor_grab) {
188        *toggle_cursor_grab = !*toggle_cursor_grab;
189        cursor_grab_change = true;
190    }
191    if mouse_button_input.just_pressed(controller.mouse_key_cursor_grab) {
192        *mouse_cursor_grab = true;
193        cursor_grab_change = true;
194    }
195    if mouse_button_input.just_released(controller.mouse_key_cursor_grab) {
196        *mouse_cursor_grab = false;
197        cursor_grab_change = true;
198    }
199    let cursor_grab = *mouse_cursor_grab || *toggle_cursor_grab;
200
201    // Update velocity
202    if axis_input != Vec3::ZERO {
203        let max_speed = if key_input.pressed(controller.key_run) {
204            controller.run_speed
205        } else {
206            controller.walk_speed
207        };
208        controller.velocity = axis_input.normalize() * max_speed;
209    } else {
210        let friction = controller.friction.clamp(0.0, 1.0);
211        controller.velocity *= 1.0 - friction;
212        if controller.velocity.length_squared() < 1e-6 {
213            controller.velocity = Vec3::ZERO;
214        }
215    }
216
217    // Apply movement update
218    if controller.velocity != Vec3::ZERO {
219        let forward = *transform.forward();
220        let right = *transform.right();
221        transform.translation += controller.velocity.x * dt * right
222            + controller.velocity.y * dt * Vec3::Y
223            + controller.velocity.z * dt * forward;
224    }
225
226    // Handle cursor grab
227    if cursor_grab_change {
228        if cursor_grab {
229            for (window, mut cursor_options) in &mut windows {
230                if !window.focused {
231                    continue;
232                }
233
234                cursor_options.grab_mode = CursorGrabMode::Locked;
235                cursor_options.visible = false;
236            }
237        } else {
238            for (_, mut cursor_options) in &mut windows {
239                cursor_options.grab_mode = CursorGrabMode::None;
240                cursor_options.visible = true;
241            }
242        }
243    }
244
245    // Handle mouse input
246    if accumulated_mouse_motion.delta != Vec2::ZERO && cursor_grab {
247        // Apply look update
248        controller.pitch = (controller.pitch
249            - accumulated_mouse_motion.delta.y * RADIANS_PER_DOT * controller.sensitivity)
250            .clamp(-PI / 2., PI / 2.);
251        controller.yaw -=
252            accumulated_mouse_motion.delta.x * RADIANS_PER_DOT * controller.sensitivity;
253        transform.rotation = Quat::from_euler(EulerRot::ZYX, 0.0, controller.yaw, controller.pitch);
254    }
255}

Source

pub fn local_y(&self) -> Dir3

Get the unit vector in the local Y direction.

Examples found in repository ?

examples/transforms/transform.rs (line 114)

101fn rotate_cube(
102    mut cubes: Query<(&mut Transform, &mut CubeState), Without<Center>>,
103    center_spheres: Query<&Transform, With<Center>>,
104    timer: Res<Time>,
105) {
106    // Calculate the point to circle around. (The position of the center_sphere)
107    let mut center: Vec3 = Vec3::ZERO;
108    for sphere in &center_spheres {
109        center += sphere.translation;
110    }
111    // Update the rotation of the cube(s).
112    for (mut transform, cube) in &mut cubes {
113        // Calculate the rotation of the cube if it would be looking at the sphere in the center.
114        let look_at_sphere = transform.looking_at(center, *transform.local_y());
115        // Interpolate between the current rotation and the fully turned rotation
116        // when looking at the sphere, with a given turn speed to get a smooth motion.
117        // With higher speed the curvature of the orbit would be smaller.
118        let incremental_turn_weight = cube.turn_speed * timer.delta_secs();
119        let old_rotation = transform.rotation;
120        transform.rotation = old_rotation.lerp(look_at_sphere.rotation, incremental_turn_weight);
121    }
122}

Source

pub fn up(&self) -> Dir3

Equivalent to local_y()

Source

pub fn down(&self) -> Dir3

Equivalent to -local_y()

Source

pub fn local_z(&self) -> Dir3

Get the unit vector in the local Z direction.

Examples found in repository ?

examples/3d/ssr.rs (line 328)

300fn move_camera(
301    keyboard_input: Res<ButtonInput<KeyCode>>,
302    mut mouse_wheel_reader: MessageReader<MouseWheel>,
303    mut cameras: Query<&mut Transform, With<Camera>>,
304) {
305    let (mut distance_delta, mut theta_delta) = (0.0, 0.0);
306
307    // Handle keyboard events.
308    if keyboard_input.pressed(KeyCode::KeyW) {
309        distance_delta -= CAMERA_KEYBOARD_ZOOM_SPEED;
310    }
311    if keyboard_input.pressed(KeyCode::KeyS) {
312        distance_delta += CAMERA_KEYBOARD_ZOOM_SPEED;
313    }
314    if keyboard_input.pressed(KeyCode::KeyA) {
315        theta_delta += CAMERA_KEYBOARD_ORBIT_SPEED;
316    }
317    if keyboard_input.pressed(KeyCode::KeyD) {
318        theta_delta -= CAMERA_KEYBOARD_ORBIT_SPEED;
319    }
320
321    // Handle mouse events.
322    for mouse_wheel in mouse_wheel_reader.read() {
323        distance_delta -= mouse_wheel.y * CAMERA_MOUSE_WHEEL_ZOOM_SPEED;
324    }
325
326    // Update transforms.
327    for mut camera_transform in cameras.iter_mut() {
328        let local_z = camera_transform.local_z().as_vec3().normalize_or_zero();
329        if distance_delta != 0.0 {
330            camera_transform.translation = (camera_transform.translation.length() + distance_delta)
331                .clamp(CAMERA_ZOOM_RANGE.start, CAMERA_ZOOM_RANGE.end)
332                * local_z;
333        }
334        if theta_delta != 0.0 {
335            camera_transform
336                .translate_around(Vec3::ZERO, Quat::from_axis_angle(Vec3::Y, theta_delta));
337            camera_transform.look_at(Vec3::ZERO, Vec3::Y);
338        }
339    }
340}

Source

pub fn forward(&self) -> Dir3

Equivalent to -local_z()

Examples found in repository ?

examples/transforms/transform.rs (line 93)

90fn move_cube(mut cubes: Query<(&mut Transform, &mut CubeState)>, timer: Res<Time>) {
91    for (mut transform, cube) in &mut cubes {
92        // Move the cube forward smoothly at a given move_speed.
93        let forward = transform.forward();
94        transform.translation += forward * cube.move_speed * timer.delta_secs();
95    }
96}

More examples

Hide additional examples

examples/3d/tonemapping.rs (line 143)

136fn setup_color_gradient_scene(
137    mut commands: Commands,
138    mut meshes: ResMut<Assets<Mesh>>,
139    mut materials: ResMut<Assets<ColorGradientMaterial>>,
140    camera_transform: Res<CameraTransform>,
141) {
142    let mut transform = camera_transform.0;
143    transform.translation += *transform.forward();
144
145    commands.spawn((
146        Mesh3d(meshes.add(Rectangle::new(0.7, 0.7))),
147        MeshMaterial3d(materials.add(ColorGradientMaterial {})),
148        transform,
149        Visibility::Hidden,
150        SceneNumber(2),
151    ));
152}
153
154fn setup_image_viewer_scene(
155    mut commands: Commands,
156    mut meshes: ResMut<Assets<Mesh>>,
157    mut materials: ResMut<Assets<StandardMaterial>>,
158    camera_transform: Res<CameraTransform>,
159) {
160    let mut transform = camera_transform.0;
161    transform.translation += *transform.forward();
162
163    // exr/hdr viewer (exr requires enabling bevy feature)
164    commands.spawn((
165        Mesh3d(meshes.add(Rectangle::default())),
166        MeshMaterial3d(materials.add(StandardMaterial {
167            base_color_texture: None,
168            unlit: true,
169            ..default()
170        })),
171        transform,
172        Visibility::Hidden,
173        SceneNumber(3),
174        HDRViewer,
175    ));
176
177    commands.spawn((
178        Text::new("Drag and drop an HDR or EXR file"),
179        TextFont {
180            font_size: 36.0,
181            ..default()
182        },
183        TextColor(Color::BLACK),
184        TextLayout::new_with_justify(Justify::Center),
185        Node {
186            align_self: AlignSelf::Center,
187            margin: UiRect::all(auto()),
188            ..default()
189        },
190        SceneNumber(3),
191        Visibility::Hidden,
192    ));
193}

examples/3d/motion_blur.rs (line 347)

330fn move_camera(
331    camera: Single<(&mut Transform, &mut Projection), Without<CameraTracked>>,
332    tracked: Single<&Transform, With<CameraTracked>>,
333    mode: Res<CameraMode>,
334) {
335    let (mut transform, mut projection) = camera.into_inner();
336    match *mode {
337        CameraMode::Track => {
338            transform.look_at(tracked.translation, Vec3::Y);
339            transform.translation = Vec3::new(15.0, -0.5, 0.0);
340            if let Projection::Perspective(perspective) = &mut *projection {
341                perspective.fov = 0.05;
342            }
343        }
344        CameraMode::Chase => {
345            transform.translation =
346                tracked.translation + Vec3::new(0.0, 0.15, 0.0) + tracked.back() * 0.6;
347            transform.look_to(tracked.forward(), Vec3::Y);
348            if let Projection::Perspective(perspective) = &mut *projection {
349                perspective.fov = 1.0;
350            }
351        }
352    }
353}

examples/camera/camera_orbit.rs (line 140)

99fn orbit(
100    mut camera: Single<&mut Transform, With<Camera>>,
101    camera_settings: Res<CameraSettings>,
102    mouse_buttons: Res<ButtonInput<MouseButton>>,
103    mouse_motion: Res<AccumulatedMouseMotion>,
104    time: Res<Time>,
105) {
106    let delta = mouse_motion.delta;
107    let mut delta_roll = 0.0;
108
109    if mouse_buttons.pressed(MouseButton::Left) {
110        delta_roll -= 1.0;
111    }
112    if mouse_buttons.pressed(MouseButton::Right) {
113        delta_roll += 1.0;
114    }
115
116    // Mouse motion is one of the few inputs that should not be multiplied by delta time,
117    // as we are already receiving the full movement since the last frame was rendered. Multiplying
118    // by delta time here would make the movement slower that it should be.
119    let delta_pitch = delta.y * camera_settings.pitch_speed;
120    let delta_yaw = delta.x * camera_settings.yaw_speed;
121
122    // Conversely, we DO need to factor in delta time for mouse button inputs.
123    delta_roll *= camera_settings.roll_speed * time.delta_secs();
124
125    // Obtain the existing pitch, yaw, and roll values from the transform.
126    let (yaw, pitch, roll) = camera.rotation.to_euler(EulerRot::YXZ);
127
128    // Establish the new yaw and pitch, preventing the pitch value from exceeding our limits.
129    let pitch = (pitch + delta_pitch).clamp(
130        camera_settings.pitch_range.start,
131        camera_settings.pitch_range.end,
132    );
133    let roll = roll + delta_roll;
134    let yaw = yaw + delta_yaw;
135    camera.rotation = Quat::from_euler(EulerRot::YXZ, yaw, pitch, roll);
136
137    // Adjust the translation to maintain the correct orientation toward the orbit target.
138    // In our example it's a static target, but this could easily be customized.
139    let target = Vec3::ZERO;
140    camera.translation = target - camera.forward() * camera_settings.orbit_distance;
141}

examples/3d/../helpers/camera_controller.rs (line 219)

127fn run_camera_controller(
128    time: Res<Time<Real>>,
129    mut windows: Query<(&Window, &mut CursorOptions)>,
130    accumulated_mouse_motion: Res<AccumulatedMouseMotion>,
131    accumulated_mouse_scroll: Res<AccumulatedMouseScroll>,
132    mouse_button_input: Res<ButtonInput<MouseButton>>,
133    key_input: Res<ButtonInput<KeyCode>>,
134    mut toggle_cursor_grab: Local<bool>,
135    mut mouse_cursor_grab: Local<bool>,
136    mut query: Query<(&mut Transform, &mut CameraController), With<Camera>>,
137) {
138    let dt = time.delta_secs();
139
140    let Ok((mut transform, mut controller)) = query.single_mut() else {
141        return;
142    };
143
144    if !controller.initialized {
145        let (yaw, pitch, _roll) = transform.rotation.to_euler(EulerRot::YXZ);
146        controller.yaw = yaw;
147        controller.pitch = pitch;
148        controller.initialized = true;
149        info!("{}", *controller);
150    }
151    if !controller.enabled {
152        return;
153    }
154
155    let mut scroll = 0.0;
156
157    let amount = match accumulated_mouse_scroll.unit {
158        MouseScrollUnit::Line => accumulated_mouse_scroll.delta.y,
159        MouseScrollUnit::Pixel => accumulated_mouse_scroll.delta.y / 16.0,
160    };
161    scroll += amount;
162    controller.walk_speed += scroll * controller.scroll_factor * controller.walk_speed;
163    controller.run_speed = controller.walk_speed * 3.0;
164
165    // Handle key input
166    let mut axis_input = Vec3::ZERO;
167    if key_input.pressed(controller.key_forward) {
168        axis_input.z += 1.0;
169    }
170    if key_input.pressed(controller.key_back) {
171        axis_input.z -= 1.0;
172    }
173    if key_input.pressed(controller.key_right) {
174        axis_input.x += 1.0;
175    }
176    if key_input.pressed(controller.key_left) {
177        axis_input.x -= 1.0;
178    }
179    if key_input.pressed(controller.key_up) {
180        axis_input.y += 1.0;
181    }
182    if key_input.pressed(controller.key_down) {
183        axis_input.y -= 1.0;
184    }
185
186    let mut cursor_grab_change = false;
187    if key_input.just_pressed(controller.keyboard_key_toggle_cursor_grab) {
188        *toggle_cursor_grab = !*toggle_cursor_grab;
189        cursor_grab_change = true;
190    }
191    if mouse_button_input.just_pressed(controller.mouse_key_cursor_grab) {
192        *mouse_cursor_grab = true;
193        cursor_grab_change = true;
194    }
195    if mouse_button_input.just_released(controller.mouse_key_cursor_grab) {
196        *mouse_cursor_grab = false;
197        cursor_grab_change = true;
198    }
199    let cursor_grab = *mouse_cursor_grab || *toggle_cursor_grab;
200
201    // Update velocity
202    if axis_input != Vec3::ZERO {
203        let max_speed = if key_input.pressed(controller.key_run) {
204            controller.run_speed
205        } else {
206            controller.walk_speed
207        };
208        controller.velocity = axis_input.normalize() * max_speed;
209    } else {
210        let friction = controller.friction.clamp(0.0, 1.0);
211        controller.velocity *= 1.0 - friction;
212        if controller.velocity.length_squared() < 1e-6 {
213            controller.velocity = Vec3::ZERO;
214        }
215    }
216
217    // Apply movement update
218    if controller.velocity != Vec3::ZERO {
219        let forward = *transform.forward();
220        let right = *transform.right();
221        transform.translation += controller.velocity.x * dt * right
222            + controller.velocity.y * dt * Vec3::Y
223            + controller.velocity.z * dt * forward;
224    }
225
226    // Handle cursor grab
227    if cursor_grab_change {
228        if cursor_grab {
229            for (window, mut cursor_options) in &mut windows {
230                if !window.focused {
231                    continue;
232                }
233
234                cursor_options.grab_mode = CursorGrabMode::Locked;
235                cursor_options.visible = false;
236            }
237        } else {
238            for (_, mut cursor_options) in &mut windows {
239                cursor_options.grab_mode = CursorGrabMode::None;
240                cursor_options.visible = true;
241            }
242        }
243    }
244
245    // Handle mouse input
246    if accumulated_mouse_motion.delta != Vec2::ZERO && cursor_grab {
247        // Apply look update
248        controller.pitch = (controller.pitch
249            - accumulated_mouse_motion.delta.y * RADIANS_PER_DOT * controller.sensitivity)
250            .clamp(-PI / 2., PI / 2.);
251        controller.yaw -=
252            accumulated_mouse_motion.delta.x * RADIANS_PER_DOT * controller.sensitivity;
253        transform.rotation = Quat::from_euler(EulerRot::ZYX, 0.0, controller.yaw, controller.pitch);
254    }
255}

Source

pub fn back(&self) -> Dir3

Equivalent to local_z()

Examples found in repository ?

examples/3d/motion_blur.rs (line 346)

330fn move_camera(
331    camera: Single<(&mut Transform, &mut Projection), Without<CameraTracked>>,
332    tracked: Single<&Transform, With<CameraTracked>>,
333    mode: Res<CameraMode>,
334) {
335    let (mut transform, mut projection) = camera.into_inner();
336    match *mode {
337        CameraMode::Track => {
338            transform.look_at(tracked.translation, Vec3::Y);
339            transform.translation = Vec3::new(15.0, -0.5, 0.0);
340            if let Projection::Perspective(perspective) = &mut *projection {
341                perspective.fov = 0.05;
342            }
343        }
344        CameraMode::Chase => {
345            transform.translation =
346                tracked.translation + Vec3::new(0.0, 0.15, 0.0) + tracked.back() * 0.6;
347            transform.look_to(tracked.forward(), Vec3::Y);
348            if let Projection::Perspective(perspective) = &mut *projection {
349                perspective.fov = 1.0;
350            }
351        }
352    }
353}

Source

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

Examples found in repository ?

examples/stress_tests/many_animated_sprites.rs (line 100)

99fn move_camera(time: Res<Time>, mut camera_transform: Single<&mut Transform, With<Camera>>) {
100    camera_transform.rotate(Quat::from_rotation_z(time.delta_secs() * 0.5));
101    **camera_transform = **camera_transform
102        * Transform::from_translation(Vec3::X * CAMERA_SPEED * time.delta_secs());
103}

More examples

Hide additional examples

examples/3d/occlusion_culling.rs (lines 372-377)

370fn spin_large_cube(mut large_cubes: Query<&mut Transform, With<LargeCube>>) {
371    for mut transform in &mut large_cubes {
372        transform.rotate(Quat::from_euler(
373            EulerRot::XYZ,
374            0.13 * ROTATION_SPEED,
375            0.29 * ROTATION_SPEED,
376            0.35 * ROTATION_SPEED,
377        ));
378    }
379}

examples/shader/shader_material_wesl.rs (line 87)

73fn update(
74    time: Res<Time>,
75    mut query: Query<(&MeshMaterial3d<CustomMaterial>, &mut Transform)>,
76    mut materials: ResMut<Assets<CustomMaterial>>,
77    keys: Res<ButtonInput<KeyCode>>,
78) {
79    for (material, mut transform) in query.iter_mut() {
80        let material = materials.get_mut(material).unwrap();
81        material.time.x = time.elapsed_secs();
82        if keys.just_pressed(KeyCode::Space) {
83            material.party_mode = !material.party_mode;
84        }
85
86        if material.party_mode {
87            transform.rotate(Quat::from_rotation_y(0.005));
88        }
89    }
90}

examples/3d/transmission.rs (line 602)

589fn flicker_system(
590    mut flame: Single<&mut Transform, (With<Flicker>, With<Mesh3d>)>,
591    light: Single<(&mut PointLight, &mut Transform), (With<Flicker>, Without<Mesh3d>)>,
592    time: Res<Time>,
593) {
594    let s = time.elapsed_secs();
595    let a = ops::cos(s * 6.0) * 0.0125 + ops::cos(s * 4.0) * 0.025;
596    let b = ops::cos(s * 5.0) * 0.0125 + ops::cos(s * 3.0) * 0.025;
597    let c = ops::cos(s * 7.0) * 0.0125 + ops::cos(s * 2.0) * 0.025;
598    let (mut light, mut light_transform) = light.into_inner();
599    light.intensity = 4_000.0 + 3000.0 * (a + b + c);
600    flame.translation = Vec3::new(-1.0, 1.23, 0.0);
601    flame.look_at(Vec3::new(-1.0 - c, 1.7 - b, 0.0 - a), Vec3::X);
602    flame.rotate(Quat::from_euler(EulerRot::XYZ, 0.0, 0.0, PI / 2.0));
603    light_transform.translation = Vec3::new(-1.0 - c, 1.7, 0.0 - a);
604    flame.translation = Vec3::new(-1.0 - c, 1.23, 0.0 - a);
605}

examples/3d/volumetric_fog.rs (line 191)

167fn move_directional_light(
168    input: Res<ButtonInput<KeyCode>>,
169    mut directional_lights: Query<&mut Transform, With<DirectionalLight>>,
170) {
171    let mut delta_theta = Vec2::ZERO;
172    if input.pressed(KeyCode::KeyW) || input.pressed(KeyCode::ArrowUp) {
173        delta_theta.y += DIRECTIONAL_LIGHT_MOVEMENT_SPEED;
174    }
175    if input.pressed(KeyCode::KeyS) || input.pressed(KeyCode::ArrowDown) {
176        delta_theta.y -= DIRECTIONAL_LIGHT_MOVEMENT_SPEED;
177    }
178    if input.pressed(KeyCode::KeyA) || input.pressed(KeyCode::ArrowLeft) {
179        delta_theta.x += DIRECTIONAL_LIGHT_MOVEMENT_SPEED;
180    }
181    if input.pressed(KeyCode::KeyD) || input.pressed(KeyCode::ArrowRight) {
182        delta_theta.x -= DIRECTIONAL_LIGHT_MOVEMENT_SPEED;
183    }
184
185    if delta_theta == Vec2::ZERO {
186        return;
187    }
188
189    let delta_quat = Quat::from_euler(EulerRot::XZY, delta_theta.y, 0.0, delta_theta.x);
190    for mut transform in directional_lights.iter_mut() {
191        transform.rotate(delta_quat);
192    }
193}

Source

pub fn rotate_axis(&mut self, axis: Dir3, 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.

§Warning

If you pass in an axis based on the current rotation (e.g. obtained via Transform::local_x), floating point errors can accumulate exponentially when applying rotations repeatedly this way. This will result in a denormalized rotation. In this case, it is recommended to normalize the Transform::rotation after each call to this method.

Examples found in repository ?

examples/ecs/fallible_params.rs (line 159)

136fn track_targets(
137    // `Single` ensures the system runs ONLY when exactly one matching entity exists.
138    mut player: Single<(&mut Transform, &Player)>,
139    // `Option<Single>` never prevents the system from running, but will be `None` if there is not exactly one matching entity.
140    enemy: Option<Single<&Transform, (With<Enemy>, Without<Player>)>>,
141    time: Res<Time>,
142) {
143    let (player_transform, player) = &mut *player;
144    if let Some(enemy_transform) = enemy {
145        // Enemy found, rotate and move towards it.
146        let delta = enemy_transform.translation - player_transform.translation;
147        let distance = delta.length();
148        let front = delta / distance;
149        let up = Vec3::Z;
150        let side = front.cross(up);
151        player_transform.rotation = Quat::from_mat3(&Mat3::from_cols(side, front, up));
152        let max_step = distance - player.min_follow_radius;
153        if 0.0 < max_step {
154            let velocity = (player.speed * time.delta_secs()).min(max_step);
155            player_transform.translation += front * velocity;
156        }
157    } else {
158        // 0 or multiple enemies found, keep searching.
159        player_transform.rotate_axis(Dir3::Z, player.rotation_speed * time.delta_secs());
160    }
161}

Source

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.

Examples found in repository ?

examples/3d/parenting.rs (line 21)

19fn rotator_system(time: Res<Time>, mut query: Query<&mut Transform, With<Rotator>>) {
20    for mut transform in &mut query {
21        transform.rotate_x(3.0 * time.delta_secs());
22    }
23}

More examples

Hide additional examples

examples/3d/atmosphere.rs (line 123)

121fn dynamic_scene(mut suns: Query<&mut Transform, With<DirectionalLight>>, time: Res<Time>) {
122    suns.iter_mut()
123        .for_each(|mut tf| tf.rotate_x(-time.delta_secs() * PI / 10.0));
124}

tests/window/desktop_request_redraw.rs (line 99)

97fn update(time: Res<Time>, mut query: Query<&mut Transform, With<AnimationActive>>) {
98    if let Ok(mut transform) = query.single_mut() {
99        transform.rotate_x(time.delta_secs().min(1.0 / 60.0));
100    }
101}

examples/stress_tests/many_lights.rs (line 138)

135fn move_camera(time: Res<Time>, mut camera_transform: Single<&mut Transform, With<Camera>>) {
136    let delta = time.delta_secs() * 0.15;
137    camera_transform.rotate_z(delta);
138    camera_transform.rotate_x(delta);
139}

examples/shader_advanced/custom_post_processing.rs (line 337)

335fn rotate(time: Res<Time>, mut query: Query<&mut Transform, With<Rotates>>) {
336    for mut transform in &mut query {
337        transform.rotate_x(0.55 * time.delta_secs());
338        transform.rotate_z(0.15 * time.delta_secs());
339    }
340}

examples/picking/mesh_picking.rs (line 196)

193fn rotate_on_drag(drag: On<Pointer<Drag>>, mut transforms: Query<&mut Transform>) {
194    let mut transform = transforms.get_mut(drag.entity).unwrap();
195    transform.rotate_y(drag.delta.x * 0.02);
196    transform.rotate_x(drag.delta.y * 0.02);
197}

Additional examples can be found in:

Source

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.

Examples found in repository ?

examples/shader/extended_material.rs (line 69)

67fn rotate_things(mut q: Query<&mut Transform, With<Rotate>>, time: Res<Time>) {
68    for mut t in &mut q {
69        t.rotate_y(time.delta_secs());
70    }
71}

More examples

Hide additional examples

examples/3d/3d_shapes.rs (line 162)

160fn rotate(mut query: Query<&mut Transform, With<Shape>>, time: Res<Time>) {
161    for mut transform in &mut query {
162        transform.rotate_y(time.delta_secs() / 2.);
163    }
164}

examples/picking/mesh_picking.rs (line 188)

186fn rotate(mut query: Query<&mut Transform, With<Shape>>, time: Res<Time>) {
187    for mut transform in &mut query {
188        transform.rotate_y(time.delta_secs() / 2.);
189    }
190}
191
192/// An observer to rotate an entity when it is dragged
193fn rotate_on_drag(drag: On<Pointer<Drag>>, mut transforms: Query<&mut Transform>) {
194    let mut transform = transforms.get_mut(drag.entity).unwrap();
195    transform.rotate_y(drag.delta.x * 0.02);
196    transform.rotate_x(drag.delta.y * 0.02);
197}

examples/3d/occlusion_culling.rs (line 362)

360fn spin_small_cubes(mut sphere_parents: Query<&mut Transform, With<SphereParent>>) {
361    for mut sphere_parent_transform in &mut sphere_parents {
362        sphere_parent_transform.rotate_y(ROTATION_SPEED);
363    }
364}

examples/3d/skybox.rs (line 180)

175fn animate_light_direction(
176    time: Res<Time>,
177    mut query: Query<&mut Transform, With<DirectionalLight>>,
178) {
179    for mut transform in &mut query {
180        transform.rotate_y(time.delta_secs() * 0.5);
181    }
182}

examples/math/custom_primitives.rs (line 214)

210fn rotate_3d_shapes(mut shapes: Query<&mut Transform, With<Shape3d>>, time: Res<Time>) {
211    let delta_seconds = time.delta_secs();
212
213    for mut transform in shapes.iter_mut() {
214        transform.rotate_y(delta_seconds);
215    }
216}

Additional examples can be found in:

Source

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.

Examples found in repository ?

examples/2d/pixel_grid_snap.rs (line 140)

137fn rotate(time: Res<Time>, mut transforms: Query<&mut Transform, With<Rotate>>) {
138    for mut transform in &mut transforms {
139        let dt = time.delta_secs();
140        transform.rotate_z(dt);
141    }
142}

More examples

Hide additional examples

examples/stress_tests/many_lights.rs (line 137)

135fn move_camera(time: Res<Time>, mut camera_transform: Single<&mut Transform, With<Camera>>) {
136    let delta = time.delta_secs() * 0.15;
137    camera_transform.rotate_z(delta);
138    camera_transform.rotate_x(delta);
139}

examples/shader_advanced/custom_post_processing.rs (line 338)

335fn rotate(time: Res<Time>, mut query: Query<&mut Transform, With<Rotates>>) {
336    for mut transform in &mut query {
337        transform.rotate_x(0.55 * time.delta_secs());
338        transform.rotate_z(0.15 * time.delta_secs());
339    }
340}

examples/3d/render_to_texture.rs (line 107)

104fn rotator_system(time: Res<Time>, mut query: Query<&mut Transform, With<FirstPassCube>>) {
105    for mut transform in &mut query {
106        transform.rotate_x(1.5 * time.delta_secs());
107        transform.rotate_z(1.3 * time.delta_secs());
108    }
109}

examples/stress_tests/many_sprites.rs (line 104)

103fn move_camera(time: Res<Time>, mut camera_transform: Single<&mut Transform, With<Camera>>) {
104    camera_transform.rotate_z(time.delta_secs() * 0.5);
105    **camera_transform = **camera_transform
106        * Transform::from_translation(Vec3::X * CAMERA_SPEED * time.delta_secs());
107}

examples/games/contributors.rs (line 310)

305fn movement(time: Res<Time>, mut query: Query<(&Velocity, &mut Transform)>) {
306    let delta = time.delta_secs();
307
308    for (velocity, mut transform) in &mut query {
309        transform.translation += delta * velocity.translation;
310        transform.rotate_z(velocity.rotation * delta);
311    }
312}

Additional examples can be found in:

Source

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.

Source

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

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

§Warning

If you pass in an axis based on the current rotation (e.g. obtained via Transform::local_x), floating point errors can accumulate exponentially when applying rotations repeatedly this way. This will result in a denormalized rotation. In this case, it is recommended to normalize the Transform::rotation after each call to this method.

Source

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

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

Examples found in repository ?

examples/3d/parallax_mapping.rs (line 158)

155fn spin(time: Res<Time>, mut query: Query<(&mut Transform, &Spin)>) {
156    for (mut transform, spin) in query.iter_mut() {
157        transform.rotate_local_y(spin.speed * time.delta_secs());
158        transform.rotate_local_x(spin.speed * time.delta_secs());
159        transform.rotate_local_z(-spin.speed * time.delta_secs());
160    }
161}

More examples

Hide additional examples

examples/3d/deferred_rendering.rs (line 263)

257fn spin(time: Res<Time>, mut query: Query<(&mut Transform, &Spin)>, pause: Res<Pause>) {
258    if pause.0 {
259        return;
260    }
261    for (mut transform, spin) in query.iter_mut() {
262        transform.rotate_local_y(spin.speed * time.delta_secs());
263        transform.rotate_local_x(spin.speed * time.delta_secs());
264        transform.rotate_local_z(-spin.speed * time.delta_secs());
265    }
266}

Source

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

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

Examples found in repository ?

examples/window/low_power.rs (line 140)

134    pub(crate) fn rotate_cube(
135        time: Res<Time>,
136        mut cube_transform: Query<&mut Transform, With<Rotator>>,
137    ) {
138        for mut transform in &mut cube_transform {
139            transform.rotate_x(time.delta_secs());
140            transform.rotate_local_y(time.delta_secs());
141        }
142    }

More examples

Hide additional examples

examples/3d/parallax_mapping.rs (line 157)

155fn spin(time: Res<Time>, mut query: Query<(&mut Transform, &Spin)>) {
156    for (mut transform, spin) in query.iter_mut() {
157        transform.rotate_local_y(spin.speed * time.delta_secs());
158        transform.rotate_local_x(spin.speed * time.delta_secs());
159        transform.rotate_local_z(-spin.speed * time.delta_secs());
160    }
161}

examples/3d/deferred_rendering.rs (line 262)

257fn spin(time: Res<Time>, mut query: Query<(&mut Transform, &Spin)>, pause: Res<Pause>) {
258    if pause.0 {
259        return;
260    }
261    for (mut transform, spin) in query.iter_mut() {
262        transform.rotate_local_y(spin.speed * time.delta_secs());
263        transform.rotate_local_x(spin.speed * time.delta_secs());
264        transform.rotate_local_z(-spin.speed * time.delta_secs());
265    }
266}

examples/3d/motion_blur.rs (line 325)

300fn move_cars(
301    time: Res<Time>,
302    mut movables: Query<(&mut Transform, &Moves, &Children)>,
303    mut spins: Query<&mut Transform, (Without<Moves>, With<Rotates>)>,
304) {
305    for (mut transform, moves, children) in &mut movables {
306        let time = time.elapsed_secs() * 0.25;
307        let t = time + 0.5 * moves.0;
308        let dx = ops::cos(t);
309        let dz = -ops::sin(3.0 * t);
310        let speed_variation = (dx * dx + dz * dz).sqrt() * 0.15;
311        let t = t + speed_variation;
312        let prev = transform.translation;
313        transform.translation.x = race_track_pos(0.0, t).x;
314        transform.translation.z = race_track_pos(0.0, t).y;
315        transform.translation.y = -0.59;
316        let delta = transform.translation - prev;
317        transform.look_to(delta, Vec3::Y);
318        for child in children.iter() {
319            let Ok(mut wheel) = spins.get_mut(child) else {
320                continue;
321            };
322            let radius = wheel.scale.x;
323            let circumference = 2.0 * std::f32::consts::PI * radius;
324            let angle = delta.length() / circumference * std::f32::consts::PI * 2.0;
325            wheel.rotate_local_y(angle);
326        }
327    }
328}

Source

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

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

Examples found in repository ?

examples/3d/parallax_mapping.rs (line 159)

155fn spin(time: Res<Time>, mut query: Query<(&mut Transform, &Spin)>) {
156    for (mut transform, spin) in query.iter_mut() {
157        transform.rotate_local_y(spin.speed * time.delta_secs());
158        transform.rotate_local_x(spin.speed * time.delta_secs());
159        transform.rotate_local_z(-spin.speed * time.delta_secs());
160    }
161}

More examples

Hide additional examples

examples/3d/deferred_rendering.rs (line 264)

257fn spin(time: Res<Time>, mut query: Query<(&mut Transform, &Spin)>, pause: Res<Pause>) {
258    if pause.0 {
259        return;
260    }
261    for (mut transform, spin) in query.iter_mut() {
262        transform.rotate_local_y(spin.speed * time.delta_secs());
263        transform.rotate_local_x(spin.speed * time.delta_secs());
264        transform.rotate_local_z(-spin.speed * time.delta_secs());
265    }
266}

Source

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.

Examples found in repository ?

examples/3d/ssr.rs (line 336)

300fn move_camera(
301    keyboard_input: Res<ButtonInput<KeyCode>>,
302    mut mouse_wheel_reader: MessageReader<MouseWheel>,
303    mut cameras: Query<&mut Transform, With<Camera>>,
304) {
305    let (mut distance_delta, mut theta_delta) = (0.0, 0.0);
306
307    // Handle keyboard events.
308    if keyboard_input.pressed(KeyCode::KeyW) {
309        distance_delta -= CAMERA_KEYBOARD_ZOOM_SPEED;
310    }
311    if keyboard_input.pressed(KeyCode::KeyS) {
312        distance_delta += CAMERA_KEYBOARD_ZOOM_SPEED;
313    }
314    if keyboard_input.pressed(KeyCode::KeyA) {
315        theta_delta += CAMERA_KEYBOARD_ORBIT_SPEED;
316    }
317    if keyboard_input.pressed(KeyCode::KeyD) {
318        theta_delta -= CAMERA_KEYBOARD_ORBIT_SPEED;
319    }
320
321    // Handle mouse events.
322    for mouse_wheel in mouse_wheel_reader.read() {
323        distance_delta -= mouse_wheel.y * CAMERA_MOUSE_WHEEL_ZOOM_SPEED;
324    }
325
326    // Update transforms.
327    for mut camera_transform in cameras.iter_mut() {
328        let local_z = camera_transform.local_z().as_vec3().normalize_or_zero();
329        if distance_delta != 0.0 {
330            camera_transform.translation = (camera_transform.translation.length() + distance_delta)
331                .clamp(CAMERA_ZOOM_RANGE.start, CAMERA_ZOOM_RANGE.end)
332                * local_z;
333        }
334        if theta_delta != 0.0 {
335            camera_transform
336                .translate_around(Vec3::ZERO, Quat::from_axis_angle(Vec3::Y, theta_delta));
337            camera_transform.look_at(Vec3::ZERO, Vec3::Y);
338        }
339    }
340}

Source

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.

Examples found in repository ?

examples/gizmos/light_gizmos.rs (line 140)

139fn rotate_camera(mut transform: Single<&mut Transform, With<Camera>>, time: Res<Time>) {
140    transform.rotate_around(Vec3::ZERO, Quat::from_rotation_y(time.delta_secs() / 2.));
141}

More examples

Hide additional examples

examples/stress_tests/many_cameras_lights.rs (line 101)

99fn rotate_cameras(time: Res<Time>, mut query: Query<&mut Transform, With<Camera>>) {
100    for mut transform in query.iter_mut() {
101        transform.rotate_around(Vec3::ZERO, Quat::from_rotation_y(time.delta_secs()));
102    }
103}

examples/shader/shader_material_screenspace_texture.rs (lines 53-56)

52fn rotate_camera(mut cam_transform: Single<&mut Transform, With<MainCamera>>, time: Res<Time>) {
53    cam_transform.rotate_around(
54        Vec3::ZERO,
55        Quat::from_axis_angle(Vec3::Y, 45f32.to_radians() * time.delta_secs()),
56    );
57    cam_transform.look_at(Vec3::ZERO, Vec3::Y);
58}

examples/3d/spotlight.rs (line 196)

188fn rotation(
189    mut transform: Single<&mut Transform, With<Camera>>,
190    input: Res<ButtonInput<KeyCode>>,
191    time: Res<Time>,
192) {
193    let delta = time.delta_secs();
194
195    if input.pressed(KeyCode::ArrowLeft) {
196        transform.rotate_around(Vec3::ZERO, Quat::from_rotation_y(delta));
197    } else if input.pressed(KeyCode::ArrowRight) {
198        transform.rotate_around(Vec3::ZERO, Quat::from_rotation_y(-delta));
199    }
200}

examples/transforms/align.rs (line 211)

191fn handle_mouse(
192    accumulated_mouse_motion: Res<AccumulatedMouseMotion>,
193    mut mouse_button_inputs: MessageReader<MouseButtonInput>,
194    mut camera_transform: Single<&mut Transform, With<Camera>>,
195    mut mouse_pressed: ResMut<MousePressed>,
196) {
197    // Store left-pressed state in the MousePressed resource
198    for mouse_button_input in mouse_button_inputs.read() {
199        if mouse_button_input.button != MouseButton::Left {
200            continue;
201        }
202        *mouse_pressed = MousePressed(mouse_button_input.state.is_pressed());
203    }
204
205    // If the mouse is not pressed, just ignore motion events
206    if !mouse_pressed.0 {
207        return;
208    }
209    if accumulated_mouse_motion.delta != Vec2::ZERO {
210        let displacement = accumulated_mouse_motion.delta.x;
211        camera_transform.rotate_around(Vec3::ZERO, Quat::from_rotation_y(-displacement / 75.));
212    }
213}

examples/math/random_sampling.rs (line 241)

221fn handle_mouse(
222    accumulated_mouse_motion: Res<AccumulatedMouseMotion>,
223    mut mouse_button_inputs: MessageReader<MouseButtonInput>,
224    mut camera_transform: Single<&mut Transform, With<Camera>>,
225    mut mouse_pressed: ResMut<MousePressed>,
226) {
227    // Store left-pressed state in the MousePressed resource
228    for mouse_button_input in mouse_button_inputs.read() {
229        if mouse_button_input.button != MouseButton::Left {
230            continue;
231        }
232        *mouse_pressed = MousePressed(mouse_button_input.state.is_pressed());
233    }
234
235    // If the mouse is not pressed, just ignore motion events
236    if !mouse_pressed.0 {
237        return;
238    }
239    if accumulated_mouse_motion.delta != Vec2::ZERO {
240        let displacement = accumulated_mouse_motion.delta.x;
241        camera_transform.rotate_around(Vec3::ZERO, Quat::from_rotation_y(-displacement / 150.));
242    }
243}

Additional examples can be found in:

Source

pub fn look_at(&mut self, target: Vec3, up: impl TryInto<Dir3>)

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 fails converting to Dir3 (e.g if it is Vec3::ZERO), Dir3::Y is used instead
if the resulting forward direction is parallel with up, an orthogonal vector is used as the “right” direction

Examples found in repository ?

examples/shader/shader_material_screenspace_texture.rs (line 57)

52fn rotate_camera(mut cam_transform: Single<&mut Transform, With<MainCamera>>, time: Res<Time>) {
53    cam_transform.rotate_around(
54        Vec3::ZERO,
55        Quat::from_axis_angle(Vec3::Y, 45f32.to_radians() * time.delta_secs()),
56    );
57    cam_transform.look_at(Vec3::ZERO, Vec3::Y);
58}

More examples

Hide additional examples

examples/3d/specular_tint.rs (line 139)

135fn rotate_camera(mut cameras: Query<&mut Transform, With<Camera3d>>) {
136    for mut camera_transform in cameras.iter_mut() {
137        camera_transform.translation =
138            Quat::from_rotation_y(ROTATION_SPEED) * camera_transform.translation;
139        camera_transform.look_at(Vec3::ZERO, Vec3::Y);
140    }
141}

examples/3d/anisotropy.rs (line 187)

180fn animate_light(
181    mut lights: Query<&mut Transform, Or<(With<DirectionalLight>, With<PointLight>)>>,
182    time: Res<Time>,
183) {
184    let now = time.elapsed_secs();
185    for mut transform in lights.iter_mut() {
186        transform.translation = vec3(ops::cos(now), 1.0, ops::sin(now)) * vec3(3.0, 4.0, 3.0);
187        transform.look_at(Vec3::ZERO, Vec3::Y);
188    }
189}

examples/math/sampling_primitives.rs (line 673)

668fn update_camera(mut camera: Query<(&mut Transform, &CameraRig), Changed<CameraRig>>) {
669    for (mut transform, rig) in camera.iter_mut() {
670        let looking_direction =
671            Quat::from_rotation_y(-rig.yaw) * Quat::from_rotation_x(rig.pitch) * Vec3::Z;
672        transform.translation = rig.target - rig.distance * looking_direction;
673        transform.look_at(rig.target, Dir3::Y);
674    }
675}

examples/3d/clearcoat.rs (line 241)

230fn animate_light(
231    mut lights: Query<&mut Transform, Or<(With<PointLight>, With<DirectionalLight>)>>,
232    time: Res<Time>,
233) {
234    let now = time.elapsed_secs();
235    for mut transform in lights.iter_mut() {
236        transform.translation = vec3(
237            ops::sin(now * 1.4),
238            ops::cos(now * 1.0),
239            ops::cos(now * 0.6),
240        ) * vec3(3.0, 4.0, 3.0);
241        transform.look_at(Vec3::ZERO, Vec3::Y);
242    }
243}

examples/3d/reflection_probes.rs (line 351)

337fn rotate_camera(
338    time: Res<Time>,
339    mut camera_query: Query<&mut Transform, With<Camera3d>>,
340    app_status: Res<AppStatus>,
341) {
342    if !app_status.rotating {
343        return;
344    }
345
346    for mut transform in camera_query.iter_mut() {
347        transform.translation = Vec2::from_angle(time.delta_secs() * PI / 5.0)
348            .rotate(transform.translation.xz())
349            .extend(transform.translation.y)
350            .xzy();
351        transform.look_at(Vec3::ZERO, Vec3::Y);
352    }
353}

Additional examples can be found in:

Source

pub fn look_to(&mut self, direction: impl TryInto<Dir3>, up: impl TryInto<Dir3>)

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 fails converting to Dir3 (e.g if it is Vec3::ZERO), Dir3::NEG_Z is used instead
if up fails converting to Dir3, Dir3::Y is used instead
if direction is parallel with up, an orthogonal vector is used as the “right” direction

Examples found in repository ?

examples/3d/generate_custom_mesh.rs (line 100)

71fn input_handler(
72    keyboard_input: Res<ButtonInput<KeyCode>>,
73    mesh_query: Query<&Mesh3d, With<CustomUV>>,
74    mut meshes: ResMut<Assets<Mesh>>,
75    mut query: Query<&mut Transform, With<CustomUV>>,
76    time: Res<Time>,
77) {
78    if keyboard_input.just_pressed(KeyCode::Space) {
79        let mesh_handle = mesh_query.single().expect("Query not successful");
80        let mesh = meshes.get_mut(mesh_handle).unwrap();
81        toggle_texture(mesh);
82    }
83    if keyboard_input.pressed(KeyCode::KeyX) {
84        for mut transform in &mut query {
85            transform.rotate_x(time.delta_secs() / 1.2);
86        }
87    }
88    if keyboard_input.pressed(KeyCode::KeyY) {
89        for mut transform in &mut query {
90            transform.rotate_y(time.delta_secs() / 1.2);
91        }
92    }
93    if keyboard_input.pressed(KeyCode::KeyZ) {
94        for mut transform in &mut query {
95            transform.rotate_z(time.delta_secs() / 1.2);
96        }
97    }
98    if keyboard_input.pressed(KeyCode::KeyR) {
99        for mut transform in &mut query {
100            transform.look_to(Vec3::NEG_Z, Vec3::Y);
101        }
102    }
103}

More examples

Hide additional examples

examples/3d/motion_blur.rs (line 317)

300fn move_cars(
301    time: Res<Time>,
302    mut movables: Query<(&mut Transform, &Moves, &Children)>,
303    mut spins: Query<&mut Transform, (Without<Moves>, With<Rotates>)>,
304) {
305    for (mut transform, moves, children) in &mut movables {
306        let time = time.elapsed_secs() * 0.25;
307        let t = time + 0.5 * moves.0;
308        let dx = ops::cos(t);
309        let dz = -ops::sin(3.0 * t);
310        let speed_variation = (dx * dx + dz * dz).sqrt() * 0.15;
311        let t = t + speed_variation;
312        let prev = transform.translation;
313        transform.translation.x = race_track_pos(0.0, t).x;
314        transform.translation.z = race_track_pos(0.0, t).y;
315        transform.translation.y = -0.59;
316        let delta = transform.translation - prev;
317        transform.look_to(delta, Vec3::Y);
318        for child in children.iter() {
319            let Ok(mut wheel) = spins.get_mut(child) else {
320                continue;
321            };
322            let radius = wheel.scale.x;
323            let circumference = 2.0 * std::f32::consts::PI * radius;
324            let angle = delta.length() / circumference * std::f32::consts::PI * 2.0;
325            wheel.rotate_local_y(angle);
326        }
327    }
328}
329
330fn move_camera(
331    camera: Single<(&mut Transform, &mut Projection), Without<CameraTracked>>,
332    tracked: Single<&Transform, With<CameraTracked>>,
333    mode: Res<CameraMode>,
334) {
335    let (mut transform, mut projection) = camera.into_inner();
336    match *mode {
337        CameraMode::Track => {
338            transform.look_at(tracked.translation, Vec3::Y);
339            transform.translation = Vec3::new(15.0, -0.5, 0.0);
340            if let Projection::Perspective(perspective) = &mut *projection {
341                perspective.fov = 0.05;
342            }
343        }
344        CameraMode::Chase => {
345            transform.translation =
346                tracked.translation + Vec3::new(0.0, 0.15, 0.0) + tracked.back() * 0.6;
347            transform.look_to(tracked.forward(), Vec3::Y);
348            if let Projection::Perspective(perspective) = &mut *projection {
349                perspective.fov = 1.0;
350            }
351        }
352    }
353}

Source

pub fn align( &mut self, main_axis: impl TryInto<Dir3>, main_direction: impl TryInto<Dir3>, secondary_axis: impl TryInto<Dir3>, secondary_direction: impl TryInto<Dir3>, )

Rotates this Transform so that the main_axis vector, reinterpreted in local coordinates, points in the given main_direction, while secondary_axis points towards secondary_direction.

For example, if a spaceship model has its nose pointing in the X-direction in its own local coordinates and its dorsal fin pointing in the Y-direction, then align(Dir3::X, v, Dir3::Y, w) will make the spaceship’s nose point in the direction of v, while the dorsal fin does its best to point in the direction w.

More precisely, the Transform::rotation produced will be such that:

applying it to main_axis results in main_direction
applying it to secondary_axis produces a vector that lies in the half-plane generated by main_direction and secondary_direction (with positive contribution by secondary_direction)

Transform::look_to is recovered, for instance, when main_axis is Dir3::NEG_Z (the Transform::forward direction in the default orientation) and secondary_axis is Dir3::Y (the Transform::up direction in the default orientation). (Failure cases may differ somewhat.)

In some cases a rotation cannot be constructed. Another axis will be picked in those cases:

if main_axis or main_direction fail converting to Dir3 (e.g are zero), Dir3::X takes their place
if secondary_axis or secondary_direction fail converting, Dir3::Y takes their place
if main_axis is parallel with secondary_axis or main_direction is parallel with secondary_direction, a rotation is constructed which takes main_axis to main_direction along a great circle, ignoring the secondary counterparts

Example

t1.align(Dir3::X, Dir3::Y, Vec3::new(1., 1., 0.), Dir3::Z);
let main_axis_image = t1.rotation * Dir3::X;
let secondary_axis_image = t1.rotation * Vec3::new(1., 1., 0.);
assert!(main_axis_image.abs_diff_eq(Vec3::Y, 1e-5));
assert!(secondary_axis_image.abs_diff_eq(Vec3::new(0., 1., 1.), 1e-5));

t1.align(Vec3::ZERO, Dir3::Z, Vec3::ZERO, Dir3::X);
t2.align(Dir3::X, Dir3::Z, Dir3::Y, Dir3::X);
assert_eq!(t1.rotation, t2.rotation);

t1.align(Dir3::X, Dir3::Z, Dir3::X, Dir3::Y);
assert_eq!(t1.rotation, Quat::from_rotation_arc(Vec3::X, Vec3::Z));

Source

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

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

Examples found in repository ?

examples/stress_tests/many_cubes.rs (line 179)

138fn setup(
139    mut commands: Commands,
140    args: Res<Args>,
141    mesh_assets: ResMut<Assets<Mesh>>,
142    material_assets: ResMut<Assets<StandardMaterial>>,
143    images: ResMut<Assets<Image>>,
144) {
145    warn!(include_str!("warning_string.txt"));
146
147    let args = args.into_inner();
148    let images = images.into_inner();
149    let material_assets = material_assets.into_inner();
150    let mesh_assets = mesh_assets.into_inner();
151
152    let meshes = init_meshes(args, mesh_assets);
153
154    let material_textures = init_textures(args, images);
155    let materials = init_materials(args, &material_textures, material_assets);
156
157    // We're seeding the PRNG here to make this example deterministic for testing purposes.
158    // This isn't strictly required in practical use unless you need your app to be deterministic.
159    let mut material_rng = ChaCha8Rng::seed_from_u64(42);
160    match args.layout {
161        Layout::Sphere => {
162            // NOTE: This pattern is good for testing performance of culling as it provides roughly
163            // the same number of visible meshes regardless of the viewing angle.
164            const N_POINTS: usize = WIDTH * HEIGHT * 4;
165            // NOTE: f64 is used to avoid precision issues that produce visual artifacts in the distribution
166            let radius = WIDTH as f64 * 2.5;
167            let golden_ratio = 0.5f64 * (1.0f64 + 5.0f64.sqrt());
168            for i in 0..N_POINTS {
169                let spherical_polar_theta_phi =
170                    fibonacci_spiral_on_sphere(golden_ratio, i, N_POINTS);
171                let unit_sphere_p = spherical_polar_to_cartesian(spherical_polar_theta_phi);
172                let (mesh, transform) = meshes.choose(&mut material_rng).unwrap();
173                commands
174                    .spawn((
175                        Mesh3d(mesh.clone()),
176                        MeshMaterial3d(materials.choose(&mut material_rng).unwrap().clone()),
177                        Transform::from_translation((radius * unit_sphere_p).as_vec3())
178                            .looking_at(Vec3::ZERO, Vec3::Y)
179                            .mul_transform(*transform),
180                    ))
181                    .insert_if(NoFrustumCulling, || args.no_frustum_culling)
182                    .insert_if(NoAutomaticBatching, || args.no_automatic_batching);
183            }
184
185            // camera
186            let mut camera = commands.spawn(Camera3d::default());
187            if args.no_indirect_drawing {
188                camera.insert(NoIndirectDrawing);
189            }
190            if args.no_cpu_culling {
191                camera.insert(NoCpuCulling);
192            }
193
194            // Inside-out box around the meshes onto which shadows are cast (though you cannot see them...)
195            commands.spawn((
196                Mesh3d(mesh_assets.add(Cuboid::from_size(Vec3::splat(radius as f32 * 2.2)))),
197                MeshMaterial3d(material_assets.add(StandardMaterial::from(Color::WHITE))),
198                Transform::from_scale(-Vec3::ONE),
199                NotShadowCaster,
200            ));
201        }
202        _ => {
203            // NOTE: This pattern is good for demonstrating that frustum culling is working correctly
204            // as the number of visible meshes rises and falls depending on the viewing angle.
205            let scale = 2.5;
206            for x in 0..WIDTH {
207                for y in 0..HEIGHT {
208                    // introduce spaces to break any kind of moiré pattern
209                    if x % 10 == 0 || y % 10 == 0 {
210                        continue;
211                    }
212                    // cube
213                    commands.spawn((
214                        Mesh3d(meshes.choose(&mut material_rng).unwrap().0.clone()),
215                        MeshMaterial3d(materials.choose(&mut material_rng).unwrap().clone()),
216                        Transform::from_xyz((x as f32) * scale, (y as f32) * scale, 0.0),
217                    ));
218                    commands.spawn((
219                        Mesh3d(meshes.choose(&mut material_rng).unwrap().0.clone()),
220                        MeshMaterial3d(materials.choose(&mut material_rng).unwrap().clone()),
221                        Transform::from_xyz(
222                            (x as f32) * scale,
223                            HEIGHT as f32 * scale,
224                            (y as f32) * scale,
225                        ),
226                    ));
227                    commands.spawn((
228                        Mesh3d(meshes.choose(&mut material_rng).unwrap().0.clone()),
229                        MeshMaterial3d(materials.choose(&mut material_rng).unwrap().clone()),
230                        Transform::from_xyz((x as f32) * scale, 0.0, (y as f32) * scale),
231                    ));
232                    commands.spawn((
233                        Mesh3d(meshes.choose(&mut material_rng).unwrap().0.clone()),
234                        MeshMaterial3d(materials.choose(&mut material_rng).unwrap().clone()),
235                        Transform::from_xyz(0.0, (x as f32) * scale, (y as f32) * scale),
236                    ));
237                }
238            }
239            // camera
240            let center = 0.5 * scale * Vec3::new(WIDTH as f32, HEIGHT as f32, WIDTH as f32);
241            commands.spawn((Camera3d::default(), Transform::from_translation(center)));
242            // Inside-out box around the meshes onto which shadows are cast (though you cannot see them...)
243            commands.spawn((
244                Mesh3d(mesh_assets.add(Cuboid::from_size(2.0 * 1.1 * center))),
245                MeshMaterial3d(material_assets.add(StandardMaterial::from(Color::WHITE))),
246                Transform::from_scale(-Vec3::ONE).with_translation(center),
247                NotShadowCaster,
248            ));
249        }
250    }
251
252    commands.spawn((
253        DirectionalLight {
254            shadows_enabled: args.shadows,
255            ..default()
256        },
257        Transform::IDENTITY.looking_at(Vec3::new(0.0, -1.0, -1.0), Vec3::Y),
258    ));
259}

Source

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

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

If this Transform has an ancestor entity with a Transform component, Transform::transform_point will transform a point in local space into its parent transform’s space.

If this Transform does not have a parent, Transform::transform_point will transform a point in local space into worldspace coordinates.

If you always want to transform a point in local space to worldspace, or if you need the inverse transformations, see GlobalTransform::transform_point().

Source

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.

Source

pub fn to_isometry(&self) -> Isometry3d

Get the isometry defined by this transform’s rotation and translation, ignoring scale.

Examples found in repository ?

examples/math/custom_primitives.rs (line 229)

219fn bounding_shapes_3d(
220    shapes: Query<&Transform, With<Shape3d>>,
221    mut gizmos: Gizmos,
222    bounding_shape: Res<State<BoundingShape>>,
223) {
224    for transform in shapes.iter() {
225        match bounding_shape.get() {
226            BoundingShape::None => (),
227            BoundingShape::BoundingBox => {
228                // Get the AABB of the extrusion with the rotation and translation of the mesh.
229                let aabb = EXTRUSION.aabb_3d(transform.to_isometry());
230
231                gizmos.primitive_3d(
232                    &Cuboid::from_size(Vec3::from(aabb.half_size()) * 2.),
233                    aabb.center(),
234                    WHITE,
235                );
236            }
237            BoundingShape::BoundingSphere => {
238                // Get the bounding sphere of the extrusion with the rotation and translation of the mesh.
239                let bounding_sphere = EXTRUSION.bounding_sphere(transform.to_isometry());
240
241                gizmos.sphere(bounding_sphere.center(), bounding_sphere.radius(), WHITE);
242            }
243        }
244    }
245}

Trait Implementations§

Source §

impl Animatable for Transform

Source §

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

Interpolates between a and b with an interpolation factor of time. Read more

Source §

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

Blends one or more values together. Read more

Source §

impl Clone for Transform

Source §

fn clone(&self) -> Transform

Returns a duplicate 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 Transform
where Transform: Send + Sync + 'static,

Required Components: GlobalTransform, TransformTreeChanged.

A component’s Required Components are inserted whenever it is inserted. Note that this will also insert the required components of the required components, recursively, in depth-first order.

Source §

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

A constant indicating the storage type used for this component.

Source §

type Mutability = Mutable

A marker type to assist Bevy with determining if this component is mutable, or immutable. Mutable components will have Component<Mutability = Mutable>, while immutable components will instead have Component<Mutability = Immutable>. Read more

Source §

fn register_required_components( _requiree: ComponentId, required_components: &mut RequiredComponentsRegistrator<'_, '_>, )

Registers required components. Read more

Source §

fn clone_behavior() -> ComponentCloneBehavior

Called when registering this component, allowing to override clone function (or disable cloning altogether) for this component. Read more

Source §

fn on_add() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_add ComponentHook for this Component if one is defined.

Source §

fn on_insert() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_insert ComponentHook for this Component if one is defined.

Source §

fn on_replace() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_replace ComponentHook for this Component if one is defined.

Source §

fn on_remove() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_remove ComponentHook for this Component if one is defined.

Source §

fn on_despawn() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_despawn ComponentHook for this Component if one is defined.

Source §

fn map_entities<E>(_this: &mut Self, _mapper: &mut E)
where E: EntityMapper,

Maps the entities on this component using the given EntityMapper. This is used to remap entities in contexts like scenes and entity cloning. When deriving Component, this is populated by annotating fields containing entities with #[entities] Read more

Source §

impl Debug for Transform

Source §

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

Formats the value using the given formatter. Read more

Source §

impl Default for Transform

Source §

fn default() -> Transform

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

Source §

impl<'de> Deserialize<'de> for Transform

Source §

fn deserialize<D>( deserializer: D, ) -> Result<Transform, <D as Deserializer<'de>>::Error>
where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more

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

Source §

fn from(transform: Transform) -> GlobalTransform

Converts to this type from the input type.

Source §

impl FromArg for Transform

Source §

type This<'from_arg> = Transform

The type to convert into. Read more

Source §

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

Creates an item from an argument. Read more

Source §

impl FromReflect for Transform

Source §

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

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 Transform

Source §

fn ownership() -> Ownership

Returns the ownership of Self.

Source §

impl GetTypeRegistration for Transform

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 Transform

Source §

fn into_return<'into_return>(self) -> Return<'into_return>
where Transform: '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<Mesh> for Transform

Source §

type Output = Mesh

The resulting type after applying the * operator.

Source §

fn mul(self, rhs: Mesh) -> <Transform as Mul<Mesh>>::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 Transform

Source §

type Output = Vec3

The resulting type after applying the * operator.

Source §

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

Performs the * operation. Read more

Source §

impl Mul for Transform

Source §

type Output = Transform

The resulting type after applying the * operator.

Source §

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

Performs the * operation. Read more

Source §

impl PartialEq for Transform

Source §

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

Source §

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

Returns the TypeInfo of the type represented by this value. 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<Transform>) -> ReflectOwned

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

Source §

fn try_into_reflect( self: Box<Transform>, ) -> 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<Transform>) -> 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 reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

Attempts to clone Self using reflection. Read more

Source §

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

Applies a reflected value to this value. Read more

Source §

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

Converts this reflected value into its dynamic representation based on its kind. Read more

Source §

fn reflect_clone_and_take<T>(&self) -> Result<T, ReflectCloneError>
where T: 'static, Self: Sized + TypePath,

For a type implementing PartialReflect, combines reflect_clone and take in a useful fashion, automatically constructing an appropriate ReflectCloneError if the downcast fails. Read more

Source §

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

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

Source §

fn is_dynamic(&self) -> bool

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

Source §

impl Reflect for Transform

Source §

fn into_any(self: Box<Transform>) -> 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<Transform>) -> 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 Transform

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

Source §

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

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

Source §

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

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

Source §

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

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

Source §

fn field_at_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 PartialReflect.

Source §

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

Returns the name of the field with index index.

Source §

fn field_len(&self) -> usize

Returns the number of fields in the struct.

Source §

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

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

Source §

fn to_dynamic_struct(&self) -> DynamicStruct

Creates a new DynamicStruct from this struct.

Source §

fn get_represented_struct_info(&self) -> Option<&'static StructInfo>

Will return None if TypeInfo is not available.

Source §

impl TransformPoint for Transform

Source §

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

Transform a point.

Source §

impl TypePath for Transform

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 Transform

Source §

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.

Source §

impl Copy for Transform

Source §

impl StructuralPartialEq for Transform

Auto Trait Implementations§

§

impl UnwindSafe for Transform

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 for T
where U: ShaderType, &'a T: for<'a> Into,

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 ComponentsRegistrator<'_>, ids: &mut impl FnMut(ComponentId), )

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<C> BundleFromComponents for C
where C: Component,

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 §

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

Source §

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

🔬This is a nightly-only experimental API. (clone_to_uninit)

Performs copy-assignment from self to dest. 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 for T
where T: Any,

Source §

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

Converts Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>, which can then be downcast into Box<dyn ConcreteType> where ConcreteType implements Trait.

Source §

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

Converts Rc<Trait> (where Trait: Downcast) to Rc<Any>, which can then be further downcast into Rc<ConcreteType> where ConcreteType implements Trait.

Source §

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

Converts &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)

Converts &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> 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> DowncastSend for T
where T: Any + Send,

Source §

fn into_any_send(self: Box<T>) -> Box<dyn Any + Send>

Converts Box<Trait> (where Trait: DowncastSend) to Box<dyn Any + Send>, which can then be downcast into Box<ConcreteType> where ConcreteType implements Trait.

Source §

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

Source §

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

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 §

type Effect = ()

An operation on the entity that happens after inserting this bundle.

Source §

unsafe fn get_components( ptr: MovingPtr<'_, C>, func: &mut impl FnMut(StorageType, OwningPtr<'_>), ) -> <C as DynamicBundle>::Effect

Moves the components out of the bundle. Read more

Source §

unsafe fn apply_effect( _ptr: MovingPtr<'_, MaybeUninit<C>>, _entity: &mut EntityWorldMut<'_>, )

Applies the after-effects of spawning this bundle. Read more

Source §

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

Source §

fn reflect_type_path(&self) -> &str

See TypePath::type_path.

Source §

fn reflect_short_type_path(&self) -> &str

See TypePath::short_type_path.

Source §

fn reflect_type_ident(&self) -> Option<&str>

See TypePath::type_ident.

Source §

fn reflect_crate_name(&self) -> Option<&str>

See TypePath::crate_name.

Source §

fn reflect_module_path(&self) -> Option<&str>

See TypePath::module_path.

Source §

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

Source §

fn reflect_type_info(&self) -> &'static TypeInfo

See Typed::type_info.

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<S> GetField for S
where S: Struct,

Source §

fn get_field<T>(&self, name: &str) -> Option<&T>
where T: Reflect,

Returns a reference to the value of the field named name, downcast to T.

Source §

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

Returns a mutable reference to the value of the field named name, downcast to T.

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<T, W> HasTypeWitness<W> for T
where W: MakeTypeWitness<Arg = T>, T: ?Sized,

Source §

const WITNESS: W = W::MAKE

A constant of the type witness

Source §

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

Source §

const TYPE_EQ: TypeEq<T, <T as Identity>::Type> = TypeEq::NEW

Proof that Self is the same type as Self::Type, provides methods for casting between Self and Self::Type.

Source §

type Type = T

The same type as Self, used to emulate type equality bounds (T == U) with associated type equality constraints (T: Identity<Type = U>).

Source §

impl<T> InitializeFromFunction<T> for T

Source §

fn initialize_from_function(f: fn() -> T) -> T

Create an instance of this type from an initialization function

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