1 /*---------------------------------------------------------------------------*
2   Project:  Horizon
3   File:     math_Matrix34.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_MATRIX34_H_
17 #define NN_MATH_MATRIX34_H_
18 
19 #include <cstring>
20 #include <nn/math/math_Config.h>
21 #include <nn/math/ARMv6/math_Matrix34.h>
22 
23 #pragma push
24 #pragma Otime
25 
26 namespace nn {
27 namespace math {
28 
29 struct MTX34;
30 
31 /* ------------------------------------------------------------------------
32     Function for MTX34
33    ------------------------------------------------------------------------ */
34 NN_MATH_INLINE MTX34* MTX34Zero(MTX34* pOut);
35 NN_MATH_INLINE bool MTX34IsIdentity(const MTX34* p);
36 NN_MATH_INLINE MTX34* MTX34Identity(MTX34* pOut);
37 NN_MATH_INLINE MTX34* MTX34Copy(MTX34* pOut, const MTX34* p);
38 
39 NN_MATH_INLINE MTX34* MTX34Add(MTX34* pOut, const MTX34* p1, const MTX34* p2);
40 NN_MATH_INLINE MTX34* MTX34Sub(MTX34* pOut, const MTX34* p1, const MTX34* p2);
41 NN_MATH_INLINE MTX34* MTX34Mult(MTX34* pOut, const MTX34* p, f32 f);
42 NN_MATH_INLINE MTX34* MTX34Mult(MTX34* pOut, const MTX34* p1, const MTX34* p2);
43 NN_MATH_INLINE MTX34* MTX34MAdd(MTX34* pOut, f32 t, const MTX34* p1, const MTX34* p2);
44 
45 NN_MATH_INLINE MTX33* MTX34ToMTX33(MTX33* pOut, const MTX34* pM);
46 NN_MATH_INLINE MTX34* MTX33ToMTX34(MTX34* pOut, const MTX33* pM);
47 
48 NN_MATH_INLINE MTX34* MTX34MultArray(MTX34* pOut, const MTX34* p1, const MTX34* pSrc, s32 count);
49 NN_MATH_INLINE u32    MTX34Inverse(MTX34* pOut, const MTX34* p);
50 NN_MATH_INLINE MTX34* MTX34Transpose(MTX34* pOut, const MTX34* p);
51 NN_MATH_INLINE u32    MTX34InvTranspose(MTX34* pOut, const MTX34* p);
52 
53 NN_MATH_INLINE MTX34* MTX34LookAt(MTX34* pOut, const VEC3* pCamPos, const VEC3* pCamUp, const VEC3* pTarget);
54 NN_MATH_INLINE MTX34* MTX34LookAt(MTX34* pOut, const VEC3* pCamPos, f32 twistDeg, const VEC3* pTarget);
55 NN_MATH_INLINE MTX34* MTX34CameraRotate(MTX34* pOut, const VEC3* pCamPos, const VEC3* pCamRotateDeg);
56 
57 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);
58 NN_MATH_INLINE MTX34* MTX34TextureProjectionPerspective(MTX34* pOut, f32 fovy, f32 aspect, f32 scaleS, f32 scaleT, f32 translateS, f32 translateT);
59 NN_MATH_INLINE MTX34* MTX34TextureProjectionOrtho(MTX34* pOut, f32 l, f32 r, f32 b, f32 t, f32 scaleS, f32 scaleT, f32 translateS, f32 translateT);
60 
61 NN_MATH_INLINE MTX34* MTX34RotXYZFIdx(MTX34* pOut, f32 fIdxX, f32 fIdxY, f32 fIdxZ);
62 NN_MATH_INLINE MTX34* MTX34RotXYZTranslateFIdx(MTX34* pOut, f32 fIdxX, f32 fIdxY, f32 fIdxZ, const VEC3* pT);
63 NN_MATH_INLINE MTX34* MTX34RotAxisFIdx(MTX34* pOut, const VEC3* pAxis, f32 fIdx);
64 
65 NN_MATH_INLINE MTX34* MTX34Scale(MTX34* pOut, const VEC3* pS);
66 NN_MATH_INLINE MTX34* MTX34MultScale(MTX34* pOut, const MTX34* pM, const VEC3* pS);
67 NN_MATH_INLINE MTX34* MTX34MultScale(MTX34* pOut, const VEC3* pS, const MTX34* pM);
68 
69 NN_MATH_INLINE MTX34* MTX34Translate(MTX34* pOut, const VEC3* pT);
70 NN_MATH_INLINE MTX34* MTX34MultTranslate(MTX34* pOut, const MTX34* pM, const VEC3* pT);
71 NN_MATH_INLINE MTX34* MTX34MultTranslate(MTX34* pOut, const VEC3* pT, const MTX34* pM);
72 NN_MATH_INLINE MTX34* QUATToMTX34(MTX34* pOut, const QUAT* p);
73 
74 NN_FORCE_INLINE MTX34* MTX34Copy(MTX34* pOut, const MTX34* p);
75 NN_FORCE_INLINE MTX34* MTX34Mult(MTX34* pOut, const MTX34* p1, const MTX34* p2);
76 NN_FORCE_INLINE MTX34* MTX34Add(MTX34* pOut, const MTX34* p1, const MTX34* p2);
77 NN_FORCE_INLINE MTX34* MTX34CameraRotate(MTX34* pOut, const VEC3* pCamPos, const VEC3* pCamRotateDeg);
78 NN_FORCE_INLINE u32    MTX34Inverse(MTX34* pOut, const MTX34* p);
79 NN_FORCE_INLINE u32    MTX34InvTranspose(MTX34* pOut, const MTX34* p);
80 NN_FORCE_INLINE MTX34* MTX34LookAt(MTX34* pOut, const VEC3* pCamPos, const VEC3* pCamUp, const VEC3* pTarget);
81 NN_FORCE_INLINE MTX34* MTX34LookAt(MTX34* pOut, const VEC3* pCamPos, f32 twistDeg, const VEC3* pTarget);
82 NN_FORCE_INLINE MTX34* MTX34MAdd(MTX34* pOut, f32 t, const MTX34* p1, const MTX34* p2);
83 NN_FORCE_INLINE MTX34* MTX34Mult(MTX34* pOut, const MTX34* p, f32 f);
84 NN_FORCE_INLINE MTX34* MTX34MultScale(MTX34* pOut, const MTX34* pM, const VEC3* pS);
85 NN_FORCE_INLINE MTX34* MTX34MultScale(MTX34* pOut, const VEC3* __restrict pS, const MTX34* pM);
86 NN_FORCE_INLINE MTX34* MTX34MultTranslate(MTX34* pOut, const VEC3* pT, const MTX34* pM);
87 NN_FORCE_INLINE MTX34* MTX34MultTranslate(MTX34* pOut, const MTX34* pM, const VEC3* pT);
88 NN_FORCE_INLINE MTX34* MTX34RotAxisRad_( MTX34* pOut, const VEC3 *pAxis, f32 fRad );
89 NN_FORCE_INLINE MTX34* MTX34Scale(MTX34* pOut, const VEC3* pS);
90 NN_FORCE_INLINE MTX34* MTX34Transpose(MTX34* pOut, const MTX34* p);
91 NN_FORCE_INLINE MTX34* QUATToMTX34(MTX34* pOut, const QUAT* pQ);
92 NN_FORCE_INLINE VEC3* VEC3Transform(VEC3* pOut, const MTX34* __restrict pM, const VEC3* __restrict pV);
93 
94 // This will be implemented before long
95 //MTX34* MTX34Inv(MTX34* pOut, f32* pDet, const MTX34* p);
96 //MTX34* MTX34InvTranspose(MTX34* pOut, f32* pDet, const MTX34* p);
97 //f32 MTX34Det(const MTX34* p);
98 
99 /* Please see man pages for details
100 
101 
102 */
103 
104 /*
105 
106 
107 
108 
109 
110 
111 
112 
113  */
114 inline MTX34*
MTX34RotXYZRad(MTX34 * pOut,f32 fRadX,f32 fRadY,f32 fRadZ)115 MTX34RotXYZRad(MTX34* pOut, f32 fRadX, f32 fRadY, f32 fRadZ)
116 {
117     return MTX34RotXYZFIdx(pOut, NN_MATH_RAD_TO_FIDX(fRadX), NN_MATH_RAD_TO_FIDX(fRadY), NN_MATH_RAD_TO_FIDX(fRadZ));
118 }
119 
120 /*
121 
122 
123 
124 
125 
126 
127 
128 
129  */
130 inline MTX34*
MTX34RotXYZDeg(MTX34 * pOut,f32 fDegX,f32 fDegY,f32 fDegZ)131 MTX34RotXYZDeg(MTX34* pOut, f32 fDegX, f32 fDegY, f32 fDegZ)
132 {
133     return MTX34RotXYZFIdx(pOut, NN_MATH_DEG_TO_FIDX(fDegX), NN_MATH_DEG_TO_FIDX(fDegY), NN_MATH_DEG_TO_FIDX(fDegZ));
134 }
135 
136 /*
137 
138 
139 
140 
141 
142 
143 
144  */
145 inline MTX34*
MTX34RotAxisRad(MTX34 * pOut,const VEC3 * pAxis,f32 fRad)146 MTX34RotAxisRad(MTX34* pOut, const VEC3* pAxis, f32 fRad)
147 {
148     return MTX34RotAxisFIdx(pOut, pAxis, NN_MATH_RAD_TO_FIDX(fRad));
149 }
150 
151 /*
152 
153 
154 
155 
156 
157 
158 
159  */
160 inline MTX34*
MTX34RotAxisDeg(MTX34 * pOut,const VEC3 * pAxis,f32 fDeg)161 MTX34RotAxisDeg(MTX34* pOut, const VEC3* pAxis, f32 fDeg)
162 {
163     return MTX34RotAxisFIdx(pOut, pAxis, NN_MATH_DEG_TO_FIDX(fDeg));
164 }
165 
166 /*
167 
168 */
169 
170 /* =======================================================================
171         Class definitions
172    ======================================================================== */
173 struct MTX34_
174 {
175     struct BaseData
176     {
177         f32 _00, _01, _02, _03;
178         f32 _10, _11, _12, _13;
179         f32 _20, _21, _22, _23;
180     };
181 
182     union
183     {
184     #if defined(NN_MATH_USE_ANONYMOUS_STRUCT)
185         struct
186         {
187             f32 _00, _01, _02, _03;
188             f32 _10, _11, _12, _13;
189             f32 _20, _21, _22, _23;
190         };
191     #endif
192         BaseData f;
193         f32 m[3][4];
194         f32 a[12];
195         VEC4_ v[3];
196     };
197 };
198 
199 /*
200 
201  */
202 struct MTX34 : public MTX34_
203 {
204 public:
205     static const int ROW_COUNT = 3; //
206     static const int COLUMN_COUNT = 4; //
207 
208      //
IdentityMTX34209     static const MTX34& Identity()
210     {
211         static const MTX34 identity(
212             1.0f, 0.0f, 0.0f, 0.0f,
213             0.0f, 1.0f, 0.0f, 0.0f,
214             0.0f, 0.0f, 1.0f, 0.0f);
215 
216         return identity;
217     }
218 
219     typedef MTX34 self_type; //
220     typedef f32   value_type; //
221 public:
222     //----------------------------------------
223     //
224     //
225 
226     //
MTX34MTX34227     MTX34() {}
228 
229     //
MTX34MTX34230     explicit MTX34(const f32* p) { (void)MTX34Copy(this, (MTX34*)p); }
231 
232     //
MTX34MTX34233     MTX34(const MTX34& rhs) { (void)MTX34Copy(this, &rhs); }
234 
235     //
MTX34MTX34236     explicit MTX34(const MTX33& rhs) { MTX33ToMTX34(this, &rhs); }
237 
238     //
MTX34MTX34239     MTX34(f32 x00, f32 x01, f32 x02, f32 x03,
240           f32 x10, f32 x11, f32 x12, f32 x13,
241           f32 x20, f32 x21, f32 x22, f32 x23)
242     {
243         f._00 = x00; f._01 = x01; f._02 = x02; f._03 = x03;
244         f._10 = x10; f._11 = x11; f._12 = x12; f._13 = x13;
245         f._20 = x20; f._21 = x21; f._22 = x22; f._23 = x23;
246     }
247 
248     //
249 
250     //----------------------------------------
251     //
252     //
253 
254     //
255     operator f32*() { return this->a; }
256 
257     //
258     operator const f32*() const { return this->a; }
259 
260     //
GetRowMTX34261     VEC4& GetRow(int index)
262     {
263         NN_MATH_MINMAXLT_ASSERT(index, 0, ROW_COUNT);
264         return *reinterpret_cast<VEC4*>(&this->v[index]);
265     }
266 
267     //
GetRowMTX34268     const VEC4& GetRow(int index) const
269     {
270         NN_MATH_MINMAXLT_ASSERT(index, 0, ROW_COUNT);
271         return *reinterpret_cast<const VEC4*>(&this->v[index]);
272     }
273 
274     //
GetColumnMTX34275     VEC3 GetColumn(int index) const
276     {
277         NN_MATH_MINMAXLT_ASSERT(index, 0, COLUMN_COUNT);
278         VEC3 column;
279         column.x = this->m[0][index];
280         column.y = this->m[1][index];
281         column.z = this->m[2][index];
282         return column;
283     }
284 
285     //
SetColumnMTX34286     void SetColumn(int index, const VEC3& column)
287     {
288         NN_MATH_MINMAXLT_ASSERT(index, 0, COLUMN_COUNT);
289         this->m[0][index] = column.x;
290         this->m[1][index] = column.y;
291         this->m[2][index] = column.z;
292     }
293     //
294 
295     //----------------------------------------
296     //
297     //
298     self_type& operator += (const self_type& rhs) { return *MTX34Add(this, this, &rhs); }
299     self_type& operator -= (const self_type& rhs) { return *MTX34Sub(this, this, &rhs); }
300 
301     //
302     self_type& operator *= (f32 f) { return *MTX34Mult(this, this, f); }
303     self_type& operator /= (f32 f) { return operator*=(1.f / f); }
304 
305     self_type operator + () const { return *this; }
306     self_type operator - () const
307     {
308         return MTX34(-f._00, -f._01, -f._02, -f._03,
309                      -f._10, -f._11, -f._12, -f._13,
310                      -f._20, -f._21, -f._22, -f._23);
311     }
312 
313     self_type operator + (const self_type& rhs) const { MTX34 tmp; return *MTX34Add(&tmp, this, &rhs); }
314     self_type operator - (const self_type& rhs) const { MTX34 tmp; return *MTX34Sub(&tmp, this, &rhs); }
315 
316     self_type operator * (f32 f) const { MTX34 tmp; return *MTX34Mult(&tmp, this, f); }
317     self_type operator / (f32 f) const { return *this * (1.f / f); }
318 
319     //
TransposeMTX34320     self_type& Transpose() { return *MTX34Transpose(this, this); }
321 
322     //
323 
324     //----------------------------------------
325     //
326     //
327 
328     //
SetupIdentityMTX34329     self_type& SetupIdentity() { return *MTX34Identity(this); }
330 
331     //
332     //
333     //
334     //
SetupScaleMTX34335     self_type& SetupScale(const VEC3& scale) { return *MTX34Scale(this, &scale); }
336 
337     //
338     //
339     //
340     //
SetupTranslateMTX34341     self_type& SetupTranslate(const VEC3& translate)
342     {
343         return *MTX34Translate(this, &translate);
344     }
345 
346     //
347     //
348     //
349     //
SetupRotateXyzMTX34350     self_type& SetupRotateXyz(const VEC3& rotate)
351     {
352         return *MTX34RotXYZRad(this, rotate.x, rotate.y, rotate.z);
353     }
354 
355     //
356     //
357     //
358     //
359     //
SetupRotateMTX34360     self_type& SetupRotate(const VEC3& axis, f32 theta)
361     {
362         return *MTX34RotAxisRad(this, &axis, theta);
363     }
364 
365     //
366     //
367     //
SetupRotateMTX34368     self_type& SetupRotate(const QUAT& quaternion)
369     {
370         return *QUATToMTX34(this, &quaternion);
371     }
372 
373     /*
374 
375 
376 
377 
378 
379      */
SetupLookAtMTX34380     self_type& SetupLookAt(const VEC3& camPos, const VEC3& camUp, const VEC3& target)
381     {
382         return *MTX34LookAt(this, &camPos, &camUp, &target);
383     }
384 
385     /*
386 
387 
388 
389 
390 
391      */
SetupLookAtMTX34392     self_type& SetupLookAt(const VEC3& camPos, f32 twistDeg, const VEC3& target)
393     {
394         return *MTX34LookAt(this, &camPos, twistDeg, &target);
395     }
396 
397     /*
398 
399 
400 
401 
402      */
SetupCameraRotateMTX34403     self_type& SetupCameraRotate(const VEC3& camPos, const VEC3& camRotateDeg)
404     {
405         return *MTX34CameraRotate(this, &camPos, &camRotateDeg);
406     }
407 
408     /*
409 
410 
411 
412 
413 
414 
415 
416 
417 
418 
419 
420      */
SetupTextureProjectionFrustumMTX34421     self_type& SetupTextureProjectionFrustum(f32 l, f32 r, f32 b, f32 t, f32 n, f32 scaleS, f32 scaleT, f32 translateS, f32 translateT)
422     {
423         return *MTX34TextureProjectionFrustum(this, l, r, b, t, n, scaleS, scaleT, translateS, translateT);
424     }
425 
426     /*
427 
428 
429 
430 
431 
432 
433 
434 
435      */
SetupTextureProjectionFrustumMTX34436     self_type& SetupTextureProjectionFrustum(f32 fovyRad, f32 aspect, f32 scaleS, f32 scaleT, f32 translateS, f32 translateT)
437     {
438         return *MTX34TextureProjectionPerspective(this, fovyRad, aspect, scaleS, scaleT, translateS, translateT);
439     }
440 
441     /*
442 
443 
444 
445 
446 
447 
448 
449 
450 
451 
452 
453      */
SetupTextureProjectionFrustumMTX34454     self_type& SetupTextureProjectionFrustum(f32 l, f32 r, f32 b, f32 t, f32 scaleS, f32 scaleT, f32 translateS, f32 translateT)
455     {
456         return *MTX34TextureProjectionOrtho(this, l, r, b, t, scaleS, scaleT, translateS, translateT);
457     }
458 
459     //
460 
461     //----------------------------------------
462     //
463     //
464 
465     //
466     bool operator == (const self_type& rhs) const { return ::std::memcmp(this, &rhs, sizeof(MTX34)) == 0; }
467 
468     //
469     bool operator != (const self_type& rhs) const { return ::std::memcmp(this, &rhs, sizeof(MTX34)) != 0; }
470 
471     //
IsIdentityMTX34472     bool IsIdentity() const { return MTX34IsIdentity(this); }
473     //
474 
475     //
476     void Report(bool bNewline = true, const char* name = NULL) const;
477 };
478 
479 typedef struct MTX34 Matrix34;
480 
481 //
482 inline MTX34 operator * (f32 f, const MTX34& rhs)
483 {
484     MTX34 tmp;
485     (void)MTX34Mult(&tmp, &rhs, f);
486     return tmp;
487 }
488 
489 /* Please see man pages for details
490 
491 
492 */
493 
494 /*
495 
496 
497 
498 
499 
500 
501  */
502 NN_FORCE_INLINE MTX34*
MTX34Copy(MTX34 * pOut,const MTX34 * p)503 MTX34Copy(MTX34* pOut, const MTX34* p)
504 {
505 
506 #if defined( NN_HARDWARE_CTR )
507     #if (MTX34COPY_CONFIG == D_ORG)
508         return ARMv6::MTX34CopyC( pOut, p );
509     #elif (MTX34COPY_CONFIG == D_FAST_C)
510     #elif (MTX34COPY_CONFIG == D_FAST_ASM)
511         return ARMv6::MTX34CopyAsm( pOut, p );
512     #elif (MTX34COPY_CONFIG == D_FAST_C_ALGO)
513     #elif (MTX34COPY_CONFIG == D_FAST_ASM_ALGO)
514     #endif
515 #else
516 #endif // #if defined( NN_HARDWARE_CTR )
517 }
518 
519 /*
520 
521 
522 
523 
524 
525 
526 
527 
528  */
529 NN_FORCE_INLINE MTX34*
MTX34Mult(MTX34 * pOut,const MTX34 * p1,const MTX34 * p2)530 MTX34Mult(MTX34* pOut, const MTX34* p1, const MTX34* p2)
531 {
532 #if defined( NN_HARDWARE_CTR )
533     #if (MTX34MULT_34_CONFIG == D_ORG)
534         return ARMv6::MTX34MultC( pOut, p1, p2 );
535     #elif (MTX34MULT_34_CONFIG == D_FAST_C)
536     #elif (MTX34MULT_34_CONFIG == D_FAST_ASM)
537         return ARMv6::MTX34MultAsm( pOut, p1, p2 );
538     #elif (MTX34MULT_34_CONFIG == D_FAST_C_ALGO)
539     #elif (MTX34MULT_34_CONFIG == D_FAST_ASM_ALGO)
540     #endif
541 #else
542 #endif // #if defined( NN_HARDWARE_CTR )
543 }
544 /*
545 
546 
547 
548 
549 
550 
551 
552  */
553 NN_FORCE_INLINE MTX34*
MTX34Mult(MTX34 * pOut,const MTX34 * p,f32 f)554 MTX34Mult(MTX34* pOut, const MTX34* p, f32 f)
555 {
556 #if defined( NN_HARDWARE_CTR )
557     #if (MTX34MULT_F32_CONFIG == D_ORG)
558         return ARMv6::MTX34MultC( pOut, p, f );
559     #elif (MTX34MULT_F32_CONFIG == D_FAST_C)
560     #elif (MTX34MULT_F32_CONFIG == D_FAST_ASM)
561         return ARMv6::MTX34MultAsm( pOut, p, f );
562     #elif (MTX34MULT_F32_CONFIG == D_FAST_C_ALGO)
563     #elif (MTX34MULT_F32_CONFIG == D_FAST_ASM_ALGO)
564     #endif
565 #else
566 #endif // #if defined( NN_HARDWARE_CTR )
567 }
568 
569 
570 /*
571 
572 
573 
574 
575 
576 
577 
578  */
579 NN_FORCE_INLINE MTX34*
MTX34Add(MTX34 * pOut,const MTX34 * p1,const MTX34 * p2)580 MTX34Add(MTX34* pOut, const MTX34* p1, const MTX34* p2)
581 {
582 #if defined( NN_HARDWARE_CTR )
583     #if (MTX34ADD_CONFIG == D_ORG)
584         return ARMv6::MTX34AddC( pOut, p1, p2 );
585     #elif (MTX34ADD_CONFIG == D_FAST_C)
586     #elif (MTX34ADD_CONFIG == D_FAST_ASM)
587         return ARMv6::MTX34AddAsm( pOut, p1, p2 );
588     #elif (MTX34ADD_CONFIG == D_FAST_C_ALGO)
589     #elif (MTX34ADD_CONFIG == D_FAST_ASM_ALGO)
590     #endif
591 #else
592 #endif // #if defined( NN_HARDWARE_CTR )
593 }
594 
595 /*
596 
597 
598 
599 
600 
601 
602 
603  */
604 NN_FORCE_INLINE MTX34*
MTX34CameraRotate(MTX34 * pOut,const VEC3 * pCamPos,const VEC3 * pCamRotateDeg)605 MTX34CameraRotate(MTX34* pOut, const VEC3* pCamPos, const VEC3* pCamRotateDeg)
606 {
607 #if defined( NN_HARDWARE_CTR )
608     #if (MTX34CAMERAROTATE_CONFIG == D_ORG)
609         return ARMv6::MTX34CameraRotateC(pOut, pCamPos, pCamRotateDeg);
610     #elif (MTX34CAMERAROTATE_CONFIG == D_FAST_C)
611         return ARMv6::MTX34CameraRotateC_FAST(pOut, pCamPos, pCamRotateDeg);
612     #elif (MTX34CAMERAROTATE_CONFIG == D_FAST_ASM)
613     #elif (MTX34CAMERAROTATE_CONFIG == D_FAST_C_ALGO)
614     #elif (MTX34CAMERAROTATE_CONFIG == D_FAST_ASM_ALGO)
615     #endif
616 #else
617 #endif // #if defined( NN_HARDWARE_CTR )
618 }
619 
620 
621 /*
622 
623 
624 
625 
626 
627 
628  */
629 NN_FORCE_INLINE u32
MTX34Inverse(MTX34 * pOut,const MTX34 * p)630 MTX34Inverse(MTX34* pOut, const MTX34* p)
631 {
632 #if defined( NN_HARDWARE_CTR )
633     #if (MTX34INVERSE_CONFIG == D_ORG)
634         return ARMv6::MTX34InverseC( pOut, p );
635     #elif (MTX34INVERSE_CONFIG == D_FAST_C)
636     #elif (MTX34INVERSE_CONFIG == D_FAST_ASM)
637         return ARMv6::MTX34InverseAsm( pOut, p);
638     #elif (MTX34INVERSE_CONFIG == D_FAST_C_ALGO)
639     #elif (MTX34INVERSE_CONFIG == D_FAST_ASM_ALGO)
640     #endif
641 #else
642 #endif // #if defined( NN_HARDWARE_CTR )
643 }
644 
645 /*
646 
647 
648 
649 
650 
651 
652  */
653 NN_FORCE_INLINE u32
MTX34InvTranspose(MTX34 * pOut,const MTX34 * __restrict p)654 MTX34InvTranspose(MTX34* pOut, const MTX34* __restrict p)
655 {
656 #if defined( NN_HARDWARE_CTR )
657     #if (MTX34INVTRANSPOSE_34TO34_CONFIG == D_ORG)
658         return ARMv6::MTX34InvTransposeC( pOut, p );
659     #elif (MTX34INVTRANSPOSE_34TO34_CONFIG == D_FAST_C)
660     #elif (MTX34INVTRANSPOSE_34TO34_CONFIG == D_FAST_ASM)
661         return ARMv6::MTX34InvTransposeAsm( pOut, p);
662     #elif (MTX34INVTRANSPOSE_34TO34_CONFIG == D_FAST_C_ALGO)
663     #elif (MTX34INVTRANSPOSE_34TO34_CONFIG == D_FAST_ASM_ALGO)
664     #endif
665 #else
666 #endif // #if defined( NN_HARDWARE_CTR )
667 }
668 
669 /*
670 
671 
672 
673 
674 
675 
676 
677 
678  */
679 NN_FORCE_INLINE MTX34*
MTX34LookAt(MTX34 * pOut,const VEC3 * pCamPos,const VEC3 * pCamUp,const VEC3 * pTarget)680 MTX34LookAt(MTX34* pOut, const VEC3* pCamPos, const VEC3* pCamUp, const VEC3* pTarget)
681 {
682 #if defined( NN_HARDWARE_CTR )
683     #if (MTX34LOOKAT_VEC3_CONFIG == D_ORG)
684         return ARMv6::MTX34LookAtC(pOut, pCamPos, pCamUp, pTarget);
685     #elif (MTX34LOOKAT_VEC3_CONFIG == D_FAST_C)
686         return ARMv6::MTX34LookAtC_FAST(pOut, pCamPos, pCamUp, pTarget);
687     #elif (MTX34LOOKAT_VEC3_CONFIG == D_FAST_ASM)
688     #elif (MTX34LOOKAT_VEC3_CONFIG == D_FAST_C_ALGO)
689     #elif (MTX34LOOKAT_VEC3_CONFIG == D_FAST_ASM_ALGO)
690     #endif
691 #else
692 #endif // #if defined( NN_HARDWARE_CTR )
693 }
694 
695 /*
696 
697 
698 
699 
700 
701 
702 
703 
704  */
705 NN_FORCE_INLINE MTX34*
MTX34LookAt(MTX34 * pOut,const VEC3 * pCamPos,f32 twistDeg,const VEC3 * pTarget)706 MTX34LookAt(MTX34* pOut, const VEC3* pCamPos, f32 twistDeg, const VEC3* pTarget)
707 {
708 #if defined( NN_HARDWARE_CTR )
709     #if (MTX34LOOKAT_F32_CONFIG == D_ORG)
710         return ARMv6::MTX34LookAtC(pOut, pCamPos, twistDeg, pTarget);
711     #elif (MTX34LOOKAT_F32_CONFIG == D_FAST_C)
712         return ARMv6::MTX34LookAtC_FAST(pOut, pCamPos, twistDeg, pTarget);
713     #elif (MTX34LOOKAT_F32_CONFIG == D_FAST_ASM)
714     #elif (MTX34LOOKAT_F32_CONFIG == D_FAST_C_ALGO)
715     #elif (MTX34LOOKAT_F32_CONFIG == D_FAST_ASM_ALGO)
716     #endif
717 #else
718 #endif // #if defined( NN_HARDWARE_CTR )
719 
720 
721 }
722 /*
723 
724 
725 
726 
727 
728 
729 
730 
731  */
732 NN_FORCE_INLINE MTX34*
MTX34MAdd(MTX34 * pOut,f32 t,const MTX34 * p1,const MTX34 * p2)733 MTX34MAdd(MTX34* pOut, f32 t, const MTX34* p1, const MTX34* p2)
734 {
735 #if defined( NN_HARDWARE_CTR )
736     #if (MTX34MADD_CONFIG == D_ORG)
737         return ARMv6::MTX34MAddC( pOut, t, p1, p2 );
738     #elif (MTX34MADD_CONFIG == D_FAST_C)
739     #elif (MTX34MADD_CONFIG == D_FAST_ASM)
740         return ARMv6::MTX34MAddAsm( pOut, t, p1, p2 );
741     #elif (MTX34MADD_CONFIG == D_FAST_C_ALGO)
742     #elif (MTX34MADD_CONFIG == D_FAST_ASM_ALGO)
743     #endif
744 #else
745 #endif // #if defined( NN_HARDWARE_CTR )
746 }
747 
748 /*
749 
750 
751 
752 
753 
754 
755 
756  */
757 NN_FORCE_INLINE MTX34*
MTX34MultScale(MTX34 * pOut,const MTX34 * pM,const VEC3 * pS)758 MTX34MultScale(MTX34* pOut, const MTX34* pM, const VEC3* pS)
759 {
760 #if defined( NN_HARDWARE_CTR )
761     #if (MTX34MULTSCALE_RIGHT_CONFIG == D_ORG)
762         return ARMv6::MTX34MultScaleC( pOut, pM, pS );
763     #elif (MTX34MULTSCALE_RIGHT_CONFIG == D_FAST_C)
764     #elif (MTX34MULTSCALE_RIGHT_CONFIG == D_FAST_ASM)
765         return ARMv6::MTX34MultScaleAsm( pOut, pM, pS );
766     #elif (MTX34MULTSCALE_RIGHT_CONFIG == D_FAST_C_ALGO)
767     #elif (MTX34MULTSCALE_RIGHT_CONFIG == D_FAST_ASM_ALGO)
768     #endif
769 #else
770 #endif // #if defined( NN_HARDWARE_CTR )
771 }
772 
773 /*
774 
775 
776 
777 
778 
779 
780 
781  */
782 NN_FORCE_INLINE MTX34*
MTX34MultScale(MTX34 * pOut,const VEC3 * __restrict pS,const MTX34 * pM)783 MTX34MultScale(MTX34* pOut, const VEC3* __restrict pS, const MTX34* pM)
784 {
785 #if defined( NN_HARDWARE_CTR )
786     #if (MTX34MULTSCALE_LEFT_CONFIG == D_ORG)
787         return ARMv6::MTX34MultScaleC( pOut, pS, pM );
788     #elif (MTX34MULTSCALE_LEFT_CONFIG == D_FAST_C)
789     #elif (MTX34MULTSCALE_LEFT_CONFIG == D_FAST_ASM)
790         return ARMv6::MTX34MultScaleAsm( pOut, pS, pM );
791     #elif (MTX34MULTSCALE_LEFT_CONFIG == D_FAST_C_ALGO)
792     #elif (MTX34MULTSCALE_LEFT_CONFIG == D_FAST_ASM_ALGO)
793     #endif
794     #else
795 #endif // #if defined( NN_HARDWARE_CTR )
796 }
797 
798 
799 /*
800 
801 
802 
803 
804 
805 
806 
807  */
808 NN_FORCE_INLINE MTX34*
MTX34MultTranslate(MTX34 * pOut,const VEC3 * pT,const MTX34 * pM)809 MTX34MultTranslate(MTX34* pOut, const VEC3* pT, const MTX34* pM)
810 {
811 #if defined( NN_HARDWARE_CTR )
812     #if (MTX34MULTTRANSLATE_LEFT_CONFIG == D_ORG)
813         return ARMv6::MTX34MultTranslateC( pOut, pT, pM );
814     #elif (MTX34MULTTRANSLATE_LEFT_CONFIG == D_FAST_C)
815     #elif (MTX34MULTTRANSLATE_LEFT_CONFIG == D_FAST_ASM)
816         return ARMv6::MTX34MultTranslateAsm( pOut, pT, pM );
817     #elif (MTX34MULTTRANSLATE_LEFT_CONFIG == D_FAST_C_ALGO)
818     #elif (MTX34MULTTRANSLATE_LEFT_CONFIG == D_FAST_ASM_ALGO)
819     #endif
820 #else
821 #endif // #if defined( NN_HARDWARE_CTR )
822 }
823 
824 /*
825 
826 
827 
828 
829 
830 
831 
832  */
833 NN_FORCE_INLINE MTX34*
MTX34MultTranslate(MTX34 * pOut,const MTX34 * pM,const VEC3 * pT)834 MTX34MultTranslate(MTX34* pOut, const MTX34* pM, const VEC3* pT)
835 {
836 #if defined( NN_HARDWARE_CTR )
837     #if (MTX34MULTTRANSLATE_RIGHT_CONFIG == D_ORG)
838         return ARMv6::MTX34MultTranslateC( pOut, pM, pT );
839     #elif (MTX34MULTTRANSLATE_RIGHT_CONFIG == D_FAST_C)
840     #elif (MTX34MULTTRANSLATE_RIGHT_CONFIG == D_FAST_ASM)
841         return ARMv6::MTX34MultTranslateAsm( pOut, pM, pT );
842     #elif (MTX34MULTTRANSLATE_RIGHT_CONFIG == D_FAST_C_ALGO)
843     #elif (MTX34MULTTRANSLATE_RIGHT_CONFIG == D_FAST_ASM_ALGO)
844     #endif
845 #else
846 #endif // #if defined( NN_HARDWARE_CTR )
847 }
848 
849 /*
850 
851 
852 
853 
854 
855 
856 
857  */
858 NN_FORCE_INLINE MTX34*
MTX34RotAxisRad_(MTX34 * pOut,const VEC3 * pAxis,f32 fRad)859 MTX34RotAxisRad_( MTX34* pOut, const VEC3 *pAxis, f32 fRad )
860 {
861 #if defined( NN_HARDWARE_CTR )
862     #if (MTX34ROTAXISRAD__CONFIG == D_ORG)
863         return ARMv6::MTX34RotAxisRad_C(pOut, pAxis, fRad);
864     #elif (MTX34ROTAXISRAD__CONFIG == D_FAST_C)
865         return ARMv6::MTX34RotAxisRad_C_FAST(pOut, pAxis, fRad);
866     #elif (MTX34ROTAXISRAD__CONFIG == D_FAST_ASM)
867     #elif (MTX34ROTAXISRAD__CONFIG == D_FAST_C_ALGO)
868         return ARMv6::MTX34RotAxisRad_C_FAST(pOut, pAxis, fRad);
869     #elif (MTX34ROTAXISRAD__CONFIG == D_FAST_ASM_ALGO)
870     #endif
871 #else
872 #endif // #if defined( NN_HARDWARE_CTR )
873 
874 }
875 
876 
877 /*
878 
879 
880 
881 
882 
883 
884 
885 
886  */
887 NN_FORCE_INLINE MTX34*
MTX34RotXYZFIdx(MTX34 * pOut,f32 fIdxX,f32 fIdxY,f32 fIdxZ)888 MTX34RotXYZFIdx(MTX34* pOut, f32 fIdxX, f32 fIdxY, f32 fIdxZ)
889 {
890 #if defined( NN_HARDWARE_CTR )
891     #if (MTX34ROTXYZFIDX_CONFIG == D_ORG)
892         return ARMv6::MTX34RotXYZFIdxC(pOut, fIdxX, fIdxY, fIdxZ);
893     #elif (MTX34ROTXYZFIDX_CONFIG == D_FAST_C)
894         return ARMv6::MTX34RotXYZFIdxC_FAST(pOut, fIdxX, fIdxY, fIdxZ);
895     #elif (MTX34ROTXYZFIDX_CONFIG == D_FAST_ASM)
896     #elif (MTX34ROTXYZFIDX_CONFIG == D_FAST_C_ALGO)
897     #elif (MTX34ROTXYZFIDX_CONFIG == D_FAST_ASM_ALGO)
898     #endif
899 #else
900 #endif // #if defined( NN_HARDWARE_CTR )
901 
902 }
903 
904 
905 /*
906 
907 
908 
909 
910 
911 
912  */
913 NN_FORCE_INLINE MTX34*
MTX34Scale(MTX34 * pOut,const VEC3 * pS)914 MTX34Scale(MTX34* pOut, const VEC3* pS)
915 {
916 #if defined( NN_HARDWARE_CTR )
917     #if (MTX34SCALE_CONFIG == D_ORG)
918         return ARMv6::MTX34ScaleC(pOut, pS);
919     #elif (MTX34SCALE_CONFIG == D_FAST_C)
920         return ARMv6::MTX34ScaleC_FAST(pOut, pS);
921     #elif (MTX34SCALE_CONFIG == D_FAST_ASM)
922         return ARMv6::MTX34ScaleAsm(pOut, pS);
923     #elif (MTX34SCALE_CONFIG == D_FAST_C_ALGO)
924     #elif (MTX34SCALE_CONFIG == D_FAST_ASM_ALGO)
925     #endif
926 #else
927 #endif // #if defined( NN_HARDWARE_CTR )
928 }
929 
930 /*
931 
932 
933 
934 
935 
936 
937  */
938 NN_FORCE_INLINE MTX34*
MTX34Translate(MTX34 * pOut,const VEC3 * pT)939 MTX34Translate(MTX34* pOut, const VEC3* pT)
940 {
941 #if defined( NN_HARDWARE_CTR )
942     #if (MTX34TRANSLATE_CONFIG == D_ORG)
943         return ARMv6::MTX34TranslateC(pOut, pT);
944     #elif (MTX34TRANSLATE_CONFIG == D_FAST_C)
945         return ARMv6::MTX34TranslateC_FAST(pOut, pT);
946     #elif (MTX34TRANSLATE_CONFIG == D_FAST_ASM)
947     #elif (MTX34TRANSLATE_CONFIG == D_FAST_C_ALGO)
948     #elif (MTX34TRANSLATE_CONFIG == D_FAST_ASM_ALGO)
949     #endif
950 #else
951 #endif // #if defined( NN_HARDWARE_CTR )
952 }
953 
954 /*
955 
956 
957 
958 
959 
960 
961  */
962 NN_FORCE_INLINE MTX34*
MTX34Transpose(MTX34 * pOut,const MTX34 * p)963 MTX34Transpose(MTX34* pOut, const MTX34* p)
964 {
965 #if defined( NN_HARDWARE_CTR )
966     #if (MTX34TRANSPOSE_34TO34_CONFIG == D_ORG)
967         return ARMv6::MTX34TransposeC(pOut, p);
968     #elif (MTX34TRANSPOSE_34TO34_CONFIG == D_FAST_C)
969     #elif (MTX34TRANSPOSE_34TO34_CONFIG == D_FAST_ASM)
970         return ARMv6::MTX34TransposeAsm(pOut, p);
971     #elif (MTX34TRANSPOSE_34TO34_CONFIG == D_FAST_C_ALGO)
972     #elif (MTX34TRANSPOSE_34TO34_CONFIG == D_FAST_ASM_ALGO)
973     #endif
974 #else
975 #endif // #if defined( NN_HARDWARE_CTR )
976 }
977 
978 /* Please see man pages for details
979 
980 
981 */
982 
983 /*
984 
985 
986 
987 
988 
989 
990  */
991 NN_FORCE_INLINE MTX34*
QUATToMTX34(MTX34 * pOut,const QUAT * pQ)992 QUATToMTX34(MTX34* pOut, const QUAT* pQ)
993 {
994 #if defined( NN_HARDWARE_CTR )
995     #if (QUATTOMTX34_CONFIG == D_ORG)
996         return ARMv6::QUATToMTX34C(pOut, pQ);
997     #elif (QUATTOMTX34_CONFIG == D_FAST_C)
998         return ARMv6::QUATToMTX34C_FAST(pOut, pQ);
999     #elif (QUATTOMTX34_CONFIG == D_FAST_ASM)
1000     #elif (QUATTOMTX34_CONFIG == D_FAST_C_ALGO)
1001     #elif (QUATTOMTX34_CONFIG == D_FAST_ASM_ALGO)
1002     #endif
1003 #else
1004 #endif // #if defined( NN_HARDWARE_CTR )
1005 }
1006 
1007 /*
1008 
1009 */
1010 
1011 /* Please see man pages for details
1012 
1013 
1014 */
1015 
1016 /*
1017 
1018 
1019 
1020 
1021 
1022 
1023 
1024 
1025  */
1026 NN_FORCE_INLINE VEC3*
VEC3Transform(VEC3 * pOut,const MTX34 * __restrict pM,const VEC3 * __restrict pV)1027 VEC3Transform(VEC3* pOut, const MTX34* __restrict pM, const VEC3* __restrict pV)
1028 {
1029 #if defined( NN_HARDWARE_CTR )
1030     #if (VEC3TRANSFORM_34XVEC3_CONFIG == D_ORG)
1031         return ARMv6::VEC3TransformC(pOut, pM, pV);
1032     #elif (VEC3TRANSFORM_34XVEC3_CONFIG == D_FAST_C)
1033     #elif (VEC3TRANSFORM_34XVEC3_CONFIG == D_FAST_ASM)
1034         return ARMv6::VEC3TransformAsm(pOut, pM, pV);
1035     #elif (VEC3TRANSFORM_34XVEC3_CONFIG == D_FAST_C_ALGO)
1036     #elif (VEC3TRANSFORM_34XVEC3_CONFIG == D_FAST_ASM_ALGO)
1037     #endif
1038 #else
1039 #endif // #if defined( NN_HARDWARE_CTR )
1040 }
1041 
1042 /*
1043 
1044 */
1045 
1046 
1047 }  // namespace math
1048 }  // namespace nn
1049 
1050 namespace nn {
1051 namespace math {
1052 
1053 //-- Overloads that reference const type arguments
1054 
MTX34IsIdentity(const MTX34 & m)1055 inline bool MTX34IsIdentity(const MTX34& m) { return MTX34IsIdentity( &m ); }
1056 
MTX34Add(MTX34 * pOut,const MTX34 & m1,const MTX34 & m2)1057 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)1058 inline MTX34* MTX34Sub(MTX34* pOut, const MTX34& m1, const MTX34& m2) { return MTX34Sub( pOut, &m1, &m2 ); }
MTX34Mult(MTX34 * pOut,const MTX34 & m,f32 f)1059 inline MTX34* MTX34Mult(MTX34* pOut, const MTX34& m, f32 f) { return MTX34Mult( pOut, &m, f ); }
MTX34Mult(MTX34 * pOut,const MTX34 & m1,const MTX34 & m2)1060 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)1061 inline MTX34* MTX34MAdd(MTX34* pOut, f32 t, const MTX34& m1, const MTX34& m2) { return MTX34MAdd( pOut, t, &m1, &m2 ); }
1062 
MTX34Copy(MTX34 * pOut,const MTX34 & m)1063 inline MTX34* MTX34Copy(MTX34* pOut, const MTX34& m) { return MTX34Copy( pOut, &m ); }
MTX34MultArray(MTX34 * pOut,const MTX34 & m1,const MTX34 * pSrc,s32 count)1064 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)1065 inline u32    MTX34Inverse(MTX34* pOut, const MTX34& m) { return MTX34Inverse( pOut, &m ); }
MTX34Transpose(MTX34 * pOut,const MTX34 & m)1066 inline MTX34* MTX34Transpose(MTX34* pOut, const MTX34& m) { return MTX34Transpose( pOut, &m ); }
MTX34InvTranspose(MTX34 * pOut,const MTX34 & m)1067 inline u32    MTX34InvTranspose(MTX34* pOut, const MTX34& m) { return MTX34InvTranspose( pOut, &m ); }
1068 
MTX34LookAt(MTX34 * pOut,const VEC3 & vCamPos,const VEC3 & vCamUp,const VEC3 & vTarget)1069 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)1070 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)1071 inline MTX34* MTX34CameraRotate(MTX34* pOut, const VEC3& vCamPos, const VEC3& vCamRotateDeg) { return MTX34CameraRotate( pOut, &vCamPos, &vCamRotateDeg ); }
1072 
MTX34RotXYZTranslateFIdx(MTX34 * pOut,f32 fIdxX,f32 fIdxY,f32 fIdxZ,const VEC3 & vT)1073 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)1074 inline MTX34* MTX34RotAxisFIdx(MTX34* pOut, const VEC3& vAxis, f32 fIdx) { return MTX34RotAxisFIdx( pOut, &vAxis, fIdx ); }
MTX34RotAxisRad(MTX34 * pOut,const VEC3 & vAxis,f32 fRad)1075 inline MTX34* MTX34RotAxisRad(MTX34* pOut, const VEC3& vAxis, f32 fRad) { return MTX34RotAxisRad( pOut, &vAxis, fRad ); }
MTX34RotAxisDeg(MTX34 * pOut,const VEC3 & vAxis,f32 fDeg)1076 inline MTX34* MTX34RotAxisDeg(MTX34* pOut, const VEC3& vAxis, f32 fDeg) { return MTX34RotAxisDeg( pOut, &vAxis, fDeg ); }
1077 
MTX34Scale(MTX34 * pOut,const VEC3 & vS)1078 inline MTX34* MTX34Scale(MTX34* pOut, const VEC3& vS) { return MTX34Scale( pOut, &vS ); }
MTX34MultScale(MTX34 * pOut,const MTX34 & m,const VEC3 & vS)1079 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)1080 inline MTX34* MTX34MultScale(MTX34* pOut, const VEC3& vS, const MTX34& m) { return MTX34MultScale( pOut, &vS, &m ); }
1081 
MTX34Translate(MTX34 * pOut,const VEC3 & vT)1082 inline MTX34* MTX34Translate(MTX34* pOut, const VEC3& vT) { return MTX34Translate( pOut, &vT ); }
MTX34MultTranslate(MTX34 * pOut,const MTX34 & m,const VEC3 & vT)1083 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)1084 inline MTX34* MTX34MultTranslate(MTX34* pOut, const VEC3& vT, const MTX34& m) { return MTX34MultTranslate( pOut, &vT, &m ); }
QUATToMTX34(MTX34 * pOut,const QUAT & q)1085 inline MTX34* QUATToMTX34(MTX34* pOut, const QUAT& q) { return QUATToMTX34( pOut, &q ); }
1086 
1087 }  // namespace math
1088 }  // namespace nn
1089 
1090 #if defined(NN_MATH_AS_INLINE)
1091 #include <nn/math/inline/math_Matrix34.ipp>
1092 #include <nn/math/ARMv6/inline/math_Matrix34.ipp>
1093 #endif
1094 
1095 #pragma pop
1096 
1097 #endif
1098