1 /*---------------------------------------------------------------------------*
2 Project: Horizon
3 File: math_Matrix44.h
4
5 Copyright (C)2009-2010 Nintendo Co., Ltd. All rights reserved.
6
7 These coded instructions, statements, and computer programs contain
8 proprietary information of Nintendo of America Inc. and/or Nintendo
9 Company Ltd., and are protected by Federal copyright law. They may
10 not be disclosed to third parties or copied or duplicated in any form,
11 in whole or in part, without the prior written consent of Nintendo.
12
13 $Revision: 34617 $
14 *---------------------------------------------------------------------------*/
15
16 #ifndef NN_MATH_MATRIX44_H_
17 #define NN_MATH_MATRIX44_H_
18
19 #include <cstring>
20 #include <nn/math/math_Config.h>
21
22 #pragma push
23 #pragma Otime
24
25 namespace nn {
26 namespace math {
27
28 /* Please see man pages for details
29
30
31 */
32
33 /*
34
35
36 */
37 enum PivotDirection
38 {
39 PIVOT_NONE, //
40 PIVOT_UPSIDE_TO_TOP, //
41 PIVOT_UPSIDE_TO_RIGHT, //
42 PIVOT_UPSIDE_TO_BOTTOM, //
43 PIVOT_UPSIDE_TO_LEFT, //
44 PIVOT_NUM
45 };
46
47 /*
48
49 */
50
51 /* ------------------------------------------------------------------------
52 Function for MTX44
53 ------------------------------------------------------------------------ */
54 struct MTX44;
55
56 NN_MATH_INLINE MTX44* MTX44Zero(MTX44* pOut);
57 NN_MATH_INLINE bool MTX44IsIdentity(const MTX44* p);
58 NN_MATH_INLINE MTX44* MTX44Identity(MTX44* pOut);
59 NN_MATH_INLINE MTX44* MTX44Copy(MTX44* pOut, const MTX44* p);
60
61 NN_MATH_INLINE MTX44* MTX44Add(MTX44* pOut, const MTX44* p1, const MTX44* p2);
62 NN_MATH_INLINE MTX44* MTX44Sub(MTX44* pOut, const MTX44* p1, const MTX44* p2);
63 NN_MATH_INLINE MTX44* MTX44Mult(MTX44* pOut, const MTX44* p, f32 f);
64 NN_MATH_INLINE MTX44* MTX44Mult(MTX44* pOut, const MTX44* p1, const MTX44* p2);
65
66 NN_MATH_INLINE MTX44* MTX44Frustum(MTX44* pOut, f32 l, f32 r, f32 b, f32 t, f32 n, f32 f);
67 NN_MATH_INLINE MTX44* MTX44Ortho(MTX44* pOut, f32 l, f32 r, f32 b, f32 t, f32 n, f32 f);
68 NN_MATH_INLINE MTX44* MTX44PerspectiveRad(MTX44* pOut, f32 fovy, f32 aspect, f32 n, f32 f);
69 NN_MATH_INLINE MTX44* MTX44Transpose(MTX44* pOut, const MTX44 *pSrc);
70 NN_MATH_INLINE MTX44* MTX44MultArray(MTX44* pOut, const MTX44* p1, const MTX44* pSrc, s32 count);
71 NN_MATH_INLINE u32 MTX44Inverse(MTX44* pOut, const MTX44* p);
72
73 NN_MATH_INLINE MTX44* MTX44RotXYZFIdx(MTX44* pOut, f32 fIdxX, f32 fIdxY, f32 fIdxZ);
74 NN_MATH_INLINE MTX44* MTX44RotAxisFIdx(MTX44* pOut, const VEC3* pAxis, f32 fIdx);
75
76 NN_MATH_INLINE MTX44* MTX44Scale(MTX44* pOut, const VEC3* pS);
77 NN_MATH_INLINE MTX44* MTX44MultScale(MTX44* pOut, const MTX44* pM, const VEC3* pS);
78 NN_MATH_INLINE MTX44* MTX44MultScale(MTX44* pOut, const VEC3* pS, const MTX44* pM);
79
80 NN_MATH_INLINE MTX44* MTX44Translate(MTX44* pOut, const VEC3* pT);
81 NN_MATH_INLINE MTX44* MTX44MultTranslate(MTX44* pOut, const MTX44* pM, const VEC3* pT);
82 NN_MATH_INLINE MTX44* MTX44MultTranslate(MTX44* pOut, const VEC3* pT, const MTX44* pM);
83
84 NN_MATH_INLINE MTX44* MTX44FrustumPivot(MTX44* pOut, f32 l, f32 r, f32 b, f32 t, f32 n, f32 f, PivotDirection pivot = PIVOT_NONE);
85 NN_MATH_INLINE MTX44* MTX44OrthoPivot(MTX44* pOut, f32 l, f32 r, f32 b, f32 t, f32 n, f32 f, PivotDirection pivot = PIVOT_NONE);
86 NN_MATH_INLINE MTX44* MTX44PerspectivePivotRad(MTX44* pOut, f32 fovy, f32 aspect, f32 n, f32 f, PivotDirection pivot = PIVOT_NONE);
87
88 NN_FORCE_INLINE MTX44* MTX44Add(MTX44* pOut, const MTX44* p1, const MTX44* p2);
89 NN_FORCE_INLINE MTX44* MTX44Copy(MTX44* pOut, const MTX44* p);
90 NN_FORCE_INLINE MTX44* MTX44Frustum(MTX44* pOut, f32 l, f32 r, f32 b, f32 t, f32 n, f32 f);
91 NN_FORCE_INLINE u32 MTX44Inverse(MTX44* pOut, const MTX44* p);
92 NN_FORCE_INLINE MTX44* MTX44Mult(MTX44* pOut, const MTX44* __restrict p1, const MTX44* __restrict p2);
93 NN_FORCE_INLINE MTX44* MTX44Mult(MTX44* pOut, const MTX44* p, f32 f);
94 NN_FORCE_INLINE MTX44* MTX44MultScale(MTX44* pOut, const MTX44* pM, const VEC3* pS);
95 NN_FORCE_INLINE MTX44* MTX44MultScale(MTX44* pOut, const VEC3* pS, const MTX44* pM);
96 NN_FORCE_INLINE MTX44* MTX44MultTranslate(MTX44* pOut, const VEC3* pT, const MTX44* pM);
97 NN_FORCE_INLINE MTX44* MTX44MultTranslate(MTX44* pOut, const MTX44* pM, const VEC3* pT);
98 NN_FORCE_INLINE MTX44* MTX44Ortho(MTX44* pOut, f32 l, f32 r, f32 b, f32 t, f32 n, f32 f);
99 NN_FORCE_INLINE MTX44* MTX44PerspectiveRad(MTX44* pOut, f32 fovy, f32 aspect, f32 n, f32 f);
100 NN_FORCE_INLINE MTX44* MTX44RotAxisRad_( MTX44* pOut, const VEC3 *pAxis, f32 fRad );
101 NN_FORCE_INLINE MTX44* MTX44RotXYZFIdx(MTX44* pOut, f32 fIdxX, f32 fIdxY, f32 fIdxZ);
102 NN_FORCE_INLINE MTX44* MTX44Scale(MTX44* pOut, const VEC3* pS);
103 NN_FORCE_INLINE MTX44* MTX44Translate(MTX44* pOut, const VEC3* pT);
104 NN_FORCE_INLINE MTX44* MTX44Transpose(MTX44* pOut, const MTX44 *pSrc);
105
106 NN_FORCE_INLINE VEC4* VEC3Transform(VEC4* pOut, const MTX44* pM, const VEC3* pV);
107
108 NN_FORCE_INLINE MTX44* MTX44Pivot( MTX44* pOut, PivotDirection pivot );
109
110 /* Please see man pages for details
111
112
113 */
114
115 /*
116
117
118
119
120
121
122
123
124
125 */
126 inline MTX44*
MTX44PerspectiveDeg(MTX44 * pOut,f32 fovy,f32 aspect,f32 n,f32 f)127 MTX44PerspectiveDeg(MTX44* pOut, f32 fovy, f32 aspect, f32 n, f32 f)
128 {
129 return MTX44PerspectiveRad(pOut, NN_MATH_DEG_TO_RAD(fovy), aspect, n, f);
130 }
131
132
133 // Alias for the MTX44PerspectiveDeg function.
134 // For compatibility purposes, "Perspective" functions that do not have suffixes are the versions that use degrees.
135 inline MTX44*
MTX44Perspective(MTX44 * pOut,f32 fovy,f32 aspect,f32 n,f32 f)136 MTX44Perspective(MTX44* pOut, f32 fovy, f32 aspect, f32 n, f32 f)
137 {
138 return MTX44PerspectiveDeg(pOut, fovy, aspect, n, f);
139 }
140
141 /*
142
143
144
145
146
147
148
149
150
151 */
152 inline MTX44*
153 MTX44PerspectivePivotDeg(MTX44* pOut, f32 fovy, f32 aspect, f32 n, f32 f, PivotDirection pivot = PIVOT_NONE )
154 {
155 return MTX44PerspectivePivotRad(pOut, NN_MATH_DEG_TO_RAD(fovy), aspect, n, f, pivot);
156 }
157
158
159 /*
160
161
162
163
164
165
166
167
168 */
169 inline MTX44*
MTX44RotXYZRad(MTX44 * pOut,f32 fRadX,f32 fRadY,f32 fRadZ)170 MTX44RotXYZRad(MTX44* pOut, f32 fRadX, f32 fRadY, f32 fRadZ)
171 {
172 return MTX44RotXYZFIdx(pOut, NN_MATH_RAD_TO_FIDX(fRadX), NN_MATH_RAD_TO_FIDX(fRadY), NN_MATH_RAD_TO_FIDX(fRadZ));
173 }
174
175 /*
176
177
178
179
180
181
182
183
184 */
185 inline MTX44*
MTX44RotXYZDeg(MTX44 * pOut,f32 fDegX,f32 fDegY,f32 fDegZ)186 MTX44RotXYZDeg(MTX44* pOut, f32 fDegX, f32 fDegY, f32 fDegZ)
187 {
188 return MTX44RotXYZFIdx(pOut, NN_MATH_DEG_TO_FIDX(fDegX), NN_MATH_DEG_TO_FIDX(fDegY), NN_MATH_DEG_TO_FIDX(fDegZ));
189 }
190
191 /*
192
193
194
195
196
197
198
199 */
200 inline MTX44*
MTX44RotAxisRad(MTX44 * pOut,const VEC3 * pAxis,f32 fRad)201 MTX44RotAxisRad(MTX44* pOut, const VEC3* pAxis, f32 fRad)
202 {
203 return MTX44RotAxisFIdx(pOut, pAxis, NN_MATH_RAD_TO_FIDX(fRad));
204 }
205
206 /*
207
208
209
210
211
212
213
214 */
215 inline MTX44*
MTX44RotAxisDeg(MTX44 * pOut,const VEC3 * pAxis,f32 fDeg)216 MTX44RotAxisDeg(MTX44* pOut, const VEC3* pAxis, f32 fDeg)
217 {
218 return MTX44RotAxisFIdx(pOut, pAxis, NN_MATH_DEG_TO_FIDX(fDeg));
219 }
220
221 /* =======================================================================
222 Class definitions
223 ======================================================================== */
224 struct MTX34;
225
226 struct MTX44_
227 {
228 struct BaseData
229 {
230 f32 _00, _01, _02, _03;
231 f32 _10, _11, _12, _13;
232 f32 _20, _21, _22, _23;
233 f32 _30, _31, _32, _33;
234 };
235
236 union
237 {
238 #if defined(NN_MATH_USE_ANONYMOUS_STRUCT)
239 struct
240 {
241 f32 _00, _01, _02, _03;
242 f32 _10, _11, _12, _13;
243 f32 _20, _21, _22, _23;
244 f32 _30, _31, _32, _33;
245 };
246 #endif
247 BaseData f;
248 f32 m[4][4];
249 f32 a[16];
250 VEC4_ v[4];
251 };
252 };
253
254 /*
255
256 */
257 struct MTX44 : public MTX44_
258 {
259 public:
260 static const int ROW_COUNT = 4; //
261 static const int COLUMN_COUNT = 4; //
262
263 //
IdentityMTX44264 static const MTX44& Identity()
265 {
266 static const MTX44 identity(
267 1.0f, 0.0f, 0.0f, 0.0f,
268 0.0f, 1.0f, 0.0f, 0.0f,
269 0.0f, 0.0f, 1.0f, 0.0f,
270 0.0f, 0.0f, 0.0f, 1.0f);
271
272 return identity;
273 }
274 typedef MTX44 self_type; //
275 typedef f32 value_type; //
276
277 public:
278 //----------------------------------------
279 //
280 //
281
282 //
MTX44MTX44283 MTX44() {}
284
285 //
MTX44MTX44286 explicit MTX44(const f32* p) { (void)MTX44Copy(this, (MTX44*)p); }
287
288 //
MTX44MTX44289 explicit MTX44(const MTX34& rhs)
290 {
291 (void)MTX34Copy((MTX34*)this, (MTX34*)&rhs);
292 f._30 = f._31 = f._32 = 0.f; f._33 = 1.f;
293 }
294
295 //
MTX44MTX44296 MTX44(const MTX44& rhs) { (void)MTX44Copy(this, &rhs); }
297
298 //
MTX44MTX44299 MTX44(f32 x00, f32 x01, f32 x02, f32 x03,
300 f32 x10, f32 x11, f32 x12, f32 x13,
301 f32 x20, f32 x21, f32 x22, f32 x23,
302 f32 x30, f32 x31, f32 x32, f32 x33)
303 {
304 f._00 = x00; f._01 = x01; f._02 = x02; f._03 = x03;
305 f._10 = x10; f._11 = x11; f._12 = x12; f._13 = x13;
306 f._20 = x20; f._21 = x21; f._22 = x22; f._23 = x23;
307 f._30 = x30; f._31 = x31; f._32 = x32; f._33 = x33;
308 }
309
310 //
311
312 //----------------------------------------
313 //
314 //
315
316 //
317 operator f32*() { return this->a; }
318
319 //
320 operator const f32*() const { return this->a; }
321
322 //
GetRowMTX44323 VEC4& GetRow(int index)
324 {
325 NN_MATH_MINMAXLT_ASSERT(index, 0, ROW_COUNT);
326 return *reinterpret_cast<VEC4*>(&this->v[index]);
327 }
328
329 //
GetRowMTX44330 const VEC4& GetRow(int index) const
331 {
332 NN_MATH_MINMAXLT_ASSERT(index, 0, ROW_COUNT);
333 return *reinterpret_cast<const VEC4*>(&this->v[index]);
334 }
335
336 //
GetColumnMTX44337 VEC4 GetColumn(int index) const
338 {
339 NN_MATH_MINMAXLT_ASSERT(index, 0, COLUMN_COUNT);
340 VEC4 column;
341 column.x = this->m[0][index];
342 column.y = this->m[1][index];
343 column.z = this->m[2][index];
344 column.w = this->m[3][index];
345 return column;
346 }
347
348 //
SetColumnMTX44349 void SetColumn(int index, const VEC4& column)
350 {
351 NN_MATH_MINMAXLT_ASSERT(index, 0, COLUMN_COUNT);
352 this->m[0][index] = column.x;
353 this->m[1][index] = column.y;
354 this->m[2][index] = column.z;
355 this->m[3][index] = column.w;
356 }
357 //
358
359 //----------------------------------------
360 //
361 //
362
363 //
364 self_type& operator *= (const self_type& rhs) { return *MTX44Mult(this, this, &rhs); }
365
366 self_type& operator += (const self_type& rhs) { return *MTX44Add(this, this, &rhs); }
367 self_type& operator -= (const self_type& rhs) { return *MTX44Sub(this, this, &rhs); }
368
369 self_type& operator *= (f32 f) { return *MTX44Mult(this, this, f); }
370 self_type& operator /= (f32 f) { return operator*=(1.f / f); }
371
372 self_type operator + () const { return *this; }
373 self_type operator - () const
374 {
375 return MTX44(-f._00, -f._01, -f._02, -f._03,
376 -f._10, -f._11, -f._12, -f._13,
377 -f._20, -f._21, -f._22, -f._23,
378 -f._30, -f._31, -f._32, -f._33);
379 }
380
381 self_type operator + (const self_type& rhs) const { MTX44 tmp; return *MTX44Add(&tmp, this, &rhs); }
382 self_type operator - (const self_type& rhs) const { MTX44 tmp; return *MTX44Sub(&tmp, this, &rhs); }
383
384 self_type operator * (f32 f) const { MTX44 tmp; return *MTX44Mult(&tmp, this, f); }
385 self_type operator / (f32 f) const { return *this * (1.f / f); }
386
387 //
TransposeMTX44388 self_type& Transpose() { return *MTX44Transpose(this, this); }
389 //
390
391 //----------------------------------------
392 //
393 //
394
395 //
SetupIdentityMTX44396 self_type& SetupIdentity() { return *MTX44Identity(this); }
397
398 //
399 //
400 //
401 //
SetupScaleMTX44402 self_type& SetupScale(const VEC3& scale) { return *MTX44Scale(this, &scale); }
403
404 //
405 //
406 //
407 //
SetupTranslateMTX44408 self_type& SetupTranslate(const VEC3& translate)
409 {
410 return *MTX44Translate(this, &translate);
411 }
412
413 //
414 //
415 //
416 //
SetupRotateXyzMTX44417 self_type& SetupRotateXyz(const VEC3& rotateRad)
418 {
419 return *MTX44RotXYZRad(this, rotateRad.x, rotateRad.y, rotateRad.z);
420 }
421
422 //
423 //
424 //
425 //
426 //
SetupRotateMTX44427 self_type& SetupRotate(const VEC3& axis, f32 thetaRad)
428 {
429 return *MTX44RotAxisRad(this, &axis, thetaRad);
430 }
431
432 //
433 //
434 //
435 //
436 //
437 //
438 //
439 //
440 //
441 //
442 //
443 self_type& SetupFrustum(f32 l, f32 r, f32 b, f32 t, f32 n, f32 f, PivotDirection pivot = PIVOT_NONE)
444 {
445 return *MTX44FrustumPivot(this, l, r, b, t, n, f, pivot);
446 }
447
448 //
449 //
450 //
451 //
452 //
453 //
454 //
455 //
456 //
457 //
458 //
459 self_type& SetupOrtho(f32 l, f32 r, f32 b, f32 t, f32 n, f32 f, PivotDirection pivot = PIVOT_NONE)
460 {
461 return *MTX44OrthoPivot(this, l, r, b, t, n, f, pivot);
462 }
463
464 //
465 //
466 //
467 //
468 //
469 //
470 //
471 //
472 self_type& SetupPerspective(f32 fovyRad, f32 aspect, f32 n, f32 f, PivotDirection pivot = PIVOT_NONE)
473 {
474 return *MTX44PerspectivePivotRad(this, fovyRad, aspect, n, f, pivot);
475 }
476
477 //
478
479 //----------------------------------------
480 //
481 //
482
483 //
484 bool operator == (const self_type& rhs) const { return ::std::memcmp(this, &rhs, sizeof(MTX44)) == 0; }
485
486 //
487 bool operator != (const self_type& rhs) const { return ::std::memcmp(this, &rhs, sizeof(MTX44)) != 0; }
488
489 //
IsIdentityMTX44490 bool IsIdentity() const { return MTX44IsIdentity(this); }
491 //
492
493 //
494 void Report(bool bNewline = true, const char* name = NULL) const;
495 };
496
497 typedef struct MTX44 Matrix44;
498
499 /*
500
501 */
502
503 } // namespace math
504 } // namespace nn
505
506 #include <nn/math/ARMv6/math_Matrix44.h>
507
508 namespace nn {
509 namespace math {
510
511 /* Please see man pages for details
512
513
514 */
515
516 /*
517
518
519
520
521
522
523
524 */
525 NN_FORCE_INLINE MTX44*
MTX44Add(MTX44 * pOut,const MTX44 * p1,const MTX44 * p2)526 MTX44Add(MTX44* pOut, const MTX44* p1, const MTX44* p2)
527 {
528
529 #if defined( NN_HARDWARE_CTR )
530 #if (MTX44ADD_ASM_CONFIG == D_ORG)
531 return ARMv6::MTX44AddC(pOut, p1, p2);
532 #elif (MTX44ADD_ASM_CONFIG == D_FAST_C)
533 #elif (MTX44ADD_ASM_CONFIG == D_FAST_ASM)
534 return ARMv6::MTX44AddAsm(pOut, p1, p2);
535 #elif (MTX44ADD_ASM_CONFIG == D_FAST_C_ALGO)
536 #elif (MTX44ADD_ASM_CONFIG == D_FAST_ASM_ALGO)
537 #endif
538 #else
539 #endif // #if defined( NN_HARDWARE_CTR )
540 }
541
542
543 /*
544
545
546
547
548
549
550 */
551 NN_FORCE_INLINE MTX44*
MTX44Copy(MTX44 * pOut,const MTX44 * p)552 MTX44Copy(MTX44* pOut, const MTX44* p)
553 {
554 #if defined( NN_HARDWARE_CTR )
555 #if (MTX44COPY_CONFIG == D_ORG)
556 return ARMv6::MTX44CopyC(pOut, p);
557 #elif (MTX44COPY_CONFIG == D_FAST_C)
558 #elif (MTX44COPY_CONFIG == D_FAST_ASM)
559 return ARMv6::MTX44CopyAsm(pOut, p);
560 #elif (MTX44COPY_CONFIG == D_FAST_C_ALGO)
561 #elif (MTX44COPY_CONFIG == D_FAST_ASM_ALGO)
562 #endif
563 #else
564 #endif // #if defined( NN_HARDWARE_CTR )
565 }
566
567 /*
568
569
570
571
572
573
574
575
576
577
578
579
580 */
581 NN_FORCE_INLINE MTX44*
MTX44Frustum(MTX44 * pOut,f32 l,f32 r,f32 b,f32 t,f32 n,f32 f)582 MTX44Frustum(MTX44* pOut, f32 l, f32 r, f32 b, f32 t, f32 n, f32 f)
583 {
584 #if defined( NN_HARDWARE_CTR )
585 #if (MTX44FRUSTUM_CONFIG == D_ORG)
586 return ARMv6::MTX44FrustumC(pOut, l, r, b, t, n, f);
587 #elif (MTX44FRUSTUM_CONFIG == D_FAST_C)
588 return ARMv6::MTX44FrustumC_FAST(pOut, l, r, b, t, n, f);
589 #elif (MTX44FRUSTUM_CONFIG == D_FAST_ASM)
590 #elif (MTX44FRUSTUM_CONFIG == D_FAST_C_ALGO)
591 #elif (MTX44FRUSTUM_CONFIG == D_FAST_ASM_ALGO)
592 #endif
593 #else
594 #endif // #if defined( NN_HARDWARE_CTR )
595 }
596
597 /*
598
599
600
601
602
603
604 */
605 NN_FORCE_INLINE u32
MTX44Inverse(MTX44 * pOut,const MTX44 * p)606 MTX44Inverse(MTX44* pOut, const MTX44* p)
607 {
608 #if defined( NN_HARDWARE_CTR )
609 #if (MTX44INVERSE_CONFIG == D_ORG)
610 return ARMv6::MTX44InverseC(pOut, p);
611 #elif (MTX44INVERSE_CONFIG == D_FAST_C)
612 #elif (MTX44INVERSE_CONFIG == D_FAST_ASM)
613 #elif (MTX44INVERSE_CONFIG == D_FAST_C_ALGO)
614 return ARMv6::MTX44InverseC_FAST_ALGO(pOut, p);
615 #elif (MTX44INVERSE_CONFIG == D_FAST_ASM_ALGO)
616 #endif
617 #else
618 #endif // #if defined( NN_HARDWARE_CTR )
619 }
620
621 /*
622
623
624
625
626
627
628
629 */
630 NN_FORCE_INLINE MTX44*
MTX44Mult(MTX44 * pOut,const MTX44 * __restrict p1,const MTX44 * __restrict p2)631 MTX44Mult(MTX44* pOut, const MTX44* __restrict p1, const MTX44* __restrict p2)
632 {
633 #if defined( NN_HARDWARE_CTR )
634 #if (MTX44MULT_44_CONFIG == D_ORG)
635 return ARMv6::MTX44MultC(pOut, p1, p2);
636 #elif (MTX44MULT_44_CONFIG == D_FAST_C)
637 #elif (MTX44MULT_44_CONFIG == D_FAST_ASM)
638 return ARMv6::MTX44MultAsm(pOut, p1, p2);
639 #elif (MTX44MULT_44_CONFIG == D_FAST_C_ALGO)
640 #elif (MTX44MULT_44_CONFIG == D_FAST_ASM_ALGO)
641 #endif
642 #else
643 #endif // #if defined( NN_HARDWARE_CTR )
644 }
645
646 /*
647
648
649
650
651
652
653
654 */
655 NN_FORCE_INLINE MTX44*
MTX44Mult(MTX44 * pOut,const MTX44 * p,f32 f)656 MTX44Mult(MTX44* pOut, const MTX44* p, f32 f)
657 {
658 #if defined( NN_HARDWARE_CTR )
659 #if (MTX44MULT_F32_CONFIG == D_ORG)
660 return ARMv6::MTX44MultC(pOut, p, f);
661 #elif (MTX44MULT_F32_CONFIG == D_FAST_C)
662 #elif (MTX44MULT_F32_CONFIG == D_FAST_ASM)
663 return ARMv6::MTX44MultAsm(pOut, p, f);
664 #elif (MTX44MULT_F32_CONFIG == D_FAST_C_ALGO)
665 #elif (MTX44MULT_F32_CONFIG == D_FAST_ASM_ALGO)
666 #endif
667 #else
668 #endif // #if defined( NN_HARDWARE_CTR )
669
670 }
671 /*
672
673
674
675
676
677
678
679 */
680 NN_FORCE_INLINE MTX44*
MTX44MultScale(MTX44 * pOut,const MTX44 * pM,const VEC3 * pS)681 MTX44MultScale(MTX44* pOut, const MTX44* pM, const VEC3* pS)
682 {
683 #if defined( NN_HARDWARE_CTR )
684 #if (MTX44MULTSCALE_RIGHT_CONFIG == D_ORG)
685 return ARMv6::MTX44MultScaleC(pOut, pM, pS);
686 #elif (MTX44MULTSCALE_RIGHT_CONFIG == D_FAST_C)
687 #elif (MTX44MULTSCALE_RIGHT_CONFIG == D_FAST_ASM)
688 return ARMv6::MTX44MultScaleAsm(pOut, pM, pS);
689 #elif (MTX44MULTSCALE_RIGHT_CONFIG == D_FAST_C_ALGO)
690 #elif (MTX44MULTSCALE_RIGHT_CONFIG == D_FAST_ASM_ALGO)
691 #endif
692 #else
693 #endif // #if defined( NN_HARDWARE_CTR )
694 }
695
696
697 /*
698
699
700
701
702
703
704
705 */
706 NN_FORCE_INLINE MTX44*
MTX44MultScale(MTX44 * pOut,const VEC3 * pS,const MTX44 * pM)707 MTX44MultScale(MTX44* pOut, const VEC3* pS, const MTX44* pM)
708 {
709 #if defined( NN_HARDWARE_CTR )
710 #if (MTX44MULTSCALE_LEFT_CONFIG == D_ORG)
711 return ARMv6::MTX44MultScaleC(pOut, pS, pM);
712 #elif (MTX44MULTSCALE_LEFT_CONFIG == D_FAST_C)
713 #elif (MTX44MULTSCALE_LEFT_CONFIG == D_FAST_ASM)
714 return ARMv6::MTX44MultScaleAsm(pOut, pS, pM);
715 #elif (MTX44MULTSCALE_LEFT_CONFIG == D_FAST_C_ALGO)
716 #elif (MTX44MULTSCALE_LEFT_CONFIG == D_FAST_ASM_ALGO)
717 #endif
718 #else
719 #endif // #if defined( NN_HARDWARE_CTR )
720 }
721
722 /*
723
724
725
726
727
728
729
730 */
731 NN_FORCE_INLINE MTX44*
MTX44MultTranslate(MTX44 * pOut,const VEC3 * pT,const MTX44 * pM)732 MTX44MultTranslate(MTX44* pOut, const VEC3* pT, const MTX44* pM)
733 {
734 #if defined( NN_HARDWARE_CTR )
735 #if (MTX44MULTTRANSLATE_LEFT_CONFIG == D_ORG)
736 return ARMv6::MTX44MultTranslateC(pOut, pT, pM);
737 #elif (MTX44MULTTRANSLATE_LEFT_CONFIG == D_FAST_C)
738 #elif (MTX44MULTTRANSLATE_LEFT_CONFIG == D_FAST_ASM)
739 return ARMv6::MTX44MultTranslateAsm(pOut, pT, pM);
740 #elif (MTX44MULTTRANSLATE_LEFT_CONFIG == D_FAST_C_ALGO)
741 #elif (MTX44MULTTRANSLATE_LEFT_CONFIG == D_FAST_ASM_ALGO)
742 #endif
743 #else
744 #endif // #if defined( NN_HARDWARE_CTR )
745 }
746
747 /*
748
749
750
751
752
753
754
755 */
756 NN_FORCE_INLINE MTX44*
MTX44MultTranslate(MTX44 * pOut,const MTX44 * pM,const VEC3 * pT)757 MTX44MultTranslate(MTX44* pOut, const MTX44* pM, const VEC3* pT)
758 {
759 #if defined( NN_HARDWARE_CTR )
760 #if (MTX44MULTTRANSLATE_RIGHT_CONFIG == D_ORG)
761 return ARMv6::MTX44MultTranslateC(pOut, pM, pT);
762 #elif (MTX44MULTTRANSLATE_RIGHT_CONFIG == D_FAST_C)
763 #elif (MTX44MULTTRANSLATE_RIGHT_CONFIG == D_FAST_ASM)
764 return ARMv6::MTX44MultTranslateAsm(pOut, pM, pT);
765 #elif (MTX44MULTTRANSLATE_RIGHT_CONFIG == D_FAST_C_ALGO)
766 #elif (MTX44MULTTRANSLATE_RIGHT_CONFIG == D_FAST_ASM_ALGO)
767 #endif
768 #else
769 #endif // #if defined( NN_HARDWARE_CTR )
770 }
771 /*
772
773
774
775
776
777
778
779
780
781
782
783
784 */
785 NN_FORCE_INLINE MTX44*
MTX44Ortho(MTX44 * pOut,f32 l,f32 r,f32 b,f32 t,f32 n,f32 f)786 MTX44Ortho(MTX44* pOut, f32 l, f32 r, f32 b, f32 t, f32 n, f32 f)
787 {
788 #if defined( NN_HARDWARE_CTR )
789 #if (MTX44ORTHO_CONFIG == D_ORG)
790 return ARMv6::MTX44OrthoC(pOut, l, r, b, t, n, f);
791 #elif (MTX44ORTHO_CONFIG == D_FAST_C)
792 return ARMv6::MTX44OrthoC_FAST(pOut, l, r, b, t, n, f);
793 #elif (MTX44ORTHO_CONFIG == D_FAST_ASM)
794 #elif (MTX44ORTHO_CONFIG == D_FAST_C_ALGO)
795 #elif (MTX44ORTHO_CONFIG == D_FAST_ASM_ALGO)
796 #endif
797 #else
798 #endif // #if defined( NN_HARDWARE_CTR )
799 }
800
801 /*
802
803
804
805
806
807
808
809
810
811 */
812 NN_FORCE_INLINE MTX44*
MTX44PerspectiveRad(MTX44 * pOut,f32 fovy,f32 aspect,f32 n,f32 f)813 MTX44PerspectiveRad(MTX44* pOut, f32 fovy, f32 aspect, f32 n, f32 f)
814 {
815 #if defined( NN_HARDWARE_CTR )
816 #if (MTX44PERSPECTIVERAD_CONFIG == D_ORG)
817 return ARMv6::MTX44PerspectiveRadC(pOut, fovy, aspect, n, f);
818 #elif (MTX44PERSPECTIVERAD_CONFIG == D_FAST_C)
819 return ARMv6::MTX44PerspectiveRadC_FAST(pOut, fovy, aspect, n, f);
820 #elif (MTX44PERSPECTIVERAD_CONFIG == D_FAST_ASM)
821 #elif (MTX44PERSPECTIVERAD_CONFIG == D_FAST_C_ALGO)
822 return ARMv6::MTX44PerspectiveRadC_FAST(pOut, fovy, aspect, n, f);
823 #elif (MTX44PERSPECTIVERAD_CONFIG == D_FAST_ASM_ALGO)
824 #endif
825 #else
826 #endif // #if defined( NN_HARDWARE_CTR )
827 }
828
829 /*
830
831
832
833
834
835
836
837 */
838 NN_FORCE_INLINE MTX44*
MTX44RotAxisRad_(MTX44 * pOut,const VEC3 * pAxis,f32 fRad)839 MTX44RotAxisRad_( MTX44* pOut, const VEC3 *pAxis, f32 fRad )
840 {
841 #if defined( NN_HARDWARE_CTR )
842 #if (MTX44ROTAXISRAD__CONFIG == D_ORG)
843 return ARMv6::MTX44RotAxisRad_C(pOut, pAxis, fRad);
844 #elif (MTX44ROTAXISRAD__CONFIG == D_FAST_C)
845 return ARMv6::MTX44RotAxisRad_C_FAST(pOut, pAxis, fRad);
846 #elif (MTX44ROTAXISRAD__CONFIG == D_FAST_ASM)
847 #elif (MTX44ROTAXISRAD__CONFIG == D_FAST_C_ALGO)
848 return ARMv6::MTX44RotAxisRad_C_FAST(pOut, pAxis, fRad);
849 #elif (MTX44ROTAXISRAD__CONFIG == D_FAST_ASM_ALGO)
850 #endif
851 #else
852 #endif // #if defined( NN_HARDWARE_CTR )
853 }
854
855 /*
856
857
858
859
860
861
862
863
864 */
865 NN_FORCE_INLINE MTX44*
MTX44RotXYZFIdx(MTX44 * pOut,f32 fIdxX,f32 fIdxY,f32 fIdxZ)866 MTX44RotXYZFIdx(MTX44* pOut, f32 fIdxX, f32 fIdxY, f32 fIdxZ)
867 {
868 #if defined( NN_HARDWARE_CTR )
869 #if (MTX44ROTXYZFIDX_CONFIG == D_ORG)
870 return ARMv6::MTX44RotXYZFIdxC(pOut, fIdxX, fIdxY, fIdxZ);
871 #elif (MTX44ROTXYZFIDX_CONFIG == D_FAST_C)
872 return ARMv6::MTX44RotXYZFIdxC_FAST(pOut, fIdxX, fIdxY, fIdxZ);
873 #elif (MTX44ROTXYZFIDX_CONFIG == D_FAST_ASM)
874 #elif (MTX44ROTXYZFIDX_CONFIG == D_FAST_C_ALGO)
875 #elif (MTX44ROTXYZFIDX_CONFIG == D_FAST_ASM_ALGO)
876 #endif
877 #else
878 #endif // #if defined( NN_HARDWARE_CTR )
879 }
880
881 /*
882
883
884
885
886
887
888 */
889 NN_FORCE_INLINE MTX44*
MTX44Scale(MTX44 * pOut,const VEC3 * pS)890 MTX44Scale(MTX44* pOut, const VEC3* pS)
891 {
892 #if defined( NN_HARDWARE_CTR )
893 #if (MTX44SCALE_CONFIG == D_ORG)
894 return ARMv6::MTX44ScaleC(pOut, pS);
895 #elif (MTX44SCALE_CONFIG == D_FAST_C)
896 return ARMv6::MTX44ScaleC_FAST(pOut, pS);
897 #elif (MTX44SCALE_CONFIG == D_FAST_ASM)
898 #elif (MTX44SCALE_CONFIG == D_FAST_C_ALGO)
899 #elif (MTX44SCALE_CONFIG == D_FAST_ASM_ALGO)
900 #endif
901 #else
902 #endif // #if defined( NN_HARDWARE_CTR )
903 }
904 /*
905
906
907
908
909
910
911 */
912 NN_FORCE_INLINE MTX44*
MTX44Translate(MTX44 * pOut,const VEC3 * pT)913 MTX44Translate(MTX44* pOut, const VEC3* pT)
914 {
915 #if defined( NN_HARDWARE_CTR )
916 #if (MTX44TRANSLATE_CONFIG == D_ORG)
917 return ARMv6::MTX44TranslateC(pOut, pT);
918 #elif (MTX44TRANSLATE_CONFIG == D_FAST_C)
919 return ARMv6::MTX44TranslateC_FAST(pOut, pT);
920 #elif (MTX44TRANSLATE_CONFIG == D_FAST_ASM)
921 #elif (MTX44TRANSLATE_CONFIG == D_FAST_C_ALGO)
922 #elif (MTX44TRANSLATE_CONFIG == D_FAST_ASM_ALGO)
923 #endif
924 #else
925 #endif // #if defined( NN_HARDWARE_CTR )
926
927 }
928 /*
929
930
931
932
933
934
935 */
936 NN_FORCE_INLINE MTX44*
MTX44Transpose(MTX44 * pOut,const MTX44 * pSrc)937 MTX44Transpose(MTX44* pOut, const MTX44 *pSrc)
938 {
939 #if defined( NN_HARDWARE_CTR )
940 #if (MTX44TRANSPOSE_44_CONFIG == D_ORG)
941 return ARMv6::MTX44TransposeC(pOut, pSrc);
942 #elif (MTX44TRANSPOSE_44_CONFIG == D_FAST_C)
943 #elif (MTX44TRANSPOSE_44_CONFIG == D_FAST_ASM)
944 return ARMv6::MTX44TransposeAsm(pOut, pSrc);
945 #elif (MTX44TRANSPOSE_44_CONFIG == D_FAST_C_ALGO)
946 #elif (MTX44TRANSPOSE_44_CONFIG == D_FAST_ASM_ALGO)
947 #endif
948 #else
949 #endif // #if defined( NN_HARDWARE_CTR )
950
951 }
952 /*
953
954 */
955
956 /* Please see man pages for details
957
958
959 */
960
961 /*
962
963
964
965
966
967
968
969 */
970 NN_FORCE_INLINE VEC4*
VEC3Transform(VEC4 * pOut,const MTX44 * pM,const VEC3 * pV)971 VEC3Transform(VEC4* pOut, const MTX44* pM, const VEC3* pV)
972 {
973 #if defined( NN_HARDWARE_CTR )
974 #if (VEC3TRANSFORM_44XVEC3_CONFIG == D_ORG)
975 return ARMv6::VEC3TransformC(pOut, pM, pV);
976 #elif (VEC3TRANSFORM_44XVEC3_CONFIG == D_FAST_C)
977 #elif (VEC3TRANSFORM_44XVEC3_CONFIG == D_FAST_ASM)
978 return ARMv6::VEC3TransformAsm(pOut, pM, pV);
979 #elif (VEC3TRANSFORM_44XVEC3_CONFIG == D_FAST_C_ALGO)
980 #elif (VEC3TRANSFORM_44XVEC3_CONFIG == D_FAST_ASM_ALGO)
981 #endif
982 #else
983 #endif // #if defined( NN_HARDWARE_CTR )
984 }
985
986 /*
987
988 */
989
990 /* Please see man pages for details
991
992
993 */
994
995 /*---------------------------------------------------------------------------*
996 Description: Rotates projection matrix in the direction of the screen.
997
998 Arguments: pOut Pointer to the matrix to rotate
999 pivot
1000
1001 Returns:
1002 *---------------------------------------------------------------------------*/
1003 NN_FORCE_INLINE MTX44*
MTX44Pivot(MTX44 * pOut,PivotDirection pivot)1004 MTX44Pivot( MTX44* pOut, PivotDirection pivot )
1005 {
1006 #if defined( NN_HARDWARE_CTR )
1007 #if (MTX44PIVOT_CONFIG == D_ORG)
1008 return ARMv6::MTX44PivotC(pOut, pivot);
1009 #elif (MTX44PIVOT_CONFIG == D_FAST_C)
1010 return ARMv6::MTX44PivotC_FAST(pOut, pivot);
1011 #elif (MTX44PIVOT_CONFIG == D_FAST_ASM)
1012 #elif (MTX44PIVOT_CONFIG == D_FAST_C_ALGO)
1013 #elif (MTX44PIVOT_CONFIG == D_FAST_ASM_ALGO)
1014 #endif
1015 #else
1016 #endif // #if defined( NN_HARDWARE_CTR )
1017
1018 }
1019
1020 /*
1021
1022 */
1023
1024 //-- Overloads that reference const type arguments
MTX44Copy(MTX44 * pOut,const MTX44 & m)1025 inline MTX44* MTX44Copy(MTX44* pOut, const MTX44& m) { return MTX44Copy( pOut, &m ); }
MTX44IsIdentity(const MTX44 & m)1026 inline bool MTX44IsIdentity(const MTX44& m) { return MTX44IsIdentity( &m ); }
1027
MTX44Add(MTX44 * pOut,const MTX44 & m1,const MTX44 & m2)1028 inline MTX44* MTX44Add(MTX44* pOut, const MTX44& m1, const MTX44& m2) { return MTX44Add( pOut, &m1, &m2 ); }
MTX44Sub(MTX44 * pOut,const MTX44 & m1,const MTX44 & m2)1029 inline MTX44* MTX44Sub(MTX44* pOut, const MTX44& m1, const MTX44& m2) { return MTX44Sub( pOut, &m1, &m2 ); }
MTX44Mult(MTX44 * pOut,const MTX44 & m,f32 f)1030 inline MTX44* MTX44Mult(MTX44* pOut, const MTX44& m, f32 f) { return MTX44Mult( pOut, &m, f ); }
MTX44Mult(MTX44 * pOut,const MTX44 & m1,const MTX44 & m2)1031 inline MTX44* MTX44Mult(MTX44* pOut, const MTX44& m1, const MTX44& m2) { return MTX44Mult( pOut, &m1, &m2 ); }
1032
MTX44Transpose(MTX44 * pOut,const MTX44 & m)1033 inline MTX44* MTX44Transpose(MTX44* pOut, const MTX44& m) { return MTX44Transpose( pOut, &m ); }
MTX44MultArray(MTX44 * pOut,const MTX44 & m1,const MTX44 * pSrc,s32 count)1034 inline MTX44* MTX44MultArray(MTX44* pOut, const MTX44& m1, const MTX44* pSrc, s32 count) { return MTX44MultArray( pOut, &m1, pSrc, count ); }
MTX44Inverse(MTX44 * pOut,const MTX44 & m)1035 inline u32 MTX44Inverse(MTX44* pOut, const MTX44& m) { return MTX44Inverse( pOut, &m ); }
1036
MTX44RotAxisFIdx(MTX44 * pOut,const VEC3 & vAxis,f32 fIdx)1037 inline MTX44* MTX44RotAxisFIdx(MTX44* pOut, const VEC3& vAxis, f32 fIdx) { return MTX44RotAxisFIdx( pOut, &vAxis, fIdx ); }
MTX44RotAxisRad(MTX44 * pOut,const VEC3 & vAxis,f32 fRad)1038 inline MTX44* MTX44RotAxisRad(MTX44* pOut, const VEC3& vAxis, f32 fRad) { return MTX44RotAxisRad( pOut, &vAxis, fRad ); }
MTX44RotAxisDeg(MTX44 * pOut,const VEC3 & vAxis,f32 fDeg)1039 inline MTX44* MTX44RotAxisDeg(MTX44* pOut, const VEC3& vAxis, f32 fDeg) { return MTX44RotAxisDeg( pOut, &vAxis, fDeg ); }
1040
MTX44Scale(MTX44 * pOut,const VEC3 & S)1041 inline MTX44* MTX44Scale(MTX44* pOut, const VEC3& S) { return MTX44Scale(pOut, &S); }
MTX44MultScale(MTX44 * pOut,const MTX44 & M,const VEC3 & S)1042 inline MTX44* MTX44MultScale(MTX44* pOut, const MTX44& M, const VEC3& S) { return MTX44MultScale(pOut, &M, &S); }
MTX44MultScale(MTX44 * pOut,const VEC3 & S,const MTX44 & M)1043 inline MTX44* MTX44MultScale(MTX44* pOut, const VEC3& S, const MTX44& M) { return MTX44MultScale(pOut, &S, &M); }
1044
MTX44Translate(MTX44 * pOut,const VEC3 & T)1045 inline MTX44* MTX44Translate(MTX44* pOut, const VEC3& T) { return MTX44Translate(pOut, &T); }
MTX44MultTranslate(MTX44 * pOut,const MTX44 & M,const VEC3 & T)1046 inline MTX44* MTX44MultTranslate(MTX44* pOut, const MTX44& M, const VEC3& T) { return MTX44MultTranslate(pOut, &M, &T); }
MTX44MultTranslate(MTX44 * pOut,const VEC3 & T,const MTX44 & M)1047 inline MTX44* MTX44MultTranslate(MTX44* pOut, const VEC3& T, const MTX44& M) { return MTX44MultTranslate(pOut, &T, &M); }
1048
1049 } // namespace math
1050 } // namespace nn
1051
1052 #if defined(NN_MATH_AS_INLINE)
1053 #include <nn/math/inline/math_Matrix44.ipp>
1054 #include <nn/math/ARMv6/inline/math_Matrix44.ipp>
1055 #endif
1056
1057 #pragma pop
1058
1059 #endif
1060