Struct CameraFrame 

pub struct CameraFrame {
    pub pos: DVec3,
    pub up: DVec3,
    pub facing: DVec3,
    pub near: f64,
    pub far: f64,
    pub perspective_blend: f64,
    pub frame_height: f64,
    pub scale: f64,
    pub fovy: f64,
}

The data of a camera

The CameraFrame has a CameraFrame::perspective_blend property (default is 0.0), which is used to blend between orthographic and perspective projection.

Fields

pos: DVec3

The position

up: DVec3

The up unit vec

facing: DVec3

The facing unit vec

near: f64

The near pane

far: f64

The far pane

perspective_blend: f64

The perspective blend value in [0.0, 1.0]

frame_height: f64

Ortho: Top - Bottom

scale: f64

Ortho: The scaling factor

fovy: f64

Perspective: The field of view angle, used in perspective projection

Implementations

impl CameraFrame

pub fn new() -> Self

Create a new CameraFrame at the origin facing to the negative z-axis and use Y as up vector with default projection settings.

impl CameraFrame

pub fn set_view_matrix(&mut self, view_matrix: DMat4)

Set the view matrix of the camera.

pub fn with_view_matrix(self, view_matrix: DMat4) -> Self

Set the view matrix of the camera and return the modified Self.

pub fn view_matrix(&self) -> DMat4

The view matrix of the camera

pub fn orthographic_mat(&self, aspect_ratio: f64) -> DMat4

Use the given frame size as left, right, bottom, top to construct an orthographic matrix

pub fn perspective_mat(&self, aspect_ratio: f64) -> DMat4

Use the given frame aspect ratio to construct a perspective matrix

pub fn projection_matrix(&self, aspect_ratio: f64) -> DMat4

Use the given frame size to construct projection matrix

pub fn view_projection_matrix(&self, aspect_ratio: f64) -> DMat4

Use the given frame size to construct view projection matrix

impl CameraFrame

pub fn from_spherical(phi: f64, theta: f64, distance: f64) -> Self

Create a perspective camera positioned using spherical coordinates (Z-up), looking at the origin.

• phi: polar angle from +Z axis in radians (0 = straight up along +Z, π/2 = XY plane)
• theta: azimuth angle in radians (0 = +X direction, π/2 = +Y direction)
• distance: distance from the origin

pub fn set_spherical( &mut self, phi: f64, theta: f64, distance: f64, target: DVec3, ) -> &mut Self

Position the camera using spherical coordinates (Z-up) around a target point.

• phi: polar angle from +Z axis in radians (0 = straight up along +Z, π/2 = XY plane)
• theta: azimuth angle in radians (0 = +X direction, π/2 = +Y direction)
• distance: distance from target
• target: the point the camera looks at

pub fn look_at(&mut self, target: DVec3) -> &mut Self

Set the camera to look at a target point.

pub fn orbit(&mut self, target: DVec3, total_angle: f64) -> AnimationCell<Self>

Create an orbit animation that rotates the camera around target by total_angle radians in the XY plane (Z-up).

The camera’s current position is used to derive the spherical coordinates (distance, elevation) which are kept constant during the orbit.

Example

use std::f64::consts::TAU;

let mut cam = CameraFrame::from_spherical(phi, theta, distance);
let r_cam = r.insert(cam.clone());
r.timeline_mut(r_cam).play(
    cam.orbit(DVec3::ZERO, TAU)
       .with_duration(8.0)
       .with_rate_func(linear),
);

impl CameraFrame

pub fn center_canvas_in_frame( &mut self, center: DVec3, width: f64, height: f64, up: DVec3, normal: DVec3, aspect_ratio: f64, ) -> &mut Self

Center the canvas in the frame when CameraFrame::perspective_blend is 1.0

Trait Implementations

impl Alignable for CameraFrame

fn is_aligned(&self, _other: &Self) -> bool

Checking if two items are aligned

fn align_with(&mut self, _other: &mut Self)

Aligning two items

impl Clone for CameraFrame

fn clone(&self) -> CameraFrame

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CameraFrame

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

Formats the value using the given formatter.

impl Default for CameraFrame

fn default() -> Self

Returns the “default value” for a type.

impl Extract for CameraFrame

type Target = CoreItem

The extraction result

fn extract_into(&self, buf: &mut Vec<Self::Target>)

Extract a Extract::Target from reference.

fn extract(&self) -> Vec<Self::Target>

Extract a Extract::Target from reference.

impl Interpolatable for CameraFrame

fn lerp(&self, target: &Self, t: f64) -> Self

Lerping between values

impl PartialEq for CameraFrame

fn eq(&self, other: &CameraFrame) -> 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 StructuralPartialEq for CameraFrame