Vendor dependencies for 0.3.0 release

vendor/bevy/examples/camera/2d_screen_shake.rs

@@ -0,0 +1,180 @@
+//! This example showcases a 2D screen shake using concept in this video: `<https://www.youtube.com/watch?v=tu-Qe66AvtY>`
+//!
+//! ## Controls
+//!
+//! | Key Binding  | Action               |
+//! |:-------------|:---------------------|
+//! | Space        | Trigger screen shake |
+
+use bevy::{prelude::*, render::camera::SubCameraView, sprite::MeshMaterial2d};
+use rand::{Rng, SeedableRng};
+use rand_chacha::ChaCha8Rng;
+
+const CAMERA_DECAY_RATE: f32 = 0.9; // Adjust this for smoother or snappier decay
+const TRAUMA_DECAY_SPEED: f32 = 0.5; // How fast trauma decays
+const TRAUMA_INCREMENT: f32 = 1.0; // Increment of trauma per frame when holding space
+
+// screen_shake parameters, maximum addition by frame not actual maximum overall values
+const MAX_ANGLE: f32 = 0.5;
+const MAX_OFFSET: f32 = 500.0;
+
+#[derive(Component)]
+struct Player;
+
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins)
+        .add_systems(Startup, (setup_scene, setup_instructions, setup_camera))
+        .add_systems(Update, (screen_shake, trigger_shake_on_space))
+        .run();
+}
+
+fn setup_scene(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<ColorMaterial>>,
+) {
+    // World where we move the player
+    commands.spawn((
+        Mesh2d(meshes.add(Rectangle::new(1000., 700.))),
+        MeshMaterial2d(materials.add(Color::srgb(0.2, 0.2, 0.3))),
+    ));
+
+    // Player
+    commands.spawn((
+        Player,
+        Mesh2d(meshes.add(Rectangle::new(50.0, 100.0))), // Rectangle size (width, height)
+        MeshMaterial2d(materials.add(Color::srgb(0.25, 0.94, 0.91))), // RGB values must be in range 0.0 to 1.0
+        Transform::from_xyz(0., 0., 2.),
+    ));
+
+    commands.spawn((
+        Mesh2d(meshes.add(Rectangle::new(50.0, 50.0))), // Rectangle size (width, height)
+        MeshMaterial2d(materials.add(Color::srgb(0.85, 0.0, 0.2))), // RGB values must be in range 0.0 to 1.0
+        Transform::from_xyz(-450.0, 200.0, 2.),
+    ));
+
+    commands.spawn((
+        Mesh2d(meshes.add(Rectangle::new(70.0, 50.0))), // Rectangle size (width, height)
+        MeshMaterial2d(materials.add(Color::srgb(0.5, 0.8, 0.2))), // RGB values must be in range 0.0 to 1.0
+        Transform::from_xyz(450.0, -150.0, 2.),
+    ));
+    commands.init_resource::<ScreenShake>();
+}
+
+fn setup_instructions(mut commands: Commands) {
+    commands.spawn((
+        Text::new("Hold space to trigger a screen shake"),
+        Node {
+            position_type: PositionType::Absolute,
+            bottom: Val::Px(12.0),
+            left: Val::Px(12.0),
+            ..default()
+        },
+    ));
+}
+
+fn setup_camera(mut commands: Commands) {
+    commands.spawn((
+        Camera2d,
+        Camera {
+            sub_camera_view: Some(SubCameraView {
+                full_size: UVec2::new(1000, 700),
+                offset: Vec2::new(0.0, 0.0),
+                size: UVec2::new(1000, 700),
+            }),
+            order: 1,
+            ..default()
+        },
+    ));
+}
+
+#[derive(Resource, Clone)]
+struct ScreenShake {
+    max_angle: f32,
+    max_offset: f32,
+    trauma: f32,
+    latest_position: Option<Vec2>,
+}
+
+impl Default for ScreenShake {
+    fn default() -> Self {
+        Self {
+            max_angle: 0.0,
+            max_offset: 0.0,
+            trauma: 0.0,
+            latest_position: Some(Vec2::default()),
+        }
+    }
+}
+
+impl ScreenShake {
+    fn start_shake(&mut self, max_angle: f32, max_offset: f32, trauma: f32, final_position: Vec2) {
+        self.max_angle = max_angle;
+        self.max_offset = max_offset;
+        self.trauma = trauma.clamp(0.0, 1.0);
+        self.latest_position = Some(final_position);
+    }
+}
+
+fn trigger_shake_on_space(
+    time: Res<Time>,
+    keyboard_input: Res<ButtonInput<KeyCode>>,
+    mut screen_shake: ResMut<ScreenShake>,
+) {
+    if keyboard_input.pressed(KeyCode::Space) {
+        let screen_shake_clone = screen_shake.clone();
+        screen_shake.start_shake(
+            MAX_ANGLE,
+            MAX_OFFSET,
+            screen_shake_clone.trauma + TRAUMA_INCREMENT * time.delta_secs(),
+            Vec2 { x: 0.0, y: 0.0 },
+        ); // final_position should be your current player position
+    }
+}
+
+fn screen_shake(
+    time: Res<Time>,
+    mut screen_shake: ResMut<ScreenShake>,
+    mut query: Query<(&mut Camera, &mut Transform)>,
+) {
+    let mut rng = ChaCha8Rng::from_entropy();
+    let shake = screen_shake.trauma * screen_shake.trauma;
+    let angle = (screen_shake.max_angle * shake).to_radians() * rng.gen_range(-1.0..1.0);
+    let offset_x = screen_shake.max_offset * shake * rng.gen_range(-1.0..1.0);
+    let offset_y = screen_shake.max_offset * shake * rng.gen_range(-1.0..1.0);
+
+    if shake > 0.0 {
+        for (mut camera, mut transform) in query.iter_mut() {
+            // Position
+            let sub_view = camera.sub_camera_view.as_mut().unwrap();
+            let target = sub_view.offset
+                + Vec2 {
+                    x: offset_x,
+                    y: offset_y,
+                };
+            sub_view
+                .offset
+                .smooth_nudge(&target, CAMERA_DECAY_RATE, time.delta_secs());
+
+            // Rotation
+            let rotation = Quat::from_rotation_z(angle);
+            transform.rotation = transform
+                .rotation
+                .interpolate_stable(&(transform.rotation.mul_quat(rotation)), CAMERA_DECAY_RATE);
+        }
+    } else {
+        // return camera to the latest position of player (it's fixed in this example case)
+        if let Ok((mut camera, mut transform)) = query.single_mut() {
+            let sub_view = camera.sub_camera_view.as_mut().unwrap();
+            let target = screen_shake.latest_position.unwrap();
+            sub_view
+                .offset
+                .smooth_nudge(&target, 1.0, time.delta_secs());
+            transform.rotation = transform.rotation.interpolate_stable(&Quat::IDENTITY, 0.1);
+        }
+    }
+    // Decay the trauma over time
+    screen_shake.trauma -= TRAUMA_DECAY_SPEED * time.delta_secs();
+    screen_shake.trauma = screen_shake.trauma.clamp(0.0, 1.0);
+}

