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