Struct Camera 

pub struct Camera {
    pub matrix: Matrix4,
    /* private fields */
}

Camera

A Scene holds only one Camera.

Fields

matrix: Matrix4

camera matrix

This matrix must be in the Euclidean momentum group, the semi-direct product of O(3) and R^3.

Implementations

impl Camera

pub fn position(&self) -> Point3

Returns the position of camera, the forth column of the camera matrix.

Examples

use truck_platform::*;
use truck_base::cgmath64::*;
let mut camera = Camera::default();
camera.matrix = Matrix4::from_translation(Vector3::new(1.0, 2.0, 3.0));
assert_eq!(camera.position(), Point3::new(1.0, 2.0, 3.0));

pub fn eye_direction(&self) -> Vector3

Returns the eye direction of camera. the inverse of the z-axis of the camera matrix.

Examples

use std::f64::consts::PI;
use truck_platform::*;
use truck_base::{cgmath64::*, tolerance::Tolerance};
let mut camera = Camera::default();
camera.matrix = Matrix4::from_axis_angle(
    Vector3::new(1.0, 1.0, 1.0).normalize(),
    Rad(2.0 * PI / 3.0),
);
assert!(camera.eye_direction().near(&-Vector3::unit_x()));

pub fn head_direction(&self) -> Vector3

Returns the direction of the head vector, the y-axis of the camera matrix.

Examples

use std::f64::consts::PI;
use truck_platform::*;
use truck_base::{cgmath64::*, tolerance::Tolerance};
let mut camera = Camera::default();
camera.matrix = Matrix4::from_axis_angle(
    Vector3::new(1.0, 1.0, 1.0).normalize(),
    Rad(2.0 * PI / 3.0),
);
assert!(camera.head_direction().near(&Vector3::unit_z()));

pub const fn projection_type(&self) -> ProjectionType

Returns the projection type of the camera.

Examples

use truck_platform::*;
// the projection type of the default camera is perspective.
assert_eq!(Camera::default().projection_type(), ProjectionType::Perspective);

pub fn perspective_camera<R: Into<Rad<f64>>>( matrix: Matrix4, field_of_view: R, near_clip: f64, far_clip: f64, ) -> Camera

Creates a perspective camera.

Arguments

• matrix: camera matrix
• field_of_view: FOV, based on the vertical direction of the screen.
• near_clip: distance to the nearest face of the view volume
• far_clip: distance to the farthest face of the view volume

Examples

use std::f64::consts::PI;
use truck_base::{cgmath64::*, tolerance::Tolerance};
use truck_platform::*;
let matrix = Matrix4::look_at_rh(
    Point3::new(1.0, 1.0, 1.0),
    Point3::origin(),
    Vector3::new(0.0, 1.0, 0.0),
);
let camera = Camera::perspective_camera(
    // depends on the difference of the style with cgmath,
    // the matrix must be inverted
    matrix.invert().unwrap(),
    Rad(PI / 4.0),
    0.1,
    1.0,
);
assert!(camera.eye_direction().near(&-Vector3::new(1.0, 1.0, 1.0).normalize()));
assert_eq!(camera.projection_type(), ProjectionType::Perspective);

pub fn parallel_camera( matrix: Matrix4, screen_size: f64, near_clip: f64, far_clip: f64, ) -> Camera

Creates a parallel camera.

Arguments

