/*---------------------------------------------------------------------------* Project: Horizon File: math_Matrix44.h Copyright (C)2009-2010 Nintendo Co., Ltd. All rights reserved. These coded instructions, statements, and computer programs contain proprietary information of Nintendo of America Inc. and/or Nintendo Company Ltd., and are protected by Federal copyright law. They may not be disclosed to third parties or copied or duplicated in any form, in whole or in part, without the prior written consent of Nintendo. $Revision: 34617 $ *---------------------------------------------------------------------------*/ #ifndef NN_MATH_MATRIX44_H_ #define NN_MATH_MATRIX44_H_ #include #include #pragma push #pragma Otime namespace nn { namespace math { /* Please see man pages for details */ /* */ enum PivotDirection { PIVOT_NONE, // PIVOT_UPSIDE_TO_TOP, // PIVOT_UPSIDE_TO_RIGHT, // PIVOT_UPSIDE_TO_BOTTOM, // PIVOT_UPSIDE_TO_LEFT, // PIVOT_NUM }; /* */ /* ------------------------------------------------------------------------ Function for MTX44 ------------------------------------------------------------------------ */ struct MTX44; NN_MATH_INLINE MTX44* MTX44Zero(MTX44* pOut); NN_MATH_INLINE bool MTX44IsIdentity(const MTX44* p); NN_MATH_INLINE MTX44* MTX44Identity(MTX44* pOut); NN_MATH_INLINE MTX44* MTX44Copy(MTX44* pOut, const MTX44* p); NN_MATH_INLINE MTX44* MTX44Add(MTX44* pOut, const MTX44* p1, const MTX44* p2); NN_MATH_INLINE MTX44* MTX44Sub(MTX44* pOut, const MTX44* p1, const MTX44* p2); NN_MATH_INLINE MTX44* MTX44Mult(MTX44* pOut, const MTX44* p, f32 f); NN_MATH_INLINE MTX44* MTX44Mult(MTX44* pOut, const MTX44* p1, const MTX44* p2); NN_MATH_INLINE MTX44* MTX44Frustum(MTX44* pOut, f32 l, f32 r, f32 b, f32 t, f32 n, f32 f); NN_MATH_INLINE MTX44* MTX44Ortho(MTX44* pOut, f32 l, f32 r, f32 b, f32 t, f32 n, f32 f); NN_MATH_INLINE MTX44* MTX44PerspectiveRad(MTX44* pOut, f32 fovy, f32 aspect, f32 n, f32 f); NN_MATH_INLINE MTX44* MTX44Transpose(MTX44* pOut, const MTX44 *pSrc); NN_MATH_INLINE MTX44* MTX44MultArray(MTX44* pOut, const MTX44* p1, const MTX44* pSrc, s32 count); NN_MATH_INLINE u32 MTX44Inverse(MTX44* pOut, const MTX44* p); NN_MATH_INLINE MTX44* MTX44RotXYZFIdx(MTX44* pOut, f32 fIdxX, f32 fIdxY, f32 fIdxZ); NN_MATH_INLINE MTX44* MTX44RotAxisFIdx(MTX44* pOut, const VEC3* pAxis, f32 fIdx); NN_MATH_INLINE MTX44* MTX44Scale(MTX44* pOut, const VEC3* pS); NN_MATH_INLINE MTX44* MTX44MultScale(MTX44* pOut, const MTX44* pM, const VEC3* pS); NN_MATH_INLINE MTX44* MTX44MultScale(MTX44* pOut, const VEC3* pS, const MTX44* pM); NN_MATH_INLINE MTX44* MTX44Translate(MTX44* pOut, const VEC3* pT); NN_MATH_INLINE MTX44* MTX44MultTranslate(MTX44* pOut, const MTX44* pM, const VEC3* pT); NN_MATH_INLINE MTX44* MTX44MultTranslate(MTX44* pOut, const VEC3* pT, const MTX44* pM); NN_MATH_INLINE MTX44* MTX44FrustumPivot(MTX44* pOut, f32 l, f32 r, f32 b, f32 t, f32 n, f32 f, PivotDirection pivot = PIVOT_NONE); NN_MATH_INLINE MTX44* MTX44OrthoPivot(MTX44* pOut, f32 l, f32 r, f32 b, f32 t, f32 n, f32 f, PivotDirection pivot = PIVOT_NONE); NN_MATH_INLINE MTX44* MTX44PerspectivePivotRad(MTX44* pOut, f32 fovy, f32 aspect, f32 n, f32 f, PivotDirection pivot = PIVOT_NONE); NN_FORCE_INLINE MTX44* MTX44Add(MTX44* pOut, const MTX44* p1, const MTX44* p2); NN_FORCE_INLINE MTX44* MTX44Copy(MTX44* pOut, const MTX44* p); NN_FORCE_INLINE MTX44* MTX44Frustum(MTX44* pOut, f32 l, f32 r, f32 b, f32 t, f32 n, f32 f); NN_FORCE_INLINE u32 MTX44Inverse(MTX44* pOut, const MTX44* p); NN_FORCE_INLINE MTX44* MTX44Mult(MTX44* pOut, const MTX44* __restrict p1, const MTX44* __restrict p2); NN_FORCE_INLINE MTX44* MTX44Mult(MTX44* pOut, const MTX44* p, f32 f); NN_FORCE_INLINE MTX44* MTX44MultScale(MTX44* pOut, const MTX44* pM, const VEC3* pS); NN_FORCE_INLINE MTX44* MTX44MultScale(MTX44* pOut, const VEC3* pS, const MTX44* pM); NN_FORCE_INLINE MTX44* MTX44MultTranslate(MTX44* pOut, const VEC3* pT, const MTX44* pM); NN_FORCE_INLINE MTX44* MTX44MultTranslate(MTX44* pOut, const MTX44* pM, const VEC3* pT); NN_FORCE_INLINE MTX44* MTX44Ortho(MTX44* pOut, f32 l, f32 r, f32 b, f32 t, f32 n, f32 f); NN_FORCE_INLINE MTX44* MTX44PerspectiveRad(MTX44* pOut, f32 fovy, f32 aspect, f32 n, f32 f); NN_FORCE_INLINE MTX44* MTX44RotAxisRad_( MTX44* pOut, const VEC3 *pAxis, f32 fRad ); NN_FORCE_INLINE MTX44* MTX44RotXYZFIdx(MTX44* pOut, f32 fIdxX, f32 fIdxY, f32 fIdxZ); NN_FORCE_INLINE MTX44* MTX44Scale(MTX44* pOut, const VEC3* pS); NN_FORCE_INLINE MTX44* MTX44Translate(MTX44* pOut, const VEC3* pT); NN_FORCE_INLINE MTX44* MTX44Transpose(MTX44* pOut, const MTX44 *pSrc); NN_FORCE_INLINE VEC4* VEC3Transform(VEC4* pOut, const MTX44* pM, const VEC3* pV); NN_FORCE_INLINE MTX44* MTX44Pivot( MTX44* pOut, PivotDirection pivot ); /* Please see man pages for details */ /* */ inline MTX44* MTX44PerspectiveDeg(MTX44* pOut, f32 fovy, f32 aspect, f32 n, f32 f) { return MTX44PerspectiveRad(pOut, NN_MATH_DEG_TO_RAD(fovy), aspect, n, f); } // Alias for the MTX44PerspectiveDeg function. // For compatibility purposes, "Perspective" functions that do not have suffixes are the versions that use degrees. inline MTX44* MTX44Perspective(MTX44* pOut, f32 fovy, f32 aspect, f32 n, f32 f) { return MTX44PerspectiveDeg(pOut, fovy, aspect, n, f); } /* */ inline MTX44* MTX44PerspectivePivotDeg(MTX44* pOut, f32 fovy, f32 aspect, f32 n, f32 f, PivotDirection pivot = PIVOT_NONE ) { return MTX44PerspectivePivotRad(pOut, NN_MATH_DEG_TO_RAD(fovy), aspect, n, f, pivot); } /* */ inline MTX44* MTX44RotXYZRad(MTX44* pOut, f32 fRadX, f32 fRadY, f32 fRadZ) { return MTX44RotXYZFIdx(pOut, NN_MATH_RAD_TO_FIDX(fRadX), NN_MATH_RAD_TO_FIDX(fRadY), NN_MATH_RAD_TO_FIDX(fRadZ)); } /* */ inline MTX44* MTX44RotXYZDeg(MTX44* pOut, f32 fDegX, f32 fDegY, f32 fDegZ) { return MTX44RotXYZFIdx(pOut, NN_MATH_DEG_TO_FIDX(fDegX), NN_MATH_DEG_TO_FIDX(fDegY), NN_MATH_DEG_TO_FIDX(fDegZ)); } /* */ inline MTX44* MTX44RotAxisRad(MTX44* pOut, const VEC3* pAxis, f32 fRad) { return MTX44RotAxisFIdx(pOut, pAxis, NN_MATH_RAD_TO_FIDX(fRad)); } /* */ inline MTX44* MTX44RotAxisDeg(MTX44* pOut, const VEC3* pAxis, f32 fDeg) { return MTX44RotAxisFIdx(pOut, pAxis, NN_MATH_DEG_TO_FIDX(fDeg)); } /* ======================================================================= Class definitions ======================================================================== */ struct MTX34; struct MTX44_ { struct BaseData { f32 _00, _01, _02, _03; f32 _10, _11, _12, _13; f32 _20, _21, _22, _23; f32 _30, _31, _32, _33; }; union { #if defined(NN_MATH_USE_ANONYMOUS_STRUCT) struct { f32 _00, _01, _02, _03; f32 _10, _11, _12, _13; f32 _20, _21, _22, _23; f32 _30, _31, _32, _33; }; #endif BaseData f; f32 m[4][4]; f32 a[16]; VEC4_ v[4]; }; }; /* */ struct MTX44 : public MTX44_ { public: static const int ROW_COUNT = 4; // static const int COLUMN_COUNT = 4; // // static const MTX44& Identity() { static const MTX44 identity( 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f); return identity; } typedef MTX44 self_type; // typedef f32 value_type; // public: //---------------------------------------- // // // MTX44() {} // explicit MTX44(const f32* p) { (void)MTX44Copy(this, (MTX44*)p); } // explicit MTX44(const MTX34& rhs) { (void)MTX34Copy((MTX34*)this, (MTX34*)&rhs); f._30 = f._31 = f._32 = 0.f; f._33 = 1.f; } // MTX44(const MTX44& rhs) { (void)MTX44Copy(this, &rhs); } // 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) { f._00 = x00; f._01 = x01; f._02 = x02; f._03 = x03; f._10 = x10; f._11 = x11; f._12 = x12; f._13 = x13; f._20 = x20; f._21 = x21; f._22 = x22; f._23 = x23; f._30 = x30; f._31 = x31; f._32 = x32; f._33 = x33; } // //---------------------------------------- // // // operator f32*() { return this->a; } // operator const f32*() const { return this->a; } // VEC4& GetRow(int index) { NN_MATH_MINMAXLT_ASSERT(index, 0, ROW_COUNT); return *reinterpret_cast(&this->v[index]); } // const VEC4& GetRow(int index) const { NN_MATH_MINMAXLT_ASSERT(index, 0, ROW_COUNT); return *reinterpret_cast(&this->v[index]); } // VEC4 GetColumn(int index) const { NN_MATH_MINMAXLT_ASSERT(index, 0, COLUMN_COUNT); VEC4 column; column.x = this->m[0][index]; column.y = this->m[1][index]; column.z = this->m[2][index]; column.w = this->m[3][index]; return column; } // void SetColumn(int index, const VEC4& column) { NN_MATH_MINMAXLT_ASSERT(index, 0, COLUMN_COUNT); this->m[0][index] = column.x; this->m[1][index] = column.y; this->m[2][index] = column.z; this->m[3][index] = column.w; } // //---------------------------------------- // // // self_type& operator *= (const self_type& rhs) { return *MTX44Mult(this, this, &rhs); } self_type& operator += (const self_type& rhs) { return *MTX44Add(this, this, &rhs); } self_type& operator -= (const self_type& rhs) { return *MTX44Sub(this, this, &rhs); } self_type& operator *= (f32 f) { return *MTX44Mult(this, this, f); } self_type& operator /= (f32 f) { return operator*=(1.f / f); } self_type operator + () const { return *this; } self_type operator - () const { return MTX44(-f._00, -f._01, -f._02, -f._03, -f._10, -f._11, -f._12, -f._13, -f._20, -f._21, -f._22, -f._23, -f._30, -f._31, -f._32, -f._33); } self_type operator + (const self_type& rhs) const { MTX44 tmp; return *MTX44Add(&tmp, this, &rhs); } self_type operator - (const self_type& rhs) const { MTX44 tmp; return *MTX44Sub(&tmp, this, &rhs); } self_type operator * (f32 f) const { MTX44 tmp; return *MTX44Mult(&tmp, this, f); } self_type operator / (f32 f) const { return *this * (1.f / f); } // self_type& Transpose() { return *MTX44Transpose(this, this); } // //---------------------------------------- // // // self_type& SetupIdentity() { return *MTX44Identity(this); } // // // // self_type& SetupScale(const VEC3& scale) { return *MTX44Scale(this, &scale); } // // // // self_type& SetupTranslate(const VEC3& translate) { return *MTX44Translate(this, &translate); } // // // // self_type& SetupRotateXyz(const VEC3& rotateRad) { return *MTX44RotXYZRad(this, rotateRad.x, rotateRad.y, rotateRad.z); } // // // // // self_type& SetupRotate(const VEC3& axis, f32 thetaRad) { return *MTX44RotAxisRad(this, &axis, thetaRad); } // // // // // // // // // // // self_type& SetupFrustum(f32 l, f32 r, f32 b, f32 t, f32 n, f32 f, PivotDirection pivot = PIVOT_NONE) { return *MTX44FrustumPivot(this, l, r, b, t, n, f, pivot); } // // // // // // // // // // // self_type& SetupOrtho(f32 l, f32 r, f32 b, f32 t, f32 n, f32 f, PivotDirection pivot = PIVOT_NONE) { return *MTX44OrthoPivot(this, l, r, b, t, n, f, pivot); } // // // // // // // // self_type& SetupPerspective(f32 fovyRad, f32 aspect, f32 n, f32 f, PivotDirection pivot = PIVOT_NONE) { return *MTX44PerspectivePivotRad(this, fovyRad, aspect, n, f, pivot); } // //---------------------------------------- // // // bool operator == (const self_type& rhs) const { return ::std::memcmp(this, &rhs, sizeof(MTX44)) == 0; } // bool operator != (const self_type& rhs) const { return ::std::memcmp(this, &rhs, sizeof(MTX44)) != 0; } // bool IsIdentity() const { return MTX44IsIdentity(this); } // // void Report(bool bNewline = true, const char* name = NULL) const; }; typedef struct MTX44 Matrix44; /* */ } // namespace math } // namespace nn #include namespace nn { namespace math { /* Please see man pages for details */ /* */ NN_FORCE_INLINE MTX44* MTX44Add(MTX44* pOut, const MTX44* p1, const MTX44* p2) { #if defined( NN_HARDWARE_CTR ) #if (MTX44ADD_ASM_CONFIG == D_ORG) return ARMv6::MTX44AddC(pOut, p1, p2); #elif (MTX44ADD_ASM_CONFIG == D_FAST_C) #elif (MTX44ADD_ASM_CONFIG == D_FAST_ASM) return ARMv6::MTX44AddAsm(pOut, p1, p2); #elif (MTX44ADD_ASM_CONFIG == D_FAST_C_ALGO) #elif (MTX44ADD_ASM_CONFIG == D_FAST_ASM_ALGO) #endif #else #endif // #if defined( NN_HARDWARE_CTR ) } /* */ NN_FORCE_INLINE MTX44* MTX44Copy(MTX44* pOut, const MTX44* p) { #if defined( NN_HARDWARE_CTR ) #if (MTX44COPY_CONFIG == D_ORG) return ARMv6::MTX44CopyC(pOut, p); #elif (MTX44COPY_CONFIG == D_FAST_C) #elif (MTX44COPY_CONFIG == D_FAST_ASM) return ARMv6::MTX44CopyAsm(pOut, p); #elif (MTX44COPY_CONFIG == D_FAST_C_ALGO) #elif (MTX44COPY_CONFIG == D_FAST_ASM_ALGO) #endif #else #endif // #if defined( NN_HARDWARE_CTR ) } /* */ NN_FORCE_INLINE MTX44* MTX44Frustum(MTX44* pOut, f32 l, f32 r, f32 b, f32 t, f32 n, f32 f) { #if defined( NN_HARDWARE_CTR ) #if (MTX44FRUSTUM_CONFIG == D_ORG) return ARMv6::MTX44FrustumC(pOut, l, r, b, t, n, f); #elif (MTX44FRUSTUM_CONFIG == D_FAST_C) return ARMv6::MTX44FrustumC_FAST(pOut, l, r, b, t, n, f); #elif (MTX44FRUSTUM_CONFIG == D_FAST_ASM) #elif (MTX44FRUSTUM_CONFIG == D_FAST_C_ALGO) #elif (MTX44FRUSTUM_CONFIG == D_FAST_ASM_ALGO) #endif #else #endif // #if defined( NN_HARDWARE_CTR ) } /* */ NN_FORCE_INLINE u32 MTX44Inverse(MTX44* pOut, const MTX44* p) { #if defined( NN_HARDWARE_CTR ) #if (MTX44INVERSE_CONFIG == D_ORG) return ARMv6::MTX44InverseC(pOut, p); #elif (MTX44INVERSE_CONFIG == D_FAST_C) #elif (MTX44INVERSE_CONFIG == D_FAST_ASM) #elif (MTX44INVERSE_CONFIG == D_FAST_C_ALGO) return ARMv6::MTX44InverseC_FAST_ALGO(pOut, p); #elif (MTX44INVERSE_CONFIG == D_FAST_ASM_ALGO) #endif #else #endif // #if defined( NN_HARDWARE_CTR ) } /* */ NN_FORCE_INLINE MTX44* MTX44Mult(MTX44* pOut, const MTX44* __restrict p1, const MTX44* __restrict p2) { #if defined( NN_HARDWARE_CTR ) #if (MTX44MULT_44_CONFIG == D_ORG) return ARMv6::MTX44MultC(pOut, p1, p2); #elif (MTX44MULT_44_CONFIG == D_FAST_C) #elif (MTX44MULT_44_CONFIG == D_FAST_ASM) return ARMv6::MTX44MultAsm(pOut, p1, p2); #elif (MTX44MULT_44_CONFIG == D_FAST_C_ALGO) #elif (MTX44MULT_44_CONFIG == D_FAST_ASM_ALGO) #endif #else #endif // #if defined( NN_HARDWARE_CTR ) } /* */ NN_FORCE_INLINE MTX44* MTX44Mult(MTX44* pOut, const MTX44* p, f32 f) { #if defined( NN_HARDWARE_CTR ) #if (MTX44MULT_F32_CONFIG == D_ORG) return ARMv6::MTX44MultC(pOut, p, f); #elif (MTX44MULT_F32_CONFIG == D_FAST_C) #elif (MTX44MULT_F32_CONFIG == D_FAST_ASM) return ARMv6::MTX44MultAsm(pOut, p, f); #elif (MTX44MULT_F32_CONFIG == D_FAST_C_ALGO) #elif (MTX44MULT_F32_CONFIG == D_FAST_ASM_ALGO) #endif #else #endif // #if defined( NN_HARDWARE_CTR ) } /* */ NN_FORCE_INLINE MTX44* MTX44MultScale(MTX44* pOut, const MTX44* pM, const VEC3* pS) { #if defined( NN_HARDWARE_CTR ) #if (MTX44MULTSCALE_RIGHT_CONFIG == D_ORG) return ARMv6::MTX44MultScaleC(pOut, pM, pS); #elif (MTX44MULTSCALE_RIGHT_CONFIG == D_FAST_C) #elif (MTX44MULTSCALE_RIGHT_CONFIG == D_FAST_ASM) return ARMv6::MTX44MultScaleAsm(pOut, pM, pS); #elif (MTX44MULTSCALE_RIGHT_CONFIG == D_FAST_C_ALGO) #elif (MTX44MULTSCALE_RIGHT_CONFIG == D_FAST_ASM_ALGO) #endif #else #endif // #if defined( NN_HARDWARE_CTR ) } /* */ NN_FORCE_INLINE MTX44* MTX44MultScale(MTX44* pOut, const VEC3* pS, const MTX44* pM) { #if defined( NN_HARDWARE_CTR ) #if (MTX44MULTSCALE_LEFT_CONFIG == D_ORG) return ARMv6::MTX44MultScaleC(pOut, pS, pM); #elif (MTX44MULTSCALE_LEFT_CONFIG == D_FAST_C) #elif (MTX44MULTSCALE_LEFT_CONFIG == D_FAST_ASM) return ARMv6::MTX44MultScaleAsm(pOut, pS, pM); #elif (MTX44MULTSCALE_LEFT_CONFIG == D_FAST_C_ALGO) #elif (MTX44MULTSCALE_LEFT_CONFIG == D_FAST_ASM_ALGO) #endif #else #endif // #if defined( NN_HARDWARE_CTR ) } /* */ NN_FORCE_INLINE MTX44* MTX44MultTranslate(MTX44* pOut, const VEC3* pT, const MTX44* pM) { #if defined( NN_HARDWARE_CTR ) #if (MTX44MULTTRANSLATE_LEFT_CONFIG == D_ORG) return ARMv6::MTX44MultTranslateC(pOut, pT, pM); #elif (MTX44MULTTRANSLATE_LEFT_CONFIG == D_FAST_C) #elif (MTX44MULTTRANSLATE_LEFT_CONFIG == D_FAST_ASM) return ARMv6::MTX44MultTranslateAsm(pOut, pT, pM); #elif (MTX44MULTTRANSLATE_LEFT_CONFIG == D_FAST_C_ALGO) #elif (MTX44MULTTRANSLATE_LEFT_CONFIG == D_FAST_ASM_ALGO) #endif #else #endif // #if defined( NN_HARDWARE_CTR ) } /* */ NN_FORCE_INLINE MTX44* MTX44MultTranslate(MTX44* pOut, const MTX44* pM, const VEC3* pT) { #if defined( NN_HARDWARE_CTR ) #if (MTX44MULTTRANSLATE_RIGHT_CONFIG == D_ORG) return ARMv6::MTX44MultTranslateC(pOut, pM, pT); #elif (MTX44MULTTRANSLATE_RIGHT_CONFIG == D_FAST_C) #elif (MTX44MULTTRANSLATE_RIGHT_CONFIG == D_FAST_ASM) return ARMv6::MTX44MultTranslateAsm(pOut, pM, pT); #elif (MTX44MULTTRANSLATE_RIGHT_CONFIG == D_FAST_C_ALGO) #elif (MTX44MULTTRANSLATE_RIGHT_CONFIG == D_FAST_ASM_ALGO) #endif #else #endif // #if defined( NN_HARDWARE_CTR ) } /* */ NN_FORCE_INLINE MTX44* MTX44Ortho(MTX44* pOut, f32 l, f32 r, f32 b, f32 t, f32 n, f32 f) { #if defined( NN_HARDWARE_CTR ) #if (MTX44ORTHO_CONFIG == D_ORG) return ARMv6::MTX44OrthoC(pOut, l, r, b, t, n, f); #elif (MTX44ORTHO_CONFIG == D_FAST_C) return ARMv6::MTX44OrthoC_FAST(pOut, l, r, b, t, n, f); #elif (MTX44ORTHO_CONFIG == D_FAST_ASM) #elif (MTX44ORTHO_CONFIG == D_FAST_C_ALGO) #elif (MTX44ORTHO_CONFIG == D_FAST_ASM_ALGO) #endif #else #endif // #if defined( NN_HARDWARE_CTR ) } /* */ NN_FORCE_INLINE MTX44* MTX44PerspectiveRad(MTX44* pOut, f32 fovy, f32 aspect, f32 n, f32 f) { #if defined( NN_HARDWARE_CTR ) #if (MTX44PERSPECTIVERAD_CONFIG == D_ORG) return ARMv6::MTX44PerspectiveRadC(pOut, fovy, aspect, n, f); #elif (MTX44PERSPECTIVERAD_CONFIG == D_FAST_C) return ARMv6::MTX44PerspectiveRadC_FAST(pOut, fovy, aspect, n, f); #elif (MTX44PERSPECTIVERAD_CONFIG == D_FAST_ASM) #elif (MTX44PERSPECTIVERAD_CONFIG == D_FAST_C_ALGO) return ARMv6::MTX44PerspectiveRadC_FAST(pOut, fovy, aspect, n, f); #elif (MTX44PERSPECTIVERAD_CONFIG == D_FAST_ASM_ALGO) #endif #else #endif // #if defined( NN_HARDWARE_CTR ) } /* */ NN_FORCE_INLINE MTX44* MTX44RotAxisRad_( MTX44* pOut, const VEC3 *pAxis, f32 fRad ) { #if defined( NN_HARDWARE_CTR ) #if (MTX44ROTAXISRAD__CONFIG == D_ORG) return ARMv6::MTX44RotAxisRad_C(pOut, pAxis, fRad); #elif (MTX44ROTAXISRAD__CONFIG == D_FAST_C) return ARMv6::MTX44RotAxisRad_C_FAST(pOut, pAxis, fRad); #elif (MTX44ROTAXISRAD__CONFIG == D_FAST_ASM) #elif (MTX44ROTAXISRAD__CONFIG == D_FAST_C_ALGO) return ARMv6::MTX44RotAxisRad_C_FAST(pOut, pAxis, fRad); #elif (MTX44ROTAXISRAD__CONFIG == D_FAST_ASM_ALGO) #endif #else #endif // #if defined( NN_HARDWARE_CTR ) } /* */ NN_FORCE_INLINE MTX44* MTX44RotXYZFIdx(MTX44* pOut, f32 fIdxX, f32 fIdxY, f32 fIdxZ) { #if defined( NN_HARDWARE_CTR ) #if (MTX44ROTXYZFIDX_CONFIG == D_ORG) return ARMv6::MTX44RotXYZFIdxC(pOut, fIdxX, fIdxY, fIdxZ); #elif (MTX44ROTXYZFIDX_CONFIG == D_FAST_C) return ARMv6::MTX44RotXYZFIdxC_FAST(pOut, fIdxX, fIdxY, fIdxZ); #elif (MTX44ROTXYZFIDX_CONFIG == D_FAST_ASM) #elif (MTX44ROTXYZFIDX_CONFIG == D_FAST_C_ALGO) #elif (MTX44ROTXYZFIDX_CONFIG == D_FAST_ASM_ALGO) #endif #else #endif // #if defined( NN_HARDWARE_CTR ) } /* */ NN_FORCE_INLINE MTX44* MTX44Scale(MTX44* pOut, const VEC3* pS) { #if defined( NN_HARDWARE_CTR ) #if (MTX44SCALE_CONFIG == D_ORG) return ARMv6::MTX44ScaleC(pOut, pS); #elif (MTX44SCALE_CONFIG == D_FAST_C) return ARMv6::MTX44ScaleC_FAST(pOut, pS); #elif (MTX44SCALE_CONFIG == D_FAST_ASM) #elif (MTX44SCALE_CONFIG == D_FAST_C_ALGO) #elif (MTX44SCALE_CONFIG == D_FAST_ASM_ALGO) #endif #else #endif // #if defined( NN_HARDWARE_CTR ) } /* */ NN_FORCE_INLINE MTX44* MTX44Translate(MTX44* pOut, const VEC3* pT) { #if defined( NN_HARDWARE_CTR ) #if (MTX44TRANSLATE_CONFIG == D_ORG) return ARMv6::MTX44TranslateC(pOut, pT); #elif (MTX44TRANSLATE_CONFIG == D_FAST_C) return ARMv6::MTX44TranslateC_FAST(pOut, pT); #elif (MTX44TRANSLATE_CONFIG == D_FAST_ASM) #elif (MTX44TRANSLATE_CONFIG == D_FAST_C_ALGO) #elif (MTX44TRANSLATE_CONFIG == D_FAST_ASM_ALGO) #endif #else #endif // #if defined( NN_HARDWARE_CTR ) } /* */ NN_FORCE_INLINE MTX44* MTX44Transpose(MTX44* pOut, const MTX44 *pSrc) { #if defined( NN_HARDWARE_CTR ) #if (MTX44TRANSPOSE_44_CONFIG == D_ORG) return ARMv6::MTX44TransposeC(pOut, pSrc); #elif (MTX44TRANSPOSE_44_CONFIG == D_FAST_C) #elif (MTX44TRANSPOSE_44_CONFIG == D_FAST_ASM) return ARMv6::MTX44TransposeAsm(pOut, pSrc); #elif (MTX44TRANSPOSE_44_CONFIG == D_FAST_C_ALGO) #elif (MTX44TRANSPOSE_44_CONFIG == D_FAST_ASM_ALGO) #endif #else #endif // #if defined( NN_HARDWARE_CTR ) } /* */ /* Please see man pages for details */ /* */ NN_FORCE_INLINE VEC4* VEC3Transform(VEC4* pOut, const MTX44* pM, const VEC3* pV) { #if defined( NN_HARDWARE_CTR ) #if (VEC3TRANSFORM_44XVEC3_CONFIG == D_ORG) return ARMv6::VEC3TransformC(pOut, pM, pV); #elif (VEC3TRANSFORM_44XVEC3_CONFIG == D_FAST_C) #elif (VEC3TRANSFORM_44XVEC3_CONFIG == D_FAST_ASM) return ARMv6::VEC3TransformAsm(pOut, pM, pV); #elif (VEC3TRANSFORM_44XVEC3_CONFIG == D_FAST_C_ALGO) #elif (VEC3TRANSFORM_44XVEC3_CONFIG == D_FAST_ASM_ALGO) #endif #else #endif // #if defined( NN_HARDWARE_CTR ) } /* */ /* Please see man pages for details */ /*---------------------------------------------------------------------------* Description: Rotates projection matrix in the direction of the screen. Arguments: pOut Pointer to the matrix to rotate pivot Returns: *---------------------------------------------------------------------------*/ NN_FORCE_INLINE MTX44* MTX44Pivot( MTX44* pOut, PivotDirection pivot ) { #if defined( NN_HARDWARE_CTR ) #if (MTX44PIVOT_CONFIG == D_ORG) return ARMv6::MTX44PivotC(pOut, pivot); #elif (MTX44PIVOT_CONFIG == D_FAST_C) return ARMv6::MTX44PivotC_FAST(pOut, pivot); #elif (MTX44PIVOT_CONFIG == D_FAST_ASM) #elif (MTX44PIVOT_CONFIG == D_FAST_C_ALGO) #elif (MTX44PIVOT_CONFIG == D_FAST_ASM_ALGO) #endif #else #endif // #if defined( NN_HARDWARE_CTR ) } /* */ //-- Overloads that reference const type arguments inline MTX44* MTX44Copy(MTX44* pOut, const MTX44& m) { return MTX44Copy( pOut, &m ); } inline bool MTX44IsIdentity(const MTX44& m) { return MTX44IsIdentity( &m ); } inline MTX44* MTX44Add(MTX44* pOut, const MTX44& m1, const MTX44& m2) { return MTX44Add( pOut, &m1, &m2 ); } inline MTX44* MTX44Sub(MTX44* pOut, const MTX44& m1, const MTX44& m2) { return MTX44Sub( pOut, &m1, &m2 ); } inline MTX44* MTX44Mult(MTX44* pOut, const MTX44& m, f32 f) { return MTX44Mult( pOut, &m, f ); } inline MTX44* MTX44Mult(MTX44* pOut, const MTX44& m1, const MTX44& m2) { return MTX44Mult( pOut, &m1, &m2 ); } inline MTX44* MTX44Transpose(MTX44* pOut, const MTX44& m) { return MTX44Transpose( pOut, &m ); } inline MTX44* MTX44MultArray(MTX44* pOut, const MTX44& m1, const MTX44* pSrc, s32 count) { return MTX44MultArray( pOut, &m1, pSrc, count ); } inline u32 MTX44Inverse(MTX44* pOut, const MTX44& m) { return MTX44Inverse( pOut, &m ); } inline MTX44* MTX44RotAxisFIdx(MTX44* pOut, const VEC3& vAxis, f32 fIdx) { return MTX44RotAxisFIdx( pOut, &vAxis, fIdx ); } inline MTX44* MTX44RotAxisRad(MTX44* pOut, const VEC3& vAxis, f32 fRad) { return MTX44RotAxisRad( pOut, &vAxis, fRad ); } inline MTX44* MTX44RotAxisDeg(MTX44* pOut, const VEC3& vAxis, f32 fDeg) { return MTX44RotAxisDeg( pOut, &vAxis, fDeg ); } inline MTX44* MTX44Scale(MTX44* pOut, const VEC3& S) { return MTX44Scale(pOut, &S); } inline MTX44* MTX44MultScale(MTX44* pOut, const MTX44& M, const VEC3& S) { return MTX44MultScale(pOut, &M, &S); } inline MTX44* MTX44MultScale(MTX44* pOut, const VEC3& S, const MTX44& M) { return MTX44MultScale(pOut, &S, &M); } inline MTX44* MTX44Translate(MTX44* pOut, const VEC3& T) { return MTX44Translate(pOut, &T); } inline MTX44* MTX44MultTranslate(MTX44* pOut, const MTX44& M, const VEC3& T) { return MTX44MultTranslate(pOut, &M, &T); } inline MTX44* MTX44MultTranslate(MTX44* pOut, const VEC3& T, const MTX44& M) { return MTX44MultTranslate(pOut, &T, &M); } } // namespace math } // namespace nn #if defined(NN_MATH_AS_INLINE) #include #include #endif #pragma pop #endif