vendor/bevy/examples/camera/2d_top_down_camera.rs

@@ -0,0 +1,123 @@
+//! This example showcases a 2D top-down camera with smooth player tracking.
+//!
+//! ## Controls
+//!
+//! | Key Binding          | Action        |
+//! |:---------------------|:--------------|
+//! | `W`                  | Move up       |
+//! | `S`                  | Move down     |
+//! | `A`                  | Move left     |
+//! | `D`                  | Move right    |
+
+use bevy::{core_pipeline::bloom::Bloom, prelude::*};
+
+/// Player movement speed factor.
+const PLAYER_SPEED: f32 = 100.;
+
+/// How quickly should the camera snap to the desired location.
+const CAMERA_DECAY_RATE: f32 = 2.;
+
+#[derive(Component)]
+struct Player;
+
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins)
+        .add_systems(Startup, (setup_scene, setup_instructions, setup_camera))
+        .add_systems(Update, (move_player, update_camera).chain())
+        .run();
+}
+
+fn setup_scene(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<ColorMaterial>>,
+) {
+    // World where we move the player
+    commands.spawn((
+        Mesh2d(meshes.add(Rectangle::new(1000., 700.))),
+        MeshMaterial2d(materials.add(Color::srgb(0.2, 0.2, 0.3))),
+    ));
+
+    // Player
+    commands.spawn((
+        Player,
+        Mesh2d(meshes.add(Circle::new(25.))),
+        MeshMaterial2d(materials.add(Color::srgb(6.25, 9.4, 9.1))), // RGB values exceed 1 to achieve a bright color for the bloom effect
+        Transform::from_xyz(0., 0., 2.),
+    ));
+}
+
+fn setup_instructions(mut commands: Commands) {
+    commands.spawn((
+        Text::new("Move the light with WASD.\nThe camera will smoothly track the light."),
+        Node {
+            position_type: PositionType::Absolute,
+            bottom: Val::Px(12.0),
+            left: Val::Px(12.0),
+            ..default()
+        },
+    ));
+}
+
+fn setup_camera(mut commands: Commands) {
+    commands.spawn((
+        Camera2d,
+        Camera {
+            hdr: true, // HDR is required for the bloom effect
+            ..default()
+        },
+        Bloom::NATURAL,
+    ));
+}
+
+/// Update the camera position by tracking the player.
+fn update_camera(
+    mut camera: Single<&mut Transform, (With<Camera2d>, Without<Player>)>,
+    player: Single<&Transform, (With<Player>, Without<Camera2d>)>,
+    time: Res<Time>,
+) {
+    let Vec3 { x, y, .. } = player.translation;
+    let direction = Vec3::new(x, y, camera.translation.z);
+
+    // Applies a smooth effect to camera movement using stable interpolation
+    // between the camera position and the player position on the x and y axes.
+    camera
+        .translation
+        .smooth_nudge(&direction, CAMERA_DECAY_RATE, time.delta_secs());
+}
+
+/// Update the player position with keyboard inputs.
+/// Note that the approach used here is for demonstration purposes only,
+/// as the point of this example is to showcase the camera tracking feature.
+///
+/// A more robust solution for player movement can be found in `examples/movement/physics_in_fixed_timestep.rs`.
+fn move_player(
+    mut player: Single<&mut Transform, With<Player>>,
+    time: Res<Time>,
+    kb_input: Res<ButtonInput<KeyCode>>,
+) {
+    let mut direction = Vec2::ZERO;
+
+    if kb_input.pressed(KeyCode::KeyW) {
+        direction.y += 1.;
+    }
+
+    if kb_input.pressed(KeyCode::KeyS) {
+        direction.y -= 1.;
+    }
+
+    if kb_input.pressed(KeyCode::KeyA) {
+        direction.x -= 1.;
+    }
+
+    if kb_input.pressed(KeyCode::KeyD) {
+        direction.x += 1.;
+    }
+
+    // Progressively update the player's position over time. Normalize the
+    // direction vector to prevent it from exceeding a magnitude of 1 when
+    // moving diagonally.
+    let move_delta = direction.normalize_or_zero() * PLAYER_SPEED * time.delta_secs();
+    player.translation += move_delta.extend(0.);
+}

