termgpu 0.1.0

A GPU-accelerated terminal graphics engine for Rust, enabling real-time 3D rendering in the terminal.
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
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

//! Transform module contains transformation components 
//! (structs, traits and GPU structs)

use bytemuck::{Pod, Zeroable};
use serde::{Serialize, Deserialize};
use nalgebra_glm as glm;

use crate::render::{InstanceData, Transformation, TransformationType::{self, *}};

/// A structure representing a transformation in 3D space, including translation, rotation, and scale.
///
/// The transformation is represented by a translation vector, a rotation quaternion, and a uniform scale factor.
#[derive(Serialize, Deserialize, Debug, Clone, Copy, PartialEq)]
pub struct Transform {
    /// The type vector of the transformation.
    pub transformation_type: TransformationType,

    /// The translation vector of the transformation.
    pub translation: glm::Vec3,
    
    /// The rotation of the transformation, represented as a quaternion.
    pub rotation: glm::Quat,

    /// The point relative to which the object will be transformed
    pub pivot: glm::Vec3,
}

impl Transformation for Transform {
    fn from_transform(
        transformation_type: TransformationType,
        translation: nalgebra_glm::Vec3, 
        rotation: nalgebra_glm::Quat, 
        pivot: nalgebra_glm::Vec3,
    ) -> Self {
        Transform::new(transformation_type, translation, rotation, pivot)
    }
}

impl Transform {
    /// Constructs a new `Transform` instance with the given translation, rotation, and scale.
    pub fn new(
        transformation_type: TransformationType,
        translation: glm::Vec3, 
        rotation: glm::Quat, 
        pivot: glm::Vec3,
    ) -> Transform {
        Transform { transformation_type, translation, rotation, pivot }
    }

    /// Returns a `Transform` instance with default properties (identity transformation).
    pub fn identity() -> Transform {
        Transform::default()
    }

    /// Constructs a new `Transform` instance with the given translation and default rotation and scale.
    pub fn new_from_translation(translation: glm::Vec3) -> Transform {
        Transform { translation, ..Default::default() }
    }

    /// Constructs a new `Transform` instance with the given rotation and default translation and scale.
    pub fn new_from_rotation(rotation: glm::Quat) -> Transform {
        Transform { rotation, ..Default::default() }
    }

    /// Returns the local x-axis direction vector in world space.
    pub fn local_x(&self) -> glm::Vec3 {
        let m = TransformUniform::new(self).transform_matrix;
        
        glm::vec3(
            m[(0, 0)],
            m[(0, 1)], 
            m[(0, 2)]
        )
    }
    
    /// Returns the local y-axis direction vector in world space.
    pub fn local_y(&self) -> glm::Vec3 {
        let m = TransformUniform::new(self).transform_matrix;
        
        glm::vec3(
            m[(1, 0)],
            m[(1, 1)], 
            m[(1, 2)]
        )
    }
    
    /// Returns the local z-axis direction vector in world space.
    pub fn local_z(&self) -> glm::Vec3 {
        let m = TransformUniform::new(self).transform_matrix;
        
        glm::vec3(
            m[(2, 0)],
            m[(2, 1)], 
            m[(2, 2)]
        )
    }
}

impl Default for Transform {
    fn default() -> Self {
        Transform {
            transformation_type: TransformationType::LookAt,
            translation: glm::vec3(0.0, 0.0, 0.0),
            rotation: glm::Quat::identity(),
            pivot: glm::vec3(0.0, 0.0, 0.0),
        }
    }
}

/// A structure representing the transformation matrices used for rendering.
///
/// Contains both the transformation matrix and its inverse.
#[repr(C)]
#[derive(Debug, Clone, Copy, Zeroable, Pod)]
pub struct TransformUniform {
    /// The transformation matrix that combines translation, rotation, and scale.
    pub transform_matrix: glm::Mat4,
    
    /// The inverse of the transformation matrix.
    pub inverse_matrix: glm::Mat4,
}

impl Default for TransformUniform {
    fn default() -> Self {
        TransformUniform {
            transform_matrix: glm::Mat4::identity(),
            inverse_matrix: glm::Mat4::identity().try_inverse().unwrap(),
        }
    }
}

impl TransformUniform {
    /// Creates a new `TransformUniform` instance based on the provided `Transform`.
    pub fn new(transform: &Transform) -> TransformUniform {
        let transform_matrix = if transform.transformation_type == LookAt {
            glm::Mat4::identity()
                * glm::translation(&transform.translation)
                * glm::quat_cast(&transform.rotation)
                * glm::translation(&-transform.pivot)
        } else {
            glm::Mat4::identity()
                * glm::quat_cast(&transform.rotation)
                * glm::translation(&transform.translation)
                * glm::translation(&-transform.pivot)
        };

        let inverse_matrix = transform_matrix.try_inverse().unwrap();

        TransformUniform {
            transform_matrix,
            inverse_matrix,
        }
    }
}

impl InstanceData for Transform {
    type UniformData = TransformUniform;

    fn uniform_data(&self) -> Self::UniformData {
        TransformUniform::new(self)
    }
}