Struct Camera 

pub struct Camera {
    pub projection: Projection,
    pub center: Vec3,
    pub distance: f32,
    pub orientation: Quat,
    pub fov_y: f32,
    pub aspect: f32,
    pub znear: f32,
    pub zfar: f32,
}

Arcball camera for the 3D viewport.

The camera orbits around a center point. orientation is a quaternion that maps camera-space axes to world-space: eye = center + orientation * (Z * distance). Pan translates the center in camera-space. Zoom adjusts the distance.

Using a quaternion avoids gimbal lock and allows full 360° orbit in any direction. All matrices are computed right-handed (wgpu NDC convention).

Fields

projection: Projection

Projection mode (perspective or orthographic).

center: Vec3

Orbit target point in world space.

distance: f32

Distance from center to eye (zoom).

orientation: Quat

Camera orientation as a unit quaternion. eye = center + orientation * (Vec3::Z * distance). Identity = looking along -Z from +Z position (standard front view).

fov_y: f32

Vertical field of view in radians.

aspect: f32

Viewport width / height ratio — updated each frame from viewport rect.

znear: f32

Near clipping plane distance.

zfar: f32

Far clipping plane distance.

Implementations

impl Camera

pub const MIN_DISTANCE: f32 = 0.01

Minimum allowed camera distance (zoom limit).

pub const MAX_DISTANCE: f32 = 1.0e6

Maximum allowed camera distance (zoom limit).

pub fn center(&self) -> Vec3

Return the orbit target center in world space.

Forward-compatible accessor — equivalent to reading self.center.

pub fn set_center(&mut self, center: Vec3)

Set the orbit target center in world space.

pub fn distance(&self) -> f32

Return the camera distance (zoom).

Forward-compatible accessor — equivalent to reading self.distance.

pub fn set_distance(&mut self, d: f32)

Set the camera distance, clamped to [MIN_DISTANCE, MAX_DISTANCE].

pub fn orientation(&self) -> Quat

Return the camera orientation quaternion.

Forward-compatible accessor — equivalent to reading self.orientation.

pub fn set_orientation(&mut self, q: Quat)

Set the camera orientation, normalizing the quaternion.

pub fn set_fov_y(&mut self, fov_y: f32)

Set the vertical field of view in radians.

pub fn set_aspect_ratio(&mut self, width: f32, height: f32)

Set the aspect ratio from pixel dimensions.

If height is zero or negative, aspect is set to 1.0.

pub fn set_clip_planes(&mut self, znear: f32, zfar: f32)

Set the near and far clipping plane distances.

pub fn orbit(&mut self, yaw: f32, pitch: f32)

Orbit the camera by yaw and pitch radians.

Applies Quat::from_rotation_y(-yaw) * orientation * Quat::from_rotation_x(-pitch). The sign convention matches all examples: positive yaw rotates counter-clockwise when viewed from above, positive pitch tilts up.

pub fn pan_world(&mut self, right_delta: f32, up_delta: f32)

Pan the camera by world-space deltas.

right_delta subtracts from center along the camera right vector; up_delta adds to center along the camera up vector. This sign convention matches mouse pan: dragging right moves the scene left.

pub fn pan_pixels(&mut self, delta_pixels: Vec2, viewport_height: f32)

Pan the camera by pixel-space deltas.

Computes pan_scale = 2 * distance * tan(fov_y/2) / viewport_height then delegates to pan_world.

pub fn zoom_by_factor(&mut self, factor: f32)

Zoom by multiplying the distance by factor, clamped to [MIN_DISTANCE, MAX_DISTANCE].

pub fn zoom_by_delta(&mut self, delta: f32)

Zoom by adding delta to the distance, clamped to [MIN_DISTANCE, MAX_DISTANCE].

pub fn frame_sphere(&mut self, center: Vec3, radius: f32)

Frame the camera to contain a bounding sphere, applying the result directly.

pub fn frame_aabb(&mut self, aabb: &Aabb)

Frame the camera to contain an AABB, applying the result directly.

pub fn fit_sphere_target(&self, center: Vec3, radius: f32) -> CameraTarget

Compute a CameraTarget that would frame a bounding sphere, preserving the current orientation.

pub fn fit_aabb_target(&self, aabb: &Aabb) -> CameraTarget

Compute a CameraTarget that would frame an AABB, preserving the current orientation.

pub fn eye_position(&self) -> Vec3

Eye (camera) position in world space.

pub fn view_matrix(&self) -> Mat4

Right-handed view matrix (world -> camera space).

pub fn proj_matrix(&self) -> Mat4

Right-handed projection matrix (wgpu depth 0..1).

In orthographic mode the viewing volume is derived from distance and fov_y so that switching between perspective and orthographic at the same distance produces a similar framing.

pub fn view_proj_matrix(&self) -> Mat4

Combined view-projection matrix for use in the camera uniform buffer. Note: projection * view (column-major order: proj applied after view).

pub fn right(&self) -> Vec3

Camera right vector in world space (used for pan).

pub fn up(&self) -> Vec3

Camera up vector in world space (used for pan).

pub fn frustum(&self) -> Frustum

Extract the view frustum from the current view-projection matrix.

pub fn fit_sphere(&self, center: Vec3, radius: f32) -> (Vec3, f32)

Compute (center, distance) that would frame a bounding sphere in view, preserving the current orientation.

A 1.2× padding factor is applied so the object doesn’t touch the edges.

pub fn fit_aabb(&self, aabb: &Aabb) -> (Vec3, f32)

Compute (center, distance) that would frame an AABB in view, preserving the current orientation.

Converts the AABB to a bounding sphere and delegates to fit_sphere.

pub fn center_on_domain(&mut self, nx: f32, ny: f32, nz: f32)

Center the camera on a domain of the given extents, adjusting distance and clipping planes so the entire domain is visible.

Trait Implementations

impl Clone for Camera

fn clone(&self) -> Camera

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Default for Camera

fn default() -> Self

Returns the “default value” for a type.