vendor/bevy/examples/camera/camera_orbit.rs

@@ -0,0 +1,141 @@
+//! Shows how to orbit camera around a static scene using pitch, yaw, and roll.
+//!
+//! See also: `first_person_view_model` example, which does something similar but as a first-person
+//! camera view.
+
+use std::{f32::consts::FRAC_PI_2, ops::Range};
+
+use bevy::{input::mouse::AccumulatedMouseMotion, prelude::*};
+
+#[derive(Debug, Resource)]
+struct CameraSettings {
+    pub orbit_distance: f32,
+    pub pitch_speed: f32,
+    // Clamp pitch to this range
+    pub pitch_range: Range<f32>,
+    pub roll_speed: f32,
+    pub yaw_speed: f32,
+}
+
+impl Default for CameraSettings {
+    fn default() -> Self {
+        // Limiting pitch stops some unexpected rotation past 90° up or down.
+        let pitch_limit = FRAC_PI_2 - 0.01;
+        Self {
+            // These values are completely arbitrary, chosen because they seem to produce
+            // "sensible" results for this example. Adjust as required.
+            orbit_distance: 20.0,
+            pitch_speed: 0.003,
+            pitch_range: -pitch_limit..pitch_limit,
+            roll_speed: 1.0,
+            yaw_speed: 0.004,
+        }
+    }
+}
+
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins)
+        .init_resource::<CameraSettings>()
+        .add_systems(Startup, (setup, instructions))
+        .add_systems(Update, orbit)
+        .run();
+}
+
+/// Set up a simple 3D scene
+fn setup(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+) {
+    commands.spawn((
+        Name::new("Camera"),
+        Camera3d::default(),
+        Transform::from_xyz(5.0, 5.0, 5.0).looking_at(Vec3::ZERO, Vec3::Y),
+    ));
+
+    commands.spawn((
+        Name::new("Plane"),
+        Mesh3d(meshes.add(Plane3d::default().mesh().size(5.0, 5.0))),
+        MeshMaterial3d(materials.add(StandardMaterial {
+            base_color: Color::srgb(0.3, 0.5, 0.3),
+            // Turning off culling keeps the plane visible when viewed from beneath.
+            cull_mode: None,
+            ..default()
+        })),
+    ));
+
+    commands.spawn((
+        Name::new("Cube"),
+        Mesh3d(meshes.add(Cuboid::default())),
+        MeshMaterial3d(materials.add(Color::srgb(0.8, 0.7, 0.6))),
+        Transform::from_xyz(1.5, 0.51, 1.5),
+    ));
+
+    commands.spawn((
+        Name::new("Light"),
+        PointLight::default(),
+        Transform::from_xyz(3.0, 8.0, 5.0),
+    ));
+}
+
+fn instructions(mut commands: Commands) {
+    commands.spawn((
+        Name::new("Instructions"),
+        Text::new(
+            "Mouse up or down: pitch\n\
+            Mouse left or right: yaw\n\
+            Mouse buttons: roll",
+        ),
+        Node {
+            position_type: PositionType::Absolute,
+            top: Val::Px(12.),
+            left: Val::Px(12.),
+            ..default()
+        },
+    ));
+}
+
+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;
+}

