2.13 转换矩阵

转换矩阵引用了库nalgebra，使用时研究详细实现。

1. use std::ops;
3. use nalgebra::Perspective3;
5. use crate::Scalar;
7. use super::{Aabb, LineSegment, Point, Triangle, Vector};
9. /// An affine transform
10. #[repr(C)]
11. #[derive(Debug, Clone, Copy, Default)]
12. pub struct Transform(nalgebra::Transform<f64, nalgebra::TAffine, 3>);
14. impl Transform {
15.     /// Construct an identity transform
16.     pub fn identity() -> Self {
17.         Self(nalgebra::Transform::identity())
18.     }
20.     /// Construct a translation
21.     pub fn translation(offset: impl Into<Vector<3>>) -> Self {
22.         let offset = offset.into();
24.         Self(nalgebra::Transform::from_matrix_unchecked(
25.             nalgebra::OMatrix::new_translation(&offset.to_na()),
26.         ))
27.     }
29.     /// Construct a rotation
30.     ///
31.     /// The direction of the vector defines the rotation axis. Its length
32.     /// defines the angle of the rotation.
33.     pub fn rotation(axis_angle: impl Into<Vector<3>>) -> Self {
34.         let axis_angle = axis_angle.into();
36.         Self(nalgebra::Transform::from_matrix_unchecked(
37.             nalgebra::OMatrix::<_, nalgebra::Const<4>, _>::new_rotation(
38.                 axis_angle.to_na(),
39.             ),
40.         ))
41.     }
43.     /// Construct a scaling
44.     pub fn scale(scaling_factor: f64) -> Self {
45.         Self(nalgebra::Transform::from_matrix_unchecked(
46.             nalgebra::OMatrix::new_scaling(scaling_factor),
47.         ))
48.     }
50.     /// # Extract the "right" vector from the rotational component
51.     pub fn right(&self) -> Vector<3> {
52.         let d = self.data();
53.         Vector::from([d[0], d[1], d[2]])
54.     }
56.     /// # Extract the "up" vector from the rotational component
57.     pub fn up(&self) -> Vector<3> {
58.         let d = self.data();
59.         Vector::from([d[4], d[5], d[6]])
60.     }
62.     /// Transform the given point
63.     pub fn transform_point(&self, point: &Point<3>) -> Point<3> {
64.         Point::from(self.0.transform_point(&point.to_na()))
65.     }
67.     /// Inverse transform given point
68.     pub fn inverse_transform_point(&self, point: &Point<3>) -> Point<3> {
69.         Point::from(self.0.inverse_transform_point(&point.to_na()))
70.     }
72.     /// Transform the given vector
73.     pub fn transform_vector(&self, vector: &Vector<3>) -> Vector<3> {
74.         Vector::from(self.0.transform_vector(&vector.to_na()))
75.     }
77.     /// Transform the given segment
78.     pub fn transform_segment(
79.         &self,
80.         segment: &LineSegment<3>,
81.     ) -> LineSegment<3> {
82.         let [a, b] = &segment.points;
83.         LineSegment::from([self.transform_point(a), self.transform_point(b)])
84.     }
86.     /// Transform the given triangle
87.     pub fn transform_triangle(&self, triangle: &Triangle<3>) -> Triangle<3> {
88.         let [a, b, c] = &triangle.points;
89.         Triangle::from([
90.             self.transform_point(a),
91.             self.transform_point(b),
92.             self.transform_point(c),
93.         ])
94.     }
96.     /// Inverse transform
97.     pub fn inverse(&self) -> Self {
98.         Self(self.0.inverse())
99.     }
101.     /// Transpose transform
102.     pub fn transpose(&self) -> Self {
103.         Self(nalgebra::Transform::from_matrix_unchecked(
104.             self.0.to_homogeneous().transpose(),
105.         ))
106.     }
108.     /// Project transform according to camera specification, return data as an array.
109.     /// Used primarily for graphics code.
110.     pub fn project_to_array(
111.         &self,
112.         aspect_ratio: f64,
113.         fovy: f64,
114.         znear: f64,
115.         zfar: f64,
116.     ) -> [Scalar; 16] {
117.         let projection = Perspective3::new(aspect_ratio, fovy, znear, zfar);
119.         let mut array = [0.; 16];
120.         array.copy_from_slice(
121.             (projection.to_projective() * self.0).matrix().as_slice(),
122.         );
124.         array.map(Scalar::from)
125.     }
127.     /// Return a copy of the inner nalgebra transform
128.     pub fn get_inner(&self) -> nalgebra::Transform<f64, nalgebra::TAffine, 3> {
129.         self.0
130.     }
132.     /// Transform the given axis-aligned bounding box
133.     pub fn transform_aabb(&self, aabb: &Aabb<3>) -> Aabb<3> {
134.         Aabb {
135.             min: self.transform_point(&aabb.min),
136.             max: self.transform_point(&aabb.max),
137.         }
138.     }
140.     /// Exposes the data of this Transform as a slice of f64.
141.     pub fn data(&self) -> &[f64] {
142.         self.0.matrix().data.as_slice()
143.     }
145.     /// Extract the rotation component of this transform
146.     pub fn extract_rotation(&self) -> Self {
147.         Self(nalgebra::Transform::from_matrix_unchecked(
148.             self.0.matrix().fixed_resize::<3, 3>(0.).to_homogeneous(),
149.         ))
150.     }
152.     /// Extract the translation component of this transform
153.     pub fn extract_translation(&self) -> Self {
154.         *self * self.extract_rotation().inverse()
155.     }
156. }
158. impl ops::Mul<Self> for Transform {
159.     type Output = Self;
161.     fn mul(self, rhs: Self) -> Self::Output {
162.         Self(self.0.mul(rhs.0))
163.     }
164. }
166. #[cfg(test)]
167. mod tests {
168.     use approx::assert_abs_diff_eq;
170.     use crate::{Scalar, Vector};
172.     use super::Transform;
174.     #[test]
175.     fn extract_rotation_translation() {
176.         let rotation =
177.             Transform::rotation(Vector::unit_z() * (Scalar::PI / 2.));
178.         let translation = Transform::translation([1., 2., 3.]);
180.         assert_abs_diff_eq!(
181.             (translation * rotation).extract_rotation().data(),
182.             rotation.data(),
183.             epsilon = 1e-8,
184.         );
186.         assert_abs_diff_eq!(
187.             (translation * rotation).extract_translation().data(),
188.             translation.data(),
189.             epsilon = 1e-8,
190.         );
192.         assert_abs_diff_eq!(
193.             (rotation * translation).extract_rotation().data(),
194.             rotation.data(),
195.             epsilon = 1e-8,
196.         );
198.         assert_abs_diff_eq!(
199.             (rotation * translation).extract_translation().data(),
200.             Transform::translation([-2., 1., 3.]).data(),
201.             epsilon = 1e-8,
202.         );
203.     }
204. }

复制代码