Struct Transform 

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

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

• To place or move an entity, you should set its Transform.
• To get the global transform of an entity, you should get its GlobalTransform.
• To be displayed, an entity must have both a Transform and a GlobalTransform. GlobalTransform is automatically inserted whenever Transform is inserted.

Transforms compose from right to left: if t1 and t2 are transforms, then t1 * t2 corresponds to applying t2 first, then applying t1.

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

impl Transform

pub const IDENTITY: Transform

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

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

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

Examples found in repository

examples/usage/debug_frustum_culling.rs (line 99)

const FREE_CAMERA_START_TRANSFORM: Transform = Transform::from_xyz(-20., 10., 22.);
const FREE_CAMERA_START_TARGET: Vec3 = Vec3::new(7., 1.5, 0.);

fn setup(
    mut commands: Commands,
    windows: Query<&Window>,
    mut config_store: ResMut<GizmoConfigStore>,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<StandardMaterial>>,
) -> Result {
    let window = windows.single()?;
    // The camera that the user controls to observe the scene.
    let free_camera = commands
        .spawn((
            Camera3d::default(),
            FREE_CAMERA_START_TRANSFORM.looking_at(FREE_CAMERA_START_TARGET, Vec3::Y),
            FreeCamera::default(),
        ))
        .id();

    // The camera that we want to debug frustum culling for. This will be rendered
    // as a picture-in-picture in the lower right ninth of the screen.
    let my_camera = commands
        .spawn((
            Camera3d::default(),
            Transform::from_xyz(0., 1.5, 0.).looking_at(Vec3::new(1.0, 1.5, 0.), Vec3::Y),
            Camera {
                order: 1,
                // The camera-to-debug's view will be in the lower right ninth of the screen.
                viewport: Some(Viewport {
                    physical_position: window.physical_size() * 2 / 3,
                    physical_size: window.physical_size() / 3,
                    ..default()
                }),
                // Do not write the free camera's view rendering back into the P-I-P
                msaa_writeback: MsaaWriteback::Off,
                ..default()
            },
            MyCamera,
        ))
        .id();

    // Instructions placed on top of the free_camera view
    commands.spawn((
        UiTargetCamera(free_camera),
        Node {
            width: percent(100),
            height: percent(100),
            ..default()
        },
        children![(
            Text::new(
                "This example utilizes free camera controls i.e. move with WASD and mouse grab to change orientation.\n\
                Press '1' to move the free camera to where MyCamera is, matching its view frustum.\n\
                Press '2' to move the free camera to its initial position in the example.",
            ),
            Node {
                position_type: PositionType::Absolute,
                top: px(12),
                left: px(12),
                ..default()
            },
        )]
    ));
    // Label for the picture-in-picture view of MyCamera
    commands.spawn((
        UiTargetCamera(my_camera),
        Node {
            width: percent(100),
            height: percent(100),
            ..default()
        },
        children![(
            Text::new("View of MyCamera"),
            Node {
                position_type: PositionType::Absolute,
                bottom: px(12),
                right: px(100),
                ..default()
            },
        )],
    ));

    // Green Floor Plane
    commands.spawn((
        Mesh3d(
            meshes.add(
                Plane3d::default()
                    .mesh()
                    .size(SHAPE_RING_RADIUS * 4., SHAPE_RING_RADIUS * 4.),
            ),
        ),
        MeshMaterial3d(materials.add(Color::srgb(0.3, 0.5, 0.3))),
    ));
    // Blue Wall Plane
    commands.spawn((
        Mesh3d(meshes.add(Plane3d::default().mesh().size(5., 5.))),
        MeshMaterial3d(materials.add(Color::srgb(0.3, 0.3, 0.5))),
        Transform::from_xyz(20., 2.5, 10.).with_rotation(Quat::from_rotation_z(PI / 2.)),
    ));
    // Light
    commands.spawn((
        PointLight {
            shadow_maps_enabled: true,
            ..default()
        },
        Transform::from_xyz(0.0, 10.0, 0.0),
    ));

    // Configure all AABB's to have a default color of red
    let (_, aabb_gizmo_config) = config_store.config_mut::<AabbGizmoConfigGroup>();
    aabb_gizmo_config.default_color = Some(Color::LinearRgba(LinearRgba::RED));

    // Configure the shapes on the ring that will have their AABB's drawn and updated
    let white_matl = materials.add(Color::WHITE);
    let shapes = [
        meshes.add(Cuboid {
            half_size: Vec3::new(2., 0.5, 1.),
        }),
        meshes.add(Tetrahedron {
            vertices: [
                Vec3::new(3., 4., 3.),
                Vec3::new(-0.5, 4., -0.5),
                Vec3::new(-0.5, -0.5, 3.),
                Vec3::new(3., -0.5, -0.5),
            ],
        }),
        meshes.add(Cylinder {
            radius: 0.1,
            half_height: 1.5,
        }),
        meshes.add(Cuboid {
            half_size: Vec3::new(1., 0.1, 2.),
        }),
        meshes.add(Sphere::default().mesh().ico(5).unwrap()),
    ];
    let shapes_len = shapes.len() as f32;
    let mut shape_ring = commands.spawn((Transform::default(), Visibility::default(), ShapeRing));
    for (i, shape) in shapes.into_iter().enumerate() {
        // Space the shapes out evenly along the ring
        let shape_angle = i as f32 * 2. * PI / shapes_len;
        let (s, c) = ops::sin_cos(shape_angle);
        let (x, z) = (SHAPE_RING_RADIUS * c, SHAPE_RING_RADIUS * s);
        shape_ring.with_child((
            Mesh3d(shape),
            MeshMaterial3d(white_matl.clone()),
            Transform::from_xyz(x, 1.5, z).with_rotation(Quat::from_rotation_x(-PI / 4.)),
            MyShape,
        ));
    }

    // Configure the shape that peeks out of the wall plane
    let wall_shape = meshes.add(Torus::default());
    commands.spawn((
        Mesh3d(wall_shape),
        MeshMaterial3d(white_matl.clone()),
        Transform::from_xyz(25., 1.5, 12.5).with_rotation(Quat::from_rotation_x(-PI / 4.)),
        WallShape,
    ));

    Ok(())
}

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

fn spawn_light(commands: &mut Commands) {
    commands.spawn((
        DirectionalLight::default(),
        Transform::from_xyz(4.0, 8.0, 4.0).looking_at(Vec3::ZERO, Vec3::Y),
    ));
}

/// Spawns the camera.
fn spawn_camera(commands: &mut Commands) {
    commands
        .spawn(Camera3d::default())
        .insert(Transform::from_xyz(0.0, 2.5, 9.0).looking_at(Vec3::ZERO, Vec3::Y))
        // Tag the camera with `Selection::Camera`.
        .insert(Selection::Camera);
}

tests/3d/test_skinned_mesh_bounds.rs (line 53)

fn setup(mut commands: Commands) {
    commands.spawn((
        Camera3d::default(),
        Transform::from_xyz(0.0, 7.5, 18.0).looking_at(Vec3::new(0.0, 5.5, 0.0), Vec3::Y),
    ));
}

#[derive(Component, Debug, Default)]
struct PendingScene(Handle<Gltf>);

#[derive(Component, Debug, Default)]
struct PendingAnimation((Handle<AnimationGraph>, AnimationNodeIndex));

fn load_scene(mut commands: Commands, asset_server: Res<AssetServer>) {
    commands.spawn((
        PendingScene(asset_server.load("models/animated/Fox.glb")),
        Transform::from_xyz(1.3, 4.3, 0.0)
            .with_scale(Vec3::splat(0.08))
            .looking_to(-Vec3::X, Vec3::Y),
    ));
}

fn spawn_scene(
    mut commands: Commands,
    query: Query<(Entity, &PendingScene)>,
    assets: Res<Assets<Gltf>>,
    mut graphs: ResMut<Assets<AnimationGraph>>,
) {
    for (entity, PendingScene(asset)) in query.iter() {
        if let Some(gltf) = assets.get(asset)
            && let Some(scene_handle) = gltf.scenes.first()
            && let Some(animation_handle) = gltf.named_animations.get("Run")
        {
            let (graph, graph_node_index) = AnimationGraph::from_clip(animation_handle.clone());

            commands
                .entity(entity)
                .remove::<PendingScene>()
                .insert((
                    WorldAssetRoot(scene_handle.clone()),
                    PendingAnimation((graphs.add(graph), graph_node_index)),
                ))
                .observe(play_animation);
        }
    }
}

fn play_animation(
    trigger: On<WorldInstanceReady>,
    mut commands: Commands,
    children: Query<&Children>,
    animations: Query<&PendingAnimation>,
    mut players: Query<&mut AnimationPlayer>,
) {
    if let Ok(PendingAnimation((graph_handle, graph_node_index))) = animations.get(trigger.entity) {
        for child in children.iter_descendants(trigger.entity) {
            if let Ok(mut player) = players.get_mut(child) {
                player.play(*graph_node_index).set_speed(0.6).repeat();

                commands
                    .entity(child)
                    .insert(AnimationGraphHandle(graph_handle.clone()));
            }
        }
    }

    commands.entity(trigger.entity).remove::<PendingAnimation>();
}

type CustomAnimationId = i8;

#[derive(Component)]
struct CustomAnimation(CustomAnimationId);

fn spawn_custom_meshes(
    mut commands: Commands,
    mut mesh_assets: ResMut<Assets<Mesh>>,
    mut material_assets: ResMut<Assets<StandardMaterial>>,
    mut inverse_bindposes_assets: ResMut<Assets<SkinnedMeshInverseBindposes>>,
) {
    let mesh_handle = mesh_assets.add(
        Mesh::new(
            PrimitiveTopology::TriangleStrip,
            // Test that skinned mesh bounds work even if the mesh is render
            // world only.
            RenderAssetUsages::RENDER_WORLD,
        )
        .with_inserted_attribute(
            Mesh::ATTRIBUTE_POSITION,
            vec![
                [-0.5, 0.0, 0.0],
                [0.5, 0.0, 0.0],
                [-0.5, 0.5, 0.0],
                [0.5, 0.5, 0.0],
                [-0.5, 1.0, 0.0],
                [0.5, 1.0, 0.0],
                [-0.5, 1.5, 0.0],
                [0.5, 1.5, 0.0],
                [-0.5, 2.0, 0.0],
                [0.5, 2.0, 0.0],
            ],
        )
        .with_inserted_attribute(Mesh::ATTRIBUTE_NORMAL, vec![[0.0, 0.0, 1.0]; 10])
        .with_inserted_attribute(
            Mesh::ATTRIBUTE_JOINT_INDEX,
            VertexAttributeValues::Uint16x4(vec![
                [1, 0, 0, 0],
                [1, 0, 0, 0],
                [1, 2, 0, 0],
                [1, 2, 0, 0],
                [1, 2, 0, 0],
                [1, 2, 0, 0],
                [2, 1, 0, 0],
                [2, 1, 0, 0],
                [2, 0, 0, 0],
                [2, 0, 0, 0],
            ]),
        )
        .with_inserted_attribute(
            Mesh::ATTRIBUTE_JOINT_WEIGHT,
            vec![
                [1.00, 0.00, 0.0, 0.0],
                [1.00, 0.00, 0.0, 0.0],
                [0.75, 0.25, 0.0, 0.0],
                [0.75, 0.25, 0.0, 0.0],
                [0.50, 0.50, 0.0, 0.0],
                [0.50, 0.50, 0.0, 0.0],
                [0.75, 0.25, 0.0, 0.0],
                [0.75, 0.25, 0.0, 0.0],
                [1.00, 0.00, 0.0, 0.0],
                [1.00, 0.00, 0.0, 0.0],
            ],
        )
        .with_generated_skinned_mesh_bounds()
        .unwrap(),
    );

    let inverse_bindposes_handle = inverse_bindposes_assets.add(vec![
        Mat4::from_translation(Vec3::new(0.0, 0.0, 0.0)),
        Mat4::from_translation(Vec3::new(0.0, 0.0, 0.0)),
        Mat4::from_translation(Vec3::new(0.0, -1.0, 0.0)),
    ]);

    struct MeshInstance {
        animations: [CustomAnimationId; 2],
    }

    let mesh_instances = [
        // Simple cases. First joint is still, second joint is all rotation/translation/scale variations.
        MeshInstance { animations: [0, 1] },
        MeshInstance { animations: [0, 2] },
        MeshInstance { animations: [0, 3] },
        MeshInstance { animations: [0, 4] },
        MeshInstance { animations: [0, 5] },
        MeshInstance { animations: [0, 6] },
        MeshInstance { animations: [0, 7] },
        MeshInstance { animations: [0, 8] },
        // Skewed cases. First joint is non-uniform scaling, second joint is rotation/translation variations.
        MeshInstance { animations: [9, 1] },
        MeshInstance { animations: [9, 2] },
        MeshInstance { animations: [9, 3] },
        MeshInstance { animations: [9, 4] },
        MeshInstance { animations: [9, 5] },
    ];

    for (i, mesh_instance) in mesh_instances.iter().enumerate() {
        let x = ((i as f32) * 2.0) - ((mesh_instances.len() - 1) as f32);

        let base_entity = commands
            .spawn((Transform::from_xyz(x, 0.0, 0.0), Visibility::default()))
            .id();

        let joints = vec![
            commands.spawn((Transform::IDENTITY,)).id(),
            commands
                .spawn((
                    CustomAnimation(mesh_instance.animations[0]),
                    Transform::IDENTITY,
                ))
                .id(),
            commands
                .spawn((
                    CustomAnimation(mesh_instance.animations[1]),
                    Transform::IDENTITY,
                ))
                .id(),
        ];

        commands.entity(joints[0]).insert(ChildOf(base_entity));

        commands.entity(joints[1]).insert(ChildOf(joints[0]));
        commands.entity(joints[2]).insert(ChildOf(joints[1]));

        let mesh_entity = commands
            .spawn((
                Transform::IDENTITY,
                Mesh3d(mesh_handle.clone()),
                MeshMaterial3d(material_assets.add(StandardMaterial {
                    base_color: Color::WHITE,
                    cull_mode: None,
                    ..default()
                })),
                SkinnedMesh {
                    inverse_bindposes: inverse_bindposes_handle.clone(),
                    joints: joints.clone(),
                },
                DynamicSkinnedMeshBounds,
            ))
            .id();

        commands.entity(mesh_entity).insert(ChildOf(base_entity));
    }
}

examples/3d/mixed_lighting.rs (line 160)

fn spawn_camera(commands: &mut Commands) {
    commands
        .spawn(Camera3d::default())
        .insert(Transform::from_xyz(-0.7, 0.7, 1.0).looking_at(vec3(0.0, 0.3, 0.0), Vec3::Y));
}

examples/3d/clustered_decal_maps.rs (line 235)

fn spawn_light(commands: &mut Commands) {
    commands.spawn((
        PointLight {
            intensity: 10_000_000.,
            range: 100.0,
            ..default()
        },
        Transform::from_xyz(8.0, 16.0, -8.0),
    ));
}

/// Spawns a camera.
fn spawn_camera(commands: &mut Commands) {
    commands.spawn((
        Camera3d::default(),
        Transform::from_xyz(2.0, 0.0, -7.0).looking_at(Vec3::ZERO, Vec3::Y),
        Hdr,
    ));
}

examples/3d/pccm.rs (line 98)

fn spawn_camera(commands: &mut Commands) {
    commands.spawn((
        Camera3d::default(),
        FreeCamera::default(),
        Transform::from_xyz(0.0, 0.0, 4.0).looking_at(Vec3::new(0.0, -2.5, 0.0), Dir3::Y),
        Hdr,
    ));
}

/// Spawns the inner reflective cube in the scene.
fn spawn_inner_cube(
    commands: &mut Commands,
    meshes: &mut Assets<Mesh>,
    materials: &mut Assets<StandardMaterial>,
) {
    let cube_mesh = meshes.add(
        Cuboid {
            half_size: Vec3::new(5.0, 1.0, 2.0),
        }
        .mesh()
        .build()
        .with_duplicated_vertices()
        .with_computed_flat_normals(),
    );
    let cube_material = materials.add(StandardMaterial {
        base_color: Color::WHITE,
        metallic: 1.0,
        reflectance: 1.0,
        perceptual_roughness: 0.0,
        ..default()
    });

    commands.spawn((
        Mesh3d(cube_mesh),
        MeshMaterial3d(cube_material),
        Transform::from_xyz(0.0, -4.0, -2.5),
        InnerCube,
    ));
}

Additional examples can be found in:

• examples/3d/occlusion_culling.rs
• examples/3d/mirror.rs
• examples/2d/move_sprite.rs
• examples/3d/reflection_probes.rs
• examples/animation/color_animation.rs
• examples/3d/irradiance_volumes.rs
• examples/ecs/delayed_commands.rs
• examples/gizmos/3d_text_gizmos.rs
• examples/async_tasks/external_source_external_thread.rs
• examples/math/render_primitives.rs
• examples/stress_tests/many_gizmos.rs
• examples/scene/world_serialization.rs
• examples/gltf/gltf_skinned_mesh.rs
• examples/showcase/alien_cake_addict.rs
• examples/shader/animate_shader.rs
• examples/gltf/query_gltf_primitives.rs
• examples/3d/lightmaps.rs
• examples/shader/shader_material_wesl.rs
• examples/3d/ssr.rs
• examples/3d/light_textures.rs
• examples/camera/2d_top_down_camera.rs
• examples/2d/pixel_grid_snap.rs
• examples/shader/fallback_image.rs
• examples/shader_advanced/custom_phase_item.rs
• examples/shader_advanced/render_depth_to_texture.rs
• examples/3d/3d_viewport_to_world.rs
• examples/camera/free_camera_controller.rs
• examples/3d/light_probe_blending.rs
• examples/shader/shader_material.rs
• examples/shader/shader_material_glsl.rs
• examples/shader_advanced/texture_binding_array.rs
• examples/async_tasks/async_channel_pattern.rs
• examples/app/externally_driven_headless_renderer.rs
• examples/asset/hot_asset_reloading.rs
• examples/asset/multi_asset_sync.rs
• examples/shader_advanced/manual_material.rs
• examples/3d/color_grading.rs
• examples/2d/transparency_2d.rs
• examples/transforms/3d_rotation.rs
• examples/transforms/scale.rs
• examples/shader_advanced/custom_vertex_attribute.rs
• examples/animation/morph_targets.rs
• examples/3d/3d_scene.rs
• tests/window/minimizing.rs
• tests/window/resizing.rs
• examples/3d/atmospheric_fog.rs
• examples/transforms/translation.rs
• examples/shader/shader_defs.rs
• examples/gltf/load_gltf_extras.rs
• examples/animation/animated_mesh.rs
• examples/showcase/loading_screen.rs
• examples/3d/parenting.rs
• examples/animation/animation_graph.rs
• examples/3d/post_processing.rs
• examples/3d/rotate_environment_map.rs
• examples/shader/shader_material_screenspace_texture.rs
• examples/3d/depth_of_field.rs
• examples/camera/2d_screen_shake.rs
• examples/camera/camera_orbit.rs
• examples/shader/shader_material_bindless.rs
• examples/gltf/edit_material_on_gltf.rs
• examples/remote/server.rs
• examples/animation/animation_masks.rs
• examples/3d/anisotropy.rs
• examples/window/screenshot.rs
• examples/3d/animated_material.rs
• examples/3d/pcss.rs
• examples/shader_advanced/custom_post_processing.rs
• examples/ecs/entity_disabling.rs
• examples/3d/clearcoat.rs
• examples/camera/custom_projection.rs
• examples/picking/custom_hit_data.rs
• examples/gltf/load_gltf.rs
• examples/3d/two_passes.rs
• examples/stress_tests/many_materials.rs
• examples/gltf/gltf_extension_animation_graph.rs
• examples/diagnostics/log_diagnostics.rs
• examples/shader/extended_material_bindless.rs
• examples/3d/tonemapping.rs
• examples/shader_advanced/custom_render_phase.rs
• examples/dev_tools/infinite_grid.rs
• examples/gltf/update_gltf_scene.rs
• examples/3d/skybox.rs
• examples/3d/fog_volumes.rs
• examples/3d/lines.rs
• examples/shader/storage_buffer.rs
• examples/window/low_power.rs
• examples/3d/order_independent_transparency.rs
• examples/shader/array_texture.rs
• examples/ecs/hierarchy.rs
• examples/3d/generate_custom_mesh.rs
• examples/2d/wireframe_2d.rs
• examples/3d/mesh_ray_cast.rs
• examples/audio/spatial_audio_2d.rs
• examples/picking/simple_picking.rs
• examples/movement/smooth_follow.rs
• examples/shader/extended_material.rs
• examples/3d/vertex_colors.rs
• examples/animation/animated_mesh_control.rs
• examples/asset/generated_assets.rs
• examples/shader_advanced/custom_shader_instancing.rs
• tests/window/desktop_request_redraw.rs
• examples/3d/orthographic.rs
• examples/showcase/contributors.rs
• examples/testbed/2d.rs
• examples/picking/debug_picking.rs
• examples/shader_advanced/specialized_mesh_pipeline.rs
• examples/window/multiple_windows.rs
• examples/3d/spherical_area_lights.rs
• examples/math/bounding_2d.rs
• examples/stress_tests/many_morph_targets.rs
• examples/transforms/transform.rs
• examples/camera/first_person_view_model.rs
• examples/gizmos/axes.rs
• examples/3d/motion_blur.rs
• examples/app/headless_renderer.rs
• examples/3d/ssao.rs
• examples/3d/atmosphere.rs
• examples/animation/animated_mesh_events.rs
• examples/app/render_recovery.rs
• examples/animation/eased_motion.rs
• examples/stress_tests/transform_hierarchy.rs
• examples/audio/spatial_audio_3d.rs
• examples/shader/automatic_instancing.rs
• examples/asset/alter_sprite.rs
• examples/ecs/error_handling.rs
• examples/camera/projection_zoom.rs
• examples/2d/rotation.rs
• examples/3d/fog.rs
• examples/3d/rect_light.rs
• examples/3d/specular_tint.rs
• examples/ui/widgets/viewport_node.rs
• examples/3d/visibility_range.rs
• examples/2d/dynamic_mip_generation.rs
• examples/3d/volumetric_fog.rs
• tests/3d/test_invalid_skinned_mesh.rs
• examples/stress_tests/many_cameras_lights.rs
• examples/3d/texture.rs
• examples/async_tasks/async_compute.rs
• examples/3d/shadow_caster_receiver.rs
• examples/3d/wireframe.rs
• examples/3d/bloom_3d.rs
• examples/3d/anti_aliasing.rs
• examples/gizmos/3d_gizmos.rs
• examples/transforms/align.rs
• examples/3d/decal.rs
• examples/math/random_sampling.rs
• examples/testbed/3d.rs
• examples/picking/sprite_picking.rs
• examples/2d/mesh2d_alpha_mode.rs
• examples/3d/scrolling_fog.rs
• examples/ecs/iter_combinations.rs
• examples/shader_advanced/compute_mesh.rs
• examples/3d/render_to_texture.rs
• examples/2d/sprite_slice.rs
• examples/gizmos/transform_gizmo.rs
• examples/3d/transparency_3d.rs
• examples/asset/repeated_texture.rs
• examples/asset/asset_settings.rs
• examples/2d/mesh2d_repeated_texture.rs
• examples/3d/spotlight.rs
• examples/asset/alter_mesh.rs
• examples/3d/pbr.rs
• examples/math/custom_primitives.rs
• examples/3d/auto_exposure.rs
• examples/animation/easing_functions.rs
• examples/asset/asset_loading.rs
• examples/window/multi_window_text.rs
• examples/gizmos/light_gizmos.rs
• examples/stress_tests/bevymark_3d.rs
• examples/shader/shader_prepass.rs
• examples/3d/shadow_biases.rs
• examples/2d/2d_shapes.rs
• examples/picking/mesh_picking.rs
• examples/ui/render_ui_to_texture.rs
• examples/showcase/desk_toy.rs
• examples/3d/parallax_mapping.rs
• examples/2d/sprite_scale.rs
• examples/stress_tests/many_foxes.rs
• examples/3d/deferred_rendering.rs
• examples/3d/contact_shadows.rs
• examples/3d/3d_shapes.rs
• examples/animation/custom_skinned_mesh.rs
• examples/3d/blend_modes.rs
• examples/animation/animated_transform.rs
• examples/3d/lighting.rs
• examples/3d/camera_sub_view.rs
• examples/3d/transmission.rs
• examples/stress_tests/many_cubes.rs

pub fn from_matrix(world_from_local: Mat4) -> Transform

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

Examples found in repository

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

fn spawn_irradiance_volume(commands: &mut Commands, assets: &ExampleAssets) {
    commands.spawn((
        Transform::from_matrix(VOXEL_FROM_WORLD),
        IrradianceVolume {
            voxels: assets.irradiance_volume.clone(),
            intensity: IRRADIANCE_VOLUME_INTENSITY,
            ..default()
        },
    ));
}

examples/3d/mirror.rs (lines 354-356)

fn calculate_mirror_camera_transform_and_projection(
    main_camera_transform: &Transform,
    main_camera_projection: &PerspectiveProjection,
    mirror_transform: &Transform,
) -> (Transform, PerspectiveProjection) {
    // Calculate the reflection matrix (a.k.a. Householder matrix) that will
    // reflect the scene across the mirror plane.
    //
    // Note that you must calculate this in *matrix* form and only *afterward*
    // convert to a `Transform` instead of composing `Transform`s. This is
    // because the reflection matrix has non-uniform scale, and composing
    // transforms can't always handle composition of matrices with non-uniform
    // scales.
    let mirror_camera_transform = Transform::from_matrix(
        Mat4::from_mat3a(reflection_matrix(Vec3::NEG_Z)) * main_camera_transform.to_matrix(),
    );

    // Compute the distance from the camera to the mirror plane. This will be
    // used to calculate the distance to the near clip plane for the mirror
    // world.
    let distance_from_camera_to_mirror = InfinitePlane3d::new(mirror_transform.rotation * Vec3::Y)
        .signed_distance(
            Isometry3d::IDENTITY,
            mirror_transform.translation - main_camera_transform.translation,
        );

    // Compute the normal of the mirror plane in view space.
    let view_from_world = main_camera_transform.compute_affine().matrix3.inverse();
    let mirror_projection_plane_normal =
        (view_from_world * (mirror_transform.rotation * Vec3::NEG_Y)).normalize();

    // Compute the final projection. It should match the main camera projection,
    // except that `near` and `near_normal` should be set to the updated near
    // plane and near normal plane as above.
    let mirror_camera_projection = PerspectiveProjection {
        near_clip_plane: mirror_projection_plane_normal.extend(distance_from_camera_to_mirror),
        ..*main_camera_projection
    };

    (mirror_camera_transform, mirror_camera_projection)
}

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

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

Examples found in repository

examples/stress_tests/many_sprite_meshes.rs (line 108)

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

examples/stress_tests/many_sprites.rs (line 106)

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

examples/stress_tests/many_animated_sprite_meshes.rs (line 104)

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

examples/stress_tests/many_animated_sprites.rs (line 102)

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

examples/math/render_primitives.rs (line 320)

fn setup_lights(mut commands: Commands) {
    commands.spawn((
        PointLight {
            intensity: 5000.0,
            ..default()
        },
        Transform::from_translation(Vec3::new(-LEFT_RIGHT_OFFSET_3D, 2.0, 0.0))
            .looking_at(Vec3::new(-LEFT_RIGHT_OFFSET_3D, 0.0, 0.0), Vec3::Y),
    ));
}

/// Marker component for header text
#[derive(Debug, Clone, Component, Default, Reflect)]
pub struct HeaderText;

/// Marker component for header node
#[derive(Debug, Clone, Component, Default, Reflect)]
pub struct HeaderNode;

fn update_active_cameras(
    state: Res<State<CameraActive>>,
    camera_2d: Single<(Entity, &mut Camera), With<Camera2d>>,
    camera_3d: Single<(Entity, &mut Camera), (With<Camera3d>, Without<Camera2d>)>,
    mut text: Query<&mut UiTargetCamera, With<HeaderNode>>,
) {
    let (entity_2d, mut cam_2d) = camera_2d.into_inner();
    let (entity_3d, mut cam_3d) = camera_3d.into_inner();
    let is_camera_2d_active = matches!(*state.get(), CameraActive::Dim2);

    cam_2d.is_active = is_camera_2d_active;
    cam_3d.is_active = !is_camera_2d_active;

    let active_camera = if is_camera_2d_active {
        entity_2d
    } else {
        entity_3d
    };

    text.iter_mut().for_each(|mut target_camera| {
        *target_camera = UiTargetCamera(active_camera);
    });
}

fn switch_cameras(current: Res<State<CameraActive>>, mut next: ResMut<NextState<CameraActive>>) {
    let next_state = match current.get() {
        CameraActive::Dim2 => CameraActive::Dim3,
        CameraActive::Dim3 => CameraActive::Dim2,
    };
    next.set(next_state);
}

fn setup_text(mut commands: Commands, cameras: Query<(Entity, &Camera)>) {
    let active_camera = cameras
        .iter()
        .find_map(|(entity, camera)| camera.is_active.then_some(entity))
        .expect("run condition ensures existence");
    commands.spawn((
        HeaderNode,
        Node {
            justify_self: JustifySelf::Center,
            top: px(5),
            ..Default::default()
        },
        UiTargetCamera(active_camera),
        children![(
            Text::default(),
            HeaderText,
            TextLayout::justify(Justify::Center),
            children![
                TextSpan::new("Primitive: "),
                TextSpan(format!("{text}", text = PrimitiveSelected::default())),
                TextSpan::new("\n\n"),
                TextSpan::new(
                    "Press 'C' to switch between 2D and 3D mode\n\
                    Press 'Up' or 'Down' to switch to the next/previous primitive",
                ),
                TextSpan::new("\n\n"),
                TextSpan::new("(If nothing is displayed, there's no rendering support yet)",),
            ]
        )],
    ));
}

fn update_text(
    primitive_state: Res<State<PrimitiveSelected>>,
    header: Query<Entity, With<HeaderText>>,
    mut writer: TextUiWriter,
) {
    let new_text = format!("{text}", text = primitive_state.get());
    header.iter().for_each(|header_text| {
        if let Some(mut text) = writer.get_text(header_text, 2) {
            (*text).clone_from(&new_text);
        };
    });
}

fn switch_to_next_primitive(
    current: Res<State<PrimitiveSelected>>,
    mut next: ResMut<NextState<PrimitiveSelected>>,
) {
    let next_state = current.get().next();
    next.set(next_state);
}

fn switch_to_previous_primitive(
    current: Res<State<PrimitiveSelected>>,
    mut next: ResMut<NextState<PrimitiveSelected>>,
) {
    let next_state = current.get().previous();
    next.set(next_state);
}

fn in_mode(active: CameraActive) -> impl Fn(Res<State<CameraActive>>) -> bool {
    move |state| *state.get() == active
}

fn draw_gizmos_2d(mut gizmos: Gizmos, state: Res<State<PrimitiveSelected>>, time: Res<Time>) {
    const POSITION: Vec2 = Vec2::new(-LEFT_RIGHT_OFFSET_2D, 0.0);
    let angle = time.elapsed_secs();
    let isometry = Isometry2d::new(POSITION, Rot2::radians(angle));
    let color = Color::WHITE;

    #[expect(
        clippy::match_same_arms,
        reason = "Certain primitives don't have any 2D rendering support yet."
    )]
    match state.get() {
        PrimitiveSelected::RectangleAndCuboid => {
            gizmos.primitive_2d(&RECTANGLE, isometry, color);
        }
        PrimitiveSelected::CircleAndSphere => {
            gizmos.primitive_2d(&CIRCLE, isometry, color);
        }
        PrimitiveSelected::Ellipse => drop(gizmos.primitive_2d(&ELLIPSE, isometry, color)),
        PrimitiveSelected::Triangle => gizmos.primitive_2d(&TRIANGLE_2D, isometry, color),
        PrimitiveSelected::Plane => gizmos.primitive_2d(&PLANE_2D, isometry, color),
        PrimitiveSelected::Line => drop(gizmos.primitive_2d(&LINE_2D, isometry, color)),
        PrimitiveSelected::Segment => {
            drop(gizmos.primitive_2d(&SEGMENT_2D, isometry, color));
        }
        PrimitiveSelected::Polyline => gizmos.primitive_2d(
            &Polyline2d {
                vertices: POLYLINE_2D_VERTICES.to_vec(),
            },
            isometry,
            color,
        ),
        PrimitiveSelected::ConvexPolygon => gizmos.primitive_2d(
            &Polygon::from(ConvexPolygon::new(CONVEX_POLYGON_VERTICES).unwrap()),
            isometry,
            color,
        ),
        PrimitiveSelected::Polygon => gizmos.primitive_2d(
            &Polygon {
                vertices: vec![
                    Vec2::new(-BIG_2D, -SMALL_2D),
                    Vec2::new(BIG_2D, -SMALL_2D),
                    Vec2::new(BIG_2D, SMALL_2D),
                    Vec2::new(0.0, 0.0),
                    Vec2::new(-BIG_2D, SMALL_2D),
                ],
            },
            isometry,
            color,
        ),
        PrimitiveSelected::RegularPolygon => {
            gizmos.primitive_2d(&REGULAR_POLYGON, isometry, color);
        }
        PrimitiveSelected::Capsule => gizmos.primitive_2d(&CAPSULE_2D, isometry, color),
        PrimitiveSelected::Cylinder => {}
        PrimitiveSelected::Cone => {}
        PrimitiveSelected::ConicalFrustum => {}
        PrimitiveSelected::Torus => drop(gizmos.primitive_2d(&ANNULUS, isometry, color)),
        PrimitiveSelected::Tetrahedron => {}
        PrimitiveSelected::Arc => gizmos.primitive_2d(&ARC, isometry, color),
        PrimitiveSelected::CircularSector => {
            gizmos.primitive_2d(&CIRCULAR_SECTOR, isometry, color);
        }
        PrimitiveSelected::CircularSegment => {
            gizmos.primitive_2d(&CIRCULAR_SEGMENT, isometry, color);
        }
    }
}

/// Marker for primitive meshes to record in which state they should be visible in
#[derive(Debug, Clone, Component, Default, Reflect)]
pub struct PrimitiveData {
    camera_mode: CameraActive,
    primitive_state: PrimitiveSelected,
}

/// Marker for meshes of 2D primitives
#[derive(Debug, Clone, Component, Default)]
pub struct MeshDim2;

/// Marker for meshes of 3D primitives
#[derive(Debug, Clone, Component, Default)]
pub struct MeshDim3;

fn spawn_primitive_2d(
    mut commands: Commands,
    mut materials: ResMut<Assets<ColorMaterial>>,
    mut meshes: ResMut<Assets<Mesh>>,
) {
    const POSITION: Vec3 = Vec3::new(LEFT_RIGHT_OFFSET_2D, 0.0, 0.0);
    let material: Handle<ColorMaterial> = materials.add(Color::WHITE);
    let camera_mode = CameraActive::Dim2;
    let polyline_2d = Polyline2d {
        vertices: POLYLINE_2D_VERTICES.to_vec(),
    };
    let convex_polygon = ConvexPolygon::new(CONVEX_POLYGON_VERTICES).unwrap();
    [
        Some(RECTANGLE.mesh().build()),
        Some(CIRCLE.mesh().build()),
        Some(ELLIPSE.mesh().build()),
        Some(TRIANGLE_2D.mesh().build()),
        None, // plane
        None, // line
        Some(SEGMENT_2D.mesh().build()),
        Some(polyline_2d.mesh().build()),
        None, // polygon
        Some(convex_polygon.mesh().build()),
        Some(REGULAR_POLYGON.mesh().build()),
        Some(CAPSULE_2D.mesh().build()),
        None, // cylinder
        None, // cone
        None, // conical frustum
        Some(ANNULUS.mesh().build()),
        None, // tetrahedron
        None, // arc
        Some(CIRCULAR_SECTOR.mesh().build()),
        Some(CIRCULAR_SEGMENT.mesh().build()),
    ]
    .into_iter()
    .zip(PrimitiveSelected::ALL)
    .for_each(|(maybe_mesh, state)| {
        if let Some(mesh) = maybe_mesh {
            commands.spawn((
                MeshDim2,
                PrimitiveData {
                    camera_mode,
                    primitive_state: state,
                },
                Mesh2d(meshes.add(mesh)),
                MeshMaterial2d(material.clone()),
                Transform::from_translation(POSITION),
            ));
        }
    });
}

fn spawn_primitive_3d(
    mut commands: Commands,
    mut materials: ResMut<Assets<StandardMaterial>>,
    mut meshes: ResMut<Assets<Mesh>>,
) {
    const POSITION: Vec3 = Vec3::new(-LEFT_RIGHT_OFFSET_3D, 0.0, 0.0);
    let material: Handle<StandardMaterial> = materials.add(Color::WHITE);
    let camera_mode = CameraActive::Dim3;
    let polyline_3d = Polyline3d {
        vertices: POLYLINE_3D_VERTICES.to_vec(),
    };
    [
        Some(CUBOID.mesh().build()),
        Some(SPHERE.mesh().build()),
        None, // ellipse
        Some(TRIANGLE_3D.mesh().build()),
        Some(PLANE_3D.mesh().build()),
        None, // line
        Some(SEGMENT_3D.mesh().build()),
        Some(polyline_3d.mesh().build()),
        None, // polygon
        None, // convex polygon
        None, // regular polygon
        Some(CAPSULE_3D.mesh().build()),
        Some(CYLINDER.mesh().build()),
        Some(CONE.mesh().build()),
        Some(CONICAL_FRUSTUM.mesh().build()),
        Some(TORUS.mesh().build()),
        Some(TETRAHEDRON.mesh().build()),
        None, // arc
        None, // circular sector
        None, // circular segment
    ]
    .into_iter()
    .zip(PrimitiveSelected::ALL)
    .for_each(|(maybe_mesh, state)| {
        if let Some(mesh) = maybe_mesh {
            commands.spawn((
                MeshDim3,
                PrimitiveData {
                    camera_mode,
                    primitive_state: state,
                },
                Mesh3d(meshes.add(mesh)),
                MeshMaterial3d(material.clone()),
                Transform::from_translation(POSITION),
            ));
        }
    });
}

