mirror of
https://github.com/bevyengine/bevy
synced 2024-12-24 03:53:06 +00:00
25bfa80e60
# Objective Yet another PR for migrating stuff to required components. This time, cameras! ## Solution As per the [selected proposal](https://hackmd.io/tsYID4CGRiWxzsgawzxG_g#Combined-Proposal-1-Selected), deprecate `Camera2dBundle` and `Camera3dBundle` in favor of `Camera2d` and `Camera3d`. Adding a `Camera` without `Camera2d` or `Camera3d` now logs a warning, as suggested by Cart [on Discord](https://discord.com/channels/691052431525675048/1264881140007702558/1291506402832945273). I would personally like cameras to work a bit differently and be split into a few more components, to avoid some footguns and confusing semantics, but that is more controversial, and shouldn't block this core migration. ## Testing I ran a few 2D and 3D examples, and tried cameras with and without render graphs. --- ## Migration Guide `Camera2dBundle` and `Camera3dBundle` have been deprecated in favor of `Camera2d` and `Camera3d`. Inserting them will now also insert the other components required by them automatically.
156 lines
5.1 KiB
Rust
156 lines
5.1 KiB
Rust
//! 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"),
|
|
NodeBundle {
|
|
style: Style {
|
|
align_items: AlignItems::Start,
|
|
flex_direction: FlexDirection::Column,
|
|
justify_content: JustifyContent::Start,
|
|
width: Val::Percent(100.),
|
|
..default()
|
|
},
|
|
..default()
|
|
},
|
|
))
|
|
.with_children(|parent| {
|
|
parent.spawn(TextBundle::from_section(
|
|
"Mouse up or down: pitch",
|
|
TextStyle::default(),
|
|
));
|
|
parent.spawn(TextBundle::from_section(
|
|
"Mouse left or right: yaw",
|
|
TextStyle::default(),
|
|
));
|
|
parent.spawn(TextBundle::from_section(
|
|
"Mouse buttons: roll",
|
|
TextStyle::default(),
|
|
));
|
|
});
|
|
}
|
|
|
|
fn orbit(
|
|
mut camera: Query<&mut Transform, With<Camera>>,
|
|
camera_settings: Res<CameraSettings>,
|
|
mouse_buttons: Res<ButtonInput<MouseButton>>,
|
|
mouse_motion: Res<AccumulatedMouseMotion>,
|
|
time: Res<Time>,
|
|
) {
|
|
let mut transform = camera.single_mut();
|
|
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_seconds();
|
|
|
|
// Obtain the existing pitch, yaw, and roll values from the transform.
|
|
let (yaw, pitch, roll) = 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_settings.pitch_range.start,
|
|
camera_settings.pitch_range.end,
|
|
);
|
|
let roll = roll + delta_roll;
|
|
let yaw = yaw + delta_yaw;
|
|
transform.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 customised.
|
|
let target = Vec3::ZERO;
|
|
transform.translation = target - transform.forward() * camera_settings.orbit_distance;
|
|
}
|