Clutter Engine 0.0.1
Loading...
Searching...
No Matches
type_mat3x4.inl
1namespace glm
2{
3 // -- Constructors --
4
5# if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
6 template<typename T, qualifier Q>
7 GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat()
8# if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALIZER_LIST
9 : value{col_type(1, 0, 0, 0), col_type(0, 1, 0, 0), col_type(0, 0, 1, 0)}
10# endif
11 {
12# if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALISATION
13 this->value[0] = col_type(1, 0, 0, 0);
14 this->value[1] = col_type(0, 1, 0, 0);
15 this->value[2] = col_type(0, 0, 1, 0);
16# endif
17 }
18# endif
19
20 template<typename T, qualifier Q>
21 template<qualifier P>
22 GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(mat<3, 4, T, P> const& m)
23# if GLM_HAS_INITIALIZER_LISTS
24 : value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
25# endif
26 {
27# if !GLM_HAS_INITIALIZER_LISTS
28 this->value[0] = m[0];
29 this->value[1] = m[1];
30 this->value[2] = m[2];
31# endif
32 }
33
34 template<typename T, qualifier Q>
35 GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(T s)
36# if GLM_HAS_INITIALIZER_LISTS
37 : value{col_type(s, 0, 0, 0), col_type(0, s, 0, 0), col_type(0, 0, s, 0)}
38# endif
39 {
40# if !GLM_HAS_INITIALIZER_LISTS
41 this->value[0] = col_type(s, 0, 0, 0);
42 this->value[1] = col_type(0, s, 0, 0);
43 this->value[2] = col_type(0, 0, s, 0);
44# endif
45 }
46
47 template<typename T, qualifier Q>
48 GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat
49 (
50 T x0, T y0, T z0, T w0,
51 T x1, T y1, T z1, T w1,
52 T x2, T y2, T z2, T w2
53 )
54# if GLM_HAS_INITIALIZER_LISTS
55 : value{
56 col_type(x0, y0, z0, w0),
57 col_type(x1, y1, z1, w1),
58 col_type(x2, y2, z2, w2)}
59# endif
60 {
61# if !GLM_HAS_INITIALIZER_LISTS
62 this->value[0] = col_type(x0, y0, z0, w0);
63 this->value[1] = col_type(x1, y1, z1, w1);
64 this->value[2] = col_type(x2, y2, z2, w2);
65# endif
66 }
67
68 template<typename T, qualifier Q>
69 GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(col_type const& v0, col_type const& v1, col_type const& v2)
70# if GLM_HAS_INITIALIZER_LISTS
71 : value{col_type(v0), col_type(v1), col_type(v2)}
72# endif
73 {
74# if !GLM_HAS_INITIALIZER_LISTS
75 this->value[0] = v0;
76 this->value[1] = v1;
77 this->value[2] = v2;
78# endif
79 }
80
81 // -- Conversion constructors --
82
83 template<typename T, qualifier Q>
84 template<
85 typename X0, typename Y0, typename Z0, typename W0,
86 typename X1, typename Y1, typename Z1, typename W1,
87 typename X2, typename Y2, typename Z2, typename W2>
88 GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat
89 (
90 X0 x0, Y0 y0, Z0 z0, W0 w0,
91 X1 x1, Y1 y1, Z1 z1, W1 w1,
92 X2 x2, Y2 y2, Z2 z2, W2 w2
93 )
94# if GLM_HAS_INITIALIZER_LISTS
95 : value{
96 col_type(x0, y0, z0, w0),
97 col_type(x1, y1, z1, w1),
98 col_type(x2, y2, z2, w2)}
99# endif
100 {
101# if !GLM_HAS_INITIALIZER_LISTS
102 this->value[0] = col_type(x0, y0, z0, w0);
103 this->value[1] = col_type(x1, y1, z1, w1);
104 this->value[2] = col_type(x2, y2, z2, w2);
105# endif
106 }
107
108 template<typename T, qualifier Q>
109 template<typename V1, typename V2, typename V3>
110 GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(vec<4, V1, Q> const& v0, vec<4, V2, Q> const& v1, vec<4, V3, Q> const& v2)
111# if GLM_HAS_INITIALIZER_LISTS
112 : value{col_type(v0), col_type(v1), col_type(v2)}
113# endif
114 {
115# if !GLM_HAS_INITIALIZER_LISTS
116 this->value[0] = col_type(v0);
117 this->value[1] = col_type(v1);
118 this->value[2] = col_type(v2);
119# endif
120 }
121
122 // -- Matrix conversions --
123
124 template<typename T, qualifier Q>
125 template<typename U, qualifier P>
126 GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(mat<3, 4, U, P> const& m)
127# if GLM_HAS_INITIALIZER_LISTS
128 : value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
129# endif
130 {
131# if !GLM_HAS_INITIALIZER_LISTS
132 this->value[0] = col_type(m[0]);
133 this->value[1] = col_type(m[1]);
134 this->value[2] = col_type(m[2]);
135# endif
136 }
137
138 template<typename T, qualifier Q>
139 GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(mat<2, 2, T, Q> const& m)
140# if GLM_HAS_INITIALIZER_LISTS
141 : value{col_type(m[0], 0, 0), col_type(m[1], 0, 0), col_type(0, 0, 1, 0)}
142# endif
143 {
144# if !GLM_HAS_INITIALIZER_LISTS
145 this->value[0] = col_type(m[0], 0, 0);
146 this->value[1] = col_type(m[1], 0, 0);
147 this->value[2] = col_type(0, 0, 1, 0);
148# endif
149 }
150
151 template<typename T, qualifier Q>
152 GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(mat<3, 3, T, Q> const& m)
153# if GLM_HAS_INITIALIZER_LISTS
154 : value{col_type(m[0], 0), col_type(m[1], 0), col_type(m[2], 0)}
155# endif
156 {
157# if !GLM_HAS_INITIALIZER_LISTS
158 this->value[0] = col_type(m[0], 0);
159 this->value[1] = col_type(m[1], 0);
160 this->value[2] = col_type(m[2], 0);
161# endif
162 }
163
164 template<typename T, qualifier Q>
165 GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(mat<4, 4, T, Q> const& m)
166# if GLM_HAS_INITIALIZER_LISTS
167 : value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
168# endif
169 {
170# if !GLM_HAS_INITIALIZER_LISTS
171 this->value[0] = col_type(m[0]);
172 this->value[1] = col_type(m[1]);
173 this->value[2] = col_type(m[2]);
174# endif
175 }
176
177 template<typename T, qualifier Q>
178 GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(mat<2, 3, T, Q> const& m)
179# if GLM_HAS_INITIALIZER_LISTS
180 : value{col_type(m[0], 0), col_type(m[1], 0), col_type(0, 0, 1, 0)}
181# endif
182 {
183# if !GLM_HAS_INITIALIZER_LISTS
184 this->value[0] = col_type(m[0], 0);
185 this->value[1] = col_type(m[1], 0);
186 this->value[2] = col_type(0, 0, 1, 0);
187# endif
188 }
189
190 template<typename T, qualifier Q>
191 GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(mat<3, 2, T, Q> const& m)
192# if GLM_HAS_INITIALIZER_LISTS
193 : value{col_type(m[0], 0, 0), col_type(m[1], 0, 0), col_type(m[2], 1, 0)}
194# endif
195 {
196# if !GLM_HAS_INITIALIZER_LISTS
197 this->value[0] = col_type(m[0], 0, 0);
198 this->value[1] = col_type(m[1], 0, 0);
199 this->value[2] = col_type(m[2], 1, 0);
200# endif
201 }
202
203 template<typename T, qualifier Q>
204 GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(mat<2, 4, T, Q> const& m)
205# if GLM_HAS_INITIALIZER_LISTS
206 : value{col_type(m[0]), col_type(m[1]), col_type(0, 0, 1, 0)}
207# endif
208 {
209# if !GLM_HAS_INITIALIZER_LISTS
210 this->value[0] = col_type(m[0]);
211 this->value[1] = col_type(m[1]);
212 this->value[2] = col_type(0, 0, 1, 0);
213# endif
214 }
215
216 template<typename T, qualifier Q>
217 GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(mat<4, 2, T, Q> const& m)
218# if GLM_HAS_INITIALIZER_LISTS
219 : value{col_type(m[0], 0, 0), col_type(m[1], 0, 0), col_type(m[2], 1, 0)}
220# endif
221 {
222# if !GLM_HAS_INITIALIZER_LISTS
223 this->value[0] = col_type(m[0], 0, 0);
224 this->value[1] = col_type(m[1], 0, 0);
225 this->value[2] = col_type(m[2], 1, 0);
226# endif
227 }
228
229 template<typename T, qualifier Q>
230 GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(mat<4, 3, T, Q> const& m)
231# if GLM_HAS_INITIALIZER_LISTS
232 : value{col_type(m[0], 0), col_type(m[1], 0), col_type(m[2], 0)}
233# endif
234 {
235# if !GLM_HAS_INITIALIZER_LISTS
236 this->value[0] = col_type(m[0], 0);
237 this->value[1] = col_type(m[1], 0);
238 this->value[2] = col_type(m[2], 0);
239# endif
240 }
241
242 // -- Accesses --
243
244 template<typename T, qualifier Q>
245 GLM_FUNC_QUALIFIER typename mat<3, 4, T, Q>::col_type & mat<3, 4, T, Q>::operator[](typename mat<3, 4, T, Q>::length_type i)
246 {
247 assert(i < this->length());
248 return this->value[i];
249 }
250
251 template<typename T, qualifier Q>
252 GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename mat<3, 4, T, Q>::col_type const& mat<3, 4, T, Q>::operator[](typename mat<3, 4, T, Q>::length_type i) const
253 {
254 assert(i < this->length());
255 return this->value[i];
256 }
257
258 // -- Unary updatable operators --
259
260 template<typename T, qualifier Q>
261 template<typename U>
262 GLM_FUNC_QUALIFIER mat<3, 4, T, Q>& mat<3, 4, T, Q>::operator=(mat<3, 4, U, Q> const& m)
263 {
264 this->value[0] = m[0];
265 this->value[1] = m[1];
266 this->value[2] = m[2];
267 return *this;
268 }
269
270 template<typename T, qualifier Q>
271 template<typename U>
272 GLM_FUNC_QUALIFIER mat<3, 4, T, Q>& mat<3, 4, T, Q>::operator+=(U s)
273 {
274 this->value[0] += s;
275 this->value[1] += s;
276 this->value[2] += s;
277 return *this;
278 }
279
280 template<typename T, qualifier Q>
281 template<typename U>
282 GLM_FUNC_QUALIFIER mat<3, 4, T, Q>& mat<3, 4, T, Q>::operator+=(mat<3, 4, U, Q> const& m)
283 {
284 this->value[0] += m[0];
285 this->value[1] += m[1];
286 this->value[2] += m[2];
287 return *this;
288 }
289
290 template<typename T, qualifier Q>
291 template<typename U>
292 GLM_FUNC_QUALIFIER mat<3, 4, T, Q>& mat<3, 4, T, Q>::operator-=(U s)
293 {
294 this->value[0] -= s;
295 this->value[1] -= s;
296 this->value[2] -= s;
297 return *this;
298 }
299
300 template<typename T, qualifier Q>
301 template<typename U>
302 GLM_FUNC_QUALIFIER mat<3, 4, T, Q>& mat<3, 4, T, Q>::operator-=(mat<3, 4, U, Q> const& m)
303 {
304 this->value[0] -= m[0];
305 this->value[1] -= m[1];
306 this->value[2] -= m[2];
307 return *this;
308 }
309
310 template<typename T, qualifier Q>
311 template<typename U>
312 GLM_FUNC_QUALIFIER mat<3, 4, T, Q>& mat<3, 4, T, Q>::operator*=(U s)
313 {
314 this->value[0] *= s;
315 this->value[1] *= s;
316 this->value[2] *= s;
317 return *this;
318 }
319
320 template<typename T, qualifier Q>
321 template<typename U>
322 GLM_FUNC_QUALIFIER mat<3, 4, T, Q> & mat<3, 4, T, Q>::operator/=(U s)
323 {
324 this->value[0] /= s;
325 this->value[1] /= s;
326 this->value[2] /= s;
327 return *this;
328 }
329
330 // -- Increment and decrement operators --
331
332 template<typename T, qualifier Q>
333 GLM_FUNC_QUALIFIER mat<3, 4, T, Q>& mat<3, 4, T, Q>::operator++()
334 {
335 ++this->value[0];
336 ++this->value[1];
337 ++this->value[2];
338 return *this;
339 }
340
341 template<typename T, qualifier Q>
342 GLM_FUNC_QUALIFIER mat<3, 4, T, Q>& mat<3, 4, T, Q>::operator--()
343 {
344 --this->value[0];
345 --this->value[1];
346 --this->value[2];
347 return *this;
348 }
349
350 template<typename T, qualifier Q>
351 GLM_FUNC_QUALIFIER mat<3, 4, T, Q> mat<3, 4, T, Q>::operator++(int)
352 {
353 mat<3, 4, T, Q> Result(*this);
354 ++*this;
355 return Result;
356 }
357
358 template<typename T, qualifier Q>
359 GLM_FUNC_QUALIFIER mat<3, 4, T, Q> mat<3, 4, T, Q>::operator--(int)
360 {
361 mat<3, 4, T, Q> Result(*this);
362 --*this;
363 return Result;
364 }
365
366 // -- Unary arithmetic operators --
367
368 template<typename T, qualifier Q>
369 GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator+(mat<3, 4, T, Q> const& m)
370 {
371 return m;
372 }
373
374 template<typename T, qualifier Q>
375 GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator-(mat<3, 4, T, Q> const& m)
376 {
377 return mat<3, 4, T, Q>(
378 -m[0],
379 -m[1],
380 -m[2]);
381 }
382
383 // -- Binary arithmetic operators --
384
385 template<typename T, qualifier Q>
386 GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator+(mat<3, 4, T, Q> const& m, T scalar)
387 {
388 return mat<3, 4, T, Q>(
389 m[0] + scalar,
390 m[1] + scalar,
391 m[2] + scalar);
392 }
393
394 template<typename T, qualifier Q>
395 GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator+(mat<3, 4, T, Q> const& m1, mat<3, 4, T, Q> const& m2)
396 {
397 return mat<3, 4, T, Q>(
398 m1[0] + m2[0],
399 m1[1] + m2[1],
400 m1[2] + m2[2]);
401 }
402
403 template<typename T, qualifier Q>
404 GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator-(mat<3, 4, T, Q> const& m, T scalar)
405 {
406 return mat<3, 4, T, Q>(
407 m[0] - scalar,
408 m[1] - scalar,
409 m[2] - scalar);
410 }
411
412 template<typename T, qualifier Q>
413 GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator-(mat<3, 4, T, Q> const& m1, mat<3, 4, T, Q> const& m2)
414 {
415 return mat<3, 4, T, Q>(
416 m1[0] - m2[0],
417 m1[1] - m2[1],
418 m1[2] - m2[2]);
419 }
420
421 template<typename T, qualifier Q>
422 GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator*(mat<3, 4, T, Q> const& m, T scalar)
423 {
424 return mat<3, 4, T, Q>(
425 m[0] * scalar,
426 m[1] * scalar,
427 m[2] * scalar);
428 }
429
430 template<typename T, qualifier Q>
431 GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator*(T scalar, mat<3, 4, T, Q> const& m)
432 {
433 return mat<3, 4, T, Q>(
434 m[0] * scalar,
435 m[1] * scalar,
436 m[2] * scalar);
437 }
438
439 template<typename T, qualifier Q>
440 GLM_FUNC_QUALIFIER typename mat<3, 4, T, Q>::col_type operator*
441 (
442 mat<3, 4, T, Q> const& m,
443 typename mat<3, 4, T, Q>::row_type const& v
444 )
445 {
446 return typename mat<3, 4, T, Q>::col_type(
447 m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z,
448 m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z,
449 m[0][2] * v.x + m[1][2] * v.y + m[2][2] * v.z,
450 m[0][3] * v.x + m[1][3] * v.y + m[2][3] * v.z);
451 }
452
453 template<typename T, qualifier Q>
454 GLM_FUNC_QUALIFIER typename mat<3, 4, T, Q>::row_type operator*
455 (
456 typename mat<3, 4, T, Q>::col_type const& v,
457 mat<3, 4, T, Q> const& m
458 )
459 {
460 return typename mat<3, 4, T, Q>::row_type(
461 v.x * m[0][0] + v.y * m[0][1] + v.z * m[0][2] + v.w * m[0][3],
462 v.x * m[1][0] + v.y * m[1][1] + v.z * m[1][2] + v.w * m[1][3],
463 v.x * m[2][0] + v.y * m[2][1] + v.z * m[2][2] + v.w * m[2][3]);
464 }
465
466 template<typename T, qualifier Q>
467 GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator*(mat<3, 4, T, Q> const& m1, mat<4, 3, T, Q> const& m2)
468 {
469 const T SrcA00 = m1[0][0];
470 const T SrcA01 = m1[0][1];
471 const T SrcA02 = m1[0][2];
472 const T SrcA03 = m1[0][3];
473 const T SrcA10 = m1[1][0];
474 const T SrcA11 = m1[1][1];
475 const T SrcA12 = m1[1][2];
476 const T SrcA13 = m1[1][3];
477 const T SrcA20 = m1[2][0];
478 const T SrcA21 = m1[2][1];
479 const T SrcA22 = m1[2][2];
480 const T SrcA23 = m1[2][3];
481
482 const T SrcB00 = m2[0][0];
483 const T SrcB01 = m2[0][1];
484 const T SrcB02 = m2[0][2];
485 const T SrcB10 = m2[1][0];
486 const T SrcB11 = m2[1][1];
487 const T SrcB12 = m2[1][2];
488 const T SrcB20 = m2[2][0];
489 const T SrcB21 = m2[2][1];
490 const T SrcB22 = m2[2][2];
491 const T SrcB30 = m2[3][0];
492 const T SrcB31 = m2[3][1];
493 const T SrcB32 = m2[3][2];
494
495 mat<4, 4, T, Q> Result;
496 Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01 + SrcA20 * SrcB02;
497 Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01 + SrcA21 * SrcB02;
498 Result[0][2] = SrcA02 * SrcB00 + SrcA12 * SrcB01 + SrcA22 * SrcB02;
499 Result[0][3] = SrcA03 * SrcB00 + SrcA13 * SrcB01 + SrcA23 * SrcB02;
500 Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11 + SrcA20 * SrcB12;
501 Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11 + SrcA21 * SrcB12;
502 Result[1][2] = SrcA02 * SrcB10 + SrcA12 * SrcB11 + SrcA22 * SrcB12;
503 Result[1][3] = SrcA03 * SrcB10 + SrcA13 * SrcB11 + SrcA23 * SrcB12;
504 Result[2][0] = SrcA00 * SrcB20 + SrcA10 * SrcB21 + SrcA20 * SrcB22;
505 Result[2][1] = SrcA01 * SrcB20 + SrcA11 * SrcB21 + SrcA21 * SrcB22;
506 Result[2][2] = SrcA02 * SrcB20 + SrcA12 * SrcB21 + SrcA22 * SrcB22;
507 Result[2][3] = SrcA03 * SrcB20 + SrcA13 * SrcB21 + SrcA23 * SrcB22;
508 Result[3][0] = SrcA00 * SrcB30 + SrcA10 * SrcB31 + SrcA20 * SrcB32;
509 Result[3][1] = SrcA01 * SrcB30 + SrcA11 * SrcB31 + SrcA21 * SrcB32;
510 Result[3][2] = SrcA02 * SrcB30 + SrcA12 * SrcB31 + SrcA22 * SrcB32;
511 Result[3][3] = SrcA03 * SrcB30 + SrcA13 * SrcB31 + SrcA23 * SrcB32;
512 return Result;
513 }
514
515 template<typename T, qualifier Q>
516 GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator*(mat<3, 4, T, Q> const& m1, mat<2, 3, T, Q> const& m2)
517 {
518 return mat<2, 4, T, Q>(
519 m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2],
520 m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2],
521 m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2],
522 m1[0][3] * m2[0][0] + m1[1][3] * m2[0][1] + m1[2][3] * m2[0][2],
523 m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2],
524 m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2],
525 m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2],
526 m1[0][3] * m2[1][0] + m1[1][3] * m2[1][1] + m1[2][3] * m2[1][2]);
527 }
528
529 template<typename T, qualifier Q>
530 GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator*(mat<3, 4, T, Q> const& m1, mat<3, 3, T, Q> const& m2)
531 {
532 return mat<3, 4, T, Q>(
533 m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2],
534 m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2],
535 m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2],
536 m1[0][3] * m2[0][0] + m1[1][3] * m2[0][1] + m1[2][3] * m2[0][2],
537 m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2],
538 m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2],
539 m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2],
540 m1[0][3] * m2[1][0] + m1[1][3] * m2[1][1] + m1[2][3] * m2[1][2],
541 m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2],
542 m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2],
543 m1[0][2] * m2[2][0] + m1[1][2] * m2[2][1] + m1[2][2] * m2[2][2],
544 m1[0][3] * m2[2][0] + m1[1][3] * m2[2][1] + m1[2][3] * m2[2][2]);
545 }
546
547 template<typename T, qualifier Q>
548 GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator/(mat<3, 4, T, Q> const& m, T scalar)
549 {
550 return mat<3, 4, T, Q>(
551 m[0] / scalar,
552 m[1] / scalar,
553 m[2] / scalar);
554 }
555
556 template<typename T, qualifier Q>
557 GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator/(T scalar, mat<3, 4, T, Q> const& m)
558 {
559 return mat<3, 4, T, Q>(
560 scalar / m[0],
561 scalar / m[1],
562 scalar / m[2]);
563 }
564
565 // -- Boolean operators --
566
567 template<typename T, qualifier Q>
568 GLM_FUNC_QUALIFIER bool operator==(mat<3, 4, T, Q> const& m1, mat<3, 4, T, Q> const& m2)
569 {
570 return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]);
571 }
572
573 template<typename T, qualifier Q>
574 GLM_FUNC_QUALIFIER bool operator!=(mat<3, 4, T, Q> const& m1, mat<3, 4, T, Q> const& m2)
575 {
576 return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]);
577 }
578} //namespace glm
glm
Core features
Definition common.hpp:21
Generated by doxygen 1.12.0