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