vendor/bevy/examples/camera/custom_projection.rs

@@ -0,0 +1,84 @@
+//! Demonstrates how to define and use custom camera projections.
+
+use bevy::prelude::*;
+use bevy::render::camera::CameraProjection;
+
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins)
+        .add_systems(Startup, setup)
+        .run();
+}
+
+/// Like a perspective projection, but the vanishing point is not centered.
+#[derive(Debug, Clone)]
+struct ObliquePerspectiveProjection {
+    horizontal_obliqueness: f32,
+    vertical_obliqueness: f32,
+    perspective: PerspectiveProjection,
+}
+
+/// Implement the [`CameraProjection`] trait for our custom projection:
+impl CameraProjection for ObliquePerspectiveProjection {
+    fn get_clip_from_view(&self) -> Mat4 {
+        let mut mat = self.perspective.get_clip_from_view();
+        mat.col_mut(2)[0] = self.horizontal_obliqueness;
+        mat.col_mut(2)[1] = self.vertical_obliqueness;
+        mat
+    }
+
+    fn get_clip_from_view_for_sub(&self, sub_view: &bevy_render::camera::SubCameraView) -> Mat4 {
+        let mut mat = self.perspective.get_clip_from_view_for_sub(sub_view);
+        mat.col_mut(2)[0] = self.horizontal_obliqueness;
+        mat.col_mut(2)[1] = self.vertical_obliqueness;
+        mat
+    }
+
+    fn update(&mut self, width: f32, height: f32) {
+        self.perspective.update(width, height);
+    }
+
+    fn far(&self) -> f32 {
+        self.perspective.far
+    }
+
+    fn get_frustum_corners(&self, z_near: f32, z_far: f32) -> [Vec3A; 8] {
+        self.perspective.get_frustum_corners(z_near, z_far)
+    }
+}
+
+fn setup(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+) {
+    commands.spawn((
+        Camera3d::default(),
+        // Use our custom projection:
+        Projection::custom(ObliquePerspectiveProjection {
+            horizontal_obliqueness: 0.2,
+            vertical_obliqueness: 0.6,
+            perspective: PerspectiveProjection::default(),
+        }),
+        Transform::from_xyz(-2.5, 4.5, 9.0).looking_at(Vec3::ZERO, Vec3::Y),
+    ));
+
+    // Scene setup
+    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(1.0, 1.0, 1.0))),
+        MeshMaterial3d(materials.add(Color::srgb_u8(124, 144, 255))),
+        Transform::from_xyz(0.0, 0.5, 0.0),
+    ));
+    commands.spawn((
+        PointLight {
+            shadows_enabled: true,
+            ..default()
+        },
+        Transform::from_xyz(4.0, 8.0, 4.0),
+    ));
+}