examples/3d/fog_volumes.rs (line 77)

fn rotate_camera(mut cameras: Query<&mut Transform, With<Camera3d>>) {
    for mut camera_transform in cameras.iter_mut() {
        *camera_transform =
            Transform::from_translation(Quat::from_rotation_y(0.01) * camera_transform.translation)
                .looking_at(vec3(0.0, 0.5, 0.0), Vec3::Y);
    }
}

Additional examples can be found in:

• examples/3d/clustered_decals.rs
• examples/stress_tests/many_text2d.rs
• examples/3d/mirror.rs
• examples/ecs/fallible_params.rs
• examples/shader_advanced/fullscreen_material.rs
• examples/3d/3d_viewport_to_world.rs
• examples/transforms/3d_rotation.rs
• examples/stress_tests/bevymark.rs
• examples/transforms/translation.rs
• examples/testbed/2d.rs
• examples/2d/dynamic_mip_generation.rs
• examples/asset/asset_saving_with_subassets.rs
• examples/asset/multi_asset_sync.rs
• examples/3d/anisotropy.rs
• examples/3d/animated_material.rs
• examples/shader_advanced/custom_post_processing.rs
• examples/testbed/3d.rs
• examples/stress_tests/many_materials.rs
• examples/movement/physics_in_fixed_timestep.rs
• examples/dev_tools/infinite_grid.rs
• examples/2d/mesh2d_vertex_color_texture.rs
• examples/3d/ssr.rs
• examples/3d/mesh_ray_cast.rs
• examples/3d/order_independent_transparency.rs
• examples/audio/spatial_audio_2d.rs
• examples/movement/smooth_follow.rs
• examples/2d/2d_viewport_to_world.rs
• examples/transforms/transform.rs
• examples/2d/bloom_2d.rs
• examples/3d/light_probe_blending.rs
• examples/3d/light_textures.rs
• examples/3d/occlusion_culling.rs
• examples/animation/eased_motion.rs
• examples/audio/spatial_audio_3d.rs
• examples/ecs/error_handling.rs
• examples/camera/projection_zoom.rs
• examples/3d/clustered_decal_maps.rs
• examples/stress_tests/many_lights.rs
• examples/picking/dragdrop_picking.rs
• examples/math/random_sampling.rs
• examples/stress_tests/transform_hierarchy.rs
• examples/3d/render_to_texture.rs
• examples/2d/sprite_slice.rs
• examples/asset/repeated_texture.rs
• examples/2d/mesh2d_repeated_texture.rs
• examples/3d/spotlight.rs
• examples/gizmos/3d_gizmos.rs
• examples/3d/meshlet.rs
• examples/3d/auto_exposure.rs
• examples/stress_tests/bevymark_3d.rs
• examples/3d/split_screen.rs
• examples/showcase/breakout.rs
• examples/3d/solari.rs
• examples/3d/parallax_mapping.rs
• examples/2d/sprite_scale.rs
• examples/stress_tests/many_foxes.rs
• examples/2d/text2d.rs
• examples/stress_tests/many_cubes.rs

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

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

Examples found in repository

examples/3d/occlusion_culling.rs (lines 358-363)

fn spawn_light(commands: &mut Commands) {
    commands
        .spawn(DirectionalLight::default())
        .insert(Transform::from_rotation(Quat::from_euler(
            EulerRot::ZYX,
            0.0,
            PI * -0.15,
            PI * -0.15,
        )));
}

examples/3d/mirror.rs (line 228)

fn spawn_ground_plane(
    commands: &mut Commands,
    meshes: &mut Assets<Mesh>,
    standard_materials: &mut Assets<StandardMaterial>,
) {
    commands.spawn((
        Mesh3d(meshes.add(Circle::new(200.0))),
        MeshMaterial3d(standard_materials.add(Color::from(GREEN))),
        Transform::from_rotation(Quat::from_rotation_x(-FRAC_PI_2))
            .with_translation(vec3(-25.0, 0.0, 0.0)),
    ));
}

examples/gltf/query_gltf_primitives.rs (line 61)

fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
    commands.spawn((
        Camera3d::default(),
        Transform::from_xyz(4.0, 4.0, 12.0).looking_at(Vec3::new(0.0, 0.0, 0.5), Vec3::Y),
    ));

    commands.spawn((
        Transform::from_rotation(Quat::from_euler(EulerRot::ZYX, 0.0, 1.0, -PI / 4.)),
        DirectionalLight::default(),
    ));

    commands.spawn(WorldAssetRoot(asset_server.load(
        GltfAssetLabel::Scene(0).from_asset("models/GltfPrimitives/gltf_primitives.glb"),
    )));
}

examples/app/externally_driven_headless_renderer.rs (line 138)

fn spawn_test_scene(
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<StandardMaterial>>,
) {
    commands.spawn((
        Mesh3d(meshes.add(Circle::new(4.0))),
        MeshMaterial3d(materials.add(Color::WHITE)),
        Transform::from_rotation(Quat::from_rotation_x(-std::f32::consts::FRAC_PI_2)),
    ));
    commands.spawn((
        Mesh3d(meshes.add(Cuboid::new(2.0, 2.0, 2.0))),
        MeshMaterial3d(materials.add(Color::srgb_u8(124, 144, 255))),
        Transform::from_xyz(0.0, 1.0, 0.0),
    ));
    commands.spawn((
        PointLight {
            shadow_maps_enabled: true,
            ..default()
        },
        Transform::from_xyz(4.0, 8.0, 4.0),
    ));
}

examples/asset/multi_asset_sync.rs (line 205)

fn setup_scene(
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<StandardMaterial>>,
) {
    // Camera
    commands.spawn((
        Camera3d::default(),
        Transform::from_xyz(10.0, 10.0, 15.0).looking_at(Vec3::new(0.0, 0.0, 0.0), Vec3::Y),
    ));

    // Light
    commands.spawn((
        DirectionalLight {
            shadow_maps_enabled: true,
            ..default()
        },
        Transform::from_rotation(Quat::from_euler(EulerRot::ZYX, 0.0, 1.0, -PI / 4.)),
    ));

    // Plane
    commands.spawn((
        Mesh3d(meshes.add(Plane3d::default().mesh().size(50000.0, 50000.0))),
        MeshMaterial3d(materials.add(Color::srgb(0.7, 0.2, 0.2))),
        Loading,
    ));
}

examples/transforms/scale.rs (line 46)

fn setup(
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<StandardMaterial>>,
) {
    // Spawn a cube to scale.
    commands.spawn((
        Mesh3d(meshes.add(Cuboid::default())),
        MeshMaterial3d(materials.add(Color::WHITE)),
        Transform::from_rotation(Quat::from_rotation_y(PI / 4.0)),
        Scaling::new(),
    ));

    // Spawn a camera looking at the entities to show what's happening in this example.
    commands.spawn((
        Camera3d::default(),
        Transform::from_xyz(0.0, 10.0, 20.0).looking_at(Vec3::ZERO, Vec3::Y),
    ));

    // Add a light source for better 3d visibility.
    commands.spawn((
        DirectionalLight::default(),
        Transform::from_xyz(3.0, 3.0, 3.0).looking_at(Vec3::ZERO, Vec3::Y),
    ));
}

Additional examples can be found in:

• examples/async_tasks/async_channel_pattern.rs
• examples/animation/morph_targets.rs
• examples/3d/pcss.rs
• examples/animation/animated_mesh.rs
• examples/animation/animation_graph.rs
• examples/3d/post_processing.rs
• examples/3d/color_grading.rs
• examples/remote/server.rs
• examples/animation/animation_masks.rs
• examples/3d/tonemapping.rs
• examples/camera/custom_projection.rs
• examples/stress_tests/many_materials.rs
• examples/testbed/3d.rs
• examples/gltf/gltf_extension_animation_graph.rs
• examples/diagnostics/log_diagnostics.rs
• examples/shader_advanced/custom_render_phase.rs
• examples/3d/mesh_ray_cast.rs
• examples/picking/simple_picking.rs
• examples/animation/animated_mesh_control.rs
• examples/picking/debug_picking.rs
• examples/stress_tests/many_morph_targets.rs
• examples/app/headless_renderer.rs
• examples/3d/ssao.rs
• examples/animation/animated_mesh_events.rs
• examples/app/render_recovery.rs
• examples/3d/order_independent_transparency.rs
• examples/3d/specular_tint.rs
• examples/3d/visibility_range.rs
• examples/stress_tests/many_cameras_lights.rs
• examples/3d/texture.rs
• examples/3d/shadow_caster_receiver.rs
• examples/3d/anti_aliasing.rs
• examples/3d/decal.rs
• examples/shader_advanced/compute_mesh.rs
• examples/gizmos/transform_gizmo.rs
• examples/3d/meshlet.rs
• examples/gizmos/light_gizmos.rs
• examples/3d/split_screen.rs
• examples/3d/solari.rs
• examples/stress_tests/many_foxes.rs
• examples/3d/deferred_rendering.rs
• examples/3d/contact_shadows.rs
• examples/3d/lighting.rs

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

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

Examples found in repository

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

fn spawn_fox(commands: &mut Commands, assets: &ExampleAssets) {
    commands.spawn((
        WorldAssetRoot(assets.fox.clone()),
        Visibility::Hidden,
        Transform::from_scale(Vec3::splat(FOX_SCALE)),
        MainObject,
    ));
}

fn spawn_text(commands: &mut Commands, app_status: &AppStatus) {
    commands.spawn((
        app_status.create_text(),
        Node {
            position_type: PositionType::Absolute,
            bottom: px(12),
            left: px(12),
            ..default()
        },
    ));
}

// A system that updates the help text.
fn update_text(mut text_query: Query<&mut Text>, app_status: Res<AppStatus>) {
    for mut text in text_query.iter_mut() {
        *text = app_status.create_text();
    }
}

impl AppStatus {
    // Constructs the help text at the bottom of the screen based on the
    // application status.
    fn create_text(&self) -> Text {
        let irradiance_volume_help_text = if self.irradiance_volume_present {
            DISABLE_IRRADIANCE_VOLUME_HELP_TEXT
        } else {
            ENABLE_IRRADIANCE_VOLUME_HELP_TEXT
        };

        let voxels_help_text = if self.voxels_visible {
            HIDE_VOXELS_HELP_TEXT
        } else {
            SHOW_VOXELS_HELP_TEXT
        };

        let rotation_help_text = if self.rotating {
            STOP_ROTATION_HELP_TEXT
        } else {
            START_ROTATION_HELP_TEXT
        };

        let switch_mesh_help_text = match self.model {
            ExampleModel::Sphere => SWITCH_TO_FOX_HELP_TEXT,
            ExampleModel::Fox => SWITCH_TO_SPHERE_HELP_TEXT,
        };

        format!(
            "{CLICK_TO_MOVE_HELP_TEXT}\n\
            {voxels_help_text}\n\
            {irradiance_volume_help_text}\n\
            {rotation_help_text}\n\
            {switch_mesh_help_text}"
        )
        .into()
    }
}

// Rotates the camera a bit every frame.
fn rotate_camera(
    mut camera_query: Query<&mut Transform, With<Camera3d>>,
    time: Res<Time>,
    app_status: Res<AppStatus>,
) {
    if !app_status.rotating {
        return;
    }

    for mut transform in camera_query.iter_mut() {
        transform.translation = Vec2::from_angle(ROTATION_SPEED * time.delta_secs())
            .rotate(transform.translation.xz())
            .extend(transform.translation.y)
            .xzy();
        transform.look_at(Vec3::ZERO, Vec3::Y);
    }
}

// Toggles between the unskinned sphere model and the skinned fox model if the
// user requests it.
fn change_main_object(
    keyboard: Res<ButtonInput<KeyCode>>,
    mut app_status: ResMut<AppStatus>,
    mut sphere_query: Query<
        &mut Visibility,
        (With<MainObject>, With<Mesh3d>, Without<WorldAssetRoot>),
    >,
    mut fox_query: Query<&mut Visibility, (With<MainObject>, With<WorldAssetRoot>)>,
) {
    if !keyboard.just_pressed(KeyCode::Tab) {
        return;
    }
    let Some(mut sphere_visibility) = sphere_query.iter_mut().next() else {
        return;
    };
    let Some(mut fox_visibility) = fox_query.iter_mut().next() else {
        return;
    };

    match app_status.model {
        ExampleModel::Sphere => {
            *sphere_visibility = Visibility::Hidden;
            *fox_visibility = Visibility::Visible;
            app_status.model = ExampleModel::Fox;
        }
        ExampleModel::Fox => {
            *sphere_visibility = Visibility::Visible;
            *fox_visibility = Visibility::Hidden;
            app_status.model = ExampleModel::Sphere;
        }
    }
}

impl Default for AppStatus {
    fn default() -> Self {
        Self {
            irradiance_volume_present: true,
            rotating: true,
            model: ExampleModel::Sphere,
            voxels_visible: false,
        }
    }
}

// Turns on and off the irradiance volume as requested by the user.
fn toggle_irradiance_volumes(
    mut commands: Commands,
    keyboard: Res<ButtonInput<KeyCode>>,
    light_probe_query: Query<Entity, With<LightProbe>>,
    mut app_status: ResMut<AppStatus>,
    assets: Res<ExampleAssets>,
    mut ambient_light: ResMut<GlobalAmbientLight>,
) {
    if !keyboard.just_pressed(KeyCode::Space) {
        return;
    };

    let Some(light_probe) = light_probe_query.iter().next() else {
        return;
    };

    if app_status.irradiance_volume_present {
        commands.entity(light_probe).remove::<IrradianceVolume>();
        ambient_light.brightness = AMBIENT_LIGHT_BRIGHTNESS * IRRADIANCE_VOLUME_INTENSITY;
        app_status.irradiance_volume_present = false;
    } else {
        commands.entity(light_probe).insert(IrradianceVolume {
            voxels: assets.irradiance_volume.clone(),
            intensity: IRRADIANCE_VOLUME_INTENSITY,
            ..default()
        });
        ambient_light.brightness = 0.0;
        app_status.irradiance_volume_present = true;
    }
}

fn toggle_rotation(keyboard: Res<ButtonInput<KeyCode>>, mut app_status: ResMut<AppStatus>) {
    if keyboard.just_pressed(KeyCode::Enter) {
        app_status.rotating = !app_status.rotating;
    }
}

// Handles clicks on the plane that reposition the object.
fn handle_mouse_clicks(
    buttons: Res<ButtonInput<MouseButton>>,
    windows: Query<&Window, With<PrimaryWindow>>,
    cameras: Query<(&Camera, &GlobalTransform)>,
    mut main_objects: Query<&mut Transform, With<MainObject>>,
) {
    if !buttons.pressed(MouseButton::Left) {
        return;
    }
    let Some(mouse_position) = windows.iter().next().and_then(Window::cursor_position) else {
        return;
    };
    let Some((camera, camera_transform)) = cameras.iter().next() else {
        return;
    };

    // Figure out where the user clicked on the plane.
    let Ok(ray) = camera.viewport_to_world(camera_transform, mouse_position) else {
        return;
    };
    let Some(plane_intersection) =
        ray.plane_intersection_point(Vec3::ZERO, InfinitePlane3d::new(Vec3::Y))
    else {
        return;
    };
    // Move all the main objects.
    for mut transform in main_objects.iter_mut() {
        transform.translation = vec3(
            plane_intersection.x,
            transform.translation.y,
            plane_intersection.z,
        );
    }
}

impl FromWorld for ExampleAssets {
    fn from_world(world: &mut World) -> Self {
        let fox_animation =
            world.load_asset(GltfAssetLabel::Animation(1).from_asset("models/animated/Fox.glb"));
        let (fox_animation_graph, fox_animation_node) =
            AnimationGraph::from_clip(fox_animation.clone());

        ExampleAssets {
            main_sphere: world.add_asset(Sphere::default().mesh().uv(32, 18)),
            fox: world.load_asset(GltfAssetLabel::Scene(0).from_asset("models/animated/Fox.glb")),
            main_sphere_material: world.add_asset(Color::from(SILVER)),
            main_scene: world.load_asset(
                GltfAssetLabel::Scene(0)
                    .from_asset("models/IrradianceVolumeExample/IrradianceVolumeExample.glb"),
            ),
            irradiance_volume: world.load_asset("irradiance_volumes/Example.vxgi.ktx2"),
            fox_animation_graph: world.add_asset(fox_animation_graph),
            fox_animation_node,
            voxel_cube: world.add_asset(Cuboid::default()),
            // Just use a specular map for the skybox since it's not too blurry.
            // In reality you wouldn't do this--you'd use a real skybox texture--but
            // reusing the textures like this saves space in the Bevy repository.
            skybox: world.load_asset("environment_maps/pisa_specular_rgb9e5_zstd.ktx2"),
        }
    }
}

// Plays the animation on the fox.
fn play_animations(
    mut commands: Commands,
    assets: Res<ExampleAssets>,
    mut players: Query<(Entity, &mut AnimationPlayer), Without<AnimationGraphHandle>>,
) {
    for (entity, mut player) in players.iter_mut() {
        commands
            .entity(entity)
            .insert(AnimationGraphHandle(assets.fox_animation_graph.clone()));
        player.play(assets.fox_animation_node).repeat();
    }
}

fn create_cubes(
    image_assets: Res<Assets<Image>>,
    mut commands: Commands,
    irradiance_volumes: Query<(&IrradianceVolume, &GlobalTransform)>,
    voxel_cube_parents: Query<Entity, With<VoxelCubeParent>>,
    voxel_cubes: Query<Entity, With<VoxelCube>>,
    example_assets: Res<ExampleAssets>,
    mut voxel_visualization_material_assets: ResMut<Assets<VoxelVisualizationMaterial>>,
) {
    // If voxel cubes have already been spawned, don't do anything.
    if !voxel_cubes.is_empty() {
        return;
    }

    let Some(voxel_cube_parent) = voxel_cube_parents.iter().next() else {
        return;
    };

    for (irradiance_volume, global_transform) in irradiance_volumes.iter() {
        let Some(image) = image_assets.get(&irradiance_volume.voxels) else {
            continue;
        };

        let resolution = image.texture_descriptor.size;

        let voxel_cube_material = voxel_visualization_material_assets.add(ExtendedMaterial {
            base: StandardMaterial::from(Color::from(RED)),
            extension: VoxelVisualizationExtension {
                irradiance_volume_info: VoxelVisualizationIrradianceVolumeInfo {
                    world_from_voxel: VOXEL_FROM_WORLD.inverse(),
                    voxel_from_world: VOXEL_FROM_WORLD,
                    resolution: uvec3(
                        resolution.width,
                        resolution.height,
                        resolution.depth_or_array_layers,
                    ),
                    intensity: IRRADIANCE_VOLUME_INTENSITY,
                },
            },
        });

        let scale = vec3(
            1.0 / resolution.width as f32,
            1.0 / resolution.height as f32,
            1.0 / resolution.depth_or_array_layers as f32,
        );

        // Spawn a cube for each voxel.
        for z in 0..resolution.depth_or_array_layers {
            for y in 0..resolution.height {
                for x in 0..resolution.width {
                    let uvw = (uvec3(x, y, z).as_vec3() + 0.5) * scale - 0.5;
                    let pos = global_transform.transform_point(uvw);
                    let voxel_cube = commands
                        .spawn((
                            Mesh3d(example_assets.voxel_cube.clone()),
                            MeshMaterial3d(voxel_cube_material.clone()),
                            Transform::from_scale(Vec3::splat(VOXEL_CUBE_SCALE))
                                .with_translation(pos),
                        ))
                        .insert(VoxelCube)
                        .insert(NotShadowCaster)
                        .id();

                    commands.entity(voxel_cube_parent).add_child(voxel_cube);
                }
            }
        }
    }
}

