Struct OrbitControls 

pub struct OrbitControls {

    pub enable_damping: bool,
    pub damping_factor: f32,
    pub zoom_damping_factor: f32,
    pub enable_zoom: bool,
    pub zoom_speed: f32,
    pub enable_rotate: bool,
    pub rotate_speed: f32,
    pub enable_pan: bool,
    pub pan_speed: f32,
    pub min_distance: f32,
    pub max_distance: f32,
    pub min_polar_angle: f32,
    pub max_polar_angle: f32,
    /* private fields */
}

Mouse-based orbit camera controller.

Allows users to rotate, zoom, and pan the camera around a target point using mouse input.

Controls

Input	Action
Left Mouse + Drag	Rotate camera around target
Right Mouse + Drag	Pan camera and target
Scroll Wheel	Zoom in/out

Features

• Smooth damping for natural feel
• Configurable rotation/zoom/pan speeds
• Distance and angle constraints

Example

let mut orbit = OrbitControls::new(
    Vec3::new(0.0, 5.0, 10.0),  // camera position
    Vec3::ZERO,                   // look-at target
);

// Customize settings
orbit.enable_damping = true;
orbit.rotate_speed = 0.5;
orbit.min_distance = 2.0;
orbit.max_distance = 50.0;

// In update loop
orbit.update(&mut camera_transform, &input, fov, dt);

Fields

enable_damping: bool

Enable smooth damping for rotation and zoom.

damping_factor: f32

Damping factor for rotation (0.0 = instant, 1.0 = no movement).

zoom_damping_factor: f32

Damping factor for zoom (0.0 = instant, 1.0 = no movement).

enable_zoom: bool

Enable mouse wheel zoom.

zoom_speed: f32

Zoom speed multiplier.

enable_rotate: bool

Enable left-click rotation.

rotate_speed: f32

Rotation speed multiplier.

enable_pan: bool

Enable right-click panning.

pan_speed: f32

Pan speed multiplier.

min_distance: f32

Minimum distance from target (zoom limit).

max_distance: f32

Maximum distance from target (zoom limit).

min_polar_angle: f32

Minimum polar angle in radians (0 = top-down view).

max_polar_angle: f32

Maximum polar angle in radians (π = bottom-up view).

Implementations

impl OrbitControls

pub fn new(camera_pos: Vec3, target: Vec3) -> OrbitControls

Creates a new orbit controller.

Arguments

• camera_pos - Initial camera world position
• target - Point to orbit around (look-at target)

pub fn update( &mut self, transform: &mut Transform, input: &Input, fov: f32, dt: f32, )

Updates the camera transform based on input.

Call this once per frame in your update loop.

Arguments

• transform - Camera’s transform component to modify
• input - Current input state
• fov - Camera field of view in radians (for pan scaling)
• dt - Delta time in seconds

pub fn set_target(&mut self, target: Vec3)

Sets the orbit target point.

The camera will orbit around this point.

pub fn set_position(&mut self, position: Vec3)

Sets the camera position directly.

Updates internal spherical coordinates to match the new position while keeping the current target.

pub fn fit(&mut self, bbox: &BoundingBox)

Frames the camera to fit a pre-computed bounding box.

Positions the camera so the entire bounding box is visible, looking at its center from an appropriate distance.