vendor/bevy/examples/camera/first_person_view_model.rs

@@ -0,0 +1,260 @@
+//! This example showcases a 3D first-person camera.
+//!
+//! The setup presented here is a very common way of organizing a first-person game
+//! where the player can see their own arms. We use two industry terms to differentiate
+//! the kinds of models we have:
+//!
+//! - The *view model* is the model that represents the player's body.
+//! - The *world model* is everything else.
+//!
+//! ## Motivation
+//!
+//! The reason for this distinction is that these two models should be rendered with different field of views (FOV).
+//! The view model is typically designed and animated with a very specific FOV in mind, so it is
+//! generally *fixed* and cannot be changed by a player. The world model, on the other hand, should
+//! be able to change its FOV to accommodate the player's preferences for the following reasons:
+//! - *Accessibility*: How prone is the player to motion sickness? A wider FOV can help.
+//! - *Tactical preference*: Does the player want to see more of the battlefield?
+//!   Or have a more zoomed-in view for precision aiming?
+//! - *Physical considerations*: How well does the in-game FOV match the player's real-world FOV?
+//!   Are they sitting in front of a monitor or playing on a TV in the living room? How big is the screen?
+//!
+//! ## Implementation
+//!
+//! The `Player` is an entity holding two cameras, one for each model. The view model camera has a fixed
+//! FOV of 70 degrees, while the world model camera has a variable FOV that can be changed by the player.
+//!
+//! We use different `RenderLayers` to select what to render.
+//!
+//! - The world model camera has no explicit `RenderLayers` component, so it uses the layer 0.
+//!   All static objects in the scene are also on layer 0 for the same reason.
+//! - The view model camera has a `RenderLayers` component with layer 1, so it only renders objects
+//!   explicitly assigned to layer 1. The arm of the player is one such object.
+//!   The order of the view model camera is additionally bumped to 1 to ensure it renders on top of the world model.
+//! - The light source in the scene must illuminate both the view model and the world model, so it is
+//!   assigned to both layers 0 and 1.
+//!
+//! ## Controls
+//!
+//! | Key Binding          | Action        |
+//! |:---------------------|:--------------|
+//! | mouse                | Look around   |
+//! | arrow up             | Decrease FOV  |
+//! | arrow down           | Increase FOV  |
+
+use std::f32::consts::FRAC_PI_2;
+
+use bevy::{
+    color::palettes::tailwind, input::mouse::AccumulatedMouseMotion, pbr::NotShadowCaster,
+    prelude::*, render::view::RenderLayers,
+};
+
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins)
+        .add_systems(
+            Startup,
+            (
+                spawn_view_model,
+                spawn_world_model,
+                spawn_lights,
+                spawn_text,
+            ),
+        )
+        .add_systems(Update, (move_player, change_fov))
+        .run();
+}
+
+#[derive(Debug, Component)]
+struct Player;
+
+#[derive(Debug, Component, Deref, DerefMut)]
+struct CameraSensitivity(Vec2);
+
+impl Default for CameraSensitivity {
+    fn default() -> Self {
+        Self(
+            // These factors are just arbitrary mouse sensitivity values.
+            // It's often nicer to have a faster horizontal sensitivity than vertical.
+            // We use a component for them so that we can make them user-configurable at runtime
+            // for accessibility reasons.
+            // It also allows you to inspect them in an editor if you `Reflect` the component.
+            Vec2::new(0.003, 0.002),
+        )
+    }
+}
+
+#[derive(Debug, Component)]
+struct WorldModelCamera;
+
+/// Used implicitly by all entities without a `RenderLayers` component.
+/// Our world model camera and all objects other than the player are on this layer.
+/// The light source belongs to both layers.
+const DEFAULT_RENDER_LAYER: usize = 0;
+
+/// Used by the view model camera and the player's arm.
+/// The light source belongs to both layers.
+const VIEW_MODEL_RENDER_LAYER: usize = 1;
+
+fn spawn_view_model(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+) {
+    let arm = meshes.add(Cuboid::new(0.1, 0.1, 0.5));
+    let arm_material = materials.add(Color::from(tailwind::TEAL_200));
+
+    commands
+        .spawn((
+            Player,
+            CameraSensitivity::default(),
+            Transform::from_xyz(0.0, 1.0, 0.0),
+            Visibility::default(),
+        ))
+        .with_children(|parent| {
+            parent.spawn((
+                WorldModelCamera,
+                Camera3d::default(),
+                Projection::from(PerspectiveProjection {
+                    fov: 90.0_f32.to_radians(),
+                    ..default()
+                }),
+            ));
+
+            // Spawn view model camera.
+            parent.spawn((
+                Camera3d::default(),
+                Camera {
+                    // Bump the order to render on top of the world model.
+                    order: 1,
+                    ..default()
+                },
+                Projection::from(PerspectiveProjection {
+                    fov: 70.0_f32.to_radians(),
+                    ..default()
+                }),
+                // Only render objects belonging to the view model.
+                RenderLayers::layer(VIEW_MODEL_RENDER_LAYER),
+            ));
+
+            // Spawn the player's right arm.
+            parent.spawn((
+                Mesh3d(arm),
+                MeshMaterial3d(arm_material),
+                Transform::from_xyz(0.2, -0.1, -0.25),
+                // Ensure the arm is only rendered by the view model camera.
+                RenderLayers::layer(VIEW_MODEL_RENDER_LAYER),
+                // The arm is free-floating, so shadows would look weird.
+                NotShadowCaster,
+            ));
+        });
+}
+
+fn spawn_world_model(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+) {
+    let floor = meshes.add(Plane3d::new(Vec3::Y, Vec2::splat(10.0)));
+    let cube = meshes.add(Cuboid::new(2.0, 0.5, 1.0));
+    let material = materials.add(Color::WHITE);
+
+    // The world model camera will render the floor and the cubes spawned in this system.
+    // Assigning no `RenderLayers` component defaults to layer 0.
+
+    commands.spawn((Mesh3d(floor), MeshMaterial3d(material.clone())));
+
+    commands.spawn((
+        Mesh3d(cube.clone()),
+        MeshMaterial3d(material.clone()),
+        Transform::from_xyz(0.0, 0.25, -3.0),
+    ));
+
+    commands.spawn((
+        Mesh3d(cube),
+        MeshMaterial3d(material),
+        Transform::from_xyz(0.75, 1.75, 0.0),
+    ));
+}
+
+fn spawn_lights(mut commands: Commands) {
+    commands.spawn((
+        PointLight {
+            color: Color::from(tailwind::ROSE_300),
+            shadows_enabled: true,
+            ..default()
+        },
+        Transform::from_xyz(-2.0, 4.0, -0.75),
+        // The light source illuminates both the world model and the view model.
+        RenderLayers::from_layers(&[DEFAULT_RENDER_LAYER, VIEW_MODEL_RENDER_LAYER]),
+    ));
+}
+
+fn spawn_text(mut commands: Commands) {
+    commands
+        .spawn(Node {
+            position_type: PositionType::Absolute,
+            bottom: Val::Px(12.0),
+            left: Val::Px(12.0),
+            ..default()
+        })
+        .with_child(Text::new(concat!(
+            "Move the camera with your mouse.\n",
+            "Press arrow up to decrease the FOV of the world model.\n",
+            "Press arrow down to increase the FOV of the world model."
+        )));
+}
+
+fn move_player(
+    accumulated_mouse_motion: Res<AccumulatedMouseMotion>,
+    player: Single<(&mut Transform, &CameraSensitivity), With<Player>>,
+) {
+    let (mut transform, camera_sensitivity) = player.into_inner();
+
+    let delta = accumulated_mouse_motion.delta;
+
+    if delta != Vec2::ZERO {
+        // Note that we are not multiplying by delta_time here.
+        // The reason is that for mouse movement, we already get the full movement that happened since the last frame.
+        // This means that if we multiply by delta_time, we will get a smaller rotation than intended by the user.
+        // This situation is reversed when reading e.g. analog input from a gamepad however, where the same rules
+        // as for keyboard input apply. Such an input should be multiplied by delta_time to get the intended rotation
+        // independent of the framerate.
+        let delta_yaw = -delta.x * camera_sensitivity.x;
+        let delta_pitch = -delta.y * camera_sensitivity.y;
+
+        let (yaw, pitch, roll) = transform.rotation.to_euler(EulerRot::YXZ);
+        let yaw = yaw + delta_yaw;
+
+        // If the pitch was ±¹⁄₂ π, the camera would look straight up or down.
+        // When the user wants to move the camera back to the horizon, which way should the camera face?
+        // The camera has no way of knowing what direction was "forward" before landing in that extreme position,
+        // so the direction picked will for all intents and purposes be arbitrary.
+        // Another issue is that for mathematical reasons, the yaw will effectively be flipped when the pitch is at the extremes.
+        // To not run into these issues, we clamp the pitch to a safe range.
+        const PITCH_LIMIT: f32 = FRAC_PI_2 - 0.01;
+        let pitch = (pitch + delta_pitch).clamp(-PITCH_LIMIT, PITCH_LIMIT);
+
+        transform.rotation = Quat::from_euler(EulerRot::YXZ, yaw, pitch, roll);
+    }
+}
+
+fn change_fov(
+    input: Res<ButtonInput<KeyCode>>,
+    mut world_model_projection: Single<&mut Projection, With<WorldModelCamera>>,
+) {
+    let Projection::Perspective(perspective) = world_model_projection.as_mut() else {
+        unreachable!(
+            "The `Projection` component was explicitly built with `Projection::Perspective`"
+        );
+    };
+
+    if input.pressed(KeyCode::ArrowUp) {
+        perspective.fov -= 1.0_f32.to_radians();
+        perspective.fov = perspective.fov.max(20.0_f32.to_radians());
+    }
+    if input.pressed(KeyCode::ArrowDown) {
+        perspective.fov += 1.0_f32.to_radians();
+        perspective.fov = perspective.fov.min(160.0_f32.to_radians());
+    }
+}