examples/gltf/gltf_extension_mesh_2d.rs (line 62)

fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
    commands.spawn((
        WorldAssetRoot(
            asset_server
                .load(GltfAssetLabel::Scene(0).from_asset("models/barycentric/barycentric.gltf")),
        ),
        Transform::from_scale(150. * Vec3::ONE),
    ));
    commands.spawn(Camera2d);
}

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

fn spawn_flight_helmet(commands: &mut Commands, asset_server: &AssetServer) {
    commands.spawn((
        WorldAssetRoot(
            asset_server
                .load(GltfAssetLabel::Scene(0).from_asset("models/FlightHelmet/FlightHelmet.gltf")),
        ),
        Transform::from_scale(Vec3::splat(2.5)),
        FlightHelmetModel,
        Visibility::Hidden,
    ));
}

// Spawns the row of capsules.
fn spawn_capsules(
    commands: &mut Commands,
    meshes: &mut Assets<Mesh>,
    standard_materials: &mut Assets<StandardMaterial>,
) {
    let capsule_mesh = meshes.add(Capsule3d::new(0.4, 0.5));
    let parent = commands
        .spawn((
            Transform::from_xyz(0.0, 0.5, 0.0),
            Visibility::Hidden,
            CapsulesParent,
        ))
        .id();

    for i in 0..5 {
        let roughness = i as f32 * 0.25;
        let child = commands
            .spawn((
                Mesh3d(capsule_mesh.clone()),
                MeshMaterial3d(standard_materials.add(StandardMaterial {
                    base_color: Color::BLACK,
                    perceptual_roughness: roughness.max(0.08),
                    ..default()
                })),
                Transform::from_xyz(i as f32 * 1.1 - (1.1 * 2.0), 0.5, 0.0),
                CapsuleModel,
            ))
            .id();
        commands.entity(parent).add_child(child);
    }
}

// Spawns the metallic base.
fn spawn_metallic_base(
    commands: &mut Commands,
    meshes: &mut Assets<Mesh>,
    standard_materials: &mut Assets<StandardMaterial>,
) {
    commands.spawn((
        Mesh3d(meshes.add(Plane3d::new(Vec3::Y, Vec2::splat(1.0)))),
        MeshMaterial3d(standard_materials.add(StandardMaterial {
            base_color: Color::from(bevy::color::palettes::css::DARK_GRAY),
            metallic: 1.0,
            perceptual_roughness: 0.3,
            ..default()
        })),
        Transform::from_scale(Vec3::splat(100.0)),
        MetallicBaseModel,
        Visibility::Hidden,
    ));
}

// Spawns the non-metallic base.
fn spawn_non_metallic_base(
    commands: &mut Commands,
    meshes: &mut Assets<Mesh>,
    standard_materials: &mut Assets<StandardMaterial>,
) {
    commands.spawn((
        Mesh3d(meshes.add(Plane3d::new(Vec3::Y, Vec2::splat(1.0)))),
        MeshMaterial3d(standard_materials.add(StandardMaterial {
            base_color: Color::from(bevy::color::palettes::css::RED),
            metallic: 0.0,
            perceptual_roughness: 0.2,
            ..default()
        })),
        Transform::from_scale(Vec3::splat(100.0)),
        RedPlaneBaseModel,
        Visibility::Hidden,
    ));
}

// Spawns the water plane.
fn spawn_water(
    commands: &mut Commands,
    asset_server: &AssetServer,
    meshes: &mut Assets<Mesh>,
    water_materials: &mut Assets<ExtendedMaterial<StandardMaterial, Water>>,
) {
    commands.spawn((
        Mesh3d(meshes.add(Plane3d::new(Vec3::Y, Vec2::splat(1.0)))),
        MeshMaterial3d(
            water_materials.add(ExtendedMaterial {
                base: StandardMaterial {
                    base_color: BLACK.into(),
                    perceptual_roughness: 0.09,
                    ..default()
                },
                extension: Water {
                    normals: asset_server
                        .load_builder()
                        .with_settings::<ImageLoaderSettings>(|settings| {
                            settings.is_srgb = false;
                            settings.sampler = ImageSampler::Descriptor(ImageSamplerDescriptor {
                                address_mode_u: ImageAddressMode::Repeat,
                                address_mode_v: ImageAddressMode::Repeat,
                                mag_filter: ImageFilterMode::Linear,
                                min_filter: ImageFilterMode::Linear,
                                ..default()
                            });
                        })
                        .load("textures/water_normals.png"),
                    // These water settings are just random values to create some
                    // variety.
                    settings: WaterSettings {
                        octave_vectors: [
                            vec4(0.080, 0.059, 0.073, -0.062),
                            vec4(0.153, 0.138, -0.149, -0.195),
                        ],
                        octave_scales: vec4(1.0, 2.1, 7.9, 14.9) * 5.0,
                        octave_strengths: vec4(0.16, 0.18, 0.093, 0.044),
                    },
                },
            }),
        ),
        Transform::from_scale(Vec3::splat(100.0)),
        WaterModel,
    ));
}

examples/movement/physics_in_fixed_timestep.rs (line 179)

fn spawn_player(mut commands: Commands) {
    commands.spawn((Camera3d::default(), CameraSensitivity::default()));
    commands.spawn((
        Name::new("Player"),
        Transform::from_scale(Vec3::splat(0.3)),
        AccumulatedInput::default(),
        Velocity::default(),
        PhysicalTranslation::default(),
        PreviousPhysicalTranslation::default(),
    ));
}

examples/gltf/custom_gltf_vertex_attribute.rs (line 62)

fn setup(
    mut commands: Commands,
    asset_server: Res<AssetServer>,
    mut materials: ResMut<Assets<CustomMaterial>>,
) {
    // Add a mesh loaded from a glTF file. This mesh has data for `ATTRIBUTE_BARYCENTRIC`.
    let mesh = asset_server.load(
        GltfAssetLabel::Primitive {
            mesh: 0,
            primitive: 0,
        }
        .from_asset("models/barycentric/barycentric.gltf"),
    );
    commands.spawn((
        Mesh2d(mesh),
        MeshMaterial2d(materials.add(CustomMaterial {})),
        Transform::from_scale(150.0 * Vec3::ONE),
    ));

    commands.spawn(Camera2d);
}

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

fn spawn_reflection_probe(commands: &mut Commands, cubemaps: &Cubemaps) {
    commands.spawn((
        LightProbe::default(),
        EnvironmentMapLight {
            diffuse_map: cubemaps.diffuse_environment_map.clone(),
            specular_map: cubemaps.specular_reflection_probe.clone(),
            intensity: ENV_MAP_INTENSITY,
            ..default()
        },
        // 2.0 because the sphere's radius is 1.0 and we want to fully enclose it.
        Transform::from_scale(Vec3::splat(2.0)),
        // Disable parallax correction because the reflected scene is quite
        // distant.
        ParallaxCorrection::None,
    ));
}

Additional examples can be found in:

• examples/3d/pccm.rs
• examples/ecs/parallel_query.rs
• examples/shader/compute_shader_game_of_life.rs
• examples/2d/sprite_sheet.rs
• examples/animation/animation_graph.rs
• examples/animation/animation_masks.rs
• examples/3d/mirror.rs
• examples/3d/atmospheric_fog.rs
• examples/ecs/hierarchy.rs
• examples/3d/light_probe_blending.rs
• examples/3d/atmosphere.rs
• examples/3d/fog.rs
• examples/2d/sprite_animation.rs
• examples/3d/volumetric_fog.rs
• examples/3d/motion_blur.rs
• examples/time/virtual_time.rs
• examples/stress_tests/many_lights.rs
• examples/3d/decal.rs
• examples/ecs/iter_combinations.rs
• examples/3d/solari.rs
• examples/showcase/desk_toy.rs
• examples/3d/deferred_rendering.rs
• examples/stress_tests/many_cubes.rs

pub fn from_isometry(iso: Isometry3d) -> Transform

Creates a new Transform that is equivalent to the given isometry.

pub fn looking_at(self, target: Vec3, up: impl TryInto<Dir3>) -> Transform

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

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

• if target is the same as the transform translation, Vec3::Z is used instead
• if up 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/3d/clustered_decals.rs (line 204)

fn spawn_light(commands: &mut Commands) {
    commands.spawn((
        DirectionalLight::default(),
        Transform::from_xyz(4.0, 8.0, 4.0).looking_at(Vec3::ZERO, Vec3::Y),
    ));
}

/// Spawns the camera.
fn spawn_camera(commands: &mut Commands) {
    commands
        .spawn(Camera3d::default())
        .insert(Transform::from_xyz(0.0, 2.5, 9.0).looking_at(Vec3::ZERO, Vec3::Y))
        // Tag the camera with `Selection::Camera`.
        .insert(Selection::Camera);
}

tests/3d/test_skinned_mesh_bounds.rs (line 53)

fn setup(mut commands: Commands) {
    commands.spawn((
        Camera3d::default(),
        Transform::from_xyz(0.0, 7.5, 18.0).looking_at(Vec3::new(0.0, 5.5, 0.0), Vec3::Y),
    ));
}

examples/3d/mixed_lighting.rs (line 160)

fn spawn_camera(commands: &mut Commands) {
    commands
        .spawn(Camera3d::default())
        .insert(Transform::from_xyz(-0.7, 0.7, 1.0).looking_at(vec3(0.0, 0.3, 0.0), Vec3::Y));
}

examples/3d/clustered_decal_maps.rs (line 243)

fn spawn_camera(commands: &mut Commands) {
    commands.spawn((
        Camera3d::default(),
        Transform::from_xyz(2.0, 0.0, -7.0).looking_at(Vec3::ZERO, Vec3::Y),
        Hdr,
    ));
}

examples/3d/pccm.rs (line 98)

fn spawn_camera(commands: &mut Commands) {
    commands.spawn((
        Camera3d::default(),
        FreeCamera::default(),
        Transform::from_xyz(0.0, 0.0, 4.0).looking_at(Vec3::new(0.0, -2.5, 0.0), Dir3::Y),
        Hdr,
    ));
}

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

fn spawn_camera(commands: &mut Commands) {
    commands
        .spawn(Camera3d::default())
        .insert(Transform::from_xyz(0.0, 0.0, 9.0).looking_at(Vec3::ZERO, Vec3::Y))
        .insert(DepthPrepass)
        .insert(OcclusionCulling);
}

Additional examples can be found in:

• examples/3d/reflection_probes.rs
• examples/app/externally_driven_headless_renderer.rs
• examples/3d/irradiance_volumes.rs
• examples/gizmos/3d_text_gizmos.rs
• examples/math/render_primitives.rs
• examples/stress_tests/many_gizmos.rs
• examples/scene/world_serialization.rs
• examples/gltf/gltf_skinned_mesh.rs
• examples/showcase/alien_cake_addict.rs
• examples/3d/mirror.rs
• examples/shader/animate_shader.rs
• examples/async_tasks/async_compute.rs
• examples/gltf/query_gltf_primitives.rs
• examples/shader/shader_material_wesl.rs
• examples/3d/light_textures.rs
• examples/shader/fallback_image.rs
• examples/shader_advanced/custom_phase_item.rs
• examples/shader_advanced/fullscreen_material.rs
• examples/3d/3d_viewport_to_world.rs
• examples/shader/shader_material.rs
• examples/shader/shader_material_glsl.rs
• examples/shader_advanced/texture_binding_array.rs
• examples/asset/hot_asset_reloading.rs
• examples/asset/multi_asset_sync.rs
• examples/shader_advanced/manual_material.rs
• examples/3d/color_grading.rs
• examples/transforms/3d_rotation.rs
• examples/transforms/scale.rs
• examples/async_tasks/async_channel_pattern.rs
• examples/shader_advanced/custom_vertex_attribute.rs
• examples/animation/morph_targets.rs
• examples/3d/3d_scene.rs
• tests/window/minimizing.rs
• tests/window/resizing.rs
• examples/3d/atmospheric_fog.rs
• examples/transforms/translation.rs
• examples/shader/shader_defs.rs
• examples/gltf/load_gltf_extras.rs
• examples/animation/animated_mesh.rs
• examples/showcase/loading_screen.rs
• examples/3d/parenting.rs
• examples/animation/animation_graph.rs
• examples/3d/post_processing.rs
• examples/shader/shader_material_screenspace_texture.rs
• examples/3d/depth_of_field.rs
• examples/camera/camera_orbit.rs
• examples/shader/shader_material_bindless.rs
• examples/gltf/edit_material_on_gltf.rs
• examples/remote/server.rs
• examples/animation/animation_masks.rs
• examples/3d/anisotropy.rs
• examples/window/screenshot.rs
• examples/3d/animated_material.rs
• examples/shader_advanced/custom_post_processing.rs
• examples/camera/custom_projection.rs
• examples/picking/custom_hit_data.rs
• examples/shader_advanced/render_depth_to_texture.rs
• examples/gltf/load_gltf.rs
• examples/3d/two_passes.rs
• examples/stress_tests/many_materials.rs
• examples/gltf/gltf_extension_animation_graph.rs
• examples/diagnostics/log_diagnostics.rs
• examples/shader/extended_material_bindless.rs
• examples/3d/tonemapping.rs
• examples/shader_advanced/custom_render_phase.rs
• examples/dev_tools/infinite_grid.rs
• examples/gltf/update_gltf_scene.rs
• examples/3d/skybox.rs
• examples/3d/fog_volumes.rs
• examples/3d/lines.rs
• examples/shader/storage_buffer.rs
• examples/window/low_power.rs
• examples/3d/order_independent_transparency.rs
• examples/shader/array_texture.rs
• examples/3d/generate_custom_mesh.rs
• examples/3d/ssr.rs
• examples/3d/mesh_ray_cast.rs
• examples/picking/simple_picking.rs
• examples/movement/smooth_follow.rs
• examples/shader/extended_material.rs
• examples/3d/vertex_colors.rs
• examples/animation/animated_mesh_control.rs
• examples/shader_advanced/custom_shader_instancing.rs
• tests/window/desktop_request_redraw.rs
• examples/3d/orthographic.rs
• examples/picking/debug_picking.rs
• examples/shader_advanced/specialized_mesh_pipeline.rs
• examples/window/multiple_windows.rs
• examples/3d/spherical_area_lights.rs
• examples/stress_tests/many_morph_targets.rs
• examples/transforms/transform.rs
• examples/gizmos/axes.rs
• examples/3d/light_probe_blending.rs
• examples/app/headless_renderer.rs
• examples/3d/ssao.rs
• examples/3d/atmosphere.rs
• examples/animation/animated_mesh_events.rs
• examples/app/render_recovery.rs
• examples/animation/eased_motion.rs
• examples/audio/spatial_audio_3d.rs
• examples/shader/automatic_instancing.rs
• examples/ecs/error_handling.rs
• examples/camera/projection_zoom.rs
• examples/3d/rect_light.rs
• examples/3d/specular_tint.rs
• examples/3d/visibility_range.rs
• examples/3d/volumetric_fog.rs
• tests/3d/test_invalid_skinned_mesh.rs
• examples/stress_tests/many_cameras_lights.rs
• examples/3d/texture.rs
• examples/3d/shadow_caster_receiver.rs
• examples/3d/wireframe.rs
• examples/3d/bloom_3d.rs
• examples/3d/anti_aliasing.rs
• examples/gizmos/3d_gizmos.rs
• examples/transforms/align.rs
• examples/3d/decal.rs
• examples/math/random_sampling.rs
• examples/testbed/3d.rs
• examples/3d/scrolling_fog.rs
• examples/ecs/iter_combinations.rs
• examples/shader_advanced/compute_mesh.rs
• examples/3d/render_to_texture.rs
• examples/gizmos/transform_gizmo.rs
• examples/3d/transparency_3d.rs
• examples/asset/repeated_texture.rs
• examples/2d/mesh2d_repeated_texture.rs
• examples/3d/spotlight.rs
• examples/asset/alter_mesh.rs
• examples/3d/meshlet.rs
• examples/3d/pbr.rs
• examples/3d/auto_exposure.rs
• examples/asset/asset_loading.rs
• examples/gizmos/light_gizmos.rs
• examples/stress_tests/bevymark_3d.rs
• examples/shader/shader_prepass.rs
• examples/3d/shadow_biases.rs
• examples/3d/split_screen.rs
• examples/picking/mesh_picking.rs
• examples/ui/render_ui_to_texture.rs
• examples/3d/parallax_mapping.rs
• examples/3d/fog.rs
• examples/stress_tests/many_foxes.rs
• examples/3d/deferred_rendering.rs
• examples/3d/contact_shadows.rs
• examples/3d/3d_shapes.rs
• examples/animation/custom_skinned_mesh.rs
• examples/usage/debug_frustum_culling.rs
• examples/3d/blend_modes.rs
• examples/animation/animated_transform.rs
• examples/3d/lighting.rs
• examples/3d/camera_sub_view.rs
• examples/3d/transmission.rs
• examples/stress_tests/many_cubes.rs

pub fn looking_to( self, direction: impl TryInto<Dir3>, up: impl TryInto<Dir3>, ) -> Transform

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

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

• if direction fails converting to Dir3 (e.g if it is Vec3::ZERO), Dir3::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

tests/3d/test_skinned_mesh_bounds.rs (line 68)

fn load_scene(mut commands: Commands, asset_server: Res<AssetServer>) {
    commands.spawn((
        PendingScene(asset_server.load("models/animated/Fox.glb")),
        Transform::from_xyz(1.3, 4.3, 0.0)
            .with_scale(Vec3::splat(0.08))
            .looking_to(-Vec3::X, Vec3::Y),
    ));
}

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

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

examples/scene/world_serialization.rs (line 133)

fn load_world_system(mut commands: Commands, asset_server: Res<AssetServer>) {
    commands.spawn(DynamicWorldRoot(asset_server.load(WORLD_FILE_PATH)));
    commands.spawn((
        Camera3d::default(),
        Transform::from_xyz(1.0, 1.0, 1.0).looking_at(Vec3::new(0.0, 0.25, 0.0), Vec3::Y),
    ));
    commands.spawn((
        DirectionalLight::default(),
        Transform::default().looking_to(Vec3::new(0.0, -1.0, -1.0), Vec3::Y),
    ));
}

