nightshade 0.13.0

A cross-platform data-oriented game engine.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

use nalgebra_glm::Mat4;

/// Perspective projection settings following glTF conventions.
///
/// Uses reverse-Z depth buffer for improved precision. Supports infinite
/// far plane when `z_far` is `None`.
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
pub struct PerspectiveCamera {
    /// Aspect ratio (width/height). If `None`, uses viewport aspect ratio.
    pub aspect_ratio: Option<f32>,
    /// Vertical field of view in radians.
    pub y_fov_rad: f32,
    /// Far clipping plane distance. If `None`, uses infinite far plane.
    pub z_far: Option<f32>,
    /// Near clipping plane distance.
    pub z_near: f32,
}

impl Default for PerspectiveCamera {
    fn default() -> Self {
        Self {
            aspect_ratio: None,
            y_fov_rad: 45.0_f32.to_radians(),
            z_far: None,
            z_near: 0.01,
        }
    }
}

impl PerspectiveCamera {
    /// Returns the projection matrix using stored or default aspect ratio.
    pub fn matrix(&self) -> Mat4 {
        let aspect_ratio = self.aspect_ratio.unwrap_or(16.0 / 9.0);
        self.matrix_with_aspect(aspect_ratio)
    }

    /// Returns the projection matrix with the specified aspect ratio.
    pub fn matrix_with_aspect(&self, aspect_ratio: f32) -> Mat4 {
        match self.z_far {
            Some(z_far) => reverse_z_perspective(aspect_ratio, self.y_fov_rad, self.z_near, z_far),
            None => infinite_reverse_z_perspective(aspect_ratio, self.y_fov_rad, self.z_near),
        }
    }
}

fn infinite_reverse_z_perspective(aspect_ratio: f32, y_fov_rad: f32, z_near: f32) -> Mat4 {
    let f = 1.0 / (y_fov_rad / 2.0).tan();
    Mat4::new(
        f / aspect_ratio,
        0.0,
        0.0,
        0.0,
        0.0,
        f,
        0.0,
        0.0,
        0.0,
        0.0,
        0.0,
        z_near,
        0.0,
        0.0,
        -1.0,
        0.0,
    )
}

fn reverse_z_perspective(aspect_ratio: f32, y_fov_rad: f32, z_near: f32, z_far: f32) -> Mat4 {
    let f = 1.0 / (y_fov_rad / 2.0).tan();
    Mat4::new(
        f / aspect_ratio,
        0.0,
        0.0,
        0.0,
        0.0,
        f,
        0.0,
        0.0,
        0.0,
        0.0,
        z_near / (z_far - z_near),
        z_near * z_far / (z_far - z_near),
        0.0,
        0.0,
        -1.0,
        0.0,
    )
}