#camera #bevy #smoothing #exponential #controller #transform #look-transform

dev smooth-bevy-cameras

Bevy camera controllers with buttery, exponential smoothing

10 breaking releases

0.11.0 Feb 19, 2024
0.10.0 Nov 4, 2023
0.9.0 Aug 4, 2023
0.8.0 Mar 11, 2023
0.2.0 Jan 10, 2022

#81 in Game dev

Download history 377/week @ 2024-03-01 455/week @ 2024-03-08 568/week @ 2024-03-15 481/week @ 2024-03-22 457/week @ 2024-03-29 495/week @ 2024-04-05 289/week @ 2024-04-12 457/week @ 2024-04-19 350/week @ 2024-04-26 196/week @ 2024-05-03 189/week @ 2024-05-10 232/week @ 2024-05-17 337/week @ 2024-05-24 269/week @ 2024-05-31 160/week @ 2024-06-07 198/week @ 2024-06-14

1,025 downloads per month
Used in 13 crates

MIT license

41KB
779 lines

smooth-bevy-cameras

crates.io docs.rs

A collection of exponentially-smoothed camera controllers for the Bevy Engine.

Look Transform

All controllers are based on a LookTransform component, which is just an eye point that looks at a target point. By modifying this component, the scene graph Transform will automatically be synchronized.

Any entities with all of Transform, LookTransform, and Smoother components will automatically have their Transform smoothed. Smoothing will have no effect on the LookTransform, only the final Transform in the scene graph.

use bevy::prelude::*;
use smooth_bevy_cameras::{LookTransform, LookTransformBundle, LookTransformPlugin, Smoother};

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        // Enables the system that synchronizes your `Transform`s and `LookTransform`s.
        .add_plugin(LookTransformPlugin)
        .add_startup_system(setup)
        .add_system(move_camera_system);
}

fn setup(mut commands: Commands) {
    let eye = Vec3::default();
    let target = Vec3::default();

    commands
        .spawn(LookTransformBundle {
            transform: LookTransform::new(eye, target),
            smoother: Smoother::new(0.9), // Value between 0.0 and 1.0, higher is smoother.
        })
        .insert_bundle(Camera3dBundle::default());

}

fn move_camera_system(mut cameras: Query<&mut LookTransform>) {
    // Later, another system will update the `Transform` and apply smoothing automatically.
    for mut c in cameras.iter_mut() { c.target += Vec3::new(1.0, 1.0, 1.0); }
}

Look Angles

When implementing a camera controller, it's often useful to work directly with the angles (pitch and yaw) of your look direction. You can do this with the LookAngles type:

use bevy::prelude::*;
use smooth_bevy_cameras::{
    LookAngles,
    LookTransform
};

fn look_angles(mut transform: LookTransform, delta: Vec2) {
    let mut angles = LookAngles::from_vector(transform.look_direction().unwrap());
    angles.add_pitch(delta.y);
    angles.add_yaw(delta.x);
    // Third-person.
    transform.eye = transform.target + 1.0 * transform.radius() * angles.unit_vector();
    // First-person.
    // transform.target = transform.eye + 1.0 * transform.radius() * angles.unit_vector();
}

This is how the built-in controllers implement rotation controls.

Built-In Controllers

These plugins depend on the LookTransformPlugin:

  • FpsCameraPlugin + FpsCameraBundle

    • WASD: Translate on the XZ plane
    • Shift/Space: Translate along the Y axis
    • Mouse: Rotate camera
  • OrbitCameraPlugin + OrbitCameraBundle

    • CTRL + mouse drag: Rotate camera
    • Right mouse drag: Pan camera
    • Mouse wheel: Zoom
  • UnrealCameraPlugin + UnrealCameraBundle

    Best use: hold Right mouse button to orbit the view while using WASD to navigate in the scene, using scroll wheel to accelerate/decelerate.

    • Left mouse drag: Locomotion
    • Right mouse drag: Rotate camera
    • Left and Right or Middle mouse drag: Pan camera
    • While holding any mouse button, use A/D for panning left/right, Q/E for panning up/down
    • While holding any mouse button, use W/S for locomotion forward/backward
    • While holding any mouse button, use scroll wheel to increase/decrease locomotion and panning speeds
    • While holding no mouse button, use scroll wheel for locomotion forward/backward

License: MIT

Dependencies

~18–46MB
~706K SLoC