examples/camera/free_camera_controller.rs (line 79)

fn spawn_camera(mut commands: Commands) {
    commands.spawn((
        Camera3d::default(),
        Transform::from_xyz(0.0, 1.0, 0.0).looking_to(Vec3::X, Vec3::Y),
        // This component stores all camera settings and state, which is used by the FreeCameraPlugin to
        // control it. These properties can be changed at runtime, but beware the controller system is
        // constantly using and modifying those values unless the enabled field is false.
        FreeCamera {
            sensitivity: 0.2,
            friction: 25.0,
            walk_speed: 3.0,
            run_speed: 9.0,
            ..default()
        },
    ));
}

examples/movement/physics_in_fixed_timestep.rs (line 219)

fn spawn_environment(
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<StandardMaterial>>,
) {
    let sphere_material = materials.add(Color::from(tailwind::SKY_200));
    let sphere_mesh = meshes.add(Sphere::new(0.3));
    let spheres_in_x = 6;
    let spheres_in_y = 4;
    let spheres_in_z = 10;
    let distance = 3.0;
    for x in 0..spheres_in_x {
        for y in 0..spheres_in_y {
            for z in 0..spheres_in_z {
                let translation = Vec3::new(
                    x as f32 * distance - (spheres_in_x as f32 - 1.0) * distance / 2.0,
                    y as f32 * distance - (spheres_in_y as f32 - 1.0) * distance / 2.0,
                    z as f32 * distance - (spheres_in_z as f32 - 1.0) * distance / 2.0,
                );
                commands.spawn((
                    Name::new("Sphere"),
                    Transform::from_translation(translation),
                    Mesh3d(sphere_mesh.clone()),
                    MeshMaterial3d(sphere_material.clone()),
                ));
            }
        }
    }

    commands.spawn((
        DirectionalLight::default(),
        Transform::default().looking_to(Vec3::new(-1.0, -3.0, 0.5), Vec3::Y),
    ));
}

examples/asset/generated_assets.rs (line 23)

fn setup(
    mut commands: Commands,
    asset_server: Res<AssetServer>,
    mut materials: ResMut<Assets<StandardMaterial>>,
    meshes: Res<Assets<Mesh>>,
) {
    commands.spawn((Camera3d::default(), Transform::from_xyz(0.0, 0.0, 5.0)));

    commands.spawn((
        DirectionalLight::default(),
        Transform::default().looking_to(Dir3::new(Vec3::new(-1.0, -1.0, -1.0)).unwrap(), Dir3::Y),
    ));

    // The simplest way to generate an asset is to add it directly to the `Assets`.
    let material_handle = materials.add(StandardMaterial::default());

    commands.spawn((
        Transform::from_xyz(-2.0, 0.0, 0.0),
        MeshMaterial3d(material_handle.clone()),
        // Alternatively, `add_async` creates a task that runs your async function. Once it
        // completes, the asset is added to the `Assets`. This is "deferred" meaning that the asset
        // may take a frame to be added after the task completes.
        Mesh3d(asset_server.add_async(generate_mesh_async())),
    ));

    // The last way to generate assets is to reserve a handle, and then use `Assets::insert` to
    // populate the asset later. In this example, the `generate_mesh_system` system runs to populate
    // the mesh.
    let mesh_handle = meshes.reserve_handle();
    commands.insert_resource(HandleToGenerate(mesh_handle.clone()));
    commands.spawn((
        Transform::from_xyz(2.0, 0.0, 0.0)
            .with_rotation(Quat::from_rotation_x(50.0f32.to_radians())),
        Mesh3d(mesh_handle),
        MeshMaterial3d(material_handle),
    ));
}

Additional examples can be found in:

• examples/testbed/3d.rs
• examples/3d/motion_blur.rs
• examples/3d/clustered_decal_maps.rs

pub fn aligned_by( self, main_axis: impl TryInto<Dir3>, main_direction: impl TryInto<Dir3>, secondary_axis: impl TryInto<Dir3>, secondary_direction: impl TryInto<Dir3>, ) -> Transform

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)

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

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

Returns this Transform with a new translation.

Examples found in repository

examples/3d/mirror.rs (line 229)

fn spawn_ground_plane(
    commands: &mut Commands,
    meshes: &mut Assets<Mesh>,
    standard_materials: &mut Assets<StandardMaterial>,
) {
    commands.spawn((
        Mesh3d(meshes.add(Circle::new(200.0))),
        MeshMaterial3d(standard_materials.add(Color::from(GREEN))),
        Transform::from_rotation(Quat::from_rotation_x(-FRAC_PI_2))
            .with_translation(vec3(-25.0, 0.0, 0.0)),
    ));
}

/// Creates the initial image that the mirror camera will render the mirror
/// world to.
fn create_mirror_texture_resource(
    commands: &mut Commands,
    windows_query: &Query<&Window>,
    images: &mut Assets<Image>,
) -> Handle<Image> {
    let window = windows_query.iter().next().expect("No window found");
    let window_size = uvec2(window.physical_width(), window.physical_height());
    let image = create_mirror_texture_image(images, window_size);
    commands.insert_resource(MirrorImage(image.clone()));
    image
}

/// Spawns the camera that renders the mirror world.
fn spawn_mirror_camera(
    commands: &mut Commands,
    camera_transform: &Transform,
    camera_projection: &PerspectiveProjection,
    mirror_transform: &Transform,
    mirror_render_target: Handle<Image>,
) {
    let (mirror_camera_transform, mirror_camera_projection) =
        calculate_mirror_camera_transform_and_projection(
            camera_transform,
            camera_projection,
            mirror_transform,
        );

    commands.spawn((
        Camera3d::default(),
        Camera {
            order: -1,
            // Reflecting the model across the mirror will flip the winding of
            // all the polygons. Therefore, in order to properly backface cull,
            // we need to turn on `invert_culling`.
            invert_culling: true,
            ..default()
        },
        RenderTarget::Image(mirror_render_target.clone().into()),
        mirror_camera_transform,
        Projection::Perspective(mirror_camera_projection),
        MirrorCamera,
    ));
}

/// Spawns the animated fox.
///
/// Note that this doesn't play the animation; that's handled in
/// [`play_fox_animation`].
fn spawn_fox(commands: &mut Commands, asset_server: &AssetServer) {
    commands.spawn((
        WorldAssetRoot(asset_server.load(GltfAssetLabel::Scene(0).from_asset(FOX_ASSET_PATH))),
        Transform::from_xyz(-50.0, 0.0, -100.0),
    ));
}

/// Spawns the mirror plane mesh and returns its transform.
fn spawn_mirror(
    commands: &mut Commands,
    meshes: &mut Assets<Mesh>,
    screen_space_texture_materials: &mut Assets<
        ExtendedMaterial<StandardMaterial, ScreenSpaceTextureExtension>,
    >,
    mirror_render_target: Handle<Image>,
) -> Transform {
    let mirror_transform = Transform::from_scale(vec3(300.0, 1.0, 150.0))
        .with_rotation(Quat::from_rotation_x(MIRROR_ROTATION_ANGLE))
        .with_translation(MIRROR_POSITION);

    commands.spawn((
        Mesh3d(meshes.add(Plane3d::default().mesh().size(1.0, 1.0))),
        MeshMaterial3d(screen_space_texture_materials.add(ExtendedMaterial {
            base: StandardMaterial {
                base_color: Color::BLACK,
                emissive: Color::WHITE.into(),
                emissive_texture: Some(mirror_render_target),
                perceptual_roughness: 0.0,
                metallic: 1.0,
                ..default()
            },
            extension: ScreenSpaceTextureExtension { dummy: 0.0 },
        })),
        mirror_transform,
        Mirror,
    ));

    mirror_transform
}

examples/ecs/parallel_query.rs (line 21)

fn spawn_system(mut commands: Commands, asset_server: Res<AssetServer>) {
    commands.spawn(Camera2d);
    let texture = asset_server.load("branding/icon.png");

    // We're seeding the PRNG here to make this example deterministic for testing purposes.
    // This isn't strictly required in practical use unless you need your app to be deterministic.
    let mut rng = ChaCha8Rng::seed_from_u64(19878367467713);
    for z in 0..128 {
        commands.spawn((
            Sprite::from_image(texture.clone()),
            Transform::from_scale(Vec3::splat(0.1))
                .with_translation(Vec2::splat(0.0).extend(z as f32)),
            Velocity(20.0 * Vec2::new(rng.random::<f32>() - 0.5, rng.random::<f32>() - 0.5)),
        ));
    }
}

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

fn spawn_light(commands: &mut Commands, app_status: &AppStatus) {
    // Because this light can become a directional light, point light, or spot
    // light depending on the settings, we add the union of the components
    // necessary for this light to behave as all three of those.
    commands
        .spawn((
            create_directional_light(app_status),
            Transform::from_rotation(Quat::from_array([
                0.6539259,
                -0.34646285,
                0.36505926,
                -0.5648683,
            ]))
            .with_translation(vec3(57.693, 34.334, -6.422)),
        ))
        // These two are needed for point lights.
        .insert(CubemapVisibleEntities::default())
        .insert(CubemapFrusta::default())
        // These two are needed for spot lights.
        .insert(VisibleMeshEntities::default())
        .insert(Frustum::default());
}

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

fn spawn_light_probes(commands: &mut Commands, asset_server: &AssetServer) {
    // Spawn the first room's light probe.
    commands.spawn((
        LightProbe {
            falloff: Vec3::splat(LIGHT_PROBE_FALLOFF),
        },
        EnvironmentMapLight {
            diffuse_map: asset_server.load(get_web_asset_url("diffuse_room1.ktx2")),
            specular_map: asset_server.load(get_web_asset_url("specular_room1.ktx2")),
            intensity: LIGHT_PROBE_INTENSITY,
            ..default()
        },
        Transform::from_scale(vec3(1.0, -1.0, 1.0) * LIGHT_PROBE_SIDE_LENGTH)
            .with_rotation(Quat::from_rotation_x(PI)),
        ParallaxCorrection::Custom(Vec3::splat(LIGHT_PROBE_PARALLAX_CORRECTION_SIDE_LENGTH)),
    ));

    // Spawn the second room's light probe.
    commands.spawn((
        LightProbe {
            falloff: Vec3::splat(LIGHT_PROBE_FALLOFF),
        },
        EnvironmentMapLight {
            diffuse_map: asset_server.load(get_web_asset_url("diffuse_room2.ktx2")),
            specular_map: asset_server.load(get_web_asset_url("specular_room2.ktx2")),
            intensity: LIGHT_PROBE_INTENSITY,
            ..default()
        },
        Transform::from_scale(vec3(1.0, -1.0, 1.0) * LIGHT_PROBE_SIDE_LENGTH)
            .with_rotation(Quat::from_rotation_x(PI))
            .with_translation(vec3(0.0, 0.0, -ROOM_SEPARATION)),
        ParallaxCorrection::Custom(Vec3::splat(LIGHT_PROBE_PARALLAX_CORRECTION_SIDE_LENGTH)),
    ));
}

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

fn setup_terrain_scene(
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut water_materials: ResMut<Assets<ExtendedMaterial<StandardMaterial, Water>>>,
    asset_server: Res<AssetServer>,
) {
    // Sun
    commands.spawn((
        DirectionalLight {
            shadow_maps_enabled: true,
            // lux::RAW_SUNLIGHT is recommended for use with this feature, since
            // other values approximate sunlight *post-scattering* in various
            // conditions. RAW_SUNLIGHT in comparison is the illuminance of the
            // sun unfiltered by the atmosphere, so it is the proper input for
            // sunlight to be filtered by the atmosphere.
            illuminance: lux::RAW_SUNLIGHT,
            ..default()
        },
        Transform::from_xyz(1.0, 0.4, 0.0).looking_at(Vec3::ZERO, Vec3::Y),
        VolumetricLight,
    ));

    // spawn the fog volume
    commands.spawn((
        FogVolume::default(),
        Transform::from_scale(Vec3::new(10.0, 1.0, 10.0)).with_translation(Vec3::Y * 0.5),
    ));

    // Terrain
    commands.spawn((
        Terrain,
        WorldAssetRoot(
            asset_server.load(GltfAssetLabel::Scene(0).from_asset("models/terrain/terrain.glb")),
        ),
        Transform::from_xyz(-1.0, 0.0, -0.5)
            .with_scale(Vec3::splat(0.5))
            .with_rotation(Quat::from_rotation_y(PI / 2.0)),
    ));

    spawn_water(
        &mut commands,
        &asset_server,
        &mut meshes,
        &mut water_materials,
    );
}

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

fn setup_pyramid_scene(
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<StandardMaterial>>,
) {
    let stone = materials.add(StandardMaterial {
        base_color: Srgba::hex("28221B").unwrap().into(),
        perceptual_roughness: 1.0,
        ..default()
    });

    // pillars
    for (x, z) in &[(-1.5, -1.5), (1.5, -1.5), (1.5, 1.5), (-1.5, 1.5)] {
        commands.spawn((
            Mesh3d(meshes.add(Cuboid::new(1.0, 3.0, 1.0))),
            MeshMaterial3d(stone.clone()),
            Transform::from_xyz(*x, 1.5, *z),
        ));
    }

    // orb
    commands.spawn((
        Mesh3d(meshes.add(Sphere::default())),
        MeshMaterial3d(materials.add(StandardMaterial {
            base_color: Srgba::hex("126212CC").unwrap().into(),
            reflectance: 1.0,
            perceptual_roughness: 0.0,
            metallic: 0.5,
            alpha_mode: AlphaMode::Blend,
            ..default()
        })),
        Transform::from_scale(Vec3::splat(1.75)).with_translation(Vec3::new(0.0, 4.0, 0.0)),
        NotShadowCaster,
        NotShadowReceiver,
    ));

    // steps
    for i in 0..50 {
        let half_size = i as f32 / 2.0 + 3.0;
        let y = -i as f32 / 2.0;
        commands.spawn((
            Mesh3d(meshes.add(Cuboid::new(2.0 * half_size, 0.5, 2.0 * half_size))),
            MeshMaterial3d(stone.clone()),
            Transform::from_xyz(0.0, y + 0.25, 0.0),
        ));
    }

    // sky
    commands.spawn((
        Mesh3d(meshes.add(Cuboid::new(2.0, 1.0, 1.0))),
        MeshMaterial3d(materials.add(StandardMaterial {
            base_color: Srgba::hex("888888").unwrap().into(),
            unlit: true,
            cull_mode: None,
            ..default()
        })),
        Transform::from_scale(Vec3::splat(1_000_000.0)),
    ));

    // light
    commands.spawn((
        PointLight {
            shadow_maps_enabled: true,
            ..default()
        },
        Transform::from_xyz(0.0, 1.0, 0.0),
    ));
}

Additional examples can be found in:

• examples/2d/sprite_animation.rs
• examples/3d/irradiance_volumes.rs
• examples/3d/meshlet.rs
• examples/3d/solari.rs
• examples/stress_tests/many_cubes.rs

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 123)

fn spawn_scene(commands: &mut Commands, asset_server: &AssetServer) {
    // Spawn the main scene.
    commands.spawn(WorldAssetRoot(asset_server.load(
        GltfAssetLabel::Scene(0).from_asset("models/TonemappingTest/TonemappingTest.gltf"),
    )));

    // Spawn the flight helmet.
    commands.spawn((
        WorldAssetRoot(
            asset_server
                .load(GltfAssetLabel::Scene(0).from_asset("models/FlightHelmet/FlightHelmet.gltf")),
        ),
        Transform::from_xyz(0.5, 0.0, -0.5).with_rotation(Quat::from_rotation_y(-0.15 * PI)),
    ));

    // Spawn the light.
    commands.spawn((
        DirectionalLight {
            illuminance: 15000.0,
            shadow_maps_enabled: true,
            ..default()
        },
        Transform::from_rotation(Quat::from_euler(EulerRot::ZYX, 0.0, PI * -0.15, PI * -0.15)),
        CascadeShadowConfigBuilder {
            maximum_distance: 3.0,
            first_cascade_far_bound: 0.9,
            ..default()
        }
        .build(),
    ));
}

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

fn add_basic_scene(commands: &mut Commands, asset_server: &AssetServer) {
    // Spawn the main scene.
    commands.spawn(WorldAssetRoot(asset_server.load(
        GltfAssetLabel::Scene(0).from_asset("models/TonemappingTest/TonemappingTest.gltf"),
    )));

    // Spawn the flight helmet.
    commands.spawn((
        WorldAssetRoot(
            asset_server
                .load(GltfAssetLabel::Scene(0).from_asset("models/FlightHelmet/FlightHelmet.gltf")),
        ),
        Transform::from_xyz(0.5, 0.0, -0.5).with_rotation(Quat::from_rotation_y(-0.15 * PI)),
    ));

    // Spawn the light.
    commands.spawn((
        DirectionalLight {
            illuminance: 15000.0,
            shadow_maps_enabled: true,
            ..default()
        },
        Transform::from_rotation(Quat::from_euler(EulerRot::ZYX, 0.0, PI * -0.15, PI * -0.15)),
        CascadeShadowConfigBuilder {
            maximum_distance: 3.0,
            first_cascade_far_bound: 0.9,
            ..default()
        }
        .build(),
    ));
}

examples/3d/mirror.rs (line 300)

fn spawn_mirror(
    commands: &mut Commands,
    meshes: &mut Assets<Mesh>,
    screen_space_texture_materials: &mut Assets<
        ExtendedMaterial<StandardMaterial, ScreenSpaceTextureExtension>,
    >,
    mirror_render_target: Handle<Image>,
) -> Transform {
    let mirror_transform = Transform::from_scale(vec3(300.0, 1.0, 150.0))
        .with_rotation(Quat::from_rotation_x(MIRROR_ROTATION_ANGLE))
        .with_translation(MIRROR_POSITION);

    commands.spawn((
        Mesh3d(meshes.add(Plane3d::default().mesh().size(1.0, 1.0))),
        MeshMaterial3d(screen_space_texture_materials.add(ExtendedMaterial {
            base: StandardMaterial {
                base_color: Color::BLACK,
                emissive: Color::WHITE.into(),
                emissive_texture: Some(mirror_render_target),
                perceptual_roughness: 0.0,
                metallic: 1.0,
                ..default()
            },
            extension: ScreenSpaceTextureExtension { dummy: 0.0 },
        })),
        mirror_transform,
        Mirror,
    ));

    mirror_transform
}

examples/3d/pcss.rs (lines 162-164)

