1use std::ops::{Add, Sub, Mul, Div};
2use crate::vec::{Vec, Math};
3use crate::vec3::Vec3;
4use crate::vec4::Vec4;
5use crate::quat::Quat;
6use crate::mat3::Mat3;
7use crate::consts::{Zero, One, PiByC180};
8
9#[repr(C)]
10#[derive(Debug, Copy, Clone, Default, Hash, Eq, PartialEq)]
11pub struct Mat4<T>
12{
13 pub a1:T, pub a2:T, pub a3:T, pub a4:T,
14 pub b1:T, pub b2:T, pub b3:T, pub b4:T,
15 pub c1:T, pub c2:T, pub c3:T, pub c4:T,
16 pub d1:T, pub d2:T, pub d3:T, pub d4:T,
17}
18
19impl<T> Add for Mat4<T> where T:Add<Output=T>
20{
21 type Output = Mat4<T>;
22
23 fn add(self, m:Self) -> Self
24 {
25 Mat4
26 {
27 a1:self.a1 + m.a1, a2:self.a2 + m.a2, a3:self.a3 + m.a3, a4:self.a4 + m.a4,
28 b1:self.b1 + m.b1, b2:self.b2 + m.b2, b3:self.b3 + m.b3, b4:self.b4 + m.b4,
29 c1:self.c1 + m.c1, c2:self.c2 + m.c2, c3:self.c3 + m.c3, c4:self.c4 + m.c4,
30 d1:self.d1 + m.d1, d2:self.d2 + m.d2, d3:self.d3 + m.d3, d4:self.d4 + m.d4,
31 }
32 }
33}
34
35impl<T> Sub for Mat4<T> where T:Sub<Output=T>
36{
37 type Output = Mat4<T>;
38
39 fn sub(self, m:Self) -> Self
40 {
41 Mat4
42 {
43 a1:self.a1 - m.a1, a2:self.a2 - m.a2, a3:self.a3 - m.a3, a4:self.a4 - m.a4,
44 b1:self.b1 - m.b1, b2:self.b2 - m.b2, b3:self.b3 - m.b3, b4:self.b4 - m.b4,
45 c1:self.c1 - m.c1, c2:self.c2 - m.c2, c3:self.c3 - m.c3, c4:self.c4 - m.c4,
46 d1:self.d1 - m.d1, d2:self.d2 - m.d2, d3:self.d3 - m.d3, d4:self.d4 - m.d4,
47 }
48 }
49}
50
51impl<T> Mul<Mat4<T>> for Vec3<T> where T:Copy + Add<Output=T> + Div<Output=T> + Mul<Output=T>
52{
53 type Output = Self;
54
55 fn mul(self, m:Mat4<T>) -> Self
56 {
57 Self
58 {
59 x:(self.x * m.a1 + self.y * m.b1 + self.z * m.c1) / m.d4,
60 y:(self.x * m.a2 + self.y * m.b2 + self.z * m.c2) / m.d4,
61 z:(self.x * m.a3 + self.y * m.b3 + self.z * m.c3) / m.d4,
62 }
63 }
64}
65
66impl<T> Mul<Mat4<T>> for Vec4<T> where T:Copy + Add<Output=T> + Mul<Output=T>
67{
68 type Output = Self;
69
70 fn mul(self, m:Mat4<T>) -> Self
71 {
72 Self
73 {
74 x:(self.x * m.a1 + self.y * m.b1 + self.z * m.c1 + self.w * m.d1),
75 y:(self.x * m.a2 + self.y * m.b2 + self.z * m.c2 + self.w * m.d2),
76 z:(self.x * m.a3 + self.y * m.b3 + self.z * m.c3 + self.w * m.d3),
77 w:(self.x * m.a4 + self.y * m.b4 + self.z * m.c4 + self.w * m.d4),
78 }
79 }
80}
81
82impl<T> Mul<Vec3<T>> for Mat4<T> where T:Copy + Add<Output=T> + Sub<Output=T> + Mul<Output=T>
83{
84 type Output = Self;
85
86 fn mul(self, v:Vec3<T>) -> Self
87 {
88 let a = self;
89
90 Self
91 {
92 a1 : a.a1 * v.x + a.b1 * v.y + a.c1 * v.z + a.d1,
93 a2 : a.a2 * v.x + a.b2 * v.y + a.c2 * v.z + a.d2,
94 a3 : a.a3 * v.x + a.b3 * v.y + a.c3 * v.z + a.d3,
95 a4 : a.a4 * v.x + a.b4 * v.y + a.c4 * v.z + a.d4,
96
97 b1 : a.a1 * v.x + a.b1 * v.y + a.c1 * v.z + a.d1,
98 b2 : a.a2 * v.x + a.b2 * v.y + a.c2 * v.z + a.d2,
99 b3 : a.a3 * v.x + a.b3 * v.y + a.c3 * v.z + a.d3,
100 b4 : a.a4 * v.x + a.b4 * v.y + a.c4 * v.z + a.d4,
101
102 c1 : a.a1 * v.x + a.b1 * v.y + a.c1 * v.z + a.d1,
103 c2 : a.a2 * v.x + a.b2 * v.y + a.c2 * v.z + a.d2,
104 c3 : a.a3 * v.x + a.b3 * v.y + a.c3 * v.z + a.d3,
105 c4 : a.a4 * v.x + a.b4 * v.y + a.c4 * v.z + a.d4,
106
107 d1 : a.a1 * v.x + a.b1 * v.y + a.c1 * v.z + a.d1,
108 d2 : a.a2 * v.x + a.b2 * v.y + a.c2 * v.z + a.d2,
109 d3 : a.a3 * v.x + a.b3 * v.y + a.c3 * v.z + a.d3,
110 d4 : a.a4 * v.x + a.b4 * v.y + a.c4 * v.z + a.d4,
111 }
112 }
113}
114
115impl<T> Mul<Vec4<T>> for Mat4<T> where T:Copy + Add<Output=T> + Mul<Output=T>
116{
117 type Output = Self;
118
119 fn mul(self, v:Vec4<T>) -> Self
120 {
121 let a = self;
122
123 Self
124 {
125 a1 : a.a1 * v.x + a.b1 * v.y + a.c1 * v.z + a.d1 * v.w,
126 a2 : a.a2 * v.x + a.b2 * v.y + a.c2 * v.z + a.d2 * v.w,
127 a3 : a.a3 * v.x + a.b3 * v.y + a.c3 * v.z + a.d3 * v.w,
128 a4 : a.a4 * v.x + a.b4 * v.y + a.c4 * v.z + a.d4 * v.w,
129
130 b1 : a.a1 * v.x + a.b1 * v.y + a.c1 * v.z + a.d1 * v.w,
131 b2 : a.a2 * v.x + a.b2 * v.y + a.c2 * v.z + a.d2 * v.w,
132 b3 : a.a3 * v.x + a.b3 * v.y + a.c3 * v.z + a.d3 * v.w,
133 b4 : a.a4 * v.x + a.b4 * v.y + a.c4 * v.z + a.d4 * v.w,
134
135 c1 : a.a1 * v.x + a.b1 * v.y + a.c1 * v.z + a.d1 * v.w,
136 c2 : a.a2 * v.x + a.b2 * v.y + a.c2 * v.z + a.d2 * v.w,
137 c3 : a.a3 * v.x + a.b3 * v.y + a.c3 * v.z + a.d3 * v.w,
138 c4 : a.a4 * v.x + a.b4 * v.y + a.c4 * v.z + a.d4 * v.w,
139
140 d1 : a.a1 * v.x + a.b1 * v.y + a.c1 * v.z + a.d1 * v.w,
141 d2 : a.a2 * v.x + a.b2 * v.y + a.c2 * v.z + a.d2 * v.w,
142 d3 : a.a3 * v.x + a.b3 * v.y + a.c3 * v.z + a.d3 * v.w,
143 d4 : a.a4 * v.x + a.b4 * v.y + a.c4 * v.z + a.d4 * v.w,
144 }
145 }
146}
147
148impl<T> Mul for Mat4<T> where T:Copy + Mul<Output=T> + Add<Output=T>
149{
150 type Output = Mat4<T>;
151
152 fn mul(self, m:Self) -> Self
153 {
154 let a = self;
155
156 Self
157 {
158 a1 : a.a1 * m.a1 + a.b1 * m.a2 + a.c1 * m.a3 + a.d1 * m.a4,
159 a2 : a.a2 * m.a1 + a.b2 * m.a2 + a.c2 * m.a3 + a.d2 * m.a4,
160 a3 : a.a3 * m.a1 + a.b3 * m.a2 + a.c3 * m.a3 + a.d3 * m.a4,
161 a4 : a.a4 * m.a1 + a.b4 * m.a2 + a.c4 * m.a3 + a.d4 * m.a4,
162
163 b1 : a.a1 * m.b1 + a.b1 * m.b2 + a.c1 * m.b3 + a.d1 * m.b4,
164 b2 : a.a2 * m.b1 + a.b2 * m.b2 + a.c2 * m.b3 + a.d2 * m.b4,
165 b3 : a.a3 * m.b1 + a.b3 * m.b2 + a.c3 * m.b3 + a.d3 * m.b4,
166 b4 : a.a4 * m.b1 + a.b4 * m.b2 + a.c4 * m.b3 + a.d4 * m.b4,
167
168 c1 : a.a1 * m.c1 + a.b1 * m.c2 + a.c1 * m.c3 + a.d1 * m.c4,
169 c2 : a.a2 * m.c1 + a.b2 * m.c2 + a.c2 * m.c3 + a.d2 * m.c4,
170 c3 : a.a3 * m.c1 + a.b3 * m.c2 + a.c3 * m.c3 + a.d3 * m.c4,
171 c4 : a.a4 * m.c1 + a.b4 * m.c2 + a.c4 * m.c3 + a.d4 * m.c4,
172
173 d1 : a.a1 * m.d1 + a.b1 * m.d2 + a.c1 * m.d3 + a.d1 * m.d4,
174 d2 : a.a2 * m.d1 + a.b2 * m.d2 + a.c2 * m.d3 + a.d2 * m.d4,
175 d3 : a.a3 * m.d1 + a.b3 * m.d2 + a.c3 * m.d3 + a.d3 * m.d4,
176 d4 : a.a4 * m.d1 + a.b4 * m.d2 + a.c4 * m.d3 + a.d4 * m.d4,
177 }
178 }
179}
180
181impl<T> Mat4<T> where T: Copy
182{
183 pub fn new(
184 m11:T, m12:T, m13:T, m14:T,
185 m21:T, m22:T, m23:T, m24:T,
186 m31:T, m32:T, m33:T, m34:T,
187 m41:T, m42:T, m43:T, m44:T) -> Self
188 {
189 Self
190 {
191 a1:m11, a2:m12, a3:m13, a4:m14,
192 b1:m21, b2:m22, b3:m23, b4:m24,
193 c1:m31, c2:m32, c3:m33, c4:m34,
194 d1:m41, d2:m42, d3:m43, d4:m44,
195 }
196 }
197
198 pub fn right(&self) -> Vec3<T>
199 {
200 Vec3::new(self.a1, self.a2, self.a3)
201 }
202
203 pub fn up(&self) -> Vec3<T>
204 {
205 Vec3::new(self.b1, self.b2, self.b3)
206 }
207
208 pub fn forward(&self) -> Vec3<T>
209 {
210 Vec3::new(self.c1, self.c2, self.c3)
211 }
212
213 pub fn position(&self) -> Vec3<T>
214 {
215 Vec3::new(self.d1, self.d2, self.d3)
216 }
217}
218
219impl<T> Mat4<T> where T:Vec + Math + PiByC180
220{
221 pub fn rotate_x(theta:T) -> Self
222 {
223 let (s,c) = theta.sincos();
224
225 let a1 = T::one();
226 let a2 = T::zero();
227 let a3 = T::zero();
228 let a4 = T::zero();
229
230 let b1 = T::zero();
231 let b2 = c;
232 let b3 = s;
233 let b4 = T::zero();
234
235 let c1 = T::zero();
236 let c2 =-s;
237 let c3 = c;
238 let c4 = T::zero();
239
240 let d1 = T::zero();
241 let d2 = T::zero();
242 let d3 = T::zero();
243 let d4 = T::one();
244
245 Mat4::new(
246 a1, a2, a3, a4,
247 b1, b2, b3, b4,
248 c1, c2, c3, c4,
249 d1, d2, d3, d4
250 )
251 }
252
253 pub fn rotate_y(theta:T) -> Self
254 {
255 let (s,c) = theta.sincos();
256
257 let a1 = c;
258 let a2 = T::zero();
259 let a3 =-s;
260 let a4 = T::zero();
261
262 let b1 = T::zero();
263 let b2 = T::one();
264 let b3 = T::zero();
265 let b4 = T::zero();
266
267 let c1 = s;
268 let c2 = T::zero();
269 let c3 = c;
270 let c4 = T::zero();
271
272 let d1 = T::zero();
273 let d2 = T::zero();
274 let d3 = T::zero();
275 let d4 = T::one();
276
277 Mat4::new(
278 a1, a2, a3, a4,
279 b1, b2, b3, b4,
280 c1, c2, c3, c4,
281 d1, d2, d3, d4
282 )
283 }
284
285 pub fn rotate_z(theta:T) -> Self
286 {
287 let (s,c) = theta.sincos();
288
289 let a1 = c;
290 let a2 = s;
291 let a3 = T::zero();
292 let a4 = T::zero();
293
294 let b1 =-s;
295 let b2 = c;
296 let b3 = T::zero();
297 let b4 = T::zero();
298
299 let c1 = T::zero();
300 let c2 = T::zero();
301 let c3 = T::one();
302 let c4 = T::zero();
303
304 let d1 = T::zero();
305 let d2 = T::zero();
306 let d3 = T::zero();
307 let d4 = T::one();
308
309 Mat4::new(
310 a1, a2, a3, a4,
311 b1, b2, b3, b4,
312 c1, c2, c3, c4,
313 d1, d2, d3, d4
314 )
315 }
316
317 pub fn rotate(axis:Vec3<T>, theta:T) -> Self
318 {
319 let (s,c) = theta.sincos();
320
321 let x = axis.x;
322 let y = axis.y;
323 let z = axis.z;
324
325 let t = T::one() - c;
326 let tx = t * x;
327 let ty = t * y;
328 let tz = t * z;
329
330 let a1 = tx * x + c;
331 let a2 = tx * y + s * z;
332 let a3 = tx * z - s * y;
333 let a4 = T::zero();
334
335 let b1 = tx * y - s * z;
336 let b2 = ty * y + c;
337 let b3 = ty * z + s * x;
338 let b4 = T::zero();
339
340 let c1 = tx * z + s * y;
341 let c2 = ty * z - s * x;
342 let c3 = tz * z + c;
343 let c4 = T::zero();
344
345 let d1 = T::zero();
346 let d2 = T::zero();
347 let d3 = T::zero();
348 let d4 = T::one();
349
350 Mat4::new(
351 a1, a2, a3, a4,
352 b1, b2, b3, b4,
353 c1, c2, c3, c4,
354 d1, d2, d3, d4
355 )
356 }
357
358 pub fn scale(x:T, y:T, z:T) -> Self
359 {
360 let (a1,a2,a3,a4) = (x, T::zero(), T::zero(), T::zero());
361 let (b1,b2,b3,b4) = (T::zero(), y, T::zero(), T::zero());
362 let (c1,c2,c3,c4) = (T::zero(), T::zero(), z, T::zero());
363 let (d1,d2,d3,d4) = (T::zero(), T::zero(), T::zero(), T::one());
364
365 Mat4::new(
366 a1, a2, a3, a4,
367 b1, b2, b3, b4,
368 c1, c2, c3, c4,
369 d1, d2, d3, d4
370 )
371 }
372
373 pub fn translate(x:T, y:T, z:T) -> Self
374 {
375 let (a1,a2,a3,a4) = (T::one(), T::zero(), T::zero(), T::zero());
376 let (b1,b2,b3,b4) = (T::zero(), T::one(), T::zero(), T::zero());
377 let (c1,c2,c3,c4) = (T::zero(), T::zero(), T::one(), T::zero());
378 let (d1,d2,d3,d4) = (x, y, z, T::one());
379
380 Mat4::new(
381 a1, a2, a3, a4,
382 b1, b2, b3, b4,
383 c1, c2, c3, c4,
384 d1, d2, d3, d4
385 )
386 }
387
388 pub fn det(&self) -> T
389 {
390 let m = self;
391 m.a1*m.b2*m.c3*m.d4 - m.a1*m.b2*m.c4*m.d3 + m.a1*m.b3*m.c4*m.d2 - m.a1*m.b3*m.c2*m.d4 +
392 m.a1*m.b4*m.c2*m.d3 - m.a1*m.b4*m.c3*m.d2 - m.a2*m.b3*m.c4*m.d1 + m.a2*m.b3*m.c1*m.d4 -
393 m.a2*m.b4*m.c1*m.d3 + m.a2*m.b4*m.c3*m.d1 - m.a2*m.b1*m.c3*m.d4 + m.a2*m.b1*m.c4*m.d3 +
394 m.a3*m.b4*m.c1*m.d2 - m.a3*m.b4*m.c2*m.d1 + m.a3*m.b1*m.c2*m.d4 - m.a3*m.b1*m.c4*m.d2 +
395 m.a3*m.b2*m.c4*m.d1 - m.a3*m.b2*m.c1*m.d4 - m.a4*m.b1*m.c2*m.d3 + m.a4*m.b1*m.c3*m.d2 -
396 m.a4*m.b2*m.c3*m.d1 + m.a4*m.b2*m.c1*m.d3 - m.a4*m.b3*m.c1*m.d2 + m.a4*m.b3*m.c2*m.d1
397 }
398
399 pub fn inverse(&self) -> Self
400 {
401 let det = self.det();
402 if det.eq(T::zero())
403 {
404 return Mat4::one();
405 }
406
407 let m = self;
408 let invdet = T::one() / det;
409
410 Self
411 {
412 a1: invdet * (m.b2 * (m.c3 * m.d4 - m.c4 * m.d3) + m.b3 * (m.c4 * m.d2 - m.c2 * m.d4) + m.b4 * (m.c2 * m.d3 - m.c3 * m.d2)),
413 a2:-invdet * (m.a2 * (m.c3 * m.d4 - m.c4 * m.d3) + m.a3 * (m.c4 * m.d2 - m.c2 * m.d4) + m.a4 * (m.c2 * m.d3 - m.c3 * m.d2)),
414 a3: invdet * (m.a2 * (m.b3 * m.d4 - m.b4 * m.d3) + m.a3 * (m.b4 * m.d2 - m.b2 * m.d4) + m.a4 * (m.b2 * m.d3 - m.b3 * m.d2)),
415 a4:-invdet * (m.a2 * (m.b3 * m.c4 - m.b4 * m.c3) + m.a3 * (m.b4 * m.c2 - m.b2 * m.c4) + m.a4 * (m.b2 * m.c3 - m.b3 * m.c2)),
416 b1:-invdet * (m.b1 * (m.c3 * m.d4 - m.c4 * m.d3) + m.b3 * (m.c4 * m.d1 - m.c1 * m.d4) + m.b4 * (m.c1 * m.d3 - m.c3 * m.d1)),
417 b2: invdet * (m.a1 * (m.c3 * m.d4 - m.c4 * m.d3) + m.a3 * (m.c4 * m.d1 - m.c1 * m.d4) + m.a4 * (m.c1 * m.d3 - m.c3 * m.d1)),
418 b3:-invdet * (m.a1 * (m.b3 * m.d4 - m.b4 * m.d3) + m.a3 * (m.b4 * m.d1 - m.b1 * m.d4) + m.a4 * (m.b1 * m.d3 - m.b3 * m.d1)),
419 b4: invdet * (m.a1 * (m.b3 * m.c4 - m.b4 * m.c3) + m.a3 * (m.b4 * m.c1 - m.b1 * m.c4) + m.a4 * (m.b1 * m.c3 - m.b3 * m.c1)),
420 c1: invdet * (m.b1 * (m.c2 * m.d4 - m.c4 * m.d2) + m.b2 * (m.c4 * m.d1 - m.c1 * m.d4) + m.b4 * (m.c1 * m.d2 - m.c2 * m.d1)),
421 c2:-invdet * (m.a1 * (m.c2 * m.d4 - m.c4 * m.d2) + m.a2 * (m.c4 * m.d1 - m.c1 * m.d4) + m.a4 * (m.c1 * m.d2 - m.c2 * m.d1)),
422 c3: invdet * (m.a1 * (m.b2 * m.d4 - m.b4 * m.d2) + m.a2 * (m.b4 * m.d1 - m.b1 * m.d4) + m.a4 * (m.b1 * m.d2 - m.b2 * m.d1)),
423 c4:-invdet * (m.a1 * (m.b2 * m.c4 - m.b4 * m.c2) + m.a2 * (m.b4 * m.c1 - m.b1 * m.c4) + m.a4 * (m.b1 * m.c2 - m.b2 * m.c1)),
424 d1:-invdet * (m.b1 * (m.c2 * m.d3 - m.c3 * m.d2) + m.b2 * (m.c3 * m.d1 - m.c1 * m.d3) + m.b3 * (m.c1 * m.d2 - m.c2 * m.d1)),
425 d2: invdet * (m.a1 * (m.c2 * m.d3 - m.c3 * m.d2) + m.a2 * (m.c3 * m.d1 - m.c1 * m.d3) + m.a3 * (m.c1 * m.d2 - m.c2 * m.d1)),
426 d3:-invdet * (m.a1 * (m.b2 * m.d3 - m.b3 * m.d2) + m.a2 * (m.b3 * m.d1 - m.b1 * m.d3) + m.a3 * (m.b1 * m.d2 - m.b2 * m.d1)),
427 d4: invdet * (m.a1 * (m.b2 * m.c3 - m.b3 * m.c2) + m.a2 * (m.b3 * m.c1 - m.b1 * m.c3) + m.a3 * (m.b1 * m.c2 - m.b2 * m.c1)),
428 }
429 }
430
431 pub fn transform_inverse(&self) -> Self
432 {
433 let m = self;
434 let det = (m.a1 * m.b2 - m.a2 * m.b1) * (m.c3) - (m.a1 * m.b3 - m.a3 * m.b1) * (m.c2) + (m.a2 * m.b3 - m.a3 * m.b2) * (m.c1);
435 if det.eq(T::zero())
436 {
437 return Mat4::one();
438 }
439
440 let invdet = T::one() / det;
441
442 Self
443 {
444 a1 : invdet * (m.b2 * m.c3 + m.b3 * -m.c2),
445 a2 : invdet * (m.c2 * m.a3 + m.c3 * -m.a2),
446 a3 : invdet * (m.a2 * m.b3 - m.a3 * m.b2),
447 a4 : T::zero(),
448 b1 : invdet * (m.b3 * m.c1 + m.b1 * -m.c3),
449 b2 : invdet * (m.c3 * m.a1 + m.c1 * -m.a3),
450 b3 : invdet * (m.a3 * m.b1 - m.a1 * m.b3),
451 b4 : T::zero(),
452 c1 : invdet * (m.b1 * m.c2 + m.b2 * -m.c1),
453 c2 : invdet * (m.c1 * m.a2 + m.c2 * -m.a1),
454 c3 : invdet * (m.a1 * m.b2 - m.a2 * m.b1),
455 c4 : T::zero(),
456 d1 : invdet * (m.b1 * (m.c3 * m.d2 - m.c2 * m.d3) + m.b2 * (m.c1 * m.d3 - m.c3 * m.d1) + m.b3 * (m.c2 * m.d1 - m.c1 * m.d2)),
457 d2 : invdet * (m.c1 * (m.a3 * m.d2 - m.a2 * m.d3) + m.c2 * (m.a1 * m.d3 - m.a3 * m.d1) + m.c3 * (m.a2 * m.d1 - m.a1 * m.d2)),
458 d3 : invdet * (m.d1 * (m.a3 * m.b2 - m.a2 * m.b3) + m.d2 * (m.a1 * m.b3 - m.a3 * m.b1) + m.d3 * (m.a2 * m.b1 - m.a1 * m.b2)),
459 d4 : invdet * (m.a1 * (m.b2 * m.c3 - m.b3 * m.c2) + m.a2 * (m.b3 * m.c1 - m.b1 * m.c3) + m.a3 * (m.b1 * m.c2 - m.b2 * m.c1)),
460 }
461 }
462
463 pub fn ortho_lh(left:T, right:T, bottom:T, top:T, znear:T, zfar:T) -> Self
464 {
465 let tx = -(right + left) / (right - left);
466 let ty = -(top + bottom) / (top - bottom);
467 let tz = -znear / (zfar - znear);
468 let cx = T::two() / (right - left);
469 let cy = T::two() / (top - bottom);
470 let cz = T::one() / (zfar - znear);
471
472 Mat4::new(
473 cx, T::zero(), T::zero(), T::zero(),
474 T::zero(), cy, T::zero(), T::zero(),
475 T::zero(), T::zero(), cz, T::zero(),
476 tx, ty, tz, T::one())
477 }
478
479 pub fn ortho_rh(left:T, right:T, bottom:T, top:T, znear:T, zfar:T) -> Self
480 {
481 let tx = -(right + left) / (right - left);
482 let ty = -(top + bottom) / (top - bottom);
483 let tz = -(zfar + znear) / (zfar - znear);
484 let cx = T::two() / (right - left);
485 let cy = T::two() / (top - bottom);
486 let cz = -T::one() / (zfar - znear);
487
488 Mat4::new(
489 cx, T::zero(), T::zero(), T::zero(),
490 T::zero(), cy, T::zero(), T::zero(),
491 T::zero(), T::zero(), cz, T::zero(),
492 tx, ty, tz, T::one())
493 }
494
495 pub fn perspective_fov_lh(fov:T, aspect:T, znear:T, zfar:T) -> Self
496 {
497 let h = aspect / (fov * T::onehalf() * T::pi_by_c180()).tan();
498 let w = h / aspect;
499 let q = zfar / (zfar - znear);
500
501 Mat4::new(
502 w, T::zero(), T::zero(), T::zero(),
503 T::zero(), h, T::zero(), T::zero(),
504 T::zero(), T::zero(), q, T::one(),
505 T::zero(), T::zero(), -znear * q, T::zero()
506 )
507 }
508
509 pub fn perspective_fov_rh(fov:T, aspect:T, znear:T, zfar:T) -> Self
510 {
511 let h = aspect / (fov * T::onehalf() * T::pi_by_c180()).tan();
512 let w = h / aspect;
513 let q = -zfar / (zfar - znear);
514
515 Mat4::new(
516 w, T::zero(), T::zero(), T::zero(),
517 T::zero(), h, T::zero(), T::zero(),
518 T::zero(), T::zero(), q, -T::one(),
519 T::zero(), T::zero(), znear * q, T::zero()
520 )
521 }
522
523 pub fn lookat_lh(eye:Vec3<T>, center:Vec3<T>, up:Vec3<T>) -> Self
524 {
525 let mut z = center - eye;
526 z = z.normalize();
527
528 let mut x = up.cross(z);
529 x = x.normalize();
530
531 let mut y = z.cross(x);
532 y = y.normalize();
533
534 let mut m = Mat4::new(
535 x.x, y.x, z.x, T::zero(),
536 x.y, y.y, z.y, T::zero(),
537 x.z, y.z, z.z, T::zero(),
538 T::zero(), T::zero(), T::zero(), T::one());
539
540 let tmp = -eye;
541 if tmp.x.ne(T::zero())
542 {
543 m.d1 += tmp.x * m.a1;
544 m.d2 += tmp.x * m.a2;
545 m.d3 += tmp.x * m.a3;
546 m.d4 += tmp.x * m.a4;
547 }
548
549 if tmp.y.ne(T::zero())
550 {
551 m.d1 += tmp.y * m.b1;
552 m.d2 += tmp.y * m.b2;
553 m.d3 += tmp.y * m.b3;
554 m.d4 += tmp.y * m.b4;
555 }
556
557 if tmp.z.ne(T::zero())
558 {
559 m.d1 += tmp.z * m.c1;
560 m.d2 += tmp.z * m.c2;
561 m.d3 += tmp.z * m.c3;
562 m.d4 += tmp.z * m.c4;
563 }
564
565 return m;
566 }
567
568 pub fn lookat_rh(eye:Vec3<T>, center:Vec3<T>, up:Vec3<T>) -> Self
569 {
570 let mut z = eye - center;
571 z = z.normalize();
572
573 let mut x = up.cross(z);
574 x = x.normalize();
575
576 let mut y = z.cross(x);
577 y = y.normalize();
578
579 let mut m = Mat4::new(
580 x.x, y.x, z.x, T::zero(),
581 x.y, y.y, z.y, T::zero(),
582 x.z, y.z, z.z, T::zero(),
583 T::zero(), T::zero(), T::zero(), T::one());
584
585 let tmp = -eye;
586 if tmp.x.ne(T::zero())
587 {
588 m.d1 += tmp.x * m.a1;
589 m.d2 += tmp.x * m.a2;
590 m.d3 += tmp.x * m.a3;
591 m.d4 += tmp.x * m.a4;
592 }
593
594 if tmp.y.ne(T::zero())
595 {
596 m.d1 += tmp.y * m.b1;
597 m.d2 += tmp.y * m.b2;
598 m.d3 += tmp.y * m.b3;
599 m.d4 += tmp.y * m.b4;
600 }
601
602 if tmp.z.ne(T::zero())
603 {
604 m.d1 += tmp.z * m.c1;
605 m.d2 += tmp.z * m.c2;
606 m.d3 += tmp.z * m.c3;
607 m.d4 += tmp.z * m.c4;
608 }
609
610 return m;
611 }
612
613 pub fn as_ptr(&self) -> *const T
614 {
615 &self.a1
616 }
617
618 pub fn to_array(&self) -> [T; 16]
619 {
620 [
621 self.a1, self.a2, self.a3, self.a4,
622 self.b1, self.b2, self.b3, self.b4,
623 self.c1, self.c2, self.c3, self.c4,
624 self.d1, self.d2, self.d3, self.d4,
625 ]
626 }
627}
628
629impl<T> Zero for Mat4<T> where T:Zero
630{
631 #[inline(always)]
632 fn zero() -> Self
633 {
634 Self
635 {
636 a1:T::zero(), a2:T::zero(), a3:T::zero(), a4:T::zero(),
637 b1:T::zero(), b2:T::zero(), b3:T::zero(), b4:T::zero(),
638 c1:T::zero(), c2:T::zero(), c3:T::zero(), c4:T::zero(),
639 d1:T::zero(), d2:T::zero(), d3:T::zero(), d4:T::zero(),
640 }
641 }
642}
643
644impl<T> One for Mat4<T> where T:One + Zero
645{
646 #[inline(always)]
647 fn one() -> Self
648 {
649 Self
650 {
651 a1:T::one(), a2:T::zero(), a3:T::zero(), a4:T::zero(),
652 b1:T::zero(), b2:T::one(), b3:T::zero(), b4:T::zero(),
653 c1:T::zero(), c2:T::zero(), c3:T::one(), c4:T::zero(),
654 d1:T::zero(), d2:T::zero(), d3:T::zero(), d4:T::one(),
655 }
656 }
657}
658
659impl<T:Vec> From<Mat3<T>> for Mat4<T>
660{
661 fn from(m:Mat3<T>) -> Self
662 {
663 Self
664 {
665 a1:m.a1, a2:m.a2, a3:m.a3, a4:T::zero(),
666 b1:m.b1, b2:m.b2, b3:m.b3, b4:T::zero(),
667 c1:m.c1, c2:m.c2, c3:m.c3, c4:T::zero(),
668 d1:T::zero(), d2:T::zero(), d3:T::zero(), d4:T::one(),
669 }
670 }
671}
672
673impl<T:Vec> From<Quat<T>> for Mat4<T>
674{
675 fn from(q:Quat<T>) -> Self
676 {
677 let (xs,ys,zs) = (q.x * T::two(), q.y * T::two(), q.z * T::two());
678
679 let (xx,xy,xz) = (q.x * xs, q.x * ys, q.x * zs);
680 let (yy,yz,zz) = (q.y * ys, q.y * zs, q.z * zs);
681 let (wx,wy,wz) = (q.w * xs, q.w * ys, q.w * zs);
682
683 Self
684 {
685 a1:T::one() - (yy + zz),
686 a2:xy + wz,
687 a3:xz - wy,
688 a4:T::zero(),
689
690 b1:xy - wz,
691 b2:T::one() - (xx + zz),
692 b3:yz + wx,
693 b4:T::zero(),
694
695 c1:xz + wy,
696 c2:yz - wx,
697 c3:T::one() - (xx + yy),
698 c4:T::zero(),
699
700 d1:T::zero(),
701 d2:T::zero(),
702 d3:T::zero(),
703 d4:T::one()
704 }
705 }
706}
707
708impl<T> From<[T;16]> for Mat4<T> where T:Copy
709{
710 fn from(v:[T;16]) -> Self
711 {
712 Self
713 {
714 a1:v[0],a2:v[1],a3:v[2],a4:v[3],
715 b1:v[4],b2:v[5],b3:v[6],b4:v[7],
716 c1:v[8],c2:v[9],c3:v[10],c4:v[11],
717 d1:v[12],d2:v[13],d3:v[14],d4:v[15],
718 }
719 }
720}
721
722impl<T> From<(T,T,T,T,T,T,T,T,T,T,T,T,T,T,T,T)> for Mat4<T> where T:Copy
723{
724 fn from(v:(T,T,T,T,T,T,T,T,T,T,T,T,T,T,T,T)) -> Self
725 {
726 Self
727 {
728 a1:v.0,a2:v.1,a3:v.2,a4:v.3,
729 b1:v.4,b2:v.5,b3:v.6,b4:v.7,
730 c1:v.8,c2:v.9,c3:v.10,c4:v.11,
731 d1:v.12,d2:v.13,d3:v.14,d4:v.15,
732 }
733 }
734}
735
736impl<T> AsRef<Mat4<T>> for Mat4<T>
737{
738 fn as_ref(&self) -> &Mat4<T>
739 {
740 self
741 }
742}
743
744impl<T> AsMut<Mat4<T>> for Mat4<T>
745{
746 fn as_mut(&mut self) -> &mut Mat4<T>
747 {
748 self
749 }
750}