1 /*---------------------------------------------------------------------------*
2 Project: Horizon
3 File: math_Matrix34.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: 48334 $
14 *---------------------------------------------------------------------------*/
15
16 #ifndef NN_MATH_MATH_MATRIX34_H_
17 #define NN_MATH_MATH_MATRIX34_H_
18
19 #include <cstring>
20 #include <nn/math/math_Config.h>
21 #include <nn/math/math_Vector3.h>
22 #include <nn/math/math_Vector4.h>
23 #include <nn/math/math_Quaternion.h>
24 #include <nn/math/ARMv6/math_Matrix34.h>
25
26 #pragma push
27 #pragma Otime
28
29 namespace nn {
30 namespace math {
31
32 struct MTX34;
33
34 /* Please see man pages for details
35
36
37 */
38
39 /* ------------------------------------------------------------------------
40 Function for MTX34
41 ------------------------------------------------------------------------ */
42 /*
43
44
45
46
47
48
49
50 */
51 NN_FORCE_INLINE MTX34* MTX34Add(MTX34* pOut, const MTX34* p1, const MTX34* p2);
52
53 /*
54
55
56
57
58
59
60
61 */
62 NN_FORCE_INLINE MTX34* MTX34CameraRotate(MTX34* pOut, const VEC3* pCamPos, const VEC3* pCamRotateDeg);
63
64 /*
65
66
67
68
69
70
71 */
72 NN_FORCE_INLINE MTX34* MTX34Copy(MTX34* pOut, const MTX34* p);
73
74 /*
75
76
77
78
79
80 */
81 NN_MATH_INLINE MTX34* MTX34Identity(MTX34* pOut);
82
83 /*
84
85
86
87
88
89
90 */
91 NN_FORCE_INLINE u32 MTX34Inverse(MTX34* pOut, const MTX34* p);
92
93 /*
94
95
96
97
98
99
100
101 */
102 NN_FORCE_INLINE u32 MTX34InvTranspose(MTX34* pOut, const MTX34* p);
103
104 /*
105
106
107
108
109
110
111
112 */
113 NN_MATH_INLINE u32 MTX34InvTranspose(MTX33* pOut, const MTX34* p);
114
115 /*
116
117
118
119
120
121 */
122 NN_MATH_INLINE bool MTX34IsIdentity(const MTX34* p);
123
124 /*
125
126
127
128
129
130
131
132
133 */
134 NN_FORCE_INLINE MTX34* MTX34LookAt(MTX34* pOut, const VEC3* pCamPos, const VEC3* pCamUp, const VEC3* pTarget);
135
136 /*
137
138
139
140
141
142
143
144
145 */
146 NN_FORCE_INLINE MTX34* MTX34LookAt(MTX34* pOut, const VEC3* pCamPos, f32 twistDeg, const VEC3* pTarget);
147
148 /*
149
150
151
152
153
154
155
156
157 */
158 NN_FORCE_INLINE MTX34* MTX34MAdd(MTX34* pOut, f32 t, const MTX34* p1, const MTX34* p2);
159
160 /*
161
162
163
164
165
166
167
168
169 */
170 NN_FORCE_INLINE MTX34* MTX34Mult(MTX34* pOut, const MTX34* p1, const MTX34* p2);
171
172 /*
173
174
175
176
177
178
179
180 */
181 NN_FORCE_INLINE MTX34* MTX34Mult(MTX34* pOut, const MTX34* p, f32 f);
182
183 /*
184
185
186
187
188
189
190
191
192 */
193 NN_MATH_INLINE MTX34* MTX34MultArray(MTX34* pOut, const MTX34* p1, const MTX34* pSrc, s32 count);
194
195 /*
196
197
198
199
200
201
202
203 */
204 NN_FORCE_INLINE MTX34* MTX34MultScale(MTX34* pOut, const MTX34* pM, const VEC3* pS);
205
206 /*
207
208
209
210
211
212
213
214 */
215 NN_FORCE_INLINE MTX34* MTX34MultScale(MTX34* pOut, const VEC3* __restrict pS, const MTX34* pM);
216
217 /*
218
219
220
221
222
223
224
225 */
226 NN_FORCE_INLINE MTX34* MTX34MultTranslate(MTX34* pOut, const VEC3* pT, const MTX34* pM);
227
228 /*
229
230
231
232
233
234
235
236 */
237 NN_FORCE_INLINE MTX34* MTX34MultTranslate(MTX34* pOut, const MTX34* pM, const VEC3* pT);
238
239 /*
240
241
242
243
244
245
246
247 */
248 NN_MATH_INLINE MTX34* MTX34RotAxisDeg(MTX34* pOut, const VEC3* pAxis, f32 fDeg);
249
250 /*
251
252
253
254
255
256
257
258 */
259 NN_FORCE_INLINE MTX34* MTX34RotAxisDegPartially(MTX34* pOut, const VEC3* pAxis, f32 fDeg);
260
261 /*
262
263
264
265
266
267
268
269 */
270 NN_MATH_INLINE MTX34* MTX34RotAxisFIdx(MTX34* pOut, const VEC3* pAxis, f32 fIdx);
271
272 /*
273
274
275
276
277
278
279
280 */
281 NN_MATH_INLINE MTX34* MTX34RotAxisRad(MTX34* pOut, const VEC3* pAxis, f32 fRad);
282
283 /*
284
285
286
287
288
289
290
291
292 */
293 NN_FORCE_INLINE MTX34* MTX34RotAxisRad_( MTX34* pOut, const VEC3 *pAxis, f32 fRad );
294
295 /*
296
297
298
299
300
301
302
303 */
304 NN_FORCE_INLINE MTX34* MTX34RotAxisRadPartially(MTX34* pOut, const VEC3* pAxis, f32 fRad);
305
306 /*
307
308
309
310
311
312
313
314
315 */
316 NN_MATH_INLINE MTX34* MTX34RotXYZDeg(MTX34* pOut, f32 fDegX, f32 fDegY, f32 fDegZ);
317
318 /*
319
320
321
322
323
324
325
326
327 */
328 NN_FORCE_INLINE MTX34* MTX34RotXYZDegPartially(MTX34* pOut, f32 fDegX, f32 fDegY, f32 fDegZ);
329
330 /*
331
332
333
334
335
336
337
338
339 */
340 NN_FORCE_INLINE MTX34* MTX34RotXYZFIdx(MTX34* pOut, f32 fIdxX, f32 fIdxY, f32 fIdxZ);
341
342 /*
343
344
345
346
347
348
349
350
351 */
352 NN_MATH_INLINE MTX34* MTX34RotXYZRad(MTX34* pOut, f32 fRadX, f32 fRadY, f32 fRadZ);
353
354 /*
355
356
357
358
359
360
361
362
363 */
364 NN_FORCE_INLINE MTX34* MTX34RotXYZRadPartially(MTX34* pOut, f32 fRadX, f32 fRadY, f32 fRadZ);
365
366 /*
367
368
369
370
371
372
373
374
375
376 */
377 NN_MATH_INLINE MTX34* MTX34RotXYZTranslateFIdx(MTX34* pOut, f32 fIdxX, f32 fIdxY, f32 fIdxZ, const VEC3* pT);
378
379 /*
380
381
382
383
384
385
386 */
387 NN_FORCE_INLINE MTX34* MTX34Scale(MTX34* pOut, const VEC3* pS);
388
389 /*
390
391
392
393
394
395
396
397
398
399
400
401 */
402 NN_MATH_INLINE MTX34* MTX34ShadowProjectionFrustum(MTX34* pOut, f32 l, f32 r, f32 b, f32 t, f32 n, f32 f);
403
404 /*
405
406
407
408
409
410
411
412
413
414
415
416 */
417 NN_MATH_INLINE MTX34* MTX34ShadowProjectionOrtho(MTX34* pOut, f32 l, f32 r, f32 b, f32 t, f32 n, f32 f);
418
419 /*
420
421
422
423
424
425
426
427
428
429 */
430 NN_MATH_INLINE MTX34* MTX34ShadowProjectionPerspective(MTX34* pOut, f32 fovy, f32 aspect, f32 n, f32 f);
431
432 /*
433
434
435
436
437
438
439
440 */
441 NN_MATH_INLINE MTX34* MTX34Sub(MTX34* pOut, const MTX34* p1, const MTX34* p2);
442
443 /*
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458 */
459 NN_MATH_INLINE MTX34* MTX34TextureProjectionFrustum(MTX34* pOut, f32 l, f32 r, f32 b, f32 t, f32 n, f32 scaleS, f32 scaleT, f32 translateS, f32 translateT);
460
461 /*
462
463
464
465
466
467
468
469
470
471
472
473
474
475 */
476 NN_MATH_INLINE MTX34* MTX34TextureProjectionOrtho(MTX34* pOut, f32 l, f32 r, f32 b, f32 t, f32 scaleS, f32 scaleT, f32 translateS, f32 translateT);
477
478 /*
479
480
481
482
483
484
485
486
487
488
489
490 */
491 NN_MATH_INLINE MTX34* MTX34TextureProjectionPerspective(MTX34* pOut, f32 fovy, f32 aspect, f32 scaleS, f32 scaleT, f32 translateS, f32 translateT);
492
493 /*
494
495
496
497
498
499
500 */
501 NN_FORCE_INLINE MTX34* MTX34Translate(MTX34* pOut, const VEC3* pT);
502
503 /*
504
505
506
507
508
509
510
511
512 */
513 NN_FORCE_INLINE MTX34* MTX34Transpose(MTX34* pOut, const MTX34* p);
514
515 /*
516
517
518
519
520
521 */
522 NN_MATH_INLINE MTX34* MTX34Zero(MTX34* pOut);
523
524 /*
525
526 */
527
528 NN_FORCE_INLINE MTX34* QUATToMTX34(MTX34* pOut, const QUAT* pQ);
529 NN_FORCE_INLINE VEC3* VEC3Transform(VEC3* pOut, const MTX34* __restrict pM, const VEC3* __restrict pV);
530
531 // This will be implemented before long
532 //MTX34* MTX34Inv(MTX34* pOut, f32* pDet, const MTX34* p);
533 //MTX34* MTX34InvTranspose(MTX34* pOut, f32* pDet, const MTX34* p);
534 //f32 MTX34Det(const MTX34* p);
535
536 /* =======================================================================
537 Class definitions
538 ======================================================================== */
539 /*
540
541
542 */
543 struct MTX34_
544 {
545 //
546 struct BaseData
547 {
548 f32 _00; //
549 f32 _01; //
550 f32 _02; //
551 f32 _03; //
552 f32 _10; //
553 f32 _11; //
554 f32 _12; //
555 f32 _13; //
556 f32 _20; //
557 f32 _21; //
558 f32 _22; //
559 f32 _23; //
560 };
561
562 union
563 {
564 //----------------------------------------
565 //
566 //
567 #if defined(NN_MATH_USE_ANONYMOUS_STRUCT)
568 //
569 struct
570 {
571 f32 _00, _01, _02, _03;
572 f32 _10, _11, _12, _13;
573 f32 _20, _21, _22, _23;
574 };
575 #endif
576 BaseData f; //
577 f32 m[3][4]; //
578 f32 a[12]; //
579 VEC4_ v[3]; //
580 //
581 };
582 };
583
584 /*
585
586
587 */
588 class MTX34 : public MTX34_
589 {
590 public:
591 static const int ROW_COUNT = 3; //
592 static const int COLUMN_COUNT = 4; //
593
594 //
Identity()595 static const MTX34& Identity()
596 {
597 static const MTX34 identity(
598 1.0f, 0.0f, 0.0f, 0.0f,
599 0.0f, 1.0f, 0.0f, 0.0f,
600 0.0f, 0.0f, 1.0f, 0.0f);
601
602 return identity;
603 }
604
605 typedef MTX34 self_type; //
606 typedef f32 value_type; //
607 public:
608 //----------------------------------------
609 //
610 //
611
612 //
MTX34()613 MTX34() {}
614
615 //
MTX34(const f32 * p)616 explicit MTX34(const f32* p) { (void)MTX34Copy(this, (MTX34*)p); }
617
618 //
MTX34(const MTX34 & rhs)619 MTX34(const MTX34& rhs) { (void)MTX34Copy(this, &rhs); }
620
621 //
MTX34(const MTX33 & rhs)622 explicit MTX34(const MTX33& rhs) { MTX33ToMTX34(this, &rhs); }
623
624 //
MTX34(f32 x00,f32 x01,f32 x02,f32 x03,f32 x10,f32 x11,f32 x12,f32 x13,f32 x20,f32 x21,f32 x22,f32 x23)625 MTX34(f32 x00, f32 x01, f32 x02, f32 x03,
626 f32 x10, f32 x11, f32 x12, f32 x13,
627 f32 x20, f32 x21, f32 x22, f32 x23)
628 {
629 f._00 = x00; f._01 = x01; f._02 = x02; f._03 = x03;
630 f._10 = x10; f._11 = x11; f._12 = x12; f._13 = x13;
631 f._20 = x20; f._21 = x21; f._22 = x22; f._23 = x23;
632 }
633
634 //
635
636 //----------------------------------------
637 //
638 //
639
640 //
641 operator f32*() { return this->a; }
642
643 //
644 operator const f32*() const { return this->a; }
645
646 //
GetRow(int index)647 VEC4& GetRow(int index)
648 {
649 NN_MATH_MINMAXLT_ASSERT(index, 0, ROW_COUNT);
650 return *reinterpret_cast<VEC4*>(&this->v[index]);
651 }
652
653 //
GetRow(int index)654 const VEC4& GetRow(int index) const
655 {
656 NN_MATH_MINMAXLT_ASSERT(index, 0, ROW_COUNT);
657 return *reinterpret_cast<const VEC4*>(&this->v[index]);
658 }
659
660 //
GetColumn(int index)661 VEC3 GetColumn(int index) const
662 {
663 NN_MATH_MINMAXLT_ASSERT(index, 0, COLUMN_COUNT);
664 VEC3 column;
665 column.x = this->m[0][index];
666 column.y = this->m[1][index];
667 column.z = this->m[2][index];
668 return column;
669 }
670
671 //
SetColumn(int index,const VEC3 & column)672 void SetColumn(int index, const VEC3& column)
673 {
674 NN_MATH_MINMAXLT_ASSERT(index, 0, COLUMN_COUNT);
675 this->m[0][index] = column.x;
676 this->m[1][index] = column.y;
677 this->m[2][index] = column.z;
678 }
679 //
680
681 //----------------------------------------
682 //
683 //
684
685 //
686 self_type& operator += (const self_type& rhs) { return *MTX34Add(this, this, &rhs); }
687
688 //
689 self_type& operator -= (const self_type& rhs) { return *MTX34Sub(this, this, &rhs); }
690
691 //
692 self_type& operator *= (f32 f) { return *MTX34Mult(this, this, f); }
693
694 //
695 self_type& operator /= (f32 f) { return operator*=(1.f / f); }
696
697 //
698 self_type operator + () const { return *this; }
699
700 //
701 self_type operator - () const
702 {
703 return MTX34(-f._00, -f._01, -f._02, -f._03,
704 -f._10, -f._11, -f._12, -f._13,
705 -f._20, -f._21, -f._22, -f._23);
706 }
707
708 //
709 self_type operator + (const self_type& rhs) const { MTX34 tmp; return *MTX34Add(&tmp, this, &rhs); }
710
711 //
712 self_type operator - (const self_type& rhs) const { MTX34 tmp; return *MTX34Sub(&tmp, this, &rhs); }
713
714 //
715 self_type operator * (f32 f) const { MTX34 tmp; return *MTX34Mult(&tmp, this, f); }
716
717 //
718 self_type operator / (f32 f) const { return *this * (1.f / f); }
719
720 //
Transpose()721 self_type& Transpose() { return *MTX34Transpose(this, this); }
722
723 //
724
725 //----------------------------------------
726 //
727 //
728
729 //
SetupIdentity()730 self_type& SetupIdentity() { return *MTX34Identity(this); }
731
732 //
733 //
734 //
735 //
SetupScale(const VEC3 & scale)736 self_type& SetupScale(const VEC3& scale) { return *MTX34Scale(this, &scale); }
737
738 //
739 //
740 //
741 //
SetupTranslate(const VEC3 & translate)742 self_type& SetupTranslate(const VEC3& translate)
743 {
744 return *MTX34Translate(this, &translate);
745 }
746
747 //
748 //
749 //
750 //
SetupRotateXyz(const VEC3 & rotate)751 self_type& SetupRotateXyz(const VEC3& rotate)
752 {
753 return *MTX34RotXYZRad(this, rotate.x, rotate.y, rotate.z);
754 }
755
756 //
757 //
758 //
759 //
760 //
SetupRotate(const VEC3 & axis,f32 theta)761 self_type& SetupRotate(const VEC3& axis, f32 theta)
762 {
763 return *MTX34RotAxisRad(this, &axis, theta);
764 }
765
766 //
767 //
768 //
SetupRotate(const QUAT & quaternion)769 self_type& SetupRotate(const QUAT& quaternion)
770 {
771 return *QUATToMTX34(this, &quaternion);
772 }
773
774 /*
775
776
777
778
779
780 */
SetupLookAt(const VEC3 & camPos,const VEC3 & camUp,const VEC3 & target)781 self_type& SetupLookAt(const VEC3& camPos, const VEC3& camUp, const VEC3& target)
782 {
783 return *MTX34LookAt(this, &camPos, &camUp, &target);
784 }
785
786 /*
787
788
789
790
791
792 */
SetupLookAt(const VEC3 & camPos,f32 twistDeg,const VEC3 & target)793 self_type& SetupLookAt(const VEC3& camPos, f32 twistDeg, const VEC3& target)
794 {
795 return *MTX34LookAt(this, &camPos, twistDeg, &target);
796 }
797
798 /*
799
800
801
802
803 */
SetupCameraRotate(const VEC3 & camPos,const VEC3 & camRotateDeg)804 self_type& SetupCameraRotate(const VEC3& camPos, const VEC3& camRotateDeg)
805 {
806 return *MTX34CameraRotate(this, &camPos, &camRotateDeg);
807 }
808
809 /*
810
811
812
813
814
815
816
817
818
819
820
821 */
SetupTextureProjectionFrustum(f32 l,f32 r,f32 b,f32 t,f32 n,f32 scaleS,f32 scaleT,f32 translateS,f32 translateT)822 self_type& SetupTextureProjectionFrustum(f32 l, f32 r, f32 b, f32 t, f32 n, f32 scaleS, f32 scaleT, f32 translateS, f32 translateT)
823 {
824 return *MTX34TextureProjectionFrustum(this, l, r, b, t, n, scaleS, scaleT, translateS, translateT);
825 }
826
827 /*
828
829
830
831
832
833
834
835
836 */
SetupTextureProjectionFrustum(f32 fovyRad,f32 aspect,f32 scaleS,f32 scaleT,f32 translateS,f32 translateT)837 self_type& SetupTextureProjectionFrustum(f32 fovyRad, f32 aspect, f32 scaleS, f32 scaleT, f32 translateS, f32 translateT)
838 {
839 return *MTX34TextureProjectionPerspective(this, fovyRad, aspect, scaleS, scaleT, translateS, translateT);
840 }
841
842 /*
843
844
845
846
847
848
849
850
851
852
853
854 */
SetupTextureProjectionFrustum(f32 l,f32 r,f32 b,f32 t,f32 scaleS,f32 scaleT,f32 translateS,f32 translateT)855 self_type& SetupTextureProjectionFrustum(f32 l, f32 r, f32 b, f32 t, f32 scaleS, f32 scaleT, f32 translateS, f32 translateT)
856 {
857 return *MTX34TextureProjectionOrtho(this, l, r, b, t, scaleS, scaleT, translateS, translateT);
858 }
859
860 //
861
862 //----------------------------------------
863 //
864 //
865
866 //
867 bool operator == (const self_type& rhs) const { return ::std::memcmp(this, &rhs, sizeof(MTX34)) == 0; }
868
869 //
870 bool operator != (const self_type& rhs) const { return ::std::memcmp(this, &rhs, sizeof(MTX34)) != 0; }
871
872 //
IsIdentity()873 bool IsIdentity() const { return MTX34IsIdentity(this); }
874 //
875
876 //
877 void Report(bool bNewline = true, const char* name = NULL) const;
878
879 private:
880 typedef void (self_type::*UnspecifiedBoolType)() const;
881 operator UnspecifiedBoolType() const;
882 operator UnspecifiedBoolType();
883 };
884
885 //
886 //
887
888 //
889 typedef class MTX34 Matrix34;
890
891 //
892
893 //
894 inline MTX34 operator * (f32 f, const MTX34& rhs)
895 {
896 MTX34 tmp;
897 (void)MTX34Mult(&tmp, &rhs, f);
898 return tmp;
899 }
900
901 NN_MATH_INLINE MTX34*
MTX34RotXYZRad(MTX34 * pOut,f32 fRadX,f32 fRadY,f32 fRadZ)902 MTX34RotXYZRad(MTX34* pOut, f32 fRadX, f32 fRadY, f32 fRadZ)
903 {
904 return MTX34RotXYZFIdx(pOut, NN_MATH_RAD_TO_FIDX(fRadX), NN_MATH_RAD_TO_FIDX(fRadY), NN_MATH_RAD_TO_FIDX(fRadZ));
905 }
906
907 NN_FORCE_INLINE MTX34*
MTX34RotXYZRadPartially(MTX34 * pOut,f32 fRadX,f32 fRadY,f32 fRadZ)908 MTX34RotXYZRadPartially(MTX34* pOut, f32 fRadX, f32 fRadY, f32 fRadZ)
909 {
910 #if defined( NN_HARDWARE_CTR )
911 #if (MTX34ROTXYZFIDX_CONFIG == D_ORG)
912 return ARMv6::MTX34RotXYZFIdxC(pOut, NN_MATH_RAD_TO_FIDX(fRadX), NN_MATH_RAD_TO_FIDX(fRadY), NN_MATH_RAD_TO_FIDX(fRadZ), false);
913 #elif (MTX34ROTXYZFIDX_CONFIG == D_FAST_C)
914 return ARMv6::MTX34RotXYZFIdxC_FAST(pOut, NN_MATH_RAD_TO_FIDX(fRadX), NN_MATH_RAD_TO_FIDX(fRadY), NN_MATH_RAD_TO_FIDX(fRadZ), false);
915 #elif (MTX34ROTXYZFIDX_CONFIG == D_FAST_ASM)
916 #elif (MTX34ROTXYZFIDX_CONFIG == D_FAST_C_ALGO)
917 #elif (MTX34ROTXYZFIDX_CONFIG == D_FAST_ASM_ALGO)
918 #endif
919 #else
920 #endif // #if defined( NN_HARDWARE_CTR )
921 }
922
923 NN_MATH_INLINE MTX34*
MTX34RotXYZDeg(MTX34 * pOut,f32 fDegX,f32 fDegY,f32 fDegZ)924 MTX34RotXYZDeg(MTX34* pOut, f32 fDegX, f32 fDegY, f32 fDegZ)
925 {
926 return MTX34RotXYZFIdx(pOut, NN_MATH_DEG_TO_FIDX(fDegX), NN_MATH_DEG_TO_FIDX(fDegY), NN_MATH_DEG_TO_FIDX(fDegZ));
927 }
928
929 NN_FORCE_INLINE MTX34*
MTX34RotXYZDegPartially(MTX34 * pOut,f32 fDegX,f32 fDegY,f32 fDegZ)930 MTX34RotXYZDegPartially(MTX34* pOut, f32 fDegX, f32 fDegY, f32 fDegZ)
931 {
932 #if defined( NN_HARDWARE_CTR )
933 #if (MTX34ROTXYZFIDX_CONFIG == D_ORG)
934 return ARMv6::MTX34RotXYZFIdxC(pOut, NN_MATH_DEG_TO_FIDX(fDegX), NN_MATH_DEG_TO_FIDX(fDegY), NN_MATH_DEG_TO_FIDX(fDegZ), false);
935 #elif (MTX34ROTXYZFIDX_CONFIG == D_FAST_C)
936 return ARMv6::MTX34RotXYZFIdxC_FAST(pOut, NN_MATH_DEG_TO_FIDX(fDegX), NN_MATH_DEG_TO_FIDX(fDegY), NN_MATH_DEG_TO_FIDX(fDegZ), false);
937 #elif (MTX34ROTXYZFIDX_CONFIG == D_FAST_ASM)
938 #elif (MTX34ROTXYZFIDX_CONFIG == D_FAST_C_ALGO)
939 #elif (MTX34ROTXYZFIDX_CONFIG == D_FAST_ASM_ALGO)
940 #endif
941 #else
942 #endif // #if defined( NN_HARDWARE_CTR )
943 }
944
945 NN_MATH_INLINE MTX34*
MTX34RotAxisRad(MTX34 * pOut,const VEC3 * pAxis,f32 fRad)946 MTX34RotAxisRad(MTX34* pOut, const VEC3* pAxis, f32 fRad)
947 {
948 return MTX34RotAxisFIdx(pOut, pAxis, NN_MATH_RAD_TO_FIDX(fRad));
949 }
950
951 NN_FORCE_INLINE MTX34*
MTX34RotAxisRadPartially(MTX34 * pOut,const VEC3 * pAxis,f32 fRad)952 MTX34RotAxisRadPartially(MTX34* pOut, const VEC3* pAxis, f32 fRad)
953 {
954 #if defined( NN_HARDWARE_CTR )
955 #if (MTX34ROTAXISRAD__CONFIG == D_ORG)
956 return ARMv6::MTX34RotAxisRad_C(pOut, pAxis, fRad, false);
957 #elif (MTX34ROTAXISRAD__CONFIG == D_FAST_C)
958 return ARMv6::MTX34RotAxisRad_C_FAST(pOut, pAxis, fRad, false);
959 #elif (MTX34ROTAXISRAD__CONFIG == D_FAST_ASM)
960 #elif (MTX34ROTAXISRAD__CONFIG == D_FAST_C_ALGO)
961 return ARMv6::MTX34RotAxisRad_C_FAST(pOut, pAxis, fRad, false);
962 #elif (MTX34ROTAXISRAD__CONFIG == D_FAST_ASM_ALGO)
963 #endif
964 #else
965 #endif // #if defined( NN_HARDWARE_CTR )
966 }
967
968 NN_MATH_INLINE MTX34*
MTX34RotAxisDeg(MTX34 * pOut,const VEC3 * pAxis,f32 fDeg)969 MTX34RotAxisDeg(MTX34* pOut, const VEC3* pAxis, f32 fDeg)
970 {
971 return MTX34RotAxisFIdx(pOut, pAxis, NN_MATH_DEG_TO_FIDX(fDeg));
972 }
973
974
975 NN_FORCE_INLINE MTX34*
MTX34RotAxisDegPartially(MTX34 * pOut,const VEC3 * pAxis,f32 fDeg)976 MTX34RotAxisDegPartially(MTX34* pOut, const VEC3* pAxis, f32 fDeg)
977 {
978 #if defined( NN_HARDWARE_CTR )
979 #if (MTX34ROTAXISRAD__CONFIG == D_ORG)
980 return ARMv6::MTX34RotAxisRad_C(pOut, pAxis, NN_MATH_DEG_TO_RAD(fDeg), false);
981 #elif (MTX34ROTAXISRAD__CONFIG == D_FAST_C)
982 return ARMv6::MTX34RotAxisRad_C_FAST(pOut, pAxis, NN_MATH_DEG_TO_RAD(fDeg), false);
983 #elif (MTX34ROTAXISRAD__CONFIG == D_FAST_ASM)
984 #elif (MTX34ROTAXISRAD__CONFIG == D_FAST_C_ALGO)
985 return ARMv6::MTX34RotAxisRad_C_FAST(pOut, pAxis, NN_MATH_DEG_TO_RAD(fDeg), false);
986 #elif (MTX34ROTAXISRAD__CONFIG == D_FAST_ASM_ALGO)
987 #endif
988 #else
989 #endif // #if defined( NN_HARDWARE_CTR )
990 }
991
992 NN_FORCE_INLINE MTX34*
MTX34Copy(MTX34 * pOut,const MTX34 * p)993 MTX34Copy(MTX34* pOut, const MTX34* p)
994 {
995
996 #if defined( NN_HARDWARE_CTR )
997 #if (MTX34COPY_CONFIG == D_ORG)
998 return ARMv6::MTX34CopyC( pOut, p );
999 #elif (MTX34COPY_CONFIG == D_FAST_C)
1000 #elif (MTX34COPY_CONFIG == D_FAST_ASM)
1001 return ARMv6::MTX34CopyAsm( pOut, p );
1002 #elif (MTX34COPY_CONFIG == D_FAST_C_ALGO)
1003 #elif (MTX34COPY_CONFIG == D_FAST_ASM_ALGO)
1004 #endif
1005 #else
1006 #endif // #if defined( NN_HARDWARE_CTR )
1007 }
1008
1009 NN_FORCE_INLINE MTX34*
MTX34Mult(MTX34 * pOut,const MTX34 * p1,const MTX34 * p2)1010 MTX34Mult(MTX34* pOut, const MTX34* p1, const MTX34* p2)
1011 {
1012 #if defined( NN_HARDWARE_CTR )
1013 #if (MTX34MULT_34_CONFIG == D_ORG)
1014 return ARMv6::MTX34MultC( pOut, p1, p2 );
1015 #elif (MTX34MULT_34_CONFIG == D_FAST_C)
1016 #elif (MTX34MULT_34_CONFIG == D_FAST_ASM)
1017 return ARMv6::MTX34MultAsm( pOut, p1, p2 );
1018 #elif (MTX34MULT_34_CONFIG == D_FAST_C_ALGO)
1019 #elif (MTX34MULT_34_CONFIG == D_FAST_ASM_ALGO)
1020 #endif
1021 #else
1022 #endif // #if defined( NN_HARDWARE_CTR )
1023 }
1024
1025 NN_FORCE_INLINE MTX34*
MTX34Mult(MTX34 * pOut,const MTX34 * p,f32 f)1026 MTX34Mult(MTX34* pOut, const MTX34* p, f32 f)
1027 {
1028 #if defined( NN_HARDWARE_CTR )
1029 #if (MTX34MULT_F32_CONFIG == D_ORG)
1030 return ARMv6::MTX34MultC( pOut, p, f );
1031 #elif (MTX34MULT_F32_CONFIG == D_FAST_C)
1032 #elif (MTX34MULT_F32_CONFIG == D_FAST_ASM)
1033 return ARMv6::MTX34MultAsm( pOut, p, f );
1034 #elif (MTX34MULT_F32_CONFIG == D_FAST_C_ALGO)
1035 #elif (MTX34MULT_F32_CONFIG == D_FAST_ASM_ALGO)
1036 #endif
1037 #else
1038 #endif // #if defined( NN_HARDWARE_CTR )
1039 }
1040
1041 NN_FORCE_INLINE MTX34*
MTX34Add(MTX34 * pOut,const MTX34 * p1,const MTX34 * p2)1042 MTX34Add(MTX34* pOut, const MTX34* p1, const MTX34* p2)
1043 {
1044 #if defined( NN_HARDWARE_CTR )
1045 #if (MTX34ADD_CONFIG == D_ORG)
1046 return ARMv6::MTX34AddC( pOut, p1, p2 );
1047 #elif (MTX34ADD_CONFIG == D_FAST_C)
1048 #elif (MTX34ADD_CONFIG == D_FAST_ASM)
1049 return ARMv6::MTX34AddAsm( pOut, p1, p2 );
1050 #elif (MTX34ADD_CONFIG == D_FAST_C_ALGO)
1051 #elif (MTX34ADD_CONFIG == D_FAST_ASM_ALGO)
1052 #endif
1053 #else
1054 #endif // #if defined( NN_HARDWARE_CTR )
1055 }
1056
1057 NN_FORCE_INLINE MTX34*
MTX34CameraRotate(MTX34 * pOut,const VEC3 * pCamPos,const VEC3 * pCamRotateDeg)1058 MTX34CameraRotate(MTX34* pOut, const VEC3* pCamPos, const VEC3* pCamRotateDeg)
1059 {
1060 #if defined( NN_HARDWARE_CTR )
1061 #if (MTX34CAMERAROTATE_CONFIG == D_ORG)
1062 return ARMv6::MTX34CameraRotateC(pOut, pCamPos, pCamRotateDeg);
1063 #elif (MTX34CAMERAROTATE_CONFIG == D_FAST_C)
1064 return ARMv6::MTX34CameraRotateC_FAST(pOut, pCamPos, pCamRotateDeg);
1065 #elif (MTX34CAMERAROTATE_CONFIG == D_FAST_ASM)
1066 #elif (MTX34CAMERAROTATE_CONFIG == D_FAST_C_ALGO)
1067 #elif (MTX34CAMERAROTATE_CONFIG == D_FAST_ASM_ALGO)
1068 #endif
1069 #else
1070 #endif // #if defined( NN_HARDWARE_CTR )
1071 }
1072
1073 NN_FORCE_INLINE u32
MTX34Inverse(MTX34 * pOut,const MTX34 * p)1074 MTX34Inverse(MTX34* pOut, const MTX34* p)
1075 {
1076 #if defined( NN_HARDWARE_CTR )
1077 #if (MTX34INVERSE_CONFIG == D_ORG)
1078 return ARMv6::MTX34InverseC( pOut, p );
1079 #elif (MTX34INVERSE_CONFIG == D_FAST_C)
1080 #elif (MTX34INVERSE_CONFIG == D_FAST_ASM)
1081 return ARMv6::MTX34InverseAsm( pOut, p);
1082 #elif (MTX34INVERSE_CONFIG == D_FAST_C_ALGO)
1083 #elif (MTX34INVERSE_CONFIG == D_FAST_ASM_ALGO)
1084 #endif
1085 #else
1086 #endif // #if defined( NN_HARDWARE_CTR )
1087 }
1088
1089 NN_FORCE_INLINE u32
MTX34InvTranspose(MTX34 * pOut,const MTX34 * __restrict p)1090 MTX34InvTranspose(MTX34* pOut, const MTX34* __restrict p)
1091 {
1092 #if defined( NN_HARDWARE_CTR )
1093 #if (MTX34INVTRANSPOSE_34TO34_CONFIG == D_ORG)
1094 return ARMv6::MTX34InvTransposeC( pOut, p );
1095 #elif (MTX34INVTRANSPOSE_34TO34_CONFIG == D_FAST_C)
1096 #elif (MTX34INVTRANSPOSE_34TO34_CONFIG == D_FAST_ASM)
1097 return ARMv6::MTX34InvTransposeAsm( pOut, p);
1098 #elif (MTX34INVTRANSPOSE_34TO34_CONFIG == D_FAST_C_ALGO)
1099 #elif (MTX34INVTRANSPOSE_34TO34_CONFIG == D_FAST_ASM_ALGO)
1100 #endif
1101 #else
1102 #endif // #if defined( NN_HARDWARE_CTR )
1103 }
1104
1105 NN_FORCE_INLINE MTX34*
MTX34LookAt(MTX34 * pOut,const VEC3 * pCamPos,const VEC3 * pCamUp,const VEC3 * pTarget)1106 MTX34LookAt(MTX34* pOut, const VEC3* pCamPos, const VEC3* pCamUp, const VEC3* pTarget)
1107 {
1108 #if defined( NN_HARDWARE_CTR )
1109 #if (MTX34LOOKAT_VEC3_CONFIG == D_ORG)
1110 return ARMv6::MTX34LookAtC(pOut, pCamPos, pCamUp, pTarget);
1111 #elif (MTX34LOOKAT_VEC3_CONFIG == D_FAST_C)
1112 return ARMv6::MTX34LookAtC_FAST(pOut, pCamPos, pCamUp, pTarget);
1113 #elif (MTX34LOOKAT_VEC3_CONFIG == D_FAST_ASM)
1114 #elif (MTX34LOOKAT_VEC3_CONFIG == D_FAST_C_ALGO)
1115 #elif (MTX34LOOKAT_VEC3_CONFIG == D_FAST_ASM_ALGO)
1116 #endif
1117 #else
1118 #endif // #if defined( NN_HARDWARE_CTR )
1119 }
1120
1121
1122 NN_FORCE_INLINE MTX34*
MTX34LookAt(MTX34 * pOut,const VEC3 * pCamPos,f32 twistDeg,const VEC3 * pTarget)1123 MTX34LookAt(MTX34* pOut, const VEC3* pCamPos, f32 twistDeg, const VEC3* pTarget)
1124 {
1125 #if defined( NN_HARDWARE_CTR )
1126 #if (MTX34LOOKAT_F32_CONFIG == D_ORG)
1127 return ARMv6::MTX34LookAtC(pOut, pCamPos, twistDeg, pTarget);
1128 #elif (MTX34LOOKAT_F32_CONFIG == D_FAST_C)
1129 return ARMv6::MTX34LookAtC_FAST(pOut, pCamPos, twistDeg, pTarget);
1130 #elif (MTX34LOOKAT_F32_CONFIG == D_FAST_ASM)
1131 #elif (MTX34LOOKAT_F32_CONFIG == D_FAST_C_ALGO)
1132 #elif (MTX34LOOKAT_F32_CONFIG == D_FAST_ASM_ALGO)
1133 #endif
1134 #else
1135 #endif // #if defined( NN_HARDWARE_CTR )
1136
1137
1138 }
1139
1140 NN_FORCE_INLINE MTX34*
MTX34MAdd(MTX34 * pOut,f32 t,const MTX34 * p1,const MTX34 * p2)1141 MTX34MAdd(MTX34* pOut, f32 t, const MTX34* p1, const MTX34* p2)
1142 {
1143 #if defined( NN_HARDWARE_CTR )
1144 #if (MTX34MADD_CONFIG == D_ORG)
1145 return ARMv6::MTX34MAddC( pOut, t, p1, p2 );
1146 #elif (MTX34MADD_CONFIG == D_FAST_C)
1147 #elif (MTX34MADD_CONFIG == D_FAST_ASM)
1148 return ARMv6::MTX34MAddAsm( pOut, t, p1, p2 );
1149 #elif (MTX34MADD_CONFIG == D_FAST_C_ALGO)
1150 #elif (MTX34MADD_CONFIG == D_FAST_ASM_ALGO)
1151 #endif
1152 #else
1153 #endif // #if defined( NN_HARDWARE_CTR )
1154 }
1155
1156 NN_FORCE_INLINE MTX34*
MTX34MultScale(MTX34 * pOut,const MTX34 * pM,const VEC3 * pS)1157 MTX34MultScale(MTX34* pOut, const MTX34* pM, const VEC3* pS)
1158 {
1159 #if defined( NN_HARDWARE_CTR )
1160 #if (MTX34MULTSCALE_RIGHT_CONFIG == D_ORG)
1161 return ARMv6::MTX34MultScaleC( pOut, pM, pS );
1162 #elif (MTX34MULTSCALE_RIGHT_CONFIG == D_FAST_C)
1163 #elif (MTX34MULTSCALE_RIGHT_CONFIG == D_FAST_ASM)
1164 return ARMv6::MTX34MultScaleAsm( pOut, pM, pS );
1165 #elif (MTX34MULTSCALE_RIGHT_CONFIG == D_FAST_C_ALGO)
1166 #elif (MTX34MULTSCALE_RIGHT_CONFIG == D_FAST_ASM_ALGO)
1167 #endif
1168 #else
1169 #endif // #if defined( NN_HARDWARE_CTR )
1170 }
1171
1172 NN_FORCE_INLINE MTX34*
MTX34MultScale(MTX34 * pOut,const VEC3 * __restrict pS,const MTX34 * pM)1173 MTX34MultScale(MTX34* pOut, const VEC3* __restrict pS, const MTX34* pM)
1174 {
1175 #if defined( NN_HARDWARE_CTR )
1176 #if (MTX34MULTSCALE_LEFT_CONFIG == D_ORG)
1177 return ARMv6::MTX34MultScaleC( pOut, pS, pM );
1178 #elif (MTX34MULTSCALE_LEFT_CONFIG == D_FAST_C)
1179 #elif (MTX34MULTSCALE_LEFT_CONFIG == D_FAST_ASM)
1180 return ARMv6::MTX34MultScaleAsm( pOut, pS, pM );
1181 #elif (MTX34MULTSCALE_LEFT_CONFIG == D_FAST_C_ALGO)
1182 #elif (MTX34MULTSCALE_LEFT_CONFIG == D_FAST_ASM_ALGO)
1183 #endif
1184 #else
1185 #endif // #if defined( NN_HARDWARE_CTR )
1186 }
1187
1188 NN_FORCE_INLINE MTX34*
MTX34MultTranslate(MTX34 * pOut,const VEC3 * pT,const MTX34 * pM)1189 MTX34MultTranslate(MTX34* pOut, const VEC3* pT, const MTX34* pM)
1190 {
1191 #if defined( NN_HARDWARE_CTR )
1192 #if (MTX34MULTTRANSLATE_LEFT_CONFIG == D_ORG)
1193 return ARMv6::MTX34MultTranslateC( pOut, pT, pM );
1194 #elif (MTX34MULTTRANSLATE_LEFT_CONFIG == D_FAST_C)
1195 #elif (MTX34MULTTRANSLATE_LEFT_CONFIG == D_FAST_ASM)
1196 return ARMv6::MTX34MultTranslateAsm( pOut, pT, pM );
1197 #elif (MTX34MULTTRANSLATE_LEFT_CONFIG == D_FAST_C_ALGO)
1198 #elif (MTX34MULTTRANSLATE_LEFT_CONFIG == D_FAST_ASM_ALGO)
1199 #endif
1200 #else
1201 #endif // #if defined( NN_HARDWARE_CTR )
1202 }
1203
1204 NN_FORCE_INLINE MTX34*
MTX34MultTranslate(MTX34 * pOut,const MTX34 * pM,const VEC3 * pT)1205 MTX34MultTranslate(MTX34* pOut, const MTX34* pM, const VEC3* pT)
1206 {
1207 #if defined( NN_HARDWARE_CTR )
1208 #if (MTX34MULTTRANSLATE_RIGHT_CONFIG == D_ORG)
1209 return ARMv6::MTX34MultTranslateC( pOut, pM, pT );
1210 #elif (MTX34MULTTRANSLATE_RIGHT_CONFIG == D_FAST_C)
1211 #elif (MTX34MULTTRANSLATE_RIGHT_CONFIG == D_FAST_ASM)
1212 return ARMv6::MTX34MultTranslateAsm( pOut, pM, pT );
1213 #elif (MTX34MULTTRANSLATE_RIGHT_CONFIG == D_FAST_C_ALGO)
1214 #elif (MTX34MULTTRANSLATE_RIGHT_CONFIG == D_FAST_ASM_ALGO)
1215 #endif
1216 #else
1217 #endif // #if defined( NN_HARDWARE_CTR )
1218 }
1219
1220 NN_FORCE_INLINE MTX34*
MTX34RotAxisRad_(MTX34 * pOut,const VEC3 * pAxis,f32 fRad)1221 MTX34RotAxisRad_( MTX34* pOut, const VEC3 *pAxis, f32 fRad )
1222 {
1223 #if defined( NN_HARDWARE_CTR )
1224 #if (MTX34ROTAXISRAD__CONFIG == D_ORG)
1225 return ARMv6::MTX34RotAxisRad_C(pOut, pAxis, fRad);
1226 #elif (MTX34ROTAXISRAD__CONFIG == D_FAST_C)
1227 return ARMv6::MTX34RotAxisRad_C_FAST(pOut, pAxis, fRad);
1228 #elif (MTX34ROTAXISRAD__CONFIG == D_FAST_ASM)
1229 #elif (MTX34ROTAXISRAD__CONFIG == D_FAST_C_ALGO)
1230 return ARMv6::MTX34RotAxisRad_C_FAST(pOut, pAxis, fRad);
1231 #elif (MTX34ROTAXISRAD__CONFIG == D_FAST_ASM_ALGO)
1232 #endif
1233 #else
1234 #endif // #if defined( NN_HARDWARE_CTR )
1235 }
1236
1237 NN_FORCE_INLINE MTX34*
MTX34RotXYZFIdx(MTX34 * pOut,f32 fIdxX,f32 fIdxY,f32 fIdxZ)1238 MTX34RotXYZFIdx(MTX34* pOut, f32 fIdxX, f32 fIdxY, f32 fIdxZ)
1239 {
1240 #if defined( NN_HARDWARE_CTR )
1241 #if (MTX34ROTXYZFIDX_CONFIG == D_ORG)
1242 return ARMv6::MTX34RotXYZFIdxC(pOut, fIdxX, fIdxY, fIdxZ);
1243 #elif (MTX34ROTXYZFIDX_CONFIG == D_FAST_C)
1244 return ARMv6::MTX34RotXYZFIdxC_FAST(pOut, fIdxX, fIdxY, fIdxZ);
1245 #elif (MTX34ROTXYZFIDX_CONFIG == D_FAST_ASM)
1246 #elif (MTX34ROTXYZFIDX_CONFIG == D_FAST_C_ALGO)
1247 #elif (MTX34ROTXYZFIDX_CONFIG == D_FAST_ASM_ALGO)
1248 #endif
1249 #else
1250 #endif // #if defined( NN_HARDWARE_CTR )
1251
1252 }
1253
1254 NN_FORCE_INLINE MTX34*
MTX34Scale(MTX34 * pOut,const VEC3 * pS)1255 MTX34Scale(MTX34* pOut, const VEC3* pS)
1256 {
1257 #if defined( NN_HARDWARE_CTR )
1258 #if (MTX34SCALE_CONFIG == D_ORG)
1259 return ARMv6::MTX34ScaleC(pOut, pS);
1260 #elif (MTX34SCALE_CONFIG == D_FAST_C)
1261 return ARMv6::MTX34ScaleC_FAST(pOut, pS);
1262 #elif (MTX34SCALE_CONFIG == D_FAST_ASM)
1263 return ARMv6::MTX34ScaleAsm(pOut, pS);
1264 #elif (MTX34SCALE_CONFIG == D_FAST_C_ALGO)
1265 #elif (MTX34SCALE_CONFIG == D_FAST_ASM_ALGO)
1266 #endif
1267 #else
1268 #endif // #if defined( NN_HARDWARE_CTR )
1269 }
1270
1271 NN_FORCE_INLINE MTX34*
MTX34Translate(MTX34 * pOut,const VEC3 * pT)1272 MTX34Translate(MTX34* pOut, const VEC3* pT)
1273 {
1274 #if defined( NN_HARDWARE_CTR )
1275 #if (MTX34TRANSLATE_CONFIG == D_ORG)
1276 return ARMv6::MTX34TranslateC(pOut, pT);
1277 #elif (MTX34TRANSLATE_CONFIG == D_FAST_C)
1278 return ARMv6::MTX34TranslateC_FAST(pOut, pT);
1279 #elif (MTX34TRANSLATE_CONFIG == D_FAST_ASM)
1280 #elif (MTX34TRANSLATE_CONFIG == D_FAST_C_ALGO)
1281 #elif (MTX34TRANSLATE_CONFIG == D_FAST_ASM_ALGO)
1282 #endif
1283 #else
1284 #endif // #if defined( NN_HARDWARE_CTR )
1285 }
1286
1287 NN_FORCE_INLINE MTX34*
MTX34Transpose(MTX34 * pOut,const MTX34 * p)1288 MTX34Transpose(MTX34* pOut, const MTX34* p)
1289 {
1290 #if defined( NN_HARDWARE_CTR )
1291 #if (MTX34TRANSPOSE_34TO34_CONFIG == D_ORG)
1292 return ARMv6::MTX34TransposeC(pOut, p);
1293 #elif (MTX34TRANSPOSE_34TO34_CONFIG == D_FAST_C)
1294 #elif (MTX34TRANSPOSE_34TO34_CONFIG == D_FAST_ASM)
1295 return ARMv6::MTX34TransposeAsm(pOut, p);
1296 #elif (MTX34TRANSPOSE_34TO34_CONFIG == D_FAST_C_ALGO)
1297 #elif (MTX34TRANSPOSE_34TO34_CONFIG == D_FAST_ASM_ALGO)
1298 #endif
1299 #else
1300 #endif // #if defined( NN_HARDWARE_CTR )
1301 }
1302
1303 NN_FORCE_INLINE VEC3*
VEC3Transform(VEC3 * pOut,const MTX34 * __restrict pM,const VEC3 * __restrict pV)1304 VEC3Transform(VEC3* pOut, const MTX34* __restrict pM, const VEC3* __restrict pV)
1305 {
1306 #if defined( NN_HARDWARE_CTR )
1307 #if (VEC3TRANSFORM_34XVEC3_CONFIG == D_ORG)
1308 return ARMv6::VEC3TransformC(pOut, pM, pV);
1309 #elif (VEC3TRANSFORM_34XVEC3_CONFIG == D_FAST_C)
1310 #elif (VEC3TRANSFORM_34XVEC3_CONFIG == D_FAST_ASM)
1311 return ARMv6::VEC3TransformAsm(pOut, pM, pV);
1312 #elif (VEC3TRANSFORM_34XVEC3_CONFIG == D_FAST_C_ALGO)
1313 #elif (VEC3TRANSFORM_34XVEC3_CONFIG == D_FAST_ASM_ALGO)
1314 #endif
1315 #else
1316 #endif // #if defined( NN_HARDWARE_CTR )
1317 }
1318
1319 } // namespace math
1320 } // namespace nn
1321
1322 namespace nn {
1323 namespace math {
1324
1325 //Overload referencing the -- const argument
1326
MTX34IsIdentity(const MTX34 & m)1327 inline bool MTX34IsIdentity(const MTX34& m) { return MTX34IsIdentity( &m ); }
1328
MTX34Add(MTX34 * pOut,const MTX34 & m1,const MTX34 & m2)1329 inline MTX34* MTX34Add(MTX34* pOut, const MTX34& m1, const MTX34& m2) { return MTX34Add( pOut, &m1, &m2 ); }
MTX34Sub(MTX34 * pOut,const MTX34 & m1,const MTX34 & m2)1330 inline MTX34* MTX34Sub(MTX34* pOut, const MTX34& m1, const MTX34& m2) { return MTX34Sub( pOut, &m1, &m2 ); }
MTX34Mult(MTX34 * pOut,const MTX34 & m,f32 f)1331 inline MTX34* MTX34Mult(MTX34* pOut, const MTX34& m, f32 f) { return MTX34Mult( pOut, &m, f ); }
MTX34Mult(MTX34 * pOut,const MTX34 & m1,const MTX34 & m2)1332 inline MTX34* MTX34Mult(MTX34* pOut, const MTX34& m1, const MTX34& m2) { return MTX34Mult( pOut, &m1, &m2 ); }
MTX34MAdd(MTX34 * pOut,f32 t,const MTX34 & m1,const MTX34 & m2)1333 inline MTX34* MTX34MAdd(MTX34* pOut, f32 t, const MTX34& m1, const MTX34& m2) { return MTX34MAdd( pOut, t, &m1, &m2 ); }
1334
MTX34Copy(MTX34 * pOut,const MTX34 & m)1335 inline MTX34* MTX34Copy(MTX34* pOut, const MTX34& m) { return MTX34Copy( pOut, &m ); }
MTX34MultArray(MTX34 * pOut,const MTX34 & m1,const MTX34 * pSrc,s32 count)1336 inline MTX34* MTX34MultArray(MTX34* pOut, const MTX34& m1, const MTX34* pSrc, s32 count) { return MTX34MultArray( pOut, m1, pSrc, count ); }
MTX34Inverse(MTX34 * pOut,const MTX34 & m)1337 inline u32 MTX34Inverse(MTX34* pOut, const MTX34& m) { return MTX34Inverse( pOut, &m ); }
MTX34Transpose(MTX34 * pOut,const MTX34 & m)1338 inline MTX34* MTX34Transpose(MTX34* pOut, const MTX34& m) { return MTX34Transpose( pOut, &m ); }
MTX34InvTranspose(MTX34 * pOut,const MTX34 & m)1339 inline u32 MTX34InvTranspose(MTX34* pOut, const MTX34& m) { return MTX34InvTranspose( pOut, &m ); }
MTX34InvTranspose(MTX33 * pOut,const MTX34 & m)1340 inline u32 MTX34InvTranspose(MTX33* pOut, const MTX34& m) { return MTX34InvTranspose( pOut, &m ); }
1341
MTX34LookAt(MTX34 * pOut,const VEC3 & vCamPos,const VEC3 & vCamUp,const VEC3 & vTarget)1342 inline MTX34* MTX34LookAt(MTX34* pOut, const VEC3& vCamPos, const VEC3& vCamUp, const VEC3& vTarget) { return MTX34LookAt( pOut, &vCamPos, &vCamUp, &vTarget ); }
MTX34LookAt(MTX34 * pOut,const VEC3 & vCamPos,f32 twistDeg,const VEC3 & vTarget)1343 inline MTX34* MTX34LookAt(MTX34* pOut, const VEC3& vCamPos, f32 twistDeg, const VEC3& vTarget) { return MTX34LookAt( pOut, &vCamPos, twistDeg, &vTarget ); }
MTX34CameraRotate(MTX34 * pOut,const VEC3 & vCamPos,const VEC3 & vCamRotateDeg)1344 inline MTX34* MTX34CameraRotate(MTX34* pOut, const VEC3& vCamPos, const VEC3& vCamRotateDeg) { return MTX34CameraRotate( pOut, &vCamPos, &vCamRotateDeg ); }
1345
MTX34RotXYZTranslateFIdx(MTX34 * pOut,f32 fIdxX,f32 fIdxY,f32 fIdxZ,const VEC3 & vT)1346 inline MTX34* MTX34RotXYZTranslateFIdx(MTX34* pOut, f32 fIdxX, f32 fIdxY, f32 fIdxZ, const VEC3& vT) { return MTX34RotXYZTranslateFIdx( pOut, fIdxX, fIdxY, fIdxZ, &vT ); }
MTX34RotAxisFIdx(MTX34 * pOut,const VEC3 & vAxis,f32 fIdx)1347 inline MTX34* MTX34RotAxisFIdx(MTX34* pOut, const VEC3& vAxis, f32 fIdx) { return MTX34RotAxisFIdx( pOut, &vAxis, fIdx ); }
MTX34RotAxisRad(MTX34 * pOut,const VEC3 & vAxis,f32 fRad)1348 inline MTX34* MTX34RotAxisRad(MTX34* pOut, const VEC3& vAxis, f32 fRad) { return MTX34RotAxisRad( pOut, &vAxis, fRad ); }
MTX34RotAxisDeg(MTX34 * pOut,const VEC3 & vAxis,f32 fDeg)1349 inline MTX34* MTX34RotAxisDeg(MTX34* pOut, const VEC3& vAxis, f32 fDeg) { return MTX34RotAxisDeg( pOut, &vAxis, fDeg ); }
1350
MTX34Scale(MTX34 * pOut,const VEC3 & vS)1351 inline MTX34* MTX34Scale(MTX34* pOut, const VEC3& vS) { return MTX34Scale( pOut, &vS ); }
MTX34MultScale(MTX34 * pOut,const MTX34 & m,const VEC3 & vS)1352 inline MTX34* MTX34MultScale(MTX34* pOut, const MTX34& m, const VEC3& vS) { return MTX34MultScale( pOut, &m, &vS ); }
MTX34MultScale(MTX34 * pOut,const VEC3 & vS,const MTX34 & m)1353 inline MTX34* MTX34MultScale(MTX34* pOut, const VEC3& vS, const MTX34& m) { return MTX34MultScale( pOut, &vS, &m ); }
1354
MTX34Translate(MTX34 * pOut,const VEC3 & vT)1355 inline MTX34* MTX34Translate(MTX34* pOut, const VEC3& vT) { return MTX34Translate( pOut, &vT ); }
MTX34MultTranslate(MTX34 * pOut,const MTX34 & m,const VEC3 & vT)1356 inline MTX34* MTX34MultTranslate(MTX34* pOut, const MTX34& m, const VEC3& vT) { return MTX34MultTranslate( pOut, &m, &vT ); }
MTX34MultTranslate(MTX34 * pOut,const VEC3 & vT,const MTX34 & m)1357 inline MTX34* MTX34MultTranslate(MTX34* pOut, const VEC3& vT, const MTX34& m) { return MTX34MultTranslate( pOut, &vT, &m ); }
1358
1359 } // namespace math
1360 } // namespace nn
1361
1362 #if defined(NN_MATH_AS_INLINE)
1363 #include <nn/math/inline/math_Matrix34.ipp>
1364 #include <nn/math/ARMv6/inline/math_Matrix34.ipp>
1365 #endif
1366
1367 #pragma pop
1368
1369 #endif
1370