fn spawn_camera(commands: &mut Commands, asset_server: &AssetServer) {
    commands
        .spawn((
            Camera3d::default(),
            Transform::from_xyz(-12.912 * 0.7, 4.466 * 0.7, -10.624 * 0.7).with_rotation(
                Quat::from_euler(EulerRot::YXZ, -134.76 / 180.0 * PI, -0.175, 0.0),
            ),
            #[cfg(feature = "free_camera")]
            FreeCamera::default(),
        ))
        .insert(ShadowFilteringMethod::Gaussian)
        // `TemporalJitter` is needed for TAA. Note that it does nothing without
        // `TemporalAntiAliasSettings`.
        .insert(TemporalJitter::default())
        // We want MSAA off for TAA to work properly.
        .insert(Msaa::Off)
        // The depth prepass is needed for TAA.
        .insert(DepthPrepass)
        // The motion vector prepass is needed for TAA.
        .insert(MotionVectorPrepass)
        // Add a nice skybox.
        .insert(Skybox {
            image: Some(asset_server.load("environment_maps/sky_skybox.ktx2")),
            brightness: 500.0,
            rotation: Quat::IDENTITY,
        });
}

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

fn setup_basic_scene(mut commands: Commands, asset_server: Res<AssetServer>) {
    // Main scene
    commands.spawn((
        WorldAssetRoot(asset_server.load(
            GltfAssetLabel::Scene(0).from_asset("models/TonemappingTest/TonemappingTest.gltf"),
        )),
        SceneNumber(1),
    ));

    // Flight Helmet
    commands.spawn((
        WorldAssetRoot(
            asset_server
                .load(GltfAssetLabel::Scene(0).from_asset("models/FlightHelmet/FlightHelmet.gltf")),
        ),
        Transform::from_xyz(0.5, 0.0, -0.5).with_rotation(Quat::from_rotation_y(-0.15 * PI)),
        SceneNumber(1),
    ));

    // light
    commands.spawn((
        DirectionalLight {
            illuminance: 15_000.,
            shadow_maps_enabled: true,
            ..default()
        },
        Transform::from_rotation(Quat::from_euler(EulerRot::ZYX, 0.0, PI * -0.15, PI * -0.15)),
        CascadeShadowConfigBuilder {
            maximum_distance: 3.0,
            first_cascade_far_bound: 0.9,
            ..default()
        }
        .build(),
        SceneNumber(1),
    ));
}

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

fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
    // directional 'sun' light
    commands.spawn((
        DirectionalLight {
            illuminance: 32000.0,
            ..default()
        },
        Transform::from_xyz(0.0, 2.0, 0.0).with_rotation(Quat::from_rotation_x(-PI / 4.)),
    ));

    let skybox_handle = asset_server.load(CUBEMAPS[0].0);
    // camera
    commands.spawn((
        Camera3d::default(),
        Msaa::Off,
        #[cfg(any(feature = "webgpu", not(target_arch = "wasm32")))]
        TemporalAntiAliasing::default(),
        ScreenSpaceAmbientOcclusion::default(),
        Transform::from_xyz(0.0, 0.0, 8.0).looking_at(Vec3::ZERO, Vec3::Y),
        FreeCamera::default(),
        Skybox {
            image: Some(skybox_handle.clone()),
            brightness: 1000.0,
            ..default()
        },
    ));

    // ambient light
    // NOTE: The ambient light is used to scale how bright the environment map is so with a bright
    // environment map, use an appropriate color and brightness to match
    commands.insert_resource(GlobalAmbientLight {
        color: Color::srgb_u8(210, 220, 240),
        brightness: 1.0,
        ..default()
    });

    commands.insert_resource(Cubemap {
        is_loaded: false,
        index: 0,
        image_handle: skybox_handle,
    });
}

Additional examples can be found in:

• examples/3d/mesh_ray_cast.rs
• examples/3d/light_probe_blending.rs
• examples/3d/atmosphere.rs
• examples/asset/generated_assets.rs
• examples/testbed/2d.rs
• examples/transforms/transform.rs
• examples/camera/free_camera_controller.rs
• examples/3d/rect_light.rs
• examples/3d/texture.rs
• examples/3d/motion_blur.rs
• examples/3d/decal.rs
• examples/picking/sprite_picking.rs
• examples/3d/render_to_texture.rs
• examples/3d/meshlet.rs
• examples/math/custom_primitives.rs
• examples/picking/mesh_picking.rs
• examples/3d/solari.rs
• examples/ui/render_ui_to_texture.rs
• examples/stress_tests/many_foxes.rs
• examples/3d/3d_shapes.rs
• examples/usage/debug_frustum_culling.rs
• examples/3d/transmission.rs

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

Returns this Transform with a new scale.

Examples found in repository

tests/3d/test_skinned_mesh_bounds.rs (line 67)

fn load_scene(mut commands: Commands, asset_server: Res<AssetServer>) {
    commands.spawn((
        PendingScene(asset_server.load("models/animated/Fox.glb")),
        Transform::from_xyz(1.3, 4.3, 0.0)
            .with_scale(Vec3::splat(0.08))
            .looking_to(-Vec3::X, Vec3::Y),
    ));
}

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

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

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

fn spawn_sphere(commands: &mut Commands, assets: &ExampleAssets) {
    commands
        .spawn((
            Mesh3d(assets.main_sphere.clone()),
            MeshMaterial3d(assets.main_sphere_material.clone()),
            Transform::from_xyz(0.0, SPHERE_SCALE, 0.0).with_scale(Vec3::splat(SPHERE_SCALE)),
        ))
        .insert(MainObject);
}

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

fn setup(
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<ColorMaterial>>,
) {
    commands.spawn(Camera2d);

    commands.spawn((
        Mesh2d(meshes.add(Rectangle::default())),
        MeshMaterial2d(materials.add(Color::from(PURPLE))),
        Transform::default().with_scale(Vec3::splat(128.)),
    ));
}

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

fn setup_mesh(
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<ColorMaterial>>,
) {
    commands.spawn((
        Mesh2d(meshes.add(Capsule2d::default())),
        MeshMaterial2d(materials.add(Color::BLACK)),
        Transform::from_xyz(25., 0., 2.).with_scale(Vec3::splat(32.)),
        Rotate,
        PIXEL_PERFECT_LAYERS,
    ));
}

examples/shader/shader_material_2d.rs (line 41)

fn setup(
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<CustomMaterial>>,
    asset_server: Res<AssetServer>,
) {
    // camera
    commands.spawn(Camera2d);

    // quad
    commands.spawn((
        Mesh2d(meshes.add(Rectangle::default())),
        MeshMaterial2d(materials.add(CustomMaterial {
            color: LinearRgba::BLUE,
            color_texture: Some(asset_server.load("branding/icon.png")),
        })),
        Transform::default().with_scale(Vec3::splat(128.)),
    ));
}

Additional examples can be found in:

• examples/shader_advanced/render_depth_to_texture.rs
• examples/stress_tests/bevymark.rs
• examples/2d/dynamic_mip_generation.rs
• examples/3d/rotate_environment_map.rs
• examples/3d/clearcoat.rs
• examples/testbed/3d.rs
• examples/2d/mesh2d_vertex_color_texture.rs
• examples/ecs/hierarchy.rs
• examples/3d/atmosphere.rs
• examples/testbed/2d.rs
• examples/3d/spherical_area_lights.rs
• examples/3d/motion_blur.rs
• examples/3d/light_textures.rs
• examples/camera/projection_zoom.rs
• examples/3d/clustered_decal_maps.rs
• examples/3d/bloom_3d.rs
• examples/picking/sprite_picking.rs
• examples/3d/scrolling_fog.rs
• examples/gizmos/3d_gizmos.rs
• examples/3d/meshlet.rs
• examples/showcase/breakout.rs
• examples/showcase/desk_toy.rs
• examples/stress_tests/many_foxes.rs
• examples/3d/solari.rs
• examples/3d/transmission.rs

pub fn to_matrix(&self) -> Mat4

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

Examples found in repository

examples/3d/mirror.rs (line 355)

fn calculate_mirror_camera_transform_and_projection(
    main_camera_transform: &Transform,
    main_camera_projection: &PerspectiveProjection,
    mirror_transform: &Transform,
) -> (Transform, PerspectiveProjection) {
    // Calculate the reflection matrix (a.k.a. Householder matrix) that will
    // reflect the scene across the mirror plane.
    //
    // Note that you must calculate this in *matrix* form and only *afterward*
    // convert to a `Transform` instead of composing `Transform`s. This is
    // because the reflection matrix has non-uniform scale, and composing
    // transforms can't always handle composition of matrices with non-uniform
    // scales.
    let mirror_camera_transform = Transform::from_matrix(
        Mat4::from_mat3a(reflection_matrix(Vec3::NEG_Z)) * main_camera_transform.to_matrix(),
    );

    // Compute the distance from the camera to the mirror plane. This will be
    // used to calculate the distance to the near clip plane for the mirror
    // world.
    let distance_from_camera_to_mirror = InfinitePlane3d::new(mirror_transform.rotation * Vec3::Y)
        .signed_distance(
            Isometry3d::IDENTITY,
            mirror_transform.translation - main_camera_transform.translation,
        );

    // Compute the normal of the mirror plane in view space.
    let view_from_world = main_camera_transform.compute_affine().matrix3.inverse();
    let mirror_projection_plane_normal =
        (view_from_world * (mirror_transform.rotation * Vec3::NEG_Y)).normalize();

    // Compute the final projection. It should match the main camera projection,
    // except that `near` and `near_normal` should be set to the updated near
    // plane and near normal plane as above.
    let mirror_camera_projection = PerspectiveProjection {
        near_clip_plane: mirror_projection_plane_normal.extend(distance_from_camera_to_mirror),
        ..*main_camera_projection
    };

    (mirror_camera_transform, mirror_camera_projection)
}

pub fn compute_affine(&self) -> Affine3A

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

Examples found in repository

examples/3d/mirror.rs (line 368)

fn calculate_mirror_camera_transform_and_projection(
    main_camera_transform: &Transform,
    main_camera_projection: &PerspectiveProjection,
    mirror_transform: &Transform,
) -> (Transform, PerspectiveProjection) {
    // Calculate the reflection matrix (a.k.a. Householder matrix) that will
    // reflect the scene across the mirror plane.
    //
    // Note that you must calculate this in *matrix* form and only *afterward*
    // convert to a `Transform` instead of composing `Transform`s. This is
    // because the reflection matrix has non-uniform scale, and composing
    // transforms can't always handle composition of matrices with non-uniform
    // scales.
    let mirror_camera_transform = Transform::from_matrix(
        Mat4::from_mat3a(reflection_matrix(Vec3::NEG_Z)) * main_camera_transform.to_matrix(),
    );

    // Compute the distance from the camera to the mirror plane. This will be
    // used to calculate the distance to the near clip plane for the mirror
    // world.
    let distance_from_camera_to_mirror = InfinitePlane3d::new(mirror_transform.rotation * Vec3::Y)
        .signed_distance(
            Isometry3d::IDENTITY,
            mirror_transform.translation - main_camera_transform.translation,
        );

    // Compute the normal of the mirror plane in view space.
    let view_from_world = main_camera_transform.compute_affine().matrix3.inverse();
    let mirror_projection_plane_normal =
        (view_from_world * (mirror_transform.rotation * Vec3::NEG_Y)).normalize();

    // Compute the final projection. It should match the main camera projection,
    // except that `near` and `near_normal` should be set to the updated near
    // plane and near normal plane as above.
    let mirror_camera_projection = PerspectiveProjection {
        near_clip_plane: mirror_projection_plane_normal.extend(distance_from_camera_to_mirror),
        ..*main_camera_projection
    };

    (mirror_camera_transform, mirror_camera_projection)
}

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)

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

pub fn left(&self) -> Dir3

Equivalent to -local_x()

pub fn right(&self) -> Dir3

Equivalent to local_x()

Examples found in repository

examples/ecs/fallible_params.rs (line 128)

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

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)

fn rotate_cube(
    mut cubes: Query<(&mut Transform, &mut CubeState), Without<Center>>,
    center_spheres: Query<&Transform, With<Center>>,
    timer: Res<Time>,
) {
    // Calculate the point to circle around. (The position of the center_sphere)
    let mut center: Vec3 = Vec3::ZERO;
    for sphere in &center_spheres {
        center += sphere.translation;
    }
    // Update the rotation of the cube(s).
    for (mut transform, cube) in &mut cubes {
        // Calculate the rotation of the cube if it would be looking at the sphere in the center.
        let look_at_sphere = transform.looking_at(center, *transform.local_y());
        // Interpolate between the current rotation and the fully turned rotation
        // when looking at the sphere, with a given turn speed to get a smooth motion.
        // With higher speed the curvature of the orbit would be smaller.
        let incremental_turn_weight = cube.turn_speed * timer.delta_secs();
        let old_rotation = transform.rotation;
        transform.rotation = old_rotation.lerp(look_at_sphere.rotation, incremental_turn_weight);
    }
}

pub fn up(&self) -> Dir3

Equivalent to local_y()

pub fn down(&self) -> Dir3

Equivalent to -local_y()

pub fn local_z(&self) -> Dir3

Get the unit vector in the local Z direction.

Examples found in repository

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

fn move_camera(
    keyboard_input: Res<ButtonInput<KeyCode>>,
    mut mouse_wheel_reader: MessageReader<MouseWheel>,
    mut cameras: Query<&mut Transform, With<Camera>>,
) {
    let (mut distance_delta, mut theta_delta) = (0.0, 0.0);

    // Handle keyboard events.
    if keyboard_input.pressed(KeyCode::KeyW) {
        distance_delta -= CAMERA_KEYBOARD_ZOOM_SPEED;
    }
    if keyboard_input.pressed(KeyCode::KeyS) {
        distance_delta += CAMERA_KEYBOARD_ZOOM_SPEED;
    }
    if keyboard_input.pressed(KeyCode::KeyA) {
        theta_delta += CAMERA_KEYBOARD_ORBIT_SPEED;
    }
    if keyboard_input.pressed(KeyCode::KeyD) {
        theta_delta -= CAMERA_KEYBOARD_ORBIT_SPEED;
    }

    // Handle mouse events.
    for mouse_wheel in mouse_wheel_reader.read() {
        distance_delta -= mouse_wheel.y * CAMERA_MOUSE_WHEEL_ZOOM_SPEED;
    }

    // Update transforms.
    for mut camera_transform in cameras.iter_mut() {
        let local_z = camera_transform.local_z().as_vec3().normalize_or_zero();
        if distance_delta != 0.0 {
            camera_transform.translation = (camera_transform.translation.length() + distance_delta)
                .clamp(CAMERA_ZOOM_RANGE.start, CAMERA_ZOOM_RANGE.end)
                * local_z;
        }
        if theta_delta != 0.0 {
            camera_transform
                .translate_around(Vec3::ZERO, Quat::from_axis_angle(Vec3::Y, theta_delta));
            camera_transform.look_at(Vec3::ZERO, Vec3::Y);
        }
    }
}

pub fn forward(&self) -> Dir3

Equivalent to -local_z()

Examples found in repository

examples/transforms/transform.rs (line 93)

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

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

fn setup_color_gradient_scene(
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<ColorGradientMaterial>>,
    camera_transform: Res<CameraTransform>,
) {
    let mut transform = camera_transform.0;
    transform.translation += *transform.forward();

    commands.spawn((
        Mesh3d(meshes.add(Rectangle::new(0.7, 0.7))),
        MeshMaterial3d(materials.add(ColorGradientMaterial {})),
        transform,
        Visibility::Hidden,
        SceneNumber(2),
    ));
}

fn setup_image_viewer_scene(
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<StandardMaterial>>,
    camera_transform: Res<CameraTransform>,
) {
    let mut transform = camera_transform.0;
    transform.translation += *transform.forward();

    // exr/hdr viewer (exr requires enabling bevy feature)
    commands.spawn((
        Mesh3d(meshes.add(Rectangle::default())),
        MeshMaterial3d(materials.add(StandardMaterial {
            base_color_texture: None,
            unlit: true,
            ..default()
        })),
        transform,
        Visibility::Hidden,
        SceneNumber(3),
        HDRViewer,
    ));

    commands.spawn((
        Text::new("Drag and drop an HDR or EXR file"),
        TextFont {
            font_size: FontSize::Px(36.0),
            ..default()
        },
        TextColor(Color::BLACK),
        TextLayout::justify(Justify::Center),
        Node {
            align_self: AlignSelf::Center,
            margin: UiRect::all(auto()),
            ..default()
        },
        SceneNumber(3),
        Visibility::Hidden,
    ));
}

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

fn move_camera(
    camera: Single<(&mut Transform, &mut Projection), Without<CameraTracked>>,
    tracked: Single<&Transform, With<CameraTracked>>,
    mode: Res<CameraMode>,
) {
    let (mut transform, mut projection) = camera.into_inner();
    match *mode {
        CameraMode::Track => {
            transform.look_at(tracked.translation, Vec3::Y);
            transform.translation = Vec3::new(15.0, -0.5, 0.0);
            if let Projection::Perspective(perspective) = &mut *projection {
                perspective.fov = 0.05;
            }
        }
        CameraMode::Chase => {
            transform.translation =
                tracked.translation + Vec3::new(0.0, 0.15, 0.0) + tracked.back() * 0.6;
            transform.look_to(tracked.forward(), Vec3::Y);
            if let Projection::Perspective(perspective) = &mut *projection {
                perspective.fov = 1.0;
            }
        }
    }
}

examples/camera/camera_orbit.rs (line 140)

fn orbit(
    mut camera: Single<&mut Transform, With<Camera>>,
    camera_settings: Res<CameraSettings>,
    mouse_buttons: Res<ButtonInput<MouseButton>>,
    mouse_motion: Res<AccumulatedMouseMotion>,
    time: Res<Time>,
) {
    let delta = mouse_motion.delta;
    let mut delta_roll = 0.0;

    if mouse_buttons.pressed(MouseButton::Left) {
        delta_roll -= 1.0;
    }
    if mouse_buttons.pressed(MouseButton::Right) {
        delta_roll += 1.0;
    }

    // Mouse motion is one of the few inputs that should not be multiplied by delta time,
    // as we are already receiving the full movement since the last frame was rendered. Multiplying
    // by delta time here would make the movement slower that it should be.
    let delta_pitch = delta.y * camera_settings.pitch_speed;
    let delta_yaw = delta.x * camera_settings.yaw_speed;

    // Conversely, we DO need to factor in delta time for mouse button inputs.
    delta_roll *= camera_settings.roll_speed * time.delta_secs();

    // Obtain the existing pitch, yaw, and roll values from the transform.
    let (yaw, pitch, roll) = camera.rotation.to_euler(EulerRot::YXZ);

    // Establish the new yaw and pitch, preventing the pitch value from exceeding our limits.
    let pitch = (pitch + delta_pitch).clamp(
        camera_settings.pitch_range.start,
        camera_settings.pitch_range.end,
    );
    let roll = roll + delta_roll;
    let yaw = yaw + delta_yaw;
    camera.rotation = Quat::from_euler(EulerRot::YXZ, yaw, pitch, roll);

    // Adjust the translation to maintain the correct orientation toward the orbit target.
    // In our example it's a static target, but this could easily be customized.
    let target = Vec3::ZERO;
    camera.translation = target - camera.forward() * camera_settings.orbit_distance;
}

examples/3d/mirror.rs (line 569)

