smooth-bevy-cameras

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