• matrix: camera matrix
• screen_size: screen size, based on the vertical direction of the screen.`
• near_clip: distance to the nearest face of the view volume
• far_clip: distance to the farthest face of the view volume

Examples

use truck_base::{cgmath64::*, tolerance::Tolerance};
use truck_platform::*;
let matrix = Matrix4::look_at_rh(
    Point3::new(1.0, 1.0, 1.0),
    Point3::origin(),
    Vector3::new(0.0, 1.0, 0.0),
);
let camera = Camera::parallel_camera(
    // depends on the difference of the style with cgmath,
    // the matrix must be inverted
    matrix.invert().unwrap(),
    1.0,
    0.1,
    1.0,
);
assert!(camera.head_direction().near(&Vector3::new(-0.5, 1.0, -0.5).normalize()));
assert_eq!(camera.projection_type(), ProjectionType::Parallel);

pub fn projection(&self, as_rat: f64) -> Matrix4

Returns the projection matrix into the normalized view volume.

Arguments

as_rat: the aspect ratio, x-resolution / y-resulution.

Examples

// perspective camera
use std::f64::consts::PI;
use truck_base::{assert_near, cgmath64::*, tolerance::*};
use truck_platform::*;

let fov = PI / 4.0;
let as_rat = 1.2;
let matrix = Matrix4::look_at_rh(
    Point3::new(1.0, 1.0, 1.0),
    Point3::origin(),
    Vector3::new(0.0, 1.0, 0.0),
);
let camera = Camera::perspective_camera(
    matrix.invert().unwrap(),
    Rad(fov),
    0.1,
    10.0,
);

// calculation by the ray-tracing
let pt = Point3::new(-1.5, -1.4, -2.5);
let vec = pt - camera.position();
let far = 1.0 / (fov / 2.0).tan();
let dir = camera.eye_direction();
let y_axis = camera.head_direction();
let x_axis = dir.cross(y_axis);
let proj_length = dir.dot(vec);
let h = (vec - proj_length * dir) * far / proj_length;
let u = h.dot(x_axis) / as_rat;
let v = h.dot(y_axis);

// check the answer
let uv = camera.projection(as_rat).transform_point(pt);
assert_near!(u, uv[0]);
assert_near!(v, uv[1]);

// parallel camera
use truck_base::{assert_near, cgmath64::*, tolerance::*};
use truck_platform::*;

let size = 3.0;
let as_rat = 1.2;
let matrix = Matrix4::look_at_rh(
    Point3::new(1.0, 1.0, 1.0),
    Point3::origin(),
    Vector3::new(0.0, 1.0, 0.0),
);
let camera = Camera::parallel_camera(
    matrix.invert().unwrap(),
    size,
    0.1,
    10.0,
);

// calculation by the ray-tracing
let pt = Point3::new(-1.5, -1.4, -2.5);
let vec = pt - camera.position();
let dir = camera.eye_direction();
let y_axis = camera.head_direction();
let x_axis = dir.cross(y_axis);
let h = vec - vec.dot(dir) * dir;
let u = h.dot(x_axis) / (size / 2.0) / as_rat;
let v = h.dot(y_axis) / (size / 2.0);

// check the answer
let uv = camera.projection(as_rat).transform_point(pt);
assert_near!(u, uv[0]);
assert_near!(v, uv[1]);

pub fn buffer(&self, as_rat: f64, device: &Device) -> BufferHandler

Creates a UNIFORM buffer of camera.

The bind group provides Scene holds this uniform buffer.

Shader Example

layout(set = 0, binding = 0) uniform Camera {
    mat4 camera_matrix;     // the camera matrix
    mat4 camera_projection; // the projection into the normalized view volume
};

pub fn ray(&self, coord: Point2) -> Ray

Returns the ray from camera with aspect-ratio = 1.0.

Examples

// Perspective case
use std::f64::consts::PI;
use truck_base::{assert_near, cgmath64::*, tolerance::Tolerance};
use truck_platform::*;


let matrix = Matrix4::look_at_rh(
    Point3::new(1.0, 1.0, 1.0),
    Point3::origin(),
    Vector3::new(0.0, 1.0, 0.0),
);
let camera = Camera::perspective_camera(
    // depends on the difference of the style with cgmath,
    // the matrix must be inverted
    matrix.invert().unwrap(),
    Rad(PI / 4.0),
    0.1,
    1.0,
);

// take a point in the 3D space
let point = Point3::new(0.1, 0.15, 0.0);
// project to the normalized view volume
let uvz = camera.projection(1.0).transform_point(point);
// coordinate on the screen
let uv = Point2::new(uvz.x, uvz.y);

let ray = camera.ray(uv);
// the origin of the ray is camera position
assert_near!(ray.origin(), camera.position());
// the direction of the ray is the normalized vector of point - camera.position().
assert_near!(ray.direction(), (point - camera.position()).normalize());

// Parallel case
use truck_base::{assert_near, cgmath64::*, tolerance::*};
use truck_platform::*;

let matrix = Matrix4::look_at_rh(
    Point3::new(1.0, 1.0, 1.0),
    Point3::origin(),
    Vector3::new(0.0, 1.0, 0.0),
);
let camera = Camera::parallel_camera(
    matrix.invert().unwrap(),
    3.0,
    0.1,
    10.0,
);

// take a point in the 3D space
let point = Point3::new(0.1, 0.15, 0.0);
// the projection of the point to the screen
let projed = point
    - camera.eye_direction() * camera.eye_direction().dot(point - camera.position());
// project to the normalized view volume
let uvz = camera.projection(1.0).transform_point(point);
// coordinate on the screen
let uv = Point2::new(uvz.x, uvz.y);

let ray = camera.ray(uv);
// the origin of the ray is the projection of the point.
assert_near!(ray.origin(), projed);
// the direction of the ray is eye direction.
assert_near!(ray.direction(), camera.eye_direction());

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 Copy for Camera

impl Debug for Camera

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

Formats the value using the given formatter.

impl Default for Camera

fn default() -> Camera

Returns the “default value” for a type.