fn move_camera_on_mouse_down(
    mut main_cameras_query: Query<&mut Transform, (With<Camera>, Without<MirrorCamera>)>,
    interactions_query: Query<&Interaction, With<RadioButton>>,
    mouse_buttons: Res<ButtonInput<MouseButton>>,
    mouse_motion: Res<AccumulatedMouseMotion>,
    app_status: Res<AppStatus>,
) {
    // Only process the mouse motion if the left mouse button is pressed, the
    // mouse action is set to move the fox, and the pointer isn't over a UI
    // widget.
    if app_status.drag_action != DragAction::MoveCamera
        || !mouse_buttons.pressed(MouseButton::Left)
        || interactions_query
            .iter()
            .any(|interaction| *interaction != Interaction::None)
    {
        return;
    }

    let delta = mouse_motion.delta;

    // Mouse motion is one of the few inputs that should not be multiplied by delta time,
    // as we are already receiving the full movement since the last frame was rendered. Multiplying
    // by delta time here would make the movement slower that it should be.
    let delta_pitch = delta.y * CAMERA_PITCH_SPEED;
    let delta_yaw = delta.x * CAMERA_YAW_SPEED;

    for mut main_camera_transform in &mut main_cameras_query {
        // Obtain the existing pitch and yaw values from the transform.
        let (yaw, pitch, _) = main_camera_transform.rotation.to_euler(EulerRot::YXZ);

        // Establish the new yaw and pitch, preventing the pitch value from exceeding our limits.
        let pitch = (pitch + delta_pitch).clamp(-CAMERA_PITCH_LIMIT, CAMERA_PITCH_LIMIT);
        let yaw = yaw + delta_yaw;
        main_camera_transform.rotation = Quat::from_euler(EulerRot::YXZ, yaw, pitch, 0.0);

        // Adjust the translation to maintain the correct orientation toward the orbit target.
        // In our example it's a static target, but this could easily be customized.
        let target = Vec3::ZERO;
        main_camera_transform.translation =
            target - main_camera_transform.forward() * CAMERA_ORBIT_DISTANCE;
    }
}

pub fn back(&self) -> Dir3

Equivalent to local_z()

Examples found in repository

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

fn move_camera(
    camera: Single<(&mut Transform, &mut Projection), Without<CameraTracked>>,
    tracked: Single<&Transform, With<CameraTracked>>,
    mode: Res<CameraMode>,
) {
    let (mut transform, mut projection) = camera.into_inner();
    match *mode {
        CameraMode::Track => {
            transform.look_at(tracked.translation, Vec3::Y);
            transform.translation = Vec3::new(15.0, -0.5, 0.0);
            if let Projection::Perspective(perspective) = &mut *projection {
                perspective.fov = 0.05;
            }
        }
        CameraMode::Chase => {
            transform.translation =
                tracked.translation + Vec3::new(0.0, 0.15, 0.0) + tracked.back() * 0.6;
            transform.look_to(tracked.forward(), Vec3::Y);
            if let Projection::Perspective(perspective) = &mut *projection {
                perspective.fov = 1.0;
            }
        }
    }
}

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_sprite_meshes.rs (line 102)

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

examples/stress_tests/many_animated_sprites.rs (line 100)

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

examples/3d/occlusion_culling.rs (lines 345-350)

fn spin_large_cube(mut large_cubes: Query<&mut Transform, With<LargeCube>>) {
    for mut transform in &mut large_cubes {
        transform.rotate(Quat::from_euler(
            EulerRot::XYZ,
            0.13 * ROTATION_SPEED,
            0.29 * ROTATION_SPEED,
            0.35 * ROTATION_SPEED,
        ));
    }
}

examples/shader/shader_material_wesl.rs (line 87)

fn update(
    time: Res<Time>,
    mut query: Query<(&MeshMaterial3d<CustomMaterial>, &mut Transform)>,
    mut materials: ResMut<Assets<CustomMaterial>>,
    keys: Res<ButtonInput<KeyCode>>,
) {
    for (material, mut transform) in query.iter_mut() {
        let mut material = materials.get_mut(material).unwrap();
        material.time.x = time.elapsed_secs();
        if keys.just_pressed(KeyCode::Space) {
            material.party_mode = !material.party_mode;
        }

        if material.party_mode {
            transform.rotate(Quat::from_rotation_y(0.005));
        }
    }
}

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

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

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

fn move_directional_light(
    input: Res<ButtonInput<KeyCode>>,
    mut directional_lights: Query<&mut Transform, With<DirectionalLight>>,
) {
    let mut delta_theta = Vec2::ZERO;
    if input.pressed(KeyCode::KeyW) || input.pressed(KeyCode::ArrowUp) {
        delta_theta.y += DIRECTIONAL_LIGHT_MOVEMENT_SPEED;
    }
    if input.pressed(KeyCode::KeyS) || input.pressed(KeyCode::ArrowDown) {
        delta_theta.y -= DIRECTIONAL_LIGHT_MOVEMENT_SPEED;
    }
    if input.pressed(KeyCode::KeyA) || input.pressed(KeyCode::ArrowLeft) {
        delta_theta.x += DIRECTIONAL_LIGHT_MOVEMENT_SPEED;
    }
    if input.pressed(KeyCode::KeyD) || input.pressed(KeyCode::ArrowRight) {
        delta_theta.x -= DIRECTIONAL_LIGHT_MOVEMENT_SPEED;
    }

    if delta_theta == Vec2::ZERO {
        return;
    }

    let delta_quat = Quat::from_euler(EulerRot::XZY, delta_theta.y, 0.0, delta_theta.x);
    for mut transform in directional_lights.iter_mut() {
        transform.rotate(delta_quat);
    }
}

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)

fn track_targets(
    // `Single` ensures the system runs ONLY when exactly one matching entity exists.
    mut player: Single<(&mut Transform, &Player)>,
    // `Option<Single>` never prevents the system from running, but will be `None` if there is not exactly one matching entity.
    enemy: Option<Single<&Transform, (With<Enemy>, Without<Player>)>>,
    time: Res<Time>,
) {
    let (player_transform, player) = &mut *player;
    if let Some(enemy_transform) = enemy {
        // Enemy found, rotate and move towards it.
        let delta = enemy_transform.translation - player_transform.translation;
        let distance = delta.length();
        let front = delta / distance;
        let up = Vec3::Z;
        let side = front.cross(up);
        player_transform.rotation = Quat::from_mat3(&Mat3::from_cols(side, front, up));
        let max_step = distance - player.min_follow_radius;
        if 0.0 < max_step {
            let velocity = (player.speed * time.delta_secs()).min(max_step);
            player_transform.translation += front * velocity;
        }
    } else {
        // 0 or multiple enemies found, keep searching.
        player_transform.rotate_axis(Dir3::Z, player.rotation_speed * time.delta_secs());
    }
}

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)

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

tests/window/desktop_request_redraw.rs (line 99)

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

examples/stress_tests/many_lights.rs (line 138)

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

examples/shader_advanced/custom_post_processing.rs (line 283)

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

examples/picking/mesh_picking.rs (line 196)

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

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

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

/// Rotates the outer cube (main pass)
fn cube_rotator_system(time: Res<Time>, mut query: Query<&mut Transform, With<MainPassCube>>) {
    for mut transform in &mut query {
        transform.rotate_x(1.0 * time.delta_secs());
        transform.rotate_y(0.7 * time.delta_secs());
    }
}

Additional examples can be found in:

• examples/picking/debug_picking.rs
• examples/picking/simple_picking.rs
• examples/ui/render_ui_to_texture.rs
• examples/shader_advanced/render_depth_to_texture.rs
• examples/window/low_power.rs
• examples/ui/widgets/viewport_node.rs
• examples/3d/atmosphere.rs
• examples/stress_tests/many_cubes.rs
• examples/3d/generate_custom_mesh.rs
• examples/3d/lighting.rs

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 70)

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

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

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

examples/picking/mesh_picking.rs (line 188)

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

/// An observer to rotate an entity when it is dragged
fn rotate_on_drag(drag: On<Pointer<Drag>>, mut transforms: Query<&mut Transform>) {
    let mut transform = transforms.get_mut(drag.entity).unwrap();
    transform.rotate_y(drag.delta.x * 0.02);
    transform.rotate_x(drag.delta.y * 0.02);
}

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

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

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

fn animate_light_direction(
    time: Res<Time>,
    mut query: Query<&mut Transform, With<DirectionalLight>>,
) {
    for mut transform in &mut query {
        transform.rotate_y(time.delta_secs() * 0.5);
    }
}

examples/math/custom_primitives.rs (line 317)

fn rotate_3d_shapes(mut shapes: Query<&mut Transform, With<Shape3d>>, time: Res<Time>) {
    let delta_seconds = time.delta_secs();

    for mut transform in shapes.iter_mut() {
        transform.rotate_y(delta_seconds);
    }
}

Additional examples can be found in:

• examples/stress_tests/many_cubes.rs
• examples/3d/render_to_texture.rs
• examples/picking/debug_picking.rs
• examples/picking/simple_picking.rs
• examples/ui/render_ui_to_texture.rs
• examples/3d/deferred_rendering.rs
• examples/shader_advanced/render_depth_to_texture.rs
• examples/ui/widgets/viewport_node.rs
• examples/showcase/alien_cake_addict.rs
• examples/stress_tests/many_foxes.rs
• examples/transforms/3d_rotation.rs
• examples/3d/clustered_decals.rs
• examples/3d/light_textures.rs
• examples/3d/generate_custom_mesh.rs
• examples/usage/debug_frustum_culling.rs
• examples/3d/contact_shadows.rs
• examples/3d/lighting.rs

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/2d_shapes.rs (line 168)

fn rotate(mut query: Query<&mut Transform, With<Mesh2d>>, time: Res<Time>) {
    for mut transform in &mut query {
        transform.rotate_z(time.delta_secs() / 2.0);
    }
}

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

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

examples/stress_tests/many_lights.rs (line 137)

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

examples/shader_advanced/custom_post_processing.rs (line 284)

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

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

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

examples/stress_tests/many_sprite_meshes.rs (line 106)

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

Additional examples can be found in:

• examples/stress_tests/many_sprites.rs
• examples/showcase/contributors.rs
• examples/shader_advanced/render_depth_to_texture.rs
• examples/stress_tests/many_cubes.rs
• examples/stress_tests/many_text2d.rs
• examples/3d/generate_custom_mesh.rs
• examples/ecs/hierarchy.rs
• examples/2d/rotation.rs
• examples/camera/2d_screen_shake.rs
• examples/3d/lighting.rs

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

Rotates this Transform by the given rotation.

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

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

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)

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

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

fn spin(time: Res<Time>, mut query: Query<(&mut Transform, &Spin)>, pause: Res<Pause>) {
    if pause.0 {
        return;
    }
    for (mut transform, spin) in query.iter_mut() {
        transform.rotate_local_y(spin.speed * time.delta_secs());
        transform.rotate_local_x(spin.speed * time.delta_secs());
        transform.rotate_local_z(-spin.speed * time.delta_secs());
    }
}

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)

    pub(crate) fn rotate_cube(
        time: Res<Time>,
        mut cube_transform: Query<&mut Transform, With<Rotator>>,
    ) {
        for mut transform in &mut cube_transform {
            transform.rotate_x(time.delta_secs());
            transform.rotate_local_y(time.delta_secs());
        }
    }

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

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

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

fn spin(time: Res<Time>, mut query: Query<(&mut Transform, &Spin)>, pause: Res<Pause>) {
    if pause.0 {
        return;
    }
    for (mut transform, spin) in query.iter_mut() {
        transform.rotate_local_y(spin.speed * time.delta_secs());
        transform.rotate_local_x(spin.speed * time.delta_secs());
        transform.rotate_local_z(-spin.speed * time.delta_secs());
    }
}

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

fn move_cars(
    time: Res<Time>,
    mut movables: Query<(&mut Transform, &Moves, &Children)>,
    mut spins: Query<&mut Transform, (Without<Moves>, With<Rotates>)>,
) {
    for (mut transform, moves, children) in &mut movables {
        let time = time.elapsed_secs() * 0.25;
        let t = time + 0.5 * moves.0;
        let dx = ops::cos(t);
        let dz = -ops::sin(3.0 * t);
        let speed_variation = (dx * dx + dz * dz).sqrt() * 0.15;
        let t = t + speed_variation;
        let prev = transform.translation;
        transform.translation.x = race_track_pos(0.0, t).x;
        transform.translation.z = race_track_pos(0.0, t).y;
        transform.translation.y = -0.59;
        let delta = transform.translation - prev;
        transform.look_to(delta, Vec3::Y);
        for child in children.iter() {
            let Ok(mut wheel) = spins.get_mut(child) else {
                continue;
            };
            let radius = wheel.scale.x;
            let circumference = 2.0 * std::f32::consts::PI * radius;
            let angle = delta.length() / circumference * std::f32::consts::PI * 2.0;
            wheel.rotate_local_y(angle);
        }
    }
}

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)

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

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

fn spin(time: Res<Time>, mut query: Query<(&mut Transform, &Spin)>, pause: Res<Pause>) {
    if pause.0 {
        return;
    }
    for (mut transform, spin) in query.iter_mut() {
        transform.rotate_local_y(spin.speed * time.delta_secs());
        transform.rotate_local_x(spin.speed * time.delta_secs());
        transform.rotate_local_z(-spin.speed * time.delta_secs());
    }
}

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 670)

fn move_camera(
    keyboard_input: Res<ButtonInput<KeyCode>>,
    mut mouse_wheel_reader: MessageReader<MouseWheel>,
    mut cameras: Query<&mut Transform, With<Camera>>,
) {
    let (mut distance_delta, mut theta_delta) = (0.0, 0.0);

    // Handle keyboard events.
    if keyboard_input.pressed(KeyCode::KeyW) {
        distance_delta -= CAMERA_KEYBOARD_ZOOM_SPEED;
    }
    if keyboard_input.pressed(KeyCode::KeyS) {
        distance_delta += CAMERA_KEYBOARD_ZOOM_SPEED;
    }
    if keyboard_input.pressed(KeyCode::KeyA) {
        theta_delta += CAMERA_KEYBOARD_ORBIT_SPEED;
    }
    if keyboard_input.pressed(KeyCode::KeyD) {
        theta_delta -= CAMERA_KEYBOARD_ORBIT_SPEED;
    }

    // Handle mouse events.
    for mouse_wheel in mouse_wheel_reader.read() {
        distance_delta -= mouse_wheel.y * CAMERA_MOUSE_WHEEL_ZOOM_SPEED;
    }

    // Update transforms.
    for mut camera_transform in cameras.iter_mut() {
        let local_z = camera_transform.local_z().as_vec3().normalize_or_zero();
        if distance_delta != 0.0 {
            camera_transform.translation = (camera_transform.translation.length() + distance_delta)
                .clamp(CAMERA_ZOOM_RANGE.start, CAMERA_ZOOM_RANGE.end)
                * local_z;
        }
        if theta_delta != 0.0 {
            camera_transform
                .translate_around(Vec3::ZERO, Quat::from_axis_angle(Vec3::Y, theta_delta));
            camera_transform.look_at(Vec3::ZERO, Vec3::Y);
        }
    }
}

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 151)

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

examples/stress_tests/many_cameras_lights.rs (line 101)

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

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

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

examples/3d/contact_shadows.rs (line 271)

fn rotate_light(
    mut lights: Query<&mut Transform, With<LightContainer>>,
    app_status: Res<AppStatus>,
) {
    if app_status.light_rotation != LightRotation::Rotating {
        return;
    }

    for mut transform in lights.iter_mut() {
        transform.rotate_around(Vec3::ZERO, Quat::from_rotation_y(LIGHT_ROTATION_SPEED));
    }
}

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

fn rotation(
    mut transform: Single<&mut Transform, With<Camera>>,
    input: Res<ButtonInput<KeyCode>>,
    time: Res<Time>,
) {
    let delta = time.delta_secs();

    if input.pressed(KeyCode::ArrowLeft) {
        transform.rotate_around(Vec3::ZERO, Quat::from_rotation_y(delta));
    } else if input.pressed(KeyCode::ArrowRight) {
        transform.rotate_around(Vec3::ZERO, Quat::from_rotation_y(-delta));
    }
}

examples/transforms/align.rs (line 211)

fn handle_mouse(
    accumulated_mouse_motion: Res<AccumulatedMouseMotion>,
    mut mouse_button_inputs: MessageReader<MouseButtonInput>,
    mut camera_transform: Single<&mut Transform, With<Camera>>,
    mut mouse_pressed: ResMut<MousePressed>,
) {
    // Store left-pressed state in the MousePressed resource
    for mouse_button_input in mouse_button_inputs.read() {
        if mouse_button_input.button != MouseButton::Left {
            continue;
        }
        *mouse_pressed = MousePressed(mouse_button_input.state.is_pressed());
    }

    // If the mouse is not pressed, just ignore motion events
    if !mouse_pressed.0 {
        return;
    }
    if accumulated_mouse_motion.delta != Vec2::ZERO {
        let displacement = accumulated_mouse_motion.delta.x;
        camera_transform.rotate_around(Vec3::ZERO, Quat::from_rotation_y(-displacement / 75.));
    }
}

Additional examples can be found in:

• examples/math/random_sampling.rs
• examples/3d/split_screen.rs
• examples/3d/auto_exposure.rs
• examples/3d/blend_modes.rs
• examples/3d/transmission.rs

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)

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

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

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

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

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

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

fn animate_light(
    mut lights: Query<&mut Transform, Or<(With<PointLight>, With<DirectionalLight>)>>,
    time: Res<Time>,
) {
    let now = time.elapsed_secs();
    for mut transform in lights.iter_mut() {
        transform.translation = vec3(
            ops::sin(now * 1.4),
            ops::cos(now * 1.0),
            ops::cos(now * 0.6),
        ) * vec3(3.0, 4.0, 3.0);
        transform.look_at(Vec3::ZERO, Vec3::Y);
    }
}

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

fn rotate_camera(
    time: Res<Time>,
    mut camera_query: Query<&mut Transform, With<Camera3d>>,
    app_status: Res<AppStatus>,
) {
    if !app_status.rotating {
        return;
    }

    for mut transform in camera_query.iter_mut() {
        transform.translation = Vec2::from_angle(time.delta_secs() * PI / 5.0)
            .rotate(transform.translation.xz())
            .extend(transform.translation.y)
            .xzy();
        transform.look_at(Vec3::ZERO, Vec3::Y);
    }
}

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

fn rotate_camera(
    mut camera_query: Query<&mut Transform, With<Camera3d>>,
    time: Res<Time>,
    app_status: Res<AppStatus>,
) {
    if !app_status.rotating {
        return;
    }

    for mut transform in camera_query.iter_mut() {
        transform.translation = Vec2::from_angle(ROTATION_SPEED * time.delta_secs())
            .rotate(transform.translation.xz())
            .extend(transform.translation.y)
            .xzy();
        transform.look_at(Vec3::ZERO, Vec3::Y);
    }
}

Additional examples can be found in:

