Struct Camera 

pub struct Camera {

    tgt_focus: Vec3<f32>,
    focus: Vec3<f32>,
    tgt_ori: Vec3<f32>,
    ori: Vec3<f32>,
    tgt_dist: f32,
    dist: f32,
    tgt_fov: f32,
    fov: f32,
    tgt_fixate: f32,
    fixate: f32,
    aspect: f32,
    mode: CameraMode,
    last_time: Option<f64>,
    dependents: Dependents,
    frustum: Frustum<f32>,
}

Fields

tgt_focus: Vec3<f32>

focus: Vec3<f32>

tgt_ori: Vec3<f32>

ori: Vec3<f32>

tgt_dist: f32

dist: f32

tgt_fov: f32

fov: f32

tgt_fixate: f32

fixate: f32

aspect: f32

mode: CameraMode

last_time: Option<f64>

dependents: Dependents

frustum: Frustum<f32>

Implementations

impl Camera

pub fn new(aspect: f32, mode: CameraMode) -> Self

Create a new Camera with default parameters.

pub fn compute_dependents(&mut self, terrain: &TerrainGrid)

Compute the transformation matrices (view matrix and projection matrix) and position of the camera.

pub fn compute_dependents_full<V: ReadVol>( &mut self, terrain: &V, is_transparent: fn(&V::Vox) -> bool, )

The is_fluid argument should return true for transparent voxels.

fn compute_dependents_near<V: ReadVol>( &mut self, terrain: &V, is_transparent: fn(&V::Vox) -> bool, )

fn compute_dependents_far<V: ReadVol>( &mut self, terrain: &V, is_transparent: fn(&V::Vox) -> bool, )

fn compute_dependents_helper(&self, dist: f32) -> Dependents

fn compute_frustum(&mut self, dependents: &Dependents) -> Frustum<f32>

pub fn frustum(&self) -> &Frustum<f32>

pub fn dependents(&self) -> Dependents

pub fn rotate_by(&mut self, delta: Vec3<f32>)

Rotate the camera about its focus by the given delta, limiting the input accordingly.

pub fn set_orientation(&mut self, ori: Vec3<f32>)

Set the orientation of the camera about its focus.

pub fn set_orientation_instant(&mut self, ori: Vec3<f32>)

Set the orientation of the camera about its focus without lerping.

pub fn zoom_by(&mut self, delta: f32, cap: Option<f32>)

Zoom the camera by the given delta, limiting the input accordingly.

pub fn zoom_switch(&mut self, delta: f32, cap: f32, scale: f32)

Zoom with the ability to switch between first and third-person mode.

Note that cap > 18237958000000.0 can cause panic due to float overflow

pub fn get_distance(&self) -> f32

Get the distance of the camera from the focus

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

Set the distance of the camera from the focus (i.e., zoom).

pub fn update(&mut self, time: f64, dt: f32, smoothing_enabled: bool)

pub fn lerp_toward(&mut self, tgt_ori: Vec3<f32>, dt: f32, rate: f32)

pub fn interp_time(&self) -> f32

pub fn get_focus_pos(&self) -> Vec3<f32>

Get the focus position of the camera.

pub fn set_focus_pos(&mut self, focus: Vec3<f32>)

Set the focus position of the camera.

pub fn force_focus_pos(&mut self, focus: Vec3<f32>)

Set the focus position of the camera, without lerping.

pub fn force_xy_focus_pos(&mut self, focus: Vec3<f32>)

Set the focus position of the camera, without lerping.

pub fn get_aspect_ratio(&self) -> f32

Get the aspect ratio of the camera.

pub fn set_aspect_ratio(&mut self, aspect: f32)

Set the aspect ratio of the camera.

pub fn get_orientation(&self) -> Vec3<f32>

Get the orientation of the camera.

pub fn get_tgt_orientation(&self) -> Vec3<f32>

Get the orientation that the camera is moving toward.

pub fn get_effective_fov(&self) -> f32

Get the field of view of the camera in radians, taking into account fixation.

pub fn set_fov(&mut self, fov: f32)

Set the field of view of the camera in radians.

pub fn set_fixate(&mut self, fixate: f32)

Set the ‘fixation’ proportion, allowing the camera to focus in with precise aiming. Fixation is applied on top of the regular FoV.

pub fn set_fov_deg(&mut self, fov: u16)

Set the FOV in degrees

pub fn set_mode(&mut self, mode: CameraMode)

Set the mode of the camera.

pub fn get_mode(&self) -> CameraMode

Get the mode of the camera

pub fn next_mode(&mut self, is_admin: bool, has_target: bool)

Cycle the camera to its next valid mode. If is_admin is false then only modes which are accessible without admin access will be cycled to.

pub fn forward(&self) -> Vec3<f32>

Return a unit vector in the forward direction for the current camera orientation

pub fn right(&self) -> Vec3<f32>

Return a unit vector in the right direction for the current camera orientation

pub fn forward_xy(&self) -> Vec2<f32>

Return a unit vector in the forward direction on the XY plane for the current camera orientation

pub fn right_xy(&self) -> Vec2<f32>

Return a unit vector in the right direction on the XY plane for the current camera orientation

pub fn get_pos_with_focus(&self) -> Vec3<f32>