Struct CameraState 

pub struct CameraState {
    pub target: Vec3,
    pub distance: f32,
    pub yaw: f32,
    pub pitch: f32,
}

Absolute, persistent orbit-camera pose for one scene. World-space — not re-derived from content each frame (see Framing). Defaults to a pleasant three-quarter view of a unit sphere at the origin; fitted re-frames it to data, gestures and programmatic moves mutate it.

Fields

target: Vec3

Look-at point in world space.

distance: f32

Eye distance from target. Multiplicative zoom_by keeps the perceived zoom rate constant at any scale.

yaw: f32

Azimuth around +Y, radians.

pitch: f32

Elevation, radians; clamped to ±~85° by orbit.

Implementations

impl CameraState

pub fn orbit(&mut self, d_yaw: f32, d_pitch: f32)

Orbit by angular deltas (radians). Pitch clamps near the poles so the up vector never degenerates.

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

Multiply the eye distance by factor, clamped to a sane range. factor > 1 pulls the camera back. Multiplicative so a scroll notch covers proportional distance whether near or far.

pub fn pan_by(&mut self, delta: Vec3)

Translate the look-at point by a world-space delta (pan).

pub fn fit_distance(radius: f32) -> f32

Distance at which a sphere of radius exactly fills the vertical fov.

pub fn fitted(&self, content: Aabb) -> CameraState

A copy framed on content: target at the centre and distance fit to the bounds, preserving the current orbit angles. Empty bounds leave a unit sphere at the origin. This is the framing operation Framing::Fit / Auto apply.

pub fn framing(content: Aabb) -> CameraState

Default angles, framed on content. The auto-framed starting pose.

pub fn look_at(&mut self, target: Vec3, distance: f32)

Point the camera at target from distance, keeping orbit angles.

pub fn focused(&self, focus: Focus) -> CameraState

A copy satisfying a Focus request, preserving orbit angles. The keyed camera springs toward this when the request changes.

pub fn eye(&self) -> Vec3

World-space eye position implied by the pose.

pub fn resolve(&self, view_bounds: Aabb) -> ResolvedCamera

Resolve to a concrete camera. view_bounds is everything that should stay inside the frustum (content and the reference grid / axes) — near/far are sized from the eye’s distance to that, not from the content radius, so geometry larger than the data (a big grid) is never plane-clipped. The pose is taken as-is; framing (fitting to data) is applied by the caller before resolving.

Trait Implementations

impl Clone for CameraState

fn clone(&self) -> CameraState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CameraState

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for CameraState

fn default() -> Self

Returns the “default value” for a type.

impl PartialEq for CameraState

fn eq(&self, other: &CameraState) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for CameraState

impl StructuralPartialEq for CameraState