• examples/3d/transmission.rs
• examples/3d/motion_blur.rs
• examples/3d/shadow_biases.rs
• examples/3d/ssr.rs
• examples/shader_advanced/render_depth_to_texture.rs
• examples/3d/visibility_range.rs
• examples/3d/clustered_decals.rs
• examples/3d/light_textures.rs

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)

fn input_handler(
    keyboard_input: Res<ButtonInput<KeyCode>>,
    mesh_query: Query<&Mesh3d, With<CustomUV>>,
    mut meshes: ResMut<Assets<Mesh>>,
    mut query: Query<&mut Transform, With<CustomUV>>,
    time: Res<Time>,
) {
    if keyboard_input.just_pressed(KeyCode::Space) {
        let mesh_handle = mesh_query.single().expect("Query not successful");
        let mesh = meshes.get_mut(mesh_handle).unwrap();
        toggle_texture(mesh.into_inner());
    }
    if keyboard_input.pressed(KeyCode::KeyX) {
        for mut transform in &mut query {
            transform.rotate_x(time.delta_secs() / 1.2);
        }
    }
    if keyboard_input.pressed(KeyCode::KeyY) {
        for mut transform in &mut query {
            transform.rotate_y(time.delta_secs() / 1.2);
        }
    }
    if keyboard_input.pressed(KeyCode::KeyZ) {
        for mut transform in &mut query {
            transform.rotate_z(time.delta_secs() / 1.2);
        }
    }
    if keyboard_input.pressed(KeyCode::KeyR) {
        for mut transform in &mut query {
            transform.look_to(Vec3::NEG_Z, Vec3::Y);
        }
    }
}

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

fn move_cars(
    time: Res<Time>,
    mut movables: Query<(&mut Transform, &Moves, &Children)>,
    mut spins: Query<&mut Transform, (Without<Moves>, With<Rotates>)>,
) {
    for (mut transform, moves, children) in &mut movables {
        let time = time.elapsed_secs() * 0.25;
        let t = time + 0.5 * moves.0;
        let dx = ops::cos(t);
        let dz = -ops::sin(3.0 * t);
        let speed_variation = (dx * dx + dz * dz).sqrt() * 0.15;
        let t = t + speed_variation;
        let prev = transform.translation;
        transform.translation.x = race_track_pos(0.0, t).x;
        transform.translation.z = race_track_pos(0.0, t).y;
        transform.translation.y = -0.59;
        let delta = transform.translation - prev;
        transform.look_to(delta, Vec3::Y);
        for child in children.iter() {
            let Ok(mut wheel) = spins.get_mut(child) else {
                continue;
            };
            let radius = wheel.scale.x;
            let circumference = 2.0 * std::f32::consts::PI * radius;
            let angle = delta.length() / circumference * std::f32::consts::PI * 2.0;
            wheel.rotate_local_y(angle);
        }
    }
}

fn move_camera(
    camera: Single<(&mut Transform, &mut Projection), Without<CameraTracked>>,
    tracked: Single<&Transform, With<CameraTracked>>,
    mode: Res<CameraMode>,
) {
    let (mut transform, mut projection) = camera.into_inner();
    match *mode {
        CameraMode::Track => {
            transform.look_at(tracked.translation, Vec3::Y);
            transform.translation = Vec3::new(15.0, -0.5, 0.0);
            if let Projection::Perspective(perspective) = &mut *projection {
                perspective.fov = 0.05;
            }
        }
        CameraMode::Chase => {
            transform.translation =
                tracked.translation + Vec3::new(0.0, 0.15, 0.0) + tracked.back() * 0.6;
            transform.look_to(tracked.forward(), Vec3::Y);
            if let Projection::Perspective(perspective) = &mut *projection {
                perspective.fov = 1.0;
            }
        }
    }
}

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));

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

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

Examples found in repository

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

fn spawn_quads(
    commands: &mut Commands,
    meshes: &mut Assets<Mesh>,
    materials: &mut Assets<StandardMaterial>,
) {
    let quad_handle = meshes.add(Rectangle::new(3.0, 3.0).mesh());
    let render_layers = RenderLayers::layer(1);
    let xform = |x, y, z| {
        Transform::from_rotation(Quat::from_rotation_y(0.5))
            .mul_transform(Transform::from_xyz(x, y, z))
    };
    commands.spawn((
        Mesh3d(quad_handle.clone()),
        MeshMaterial3d(materials.add(StandardMaterial {
            base_color: RED.with_alpha(0.5).into(),
            alpha_mode: AlphaMode::Blend,
            ..default()
        })),
        xform(1.0, -0.1, 0.),
        render_layers.clone(),
    ));
    commands.spawn((
        Mesh3d(quad_handle.clone()),
        MeshMaterial3d(materials.add(StandardMaterial {
            base_color: BLUE.with_alpha(0.8).into(),
            alpha_mode: AlphaMode::Blend,
            ..default()
        })),
        xform(0.5, 0.2, -0.5),
        render_layers.clone(),
    ));
    commands.spawn((
        Mesh3d(quad_handle.clone()),
        MeshMaterial3d(materials.add(StandardMaterial {
            base_color: GREEN.with_green(1.0).with_alpha(0.5).into(),
            alpha_mode: AlphaMode::Blend,
            ..default()
        })),
        xform(0.0, 0.4, -1.),
        render_layers.clone(),
    ));
    commands.spawn((
        Mesh3d(quad_handle.clone()),
        MeshMaterial3d(materials.add(StandardMaterial {
            base_color: YELLOW.with_alpha(0.3).into(),
            alpha_mode: AlphaMode::Blend,
            ..default()
        })),
        xform(-0.5, 0.6, -1.1),
        render_layers.clone(),
    ));
    commands.spawn((
        Mesh3d(quad_handle.clone()),
        MeshMaterial3d(materials.add(StandardMaterial {
            base_color: BLUE.with_alpha(0.2).into(),
            alpha_mode: AlphaMode::Blend,
            ..default()
        })),
        xform(-0.8, 0.8, -1.2),
        render_layers.clone(),
    ));
}

examples/stress_tests/many_cubes.rs (line 202)

fn setup(
    mut commands: Commands,
    args: Res<Args>,
    mesh_assets: ResMut<Assets<Mesh>>,
    material_assets: ResMut<Assets<StandardMaterial>>,
    images: ResMut<Assets<Image>>,
) {
    warn!(include_str!("warning_string.txt"));

    let args = args.into_inner();
    let images = images.into_inner();
    let material_assets = material_assets.into_inner();
    let mesh_assets = mesh_assets.into_inner();

    let meshes = init_meshes(args, mesh_assets);

    let material_textures = init_textures(args, images);
    let materials = init_materials(args, &material_textures, material_assets);

    // We're seeding the PRNG here to make this example deterministic for testing purposes.
    // This isn't strictly required in practical use unless you need your app to be deterministic.
    let mut material_rng = ChaCha8Rng::seed_from_u64(42);
    match args.layout {
        Layout::Sphere => {
            // NOTE: This pattern is good for testing performance of culling as it provides roughly
            // the same number of visible meshes regardless of the viewing angle.
            let n_points: usize = args.instance_count;
            // NOTE: f64 is used to avoid precision issues that produce visual artifacts in the distribution
            let radius = WIDTH as f64 * 2.5;
            let golden_ratio = 0.5f64 * (1.0f64 + 5.0f64.sqrt());
            for i in 0..n_points {
                let spherical_polar_theta_phi =
                    fibonacci_spiral_on_sphere(golden_ratio, i, n_points);
                let unit_sphere_p = spherical_polar_to_cartesian(spherical_polar_theta_phi);
                let (mesh, transform) = meshes.choose(&mut material_rng).unwrap();
                commands
                    .spawn((
                        Mesh3d(mesh.clone()),
                        MeshMaterial3d(materials.choose(&mut material_rng).unwrap().clone()),
                        Transform::from_translation((radius * unit_sphere_p).as_vec3())
                            .looking_at(Vec3::ZERO, Vec3::Y)
                            .mul_transform(*transform),
                    ))
                    .insert_if(NoFrustumCulling, || args.no_frustum_culling)
                    .insert_if(NoAutomaticBatching, || args.no_automatic_batching)
                    .insert_if(NoCpuCulling, || args.no_cpu_culling);
            }

            // camera
            let mut camera = commands.spawn(Camera3d::default());
            if args.no_indirect_drawing {
                camera.insert(NoIndirectDrawing);
            }
            if args.no_cpu_culling {
                camera.insert(NoCpuCulling);
            }
            if args.motion_blur {
                camera.insert((
                    MotionBlur {
                        // Use an unrealistically large shutter angle so that motion blur is clearly visible.
                        shutter_angle: 3.0,
                        ..Default::default()
                    },
                    // MSAA and MotionBlur are not compatible on WebGL.
                    #[cfg(all(
                        feature = "webgl2",
                        target_arch = "wasm32",
                        not(feature = "webgpu")
                    ))]
                    Msaa::Off,
                ));
            }

            // Inside-out box around the meshes onto which shadows are cast (though you cannot see them...)
            commands.spawn((
                Mesh3d(mesh_assets.add(Cuboid::from_size(Vec3::splat(radius as f32 * 2.2)))),
                MeshMaterial3d(material_assets.add(StandardMaterial::from(Color::WHITE))),
                Transform::from_scale(-Vec3::ONE),
                NotShadowCaster,
            ));
        }
        Layout::Cube => {
            // NOTE: This pattern is good for demonstrating that frustum culling is working correctly
            // as the number of visible meshes rises and falls depending on the viewing angle.
            let scale = 2.5;

            // Scale the width and height by the same factor so that we have the
            // right number of instances.
            // Because of the moiré pattern check and the fact that we're
            // spawning 4 instances per trip around the inner loop below, we're
            // solving the following equation for the factor variable:
            //
            //      4 * (9/10 * factor * width * 9/10 * factor * height) = count
            //
            // The solution is the value below.
            let factor = (5.0 / 9.0) * sqrt(args.instance_count as f32)
                / (sqrt(HEIGHT as f32) * sqrt(WIDTH as f32));
            let dimensions = (vec2(WIDTH as f32, HEIGHT as f32) * factor)
                .ceil()
                .as_uvec2();

            for x in 0..dimensions.x {
                for y in 0..dimensions.y {
                    // introduce spaces to break any kind of moiré pattern
                    if x % 10 == 0 || y % 10 == 0 {
                        continue;
                    }
                    // cube
                    commands
                        .spawn((
                            Mesh3d(meshes.choose(&mut material_rng).unwrap().0.clone()),
                            MeshMaterial3d(materials.choose(&mut material_rng).unwrap().clone()),
                            Transform::from_xyz((x as f32) * scale, (y as f32) * scale, 0.0),
                        ))
                        .insert_if(NoCpuCulling, || args.no_cpu_culling);
                    commands
                        .spawn((
                            Mesh3d(meshes.choose(&mut material_rng).unwrap().0.clone()),
                            MeshMaterial3d(materials.choose(&mut material_rng).unwrap().clone()),
                            Transform::from_xyz(
                                (x as f32) * scale,
                                dimensions.y as f32 * scale,
                                (y as f32) * scale,
                            ),
                        ))
                        .insert_if(NoCpuCulling, || args.no_cpu_culling);
                    commands
                        .spawn((
                            Mesh3d(meshes.choose(&mut material_rng).unwrap().0.clone()),
                            MeshMaterial3d(materials.choose(&mut material_rng).unwrap().clone()),
                            Transform::from_xyz((x as f32) * scale, 0.0, (y as f32) * scale),
                        ))
                        .insert_if(NoCpuCulling, || args.no_cpu_culling);
                    commands
                        .spawn((
                            Mesh3d(meshes.choose(&mut material_rng).unwrap().0.clone()),
                            MeshMaterial3d(materials.choose(&mut material_rng).unwrap().clone()),
                            Transform::from_xyz(0.0, (x as f32) * scale, (y as f32) * scale),
                        ))
                        .insert_if(NoCpuCulling, || args.no_cpu_culling);
                }
            }
            // camera
            let center = 0.5
                * scale
                * Vec3::new(
                    dimensions.x as f32,
                    dimensions.y as f32,
                    dimensions.x as f32,
                );
            commands.spawn((Camera3d::default(), Transform::from_translation(center)));
            // Inside-out box around the meshes onto which shadows are cast (though you cannot see them...)
            commands.spawn((
                Mesh3d(mesh_assets.add(Cuboid::from_size(2.0 * 1.1 * center))),
                MeshMaterial3d(material_assets.add(StandardMaterial::from(Color::WHITE))),
                Transform::from_scale(-Vec3::ONE).with_translation(center),
                NotShadowCaster,
            ));
        }
        Layout::Dense => {
            // NOTE: This pattern is good for demonstrating a dense configuration of cubes
            // overlapping each other, all within the camera frustum.
            let count = args.instance_count;
            let size = cbrt(count as f32).round();
            let gap = 1.25;

            for i in 0..count {
                let x = i as f32 % size;
                let y = (i as f32 / size) % size;
                let z = i as f32 / (size * size);
                let pos = Vec3::new(x * gap, y * gap, z * gap);
                commands
                    .spawn((
                        Mesh3d(meshes.choose(&mut material_rng).unwrap().0.clone()),
                        MeshMaterial3d(materials.choose(&mut material_rng).unwrap().clone()),
                        Transform::from_translation(pos),
                    ))
                    .insert_if(NoCpuCulling, || args.no_cpu_culling);
            }

            // camera
            commands.spawn((
                Camera3d::default(),
                Transform::from_xyz(100.0, 90.0, 100.0)
                    .looking_at(Vec3::new(0.0, -10.0, 0.0), Vec3::Y),
            ));
        }
    }

    commands.spawn((
        DirectionalLight {
            shadow_maps_enabled: args.shadows,
            ..default()
        },
        Transform::IDENTITY.looking_at(Vec3::new(0.0, -1.0, -1.0), Vec3::Y),
    ));
}

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().

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.

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 332)

fn bounding_shapes_3d(
    shapes: Query<&Transform, With<Shape3d>>,
    mut gizmos: Gizmos,
    bounding_shape: Res<State<BoundingShape>>,
) {
    for transform in shapes.iter() {
        match bounding_shape.get() {
            BoundingShape::None => (),
            BoundingShape::BoundingBox => {
                // Get the AABB of the extrusion with the rotation and translation of the mesh.
                let aabb = EXTRUSION.aabb_3d(transform.to_isometry());

                gizmos.primitive_3d(
                    &Cuboid::from_size(Vec3::from(aabb.half_size()) * 2.),
                    aabb.center(),
                    WHITE,
                );
            }
            BoundingShape::BoundingSphere => {
                // Get the bounding sphere of the extrusion with the rotation and translation of the mesh.
                let bounding_sphere = EXTRUSION.bounding_sphere(transform.to_isometry());

                gizmos.sphere(bounding_sphere.center(), bounding_sphere.radius(), WHITE);
            }
        }
    }
}

Trait Implementations

impl Animatable for Transform

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

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

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

Blends one or more values together.

impl Clone for Transform

fn clone(&self) -> Transform

Returns a duplicate of the value.

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

Performs copy-assignment from 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.

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

A constant indicating the storage type used for this component.

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

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

Registers required components.

fn clone_behavior() -> ComponentCloneBehavior

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

fn relationship_accessor() -> Option<ComponentRelationshipAccessor<Transform>>

Returns ComponentRelationshipAccessor required for working with relationships in dynamic contexts.

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

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

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

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

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

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

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

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

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

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

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]

impl Copy for Transform

impl Debug for Transform

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

Formats the value using the given formatter.

impl Default for Transform

fn default() -> Transform

Returns the “default value” for a type.

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

where Transform: Default,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<GlobalTransform> for Transform

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

fn from(transform: GlobalTransform) -> Transform

Converts to this type from the input type.

impl From<Transform> for GlobalTransform

fn from(transform: Transform) -> GlobalTransform

Converts to this type from the input type.

impl FromArg for Transform

type This<'from_arg> = Transform

The type to convert into.

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

Creates an item from an argument.

impl FromReflect for Transform

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

Constructs a concrete instance of Self from a reflected value.

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.

impl GetOwnership for Transform

fn ownership() -> Ownership

Returns the ownership of Self.

impl GetTypeRegistration for Transform

fn get_type_registration() -> TypeRegistration

Returns the default TypeRegistration for this type.

fn register_type_dependencies(registry: &mut TypeRegistry)

Registers other types needed by this type.

impl IntoReturn for Transform

fn into_return<'into_return>(self) -> Return<'into_return>

where Transform: 'into_return,

Converts Self into a Return value.

impl Mul for Transform

type Output = Transform

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<GlobalTransform> for Transform

type Output = GlobalTransform

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Mesh> for Transform

type Output = Mesh

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Transform> for GlobalTransform

type Output = GlobalTransform

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Vec3> for Transform

type Output = Vec3

The resulting type after applying the * operator.

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

Performs the * operation.

impl PartialEq for Transform

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl PartialReflect for Transform

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

Returns the TypeInfo of the type represented by this value.

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

Tries to apply a reflected value to this value.

fn reflect_kind(&self) -> ReflectKind

Returns a zero-sized enumeration of “kinds” of type.

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

Returns an immutable enumeration of “kinds” of type.

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

Returns a mutable enumeration of “kinds” of type.

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

Returns an owned enumeration of “kinds” of type.

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

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

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

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

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

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

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

Casts this type to a boxed, reflected value.

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

Casts this type to a reflected value.

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

Casts this type to a mutable, reflected value.

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

Returns a “partial equality” comparison result.

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

Returns a “partial comparison” result.

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

Debug formatter for the value.

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

Attempts to clone Self using reflection.

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

Applies a reflected value to this value.

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

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

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.

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

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

fn is_dynamic(&self) -> bool

Indicates whether or not this type is a dynamic type.

impl Reflect for Transform

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

Returns the value as a Box<dyn Any>.

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

Returns the value as a &dyn Any.

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

Returns the value as a &mut dyn Any.

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

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

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

Casts this type to a fully-reflected value.

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

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

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

Performs a type-checked assignment of a reflected value to this value.

impl Serialize for Transform

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Struct for Transform

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

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

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

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

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

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

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

Gets a mutable reference to the value of the field with index index as a &mut dyn PartialReflect.

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

Gets the name of the field with index index.

fn index_of_name(&self, name: &str) -> Option<usize>

Gets the index of the field with the given name.

fn field_len(&self) -> usize

Returns the number of fields in the struct.

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

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

fn to_dynamic_struct(&self) -> DynamicStruct

Creates a new DynamicStruct from this struct.

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

Will return None if TypeInfo is not available.

impl StructuralPartialEq for Transform

impl TransformPoint for Transform

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

Transform a point.

impl TypePath for Transform

fn type_path() -> &'static str

Returns the fully qualified path of the underlying type.

fn short_type_path() -> &'static str

Returns a short, pretty-print enabled path to the type.

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

Returns the name of the type, or None if it is anonymous.

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

Returns the name of the crate the type is in, or None if it is anonymous.

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

Returns the path to the module the type is in, or None if it is anonymous.

impl Typed for Transform

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.