vendor/bevy/examples/camera/projection_zoom.rs

@@ -0,0 +1,168 @@
+//! Shows how to zoom orthographic and perspective projection cameras.
+
+use std::{f32::consts::PI, ops::Range};
+
+use bevy::{input::mouse::AccumulatedMouseScroll, prelude::*, render::camera::ScalingMode};
+
+#[derive(Debug, Resource)]
+struct CameraSettings {
+    /// The height of the viewport in world units when the orthographic camera's scale is 1
+    pub orthographic_viewport_height: f32,
+    /// Clamp the orthographic camera's scale to this range
+    pub orthographic_zoom_range: Range<f32>,
+    /// Multiply mouse wheel inputs by this factor when using the orthographic camera
+    pub orthographic_zoom_speed: f32,
+    /// Clamp perspective camera's field of view to this range
+    pub perspective_zoom_range: Range<f32>,
+    /// Multiply mouse wheel inputs by this factor when using the perspective camera
+    pub perspective_zoom_speed: f32,
+}
+
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins)
+        .insert_resource(CameraSettings {
+            orthographic_viewport_height: 5.,
+            // In orthographic projections, we specify camera scale relative to a default value of 1,
+            // in which one unit in world space corresponds to one pixel.
+            orthographic_zoom_range: 0.1..10.0,
+            // This value was hand-tuned to ensure that zooming in and out feels smooth but not slow.
+            orthographic_zoom_speed: 0.2,
+            // Perspective projections use field of view, expressed in radians. We would
+            // normally not set it to more than π, which represents a 180° FOV.
+            perspective_zoom_range: (PI / 5.)..(PI - 0.2),
+            // Changes in FOV are much more noticeable due to its limited range in radians
+            perspective_zoom_speed: 0.05,
+        })
+        .add_systems(Startup, (setup, instructions))
+        .add_systems(Update, (switch_projection, zoom))
+        .run();
+}
+
+/// Set up a simple 3D scene
+fn setup(
+    asset_server: Res<AssetServer>,
+    camera_settings: Res<CameraSettings>,
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+) {
+    commands.spawn((
+        Name::new("Camera"),
+        Camera3d::default(),
+        Projection::from(OrthographicProjection {
+            // We can set the scaling mode to FixedVertical to keep the viewport height constant as its aspect ratio changes.
+            // The viewport height is the height of the camera's view in world units when the scale is 1.
+            scaling_mode: ScalingMode::FixedVertical {
+                viewport_height: camera_settings.orthographic_viewport_height,
+            },
+            // This is the default value for scale for orthographic projections.
+            // To zoom in and out, change this value, rather than `ScalingMode` or the camera's position.
+            scale: 1.,
+            ..OrthographicProjection::default_3d()
+        }),
+        Transform::from_xyz(5.0, 5.0, 5.0).looking_at(Vec3::ZERO, Vec3::Y),
+    ));
+
+    commands.spawn((
+        Name::new("Plane"),
+        Mesh3d(meshes.add(Plane3d::default().mesh().size(5.0, 5.0))),
+        MeshMaterial3d(materials.add(StandardMaterial {
+            base_color: Color::srgb(0.3, 0.5, 0.3),
+            // Turning off culling keeps the plane visible when viewed from beneath.
+            cull_mode: None,
+            ..default()
+        })),
+    ));
+
+    commands.spawn((
+        Name::new("Fox"),
+        SceneRoot(
+            asset_server.load(GltfAssetLabel::Scene(0).from_asset("models/animated/Fox.glb")),
+        ),
+        // Note: the scale adjustment is purely an accident of our fox model, which renders
+        // HUGE unless mitigated!
+        Transform::from_translation(Vec3::splat(0.0)).with_scale(Vec3::splat(0.025)),
+    ));
+
+    commands.spawn((
+        Name::new("Light"),
+        PointLight::default(),
+        Transform::from_xyz(3.0, 8.0, 5.0),
+    ));
+}
+
+fn instructions(mut commands: Commands) {
+    commands.spawn((
+        Name::new("Instructions"),
+        Text::new(
+            "Scroll mouse wheel to zoom in/out\n\
+            Space: switch between orthographic and perspective projections",
+        ),
+        Node {
+            position_type: PositionType::Absolute,
+            top: Val::Px(12.),
+            left: Val::Px(12.),
+            ..default()
+        },
+    ));
+}
+
+fn switch_projection(
+    mut camera: Single<&mut Projection, With<Camera>>,
+    camera_settings: Res<CameraSettings>,
+    keyboard_input: Res<ButtonInput<KeyCode>>,
+) {
+    if keyboard_input.just_pressed(KeyCode::Space) {
+        // Switch projection type
+        **camera = match **camera {
+            Projection::Orthographic(_) => Projection::Perspective(PerspectiveProjection {
+                fov: camera_settings.perspective_zoom_range.start,
+                ..default()
+            }),
+            Projection::Perspective(_) => Projection::Orthographic(OrthographicProjection {
+                scaling_mode: ScalingMode::FixedVertical {
+                    viewport_height: camera_settings.orthographic_viewport_height,
+                },
+                ..OrthographicProjection::default_3d()
+            }),
+            _ => return,
+        }
+    }
+}
+
+fn zoom(
+    camera: Single<&mut Projection, With<Camera>>,
+    camera_settings: Res<CameraSettings>,
+    mouse_wheel_input: Res<AccumulatedMouseScroll>,
+) {
+    // Usually, you won't need to handle both types of projection,
+    // but doing so makes for a more complete example.
+    match *camera.into_inner() {
+        Projection::Orthographic(ref mut orthographic) => {
+            // We want scrolling up to zoom in, decreasing the scale, so we negate the delta.
+            let delta_zoom = -mouse_wheel_input.delta.y * camera_settings.orthographic_zoom_speed;
+            // When changing scales, logarithmic changes are more intuitive.
+            // To get this effect, we add 1 to the delta, so that a delta of 0
+            // results in no multiplicative effect, positive values result in a multiplicative increase,
+            // and negative values result in multiplicative decreases.
+            let multiplicative_zoom = 1. + delta_zoom;
+
+            orthographic.scale = (orthographic.scale * multiplicative_zoom).clamp(
+                camera_settings.orthographic_zoom_range.start,
+                camera_settings.orthographic_zoom_range.end,
+            );
+        }
+        Projection::Perspective(ref mut perspective) => {
+            // We want scrolling up to zoom in, decreasing the scale, so we negate the delta.
+            let delta_zoom = -mouse_wheel_input.delta.y * camera_settings.perspective_zoom_speed;
+
+            // Adjust the field of view, but keep it within our stated range.
+            perspective.fov = (perspective.fov + delta_zoom).clamp(
+                camera_settings.perspective_zoom_range.start,
+                camera_settings.perspective_zoom_range.end,
+            );
+        }
+        _ => (),
+    }
+}