use crate::{Camera, LookAngles};
use viewport_lib_types::camera::{CameraTarget, Pose};
use crate::input::action::Action;
use crate::input::action_frame::ActionFrame;
use crate::input::context::ViewportContext;
use crate::input::event::ViewportEvent;
use crate::input::mode::NavigationMode;
use crate::input::preset::{BindingPreset, preset_bindings};
use crate::input::viewport_binding::ViewportBinding;
use crate::input::viewport_input::ViewportInput;
use super::movement::wish_from_actions;
pub struct OrbitCameraController {
input: ViewportInput,
pub navigation_mode: NavigationMode,
pub fly_speed: f32,
pub fly_boost: f32,
pub orbit_sensitivity: f32,
pub zoom_sensitivity: f32,
pub gesture_sensitivity: f32,
viewport_size: [f32; 2],
pivot: Option<CameraTarget>,
written: Option<(Pose, f32)>,
}
impl OrbitCameraController {
pub const DEFAULT_ORBIT_SENSITIVITY: f32 = 0.005;
pub const DEFAULT_ZOOM_SENSITIVITY: f32 = 0.001;
pub const DEFAULT_GESTURE_SENSITIVITY: f32 = 1.0;
pub const DEFAULT_FLY_SPEED: f32 = 6.0;
pub const DEFAULT_FLY_BOOST: f32 = 3.0;
pub fn new_stateless() -> Self {
Self::from_bindings(Vec::new())
}
pub fn new(preset: BindingPreset) -> Self {
Self::from_bindings(preset_bindings(preset))
}
fn from_bindings(bindings: Vec<ViewportBinding>) -> Self {
Self {
input: ViewportInput::new(bindings),
navigation_mode: NavigationMode::Arcball,
fly_speed: Self::DEFAULT_FLY_SPEED,
fly_boost: Self::DEFAULT_FLY_BOOST,
orbit_sensitivity: Self::DEFAULT_ORBIT_SENSITIVITY,
zoom_sensitivity: Self::DEFAULT_ZOOM_SENSITIVITY,
gesture_sensitivity: Self::DEFAULT_GESTURE_SENSITIVITY,
viewport_size: [1.0, 1.0],
pivot: None,
written: None,
}
}
pub fn viewer() -> Self {
Self::new(BindingPreset::Viewer)
}
#[deprecated(
note = "renamed: use OrbitCameraController::viewer, or new_stateless if the host owns the resolver"
)]
pub fn viewport_primitives() -> Self {
Self::new(BindingPreset::Viewer)
}
#[deprecated(
note = "renamed: use OrbitCameraController::new_stateless if a session or host owns the resolver, or new(BindingPreset::Default) for the standalone path"
)]
pub fn viewport_all() -> Self {
Self::new(BindingPreset::Default)
}
pub fn begin_frame(&mut self, ctx: ViewportContext) {
self.viewport_size = ctx.viewport_size;
self.input.begin_frame(ctx);
}
pub fn set_viewport_size(&mut self, viewport_size: [f32; 2]) {
self.viewport_size = viewport_size;
}
#[deprecated(
note = "own a ViewportInput and use OrbitCameraController::apply(&mut camera, &frame, dt)"
)]
pub fn push_event(&mut self, event: ViewportEvent) {
self.input.push_event(event);
}
pub fn resolve(&self) -> ActionFrame {
self.input.resolve()
}
#[deprecated(
note = "own a ViewportInput and use OrbitCameraController::apply(&mut camera, &frame, dt)"
)]
pub fn apply_to_camera(&mut self, camera: &mut Camera) -> ActionFrame {
let frame = self.input.resolve();
self.apply(camera, &frame, 1.0 / 60.0);
frame
}
pub fn orbit_by(&mut self, camera: &mut Camera, delta: glam::Vec2) {
if delta == glam::Vec2::ZERO {
return;
}
let mut target = self.pivot(camera);
self.orbit_target_by(&mut target, delta);
self.write(camera, target);
}
pub fn target(&self) -> Option<CameraTarget> {
self.pivot
}
pub fn sync_from_camera(&mut self, camera: &Camera) {
self.pivot = Some(camera.orbit_target());
self.written = Some((camera.pose, camera.focus_distance()));
}
fn pivot(&mut self, camera: &Camera) -> CameraTarget {
let current = (camera.pose, camera.focus_distance());
match self.pivot {
Some(pivot) if self.written == Some(current) => pivot,
_ => {
self.sync_from_camera(camera);
camera.orbit_target()
}
}
}
fn write(&mut self, camera: &mut Camera, target: CameraTarget) {
camera.set_orbit_target(target);
self.pivot = Some(target);
self.written = Some((camera.pose, camera.focus_distance()));
}
fn orbit_target_by(&self, target: &mut CameraTarget, delta: glam::Vec2) {
if delta == glam::Vec2::ZERO {
return;
}
let yaw = delta.x * self.orbit_sensitivity;
let pitch = delta.y * self.orbit_sensitivity;
orbit_in_mode(target, self.navigation_mode, yaw, pitch);
}
pub fn apply(&mut self, camera: &mut Camera, frame: &ActionFrame, dt: f32) {
let nav = &frame.navigation;
let h = self.viewport_size[1];
let start = self.pivot(camera);
let mut t = start;
let gesture = nav.twist * self.gesture_sensitivity;
let pan = |t: &mut CameraTarget| {
if nav.pan != glam::Vec2::ZERO {
let scale = camera.view_height_at(t.distance) / h.max(1.0);
t.pan_world(nav.pan.x * scale, nav.pan.y * scale);
}
};
let zoom = |t: &mut CameraTarget| {
if nav.zoom != 0.0 {
t.zoom_by_factor(1.0 - nav.zoom * self.zoom_sensitivity);
}
};
match self.navigation_mode {
NavigationMode::Arcball => {
self.orbit_target_by(&mut t, nav.orbit);
if gesture != 0.0 {
t.orbit(gesture, 0.0);
}
pan(&mut t);
zoom(&mut t);
}
NavigationMode::Turntable => {
self.orbit_target_by(&mut t, nav.orbit);
if gesture != 0.0 {
apply_turntable(&mut t, gesture, 0.0);
}
pan(&mut t);
zoom(&mut t);
}
NavigationMode::Planar => {
pan(&mut t);
zoom(&mut t);
}
NavigationMode::Fly => {
self.orbit_target_by(&mut t, nav.orbit);
if gesture != 0.0 {
apply_fly_look(&mut t, gesture, 0.0);
}
let q = t.orientation;
let forward = -(q * glam::Vec3::Z);
let wish = wish_from_actions(frame, forward, q * glam::Vec3::X, q * glam::Vec3::Y);
let speed = if frame.is_active(Action::FlySpeedBoost) {
self.fly_speed * self.fly_boost
} else {
self.fly_speed
};
t.centre += (wish * speed * dt).as_dvec3();
}
_ => {}
}
if t != start {
self.write(camera, t);
}
}
}
const POLE_LIMIT: f32 = 89.0 * std::f32::consts::PI / 180.0;
pub(crate) fn orbit_in_mode(target: &mut CameraTarget, mode: NavigationMode, yaw: f32, pitch: f32) {
match mode {
NavigationMode::Arcball => target.orbit(yaw, pitch),
NavigationMode::Turntable => apply_turntable(target, yaw, pitch),
NavigationMode::Fly => apply_fly_look(target, yaw, pitch),
_ => {}
}
}
fn apply_turntable(view: &mut CameraTarget, yaw: f32, pitch: f32) {
if yaw != 0.0 {
view.orientation = (glam::Quat::from_rotation_z(-yaw) * view.orientation).normalize();
}
if pitch != 0.0 {
let elevation = |q: glam::Quat| (q * glam::Vec3::Z).z.clamp(-1.0, 1.0).asin();
let pitched =
|amount: f32| (view.orientation * glam::Quat::from_rotation_x(-amount)).normalize();
const PROBE: f32 = 1e-3;
let current = elevation(view.orientation);
let rate = (elevation(pitched(PROBE)) - current) / PROBE;
if rate.abs() < 1e-3 {
view.orientation = pitched(pitch);
return;
}
let target = current + rate * pitch;
if target.abs() <= POLE_LIMIT {
view.orientation = pitched(pitch);
} else if target.abs() > current.abs() && current.abs() >= POLE_LIMIT {
} else {
view.orientation = pitched((POLE_LIMIT.copysign(target) - current) / rate);
}
}
}
fn apply_fly_look(view: &mut CameraTarget, yaw: f32, pitch: f32) {
let eye = view.eye();
let look = LookAngles::from_orientation(view.orientation)
.turned(yaw, -pitch)
.with_pitch_clamped(-POLE_LIMIT, POLE_LIMIT);
view.orientation = look.orientation();
view.centre = eye + (look.direction() * view.distance).as_dvec3();
}
#[cfg(test)]
mod tests {
use super::*;
use crate::input::binding::KeyCode;
use glam::DVec3;
fn camera_facing(orientation: glam::Quat) -> Camera {
Camera::orbit(DVec3::ZERO, 5.0, orientation)
}
fn default_target() -> CameraTarget {
Camera::default().orbit_target()
}
use crate::input::event::{ButtonState, ScrollUnits, ViewportEvent};
fn make_ctx() -> ViewportContext {
ViewportContext::new(crate::input::InputOwnership::full_window(), [800.0, 600.0])
}
#[test]
fn new_defaults() {
let ctrl = OrbitCameraController::viewport_primitives();
assert_eq!(ctrl.navigation_mode, NavigationMode::Arcball);
assert!((ctrl.fly_speed - OrbitCameraController::DEFAULT_FLY_SPEED).abs() < 1e-6);
assert!(
(ctrl.orbit_sensitivity - OrbitCameraController::DEFAULT_ORBIT_SENSITIVITY).abs()
< 1e-6
);
}
#[test]
fn resolve_no_events_zero_nav() {
let mut ctrl = OrbitCameraController::new(BindingPreset::Default);
ctrl.begin_frame(make_ctx());
let frame = ctrl.resolve();
assert_eq!(frame.navigation.orbit, glam::Vec2::ZERO);
assert_eq!(frame.navigation.pan, glam::Vec2::ZERO);
assert_eq!(frame.navigation.zoom, 0.0);
}
#[test]
fn apply_zoom_changes_distance() {
let mut ctrl = OrbitCameraController::viewport_primitives();
ctrl.begin_frame(make_ctx());
let mut cam = Camera::default();
let d0 = cam.focus_distance();
ctrl.push_event(ViewportEvent::Wheel {
delta: glam::Vec2::new(0.0, 100.0),
units: ScrollUnits::Pixels,
});
ctrl.apply_to_camera(&mut cam);
assert!(
(cam.focus_distance() - d0).abs() > 1e-4,
"zoom should change camera distance"
);
}
#[test]
fn orbit_by_matches_a_drag_in_every_mode() {
let delta = glam::Vec2::new(37.0, -21.0);
let mut frame = ActionFrame::default();
frame.navigation.orbit = delta;
let start =
|| camera_facing(glam::Quat::from_rotation_z(0.7) * glam::Quat::from_rotation_x(0.9));
for mode in [
NavigationMode::Arcball,
NavigationMode::Turntable,
NavigationMode::Fly,
NavigationMode::Planar,
] {
let mut ctrl = OrbitCameraController::viewer();
ctrl.navigation_mode = mode;
let mut by_drag = start();
ctrl.apply(&mut by_drag, &frame, 1.0 / 60.0);
let mut by_call = start();
ctrl.orbit_by(&mut by_call, delta);
assert!(
by_drag.orientation().angle_between(by_call.orientation()) < 1e-5,
"{mode:?}: orientation differs"
);
assert!(
(by_drag.target() - by_call.target()).length() < 1e-4,
"{mode:?}: centre differs"
);
match mode {
NavigationMode::Planar => assert_eq!(by_call.orientation(), start().orientation()),
NavigationMode::Fly => {
assert!((by_call.target() - start().target()).length() > 1e-3)
}
_ => assert!(by_call.orientation().angle_between(start().orientation()) > 1e-3),
}
}
}
#[test]
fn planar_mode_ignores_orbit() {
let mut ctrl = OrbitCameraController::viewport_primitives();
ctrl.navigation_mode = NavigationMode::Planar;
ctrl.begin_frame(make_ctx());
let mut cam = Camera::default();
let orient_before = cam.orientation();
ctrl.push_event(ViewportEvent::PointerMoved {
position: glam::Vec2::new(100.0, 100.0),
});
ctrl.push_event(ViewportEvent::MouseButton {
button: crate::input::binding::MouseButton::Left,
state: ButtonState::Pressed,
});
ctrl.push_event(ViewportEvent::PointerMoved {
position: glam::Vec2::new(200.0, 200.0),
});
ctrl.apply_to_camera(&mut cam);
let after = cam.orientation();
assert!(
(after.x - orient_before.x).abs() < 1e-6
&& (after.y - orient_before.y).abs() < 1e-6
&& (after.z - orient_before.z).abs() < 1e-6
&& (after.w - orient_before.w).abs() < 1e-6,
"planar mode should not change orientation"
);
}
#[test]
fn turntable_pitch_clamped() {
let mut cam = default_target();
for _ in 0..1000 {
apply_turntable(&mut cam, 0.0, 0.1);
}
let eye_z = (cam.orientation * glam::Vec3::Z).z;
let max_sin = 89.0_f32.to_radians().sin();
assert!(
eye_z.abs() <= max_sin + 1e-4,
"turntable pitch should be clamped: eye_z={eye_z}"
);
}
#[test]
fn fly_look_preserves_eye() {
let mut cam = default_target();
let eye_before = cam.eye();
apply_fly_look(&mut cam, 0.3, 0.2);
let eye_after = cam.eye();
let diff = (eye_after - eye_before).length();
assert!(
diff < 1e-3,
"firstperson look should preserve eye position, diff={diff}"
);
}
#[test]
fn fly_moves_camera() {
let mut ctrl = OrbitCameraController::new(BindingPreset::Default);
ctrl.navigation_mode = NavigationMode::Fly;
ctrl.fly_speed = 60.0;
ctrl.begin_frame(make_ctx());
let mut cam = camera_facing(glam::Quat::IDENTITY);
let centre_before = cam.target();
ctrl.push_event(ViewportEvent::Key {
key: KeyCode::W,
state: ButtonState::Pressed,
repeat: false,
logical: None,
});
ctrl.apply_to_camera(&mut cam);
assert!(
(cam.target() - centre_before).length() > 0.5,
"FlyForward should move camera centre"
);
}
#[test]
fn apply_consumes_external_frame() {
let mut ctrl = OrbitCameraController::viewport_primitives();
let mut cam = Camera::default();
let before = cam.orientation();
let mut frame = ActionFrame::default();
frame.navigation.orbit = glam::Vec2::new(20.0, 0.0);
ctrl.apply(&mut cam, &frame, 1.0 / 60.0);
assert_ne!(
cam.orientation(),
before,
"apply(&frame) should orbit from the frame's nav delta"
);
}
#[test]
fn pivot_follows_a_camera_moved_elsewhere() {
let mut ctrl = OrbitCameraController::new_stateless();
let mut cam = Camera::default();
let mut frame = ActionFrame::default();
frame.navigation.orbit = glam::Vec2::new(10.0, 0.0);
ctrl.apply(&mut cam, &frame, 1.0 / 60.0);
assert_eq!(ctrl.target().unwrap().centre, DVec3::ZERO);
let centre = DVec3::new(10.0, -3.0, 2.0);
cam = Camera::orbit(centre, 4.0, cam.orientation());
ctrl.apply(&mut cam, &frame, 1.0 / 60.0);
assert!((cam.target() - centre).length() < 1e-4);
assert_eq!(cam.focus_distance(), 4.0);
assert_eq!(ctrl.target().unwrap().centre, centre);
}
#[test]
fn no_input_leaves_the_camera_alone() {
let mut ctrl = OrbitCameraController::new_stateless();
let mut cam = Camera::default();
cam.set_orthographic(true);
let before = cam.clone();
ctrl.apply(&mut cam, &ActionFrame::default(), 1.0 / 60.0);
assert_eq!(cam, before);
}
#[test]
fn zoom_scales_an_orthographic_view() {
let mut ctrl = OrbitCameraController::new_stateless();
let mut cam = Camera::default();
cam.set_orthographic(true);
let height = cam.view_height_at(1.0);
let mut frame = ActionFrame::default();
frame.navigation.zoom = 500.0;
ctrl.apply(&mut cam, &frame, 1.0 / 60.0);
let ratio = cam.focus_distance() / 5.0;
assert!(ratio < 1.0);
assert!((cam.view_height_at(1.0) - height * ratio).abs() < 1e-4);
}
fn fly_frame(actions: &[Action]) -> ActionFrame {
let mut frame = ActionFrame::default();
for &a in actions {
frame
.actions
.insert(a, crate::input::action_frame::ResolvedActionState::Held);
}
frame
}
fn fly_controller() -> OrbitCameraController {
let mut ctrl = OrbitCameraController::new_stateless();
ctrl.navigation_mode = NavigationMode::Fly;
ctrl.fly_speed = 1.0;
ctrl
}
#[test]
fn fly_diagonal_moves_as_far_as_straight() {
let mut ctrl = fly_controller();
let level = LookAngles::FORWARD.orientation();
let mut moved = |actions: &[Action]| {
let mut cam = camera_facing(level);
let before = cam.target();
ctrl.apply(&mut cam, &fly_frame(actions), 1.0);
(cam.target() - before).length()
};
let straight = moved(&[Action::FlyForward]);
let diagonal = moved(&[Action::FlyForward, Action::FlyRight]);
let three = moved(&[Action::FlyForward, Action::FlyRight, Action::FlyUp]);
assert!((straight - 1.0).abs() < 1e-5);
assert!((diagonal - straight).abs() < 1e-5, "diagonal={diagonal}");
assert!((three - straight).abs() < 1e-5, "three axes={three}");
}
#[test]
fn fly_look_stops_short_of_vertical() {
let mut cam = default_target();
cam.orientation = LookAngles::FORWARD.orientation();
for _ in 0..200 {
apply_fly_look(&mut cam, 0.0, -0.1);
}
let look = LookAngles::from_orientation(cam.orientation);
assert!(
(look.pitch - POLE_LIMIT).abs() < 1e-3,
"pitch={}",
look.pitch
);
assert!((cam.orientation * glam::Vec3::X).z.abs() < 1e-4);
}
#[test]
fn fly_look_matches_the_old_turn_directions() {
let mut cam = default_target();
cam.orientation = LookAngles::FORWARD.orientation();
apply_fly_look(&mut cam, 0.2, 0.1);
let look = LookAngles::from_orientation(cam.orientation);
assert!(look.yaw > 0.0 && look.pitch < 0.0, "{look:?}");
}
#[test]
fn turntable_fast_step_reaches_the_limit() {
let mut cam = default_target();
cam.orientation = LookAngles::FORWARD.orientation();
apply_turntable(&mut cam, 0.0, 2.0);
let eye_elevation = (cam.orientation * glam::Vec3::Z).z.asin();
assert!(
(eye_elevation.abs() - POLE_LIMIT).abs() < 1e-3,
"elevation={eye_elevation}"
);
}
#[test]
fn turntable_can_back_away_from_past_the_limit() {
let mut cam = default_target();
cam.orientation = LookAngles::new(0.0, -1.565).orientation();
let before = (cam.orientation * glam::Vec3::Z).z;
apply_turntable(&mut cam, 0.0, 0.01);
assert!(((cam.orientation * glam::Vec3::Z).z - before).abs() < 1e-6);
apply_turntable(&mut cam, 0.0, -0.01);
let after = (cam.orientation * glam::Vec3::Z).z;
assert!(after < before, "before={before} after={after}");
}
#[test]
fn fly_speed_is_per_second() {
let mut ctrl = fly_controller();
let mut moved = |dt: f32, frames: usize| {
let mut cam = camera_facing(LookAngles::FORWARD.orientation());
let before = cam.target();
for _ in 0..frames {
ctrl.apply(&mut cam, &fly_frame(&[Action::FlyForward]), dt);
}
(cam.target() - before).length()
};
for (dt, frames) in [(1.0 / 30.0, 30), (1.0 / 60.0, 60), (1.0 / 144.0, 144)] {
assert!((moved(dt, frames) - 1.0).abs() < 1e-3, "dt={dt}");
}
}
#[test]
fn fly_boost_multiplies_speed() {
let mut ctrl = fly_controller();
let mut cam = camera_facing(LookAngles::FORWARD.orientation());
let before = cam.target();
ctrl.apply(
&mut cam,
&fly_frame(&[Action::FlyForward, Action::FlySpeedBoost]),
1.0,
);
let moved = (cam.target() - before).length();
assert!(
(moved - f64::from(ctrl.fly_boost)).abs() < 1e-5,
"moved={moved}"
);
}
#[test]
fn shift_resolves_to_fly_speed_boost() {
use crate::input::binding::Modifiers;
let mut input = ViewportInput::new(crate::input::viewport_default_bindings());
input.begin_frame(make_ctx());
input.push_event(ViewportEvent::ModifiersChanged(Modifiers::SHIFT));
assert!(input.resolve().is_active(Action::FlySpeedBoost));
input.push_event(ViewportEvent::ModifiersChanged(Modifiers::NONE));
assert!(!input.resolve().is_active(Action::FlySpeedBoost));
}
}