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: Option<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 deg 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 (top view in a Z-up world).

fov_y: f32

Vertical field of view in radians.

aspect: f32

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

znear: Option<f32>

Near clipping plane distance. None (the default) lets the library manage depth precision automatically. Set to Some(value) only when you need exact control over the near plane, e.g. to avoid clipping geometry that is very close to the camera.

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_z(-yaw) * orientation * Quat::from_rotation_x(-pitch). The sign convention matches all examples: positive yaw rotates counter-clockwise when viewed from above (Z-up), 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 effective_zfar(&self) -> f32

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. Effective far-plane distance : zfar floored to distance * 3 so the far plane always extends past the orbit centre regardless of zoom level.

pub fn effective_znear(&self) -> f32

Effective near-plane distance.

Keeps the near/far ratio at most 10,000:1 regardless of how far the camera has zoomed out. At close range the value is znear unchanged. At large distances it grows automatically so that f32 depth precision does not collapse and cause objects behind opaque surfaces to bleed through. Consumers do not need to adjust znear themselves.

pub fn proj_matrix(&self) -> Mat4

Returns the projection matrix for the current camera state.

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.2x 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.

impl<'de> Deserialize<'de> for Camera

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Camera

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.