/*---------------------------------------------------------------------------* Project: Horizon File: math_Matrix34.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: 24035 $ *---------------------------------------------------------------------------*/ #ifndef NN_MATH_MATRIX34_H_ #define NN_MATH_MATRIX34_H_ #include #include #include #pragma push #pragma Otime namespace nn { namespace math { struct MTX34; /* ------------------------------------------------------------------------ MTX34用の関数 ------------------------------------------------------------------------ */ NN_MATH_INLINE MTX34* MTX34Zero(MTX34* pOut); NN_MATH_INLINE bool MTX34IsIdentity(const MTX34* p); NN_MATH_INLINE MTX34* MTX34Identity(MTX34* pOut); NN_MATH_INLINE MTX34* MTX34Copy(MTX34* pOut, const MTX34* p); NN_MATH_INLINE MTX34* MTX34Add(MTX34* pOut, const MTX34* p1, const MTX34* p2); NN_MATH_INLINE MTX34* MTX34Sub(MTX34* pOut, const MTX34* p1, const MTX34* p2); NN_MATH_INLINE MTX34* MTX34Mult(MTX34* pOut, const MTX34* p, f32 f); NN_MATH_INLINE MTX34* MTX34Mult(MTX34* pOut, const MTX34* p1, const MTX34* p2); NN_MATH_INLINE MTX34* MTX34MAdd(MTX34* pOut, f32 t, const MTX34* p1, const MTX34* p2); NN_MATH_INLINE MTX33* MTX34ToMTX33(MTX33* pOut, const MTX34* pM); NN_MATH_INLINE MTX34* MTX33ToMTX34(MTX34* pOut, const MTX33* pM); NN_MATH_INLINE MTX34* MTX34MultArray(MTX34* pOut, const MTX34* p1, const MTX34* pSrc, s32 count); NN_MATH_INLINE u32 MTX34Inverse(MTX34* pOut, const MTX34* p); NN_MATH_INLINE MTX34* MTX34Transpose(MTX34* pOut, const MTX34* p); NN_MATH_INLINE u32 MTX34InvTranspose(MTX34* pOut, const MTX34* p); NN_MATH_INLINE MTX34* MTX34LookAt(MTX34* pOut, const VEC3* pCamPos, const VEC3* pCamUp, const VEC3* pTarget); NN_MATH_INLINE MTX34* MTX34LookAt(MTX34* pOut, const VEC3* pCamPos, f32 twistDeg, const VEC3* pTarget); NN_MATH_INLINE MTX34* MTX34CameraRotate(MTX34* pOut, const VEC3* pCamPos, const VEC3* pCamRotateDeg); 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); NN_MATH_INLINE MTX34* MTX34TextureProjectionPerspective(MTX34* pOut, f32 fovy, f32 aspect, f32 scaleS, f32 scaleT, f32 translateS, f32 translateT); NN_MATH_INLINE MTX34* MTX34TextureProjectionOrtho(MTX34* pOut, f32 l, f32 r, f32 b, f32 t, f32 scaleS, f32 scaleT, f32 translateS, f32 translateT); NN_MATH_INLINE MTX34* MTX34RotXYZFIdx(MTX34* pOut, f32 fIdxX, f32 fIdxY, f32 fIdxZ); NN_MATH_INLINE MTX34* MTX34RotXYZTranslateFIdx(MTX34* pOut, f32 fIdxX, f32 fIdxY, f32 fIdxZ, const VEC3* pT); NN_MATH_INLINE MTX34* MTX34RotAxisFIdx(MTX34* pOut, const VEC3* pAxis, f32 fIdx); NN_MATH_INLINE MTX34* MTX34Scale(MTX34* pOut, const VEC3* pS); NN_MATH_INLINE MTX34* MTX34MultScale(MTX34* pOut, const MTX34* pM, const VEC3* pS); NN_MATH_INLINE MTX34* MTX34MultScale(MTX34* pOut, const VEC3* pS, const MTX34* pM); NN_MATH_INLINE MTX34* MTX34Translate(MTX34* pOut, const VEC3* pT); NN_MATH_INLINE MTX34* MTX34MultTranslate(MTX34* pOut, const MTX34* pM, const VEC3* pT); NN_MATH_INLINE MTX34* MTX34MultTranslate(MTX34* pOut, const VEC3* pT, const MTX34* pM); NN_MATH_INLINE MTX34* QUATToMTX34(MTX34* pOut, const QUAT* p); NN_FORCE_INLINE MTX34* MTX34Copy(MTX34* pOut, const MTX34* p); NN_FORCE_INLINE MTX34* MTX34Mult(MTX34* pOut, const MTX34* p1, const MTX34* p2); NN_FORCE_INLINE MTX34* MTX34Add(MTX34* pOut, const MTX34* p1, const MTX34* p2); NN_FORCE_INLINE MTX34* MTX34CameraRotate(MTX34* pOut, const VEC3* pCamPos, const VEC3* pCamRotateDeg); NN_FORCE_INLINE u32 MTX34Inverse(MTX34* pOut, const MTX34* p); NN_FORCE_INLINE u32 MTX34InvTranspose(MTX34* pOut, const MTX34* p); NN_FORCE_INLINE MTX34* MTX34LookAt(MTX34* pOut, const VEC3* pCamPos, const VEC3* pCamUp, const VEC3* pTarget); NN_FORCE_INLINE MTX34* MTX34LookAt(MTX34* pOut, const VEC3* pCamPos, f32 twistDeg, const VEC3* pTarget); NN_FORCE_INLINE MTX34* MTX34MAdd(MTX34* pOut, f32 t, const MTX34* p1, const MTX34* p2); NN_FORCE_INLINE MTX34* MTX34Mult(MTX34* pOut, const MTX34* p, f32 f); NN_FORCE_INLINE MTX34* MTX34MultScale(MTX34* pOut, const MTX34* pM, const VEC3* pS); NN_FORCE_INLINE MTX34* MTX34MultScale(MTX34* pOut, const VEC3* __restrict pS, const MTX34* pM); NN_FORCE_INLINE MTX34* MTX34MultTranslate(MTX34* pOut, const VEC3* pT, const MTX34* pM); NN_FORCE_INLINE MTX34* MTX34MultTranslate(MTX34* pOut, const MTX34* pM, const VEC3* pT); NN_FORCE_INLINE MTX34* MTX34RotAxisRad_( MTX34* pOut, const VEC3 *pAxis, f32 fRad ); NN_FORCE_INLINE MTX34* MTX34Scale(MTX34* pOut, const VEC3* pS); NN_FORCE_INLINE MTX34* MTX34Transpose(MTX34* pOut, const MTX34* p); NN_FORCE_INLINE MTX34* QUATToMTX34(MTX34* pOut, const QUAT* pQ); NN_FORCE_INLINE VEC3* VEC3Transform(VEC3* pOut, const MTX34* __restrict pM, const VEC3* __restrict pV); // そのうち実装する //MTX34* MTX34Inv(MTX34* pOut, f32* pDet, const MTX34* p); //MTX34* MTX34InvTranspose(MTX34* pOut, f32* pDet, const MTX34* p); //f32 MTX34Det(const MTX34* p); /*! @name 行列 @{ */ /*!--------------------------------------------------------------------------* @brief 回転行列を作成します。 @param[out] pOut 計算結果を受け取るバッファへのポインタ。 @param[in] fRadX ラジアン単位での X 軸周りの角度 @param[in] fRadY ラジアン単位での Y 軸周りの角度 @param[in] fRadZ ラジアン単位での Z 軸周りの角度 @return pOut を返します。 *---------------------------------------------------------------------------*/ inline MTX34* MTX34RotXYZRad(MTX34* pOut, f32 fRadX, f32 fRadY, f32 fRadZ) { return MTX34RotXYZFIdx(pOut, NN_MATH_RAD_TO_FIDX(fRadX), NN_MATH_RAD_TO_FIDX(fRadY), NN_MATH_RAD_TO_FIDX(fRadZ)); } /*!--------------------------------------------------------------------------* @brief 回転行列を作成します。 @param[out] pOut 計算結果を受け取るバッファへのポインタ。 @param[in] fDegX 1 円周を 360.0 とする単位での X 軸周りの角度 @param[in] fDegY 1 円周を 360.0 とする単位での Y 軸周りの角度 @param[in] fDegZ 1 円周を 360.0 とする単位での Z 軸周りの角度 @return pOut を返します。 *---------------------------------------------------------------------------*/ inline MTX34* MTX34RotXYZDeg(MTX34* pOut, f32 fDegX, f32 fDegY, f32 fDegZ) { return MTX34RotXYZFIdx(pOut, NN_MATH_DEG_TO_FIDX(fDegX), NN_MATH_DEG_TO_FIDX(fDegY), NN_MATH_DEG_TO_FIDX(fDegZ)); } /*!--------------------------------------------------------------------------* @brief 指定する軸の周りを回転させる回転行列を作成します。 @param[out] pOut 計算結果を受け取るバッファへのポインタ。 @param[in] pAxis 回転軸を指定するベクトルへのポインタ。 @param[in] fRad ラジアン単位での回転量 @return pOut を返します。 *---------------------------------------------------------------------------*/ inline MTX34* MTX34RotAxisRad(MTX34* pOut, const VEC3* pAxis, f32 fRad) { return MTX34RotAxisFIdx(pOut, pAxis, NN_MATH_RAD_TO_FIDX(fRad)); } /*!--------------------------------------------------------------------------* @brief 指定する軸の周りを回転させる回転行列を作成します。 @param[out] pOut 計算結果を受け取るバッファへのポインタ。 @param[in] pAxis 回転軸を指定するベクトルへのポインタ。 @param[in] fDeg 1 円周を 360.0 とする単位での回転量 @return pOut を返します。 *---------------------------------------------------------------------------*/ inline MTX34* MTX34RotAxisDeg(MTX34* pOut, const VEC3* pAxis, f32 fDeg) { return MTX34RotAxisFIdx(pOut, pAxis, NN_MATH_DEG_TO_FIDX(fDeg)); } /*! @} */ /* ======================================================================= クラスの定義 ======================================================================== */ struct MTX34_ { struct BaseData { f32 _00, _01, _02, _03; f32 _10, _11, _12, _13; f32 _20, _21, _22, _23; }; union { #if defined(NN_MATH_USE_ANONYMOUS_STRUCT) struct { f32 _00, _01, _02, _03; f32 _10, _11, _12, _13; f32 _20, _21, _22, _23; }; #endif BaseData f; f32 m[3][4]; f32 a[12]; VEC4_ v[3]; }; }; /*!--------------------------------------------------------------------------* @brief 3行４列の行列クラスです。 *---------------------------------------------------------------------------*/ struct MTX34 : public MTX34_ { public: static const int ROW_COUNT = 3; //!< 行数です。 static const int COLUMN_COUNT = 4; //!< 列数です。 //! @brief 単位行列です。 static const MTX34& Identity() { static const MTX34 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); return identity; } typedef MTX34 self_type; //!< 自分の型です。 typedef f32 value_type; //!< 要素の型です。 public: //---------------------------------------- //! @name 作成 //@{ //! @brief コンストラクタです。 MTX34() {} //! @brief コンストラクタです。 MTX34(const f32* p) { (void)MTX34Copy(this, (MTX34*)p); } //! @brief コピーコンストラクタです。 MTX34(const MTX34& rhs) { (void)MTX34Copy(this, &rhs); } //! @brief コンストラクタです。 MTX34(const MTX33& rhs) { MTX33ToMTX34(this, &rhs); } //! @brief コンストラクタです。 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) { 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; } //@} //---------------------------------------- //! @name 変換 //@{ //! @brief f32 型へのキャストです。 operator f32*() { return this->a; } //! @brief f32 型へのキャストです。 operator const f32*() const { return this->a; } //! @brief VEC4 型として行を取得します。 VEC4& GetRow(int index) { NN_MATH_MINMAXLT_ASSERT(index, 0, ROW_COUNT); return *reinterpret_cast(&this->v[index]); } //! @brief VEC4 型として行を取得します。 const VEC4& GetRow(int index) const { NN_MATH_MINMAXLT_ASSERT(index, 0, ROW_COUNT); return *reinterpret_cast(&this->v[index]); } //! @brief VEC3 型として列を取得します。 VEC3 GetColumn(int index) const { NN_MATH_MINMAXLT_ASSERT(index, 0, COLUMN_COUNT); VEC3 column; column.x = this->m[0][index]; column.y = this->m[1][index]; column.z = this->m[2][index]; return column; } //! @brief VEC3 型で列を設定します。 void SetColumn(int index, const VEC3& 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; } //@} //---------------------------------------- //! @name 演算 //@{ self_type& operator += (const self_type& rhs) { return *MTX34Add(this, this, &rhs); } self_type& operator -= (const self_type& rhs) { return *MTX34Sub(this, this, &rhs); } //! @brief 行列を右からかけた値を代入します。 self_type& operator *= (f32 f) { return *MTX34Mult(this, this, f); } self_type& operator /= (f32 f) { return operator*=(1.f / f); } self_type operator + () const { return *this; } self_type operator - () const { return MTX34(-f._00, -f._01, -f._02, -f._03, -f._10, -f._11, -f._12, -f._13, -f._20, -f._21, -f._22, -f._23); } self_type operator + (const self_type& rhs) const { MTX34 tmp; return *MTX34Add(&tmp, this, &rhs); } self_type operator - (const self_type& rhs) const { MTX34 tmp; return *MTX34Sub(&tmp, this, &rhs); } self_type operator * (f32 f) const { MTX34 tmp; return *MTX34Mult(&tmp, this, f); } self_type operator / (f32 f) const { return *this * (1.f / f); } //! 転置を行います。 self_type& Transpose() { return *MTX34Transpose(this, this); } //@} //---------------------------------------- //! @name 設定 //@{ //! @brief 単位行列に設定します。 self_type& SetupIdentity() { return *MTX34Identity(this); } //! @brief スケール変換行列に設定します。 //! //! @param[in] scale スケール値です。 //! self_type& SetupScale(const VEC3& scale) { return *MTX34Scale(this, &scale); } //! @brief 平行移動行列に設定します。 //! //! @param[in] translate 平行移動値です。 //! self_type& SetupTranslate(const VEC3& translate) { return *MTX34Translate(this, &translate); } //! @brief XYZ 順の回転行列に設定します。 //! //! @param[in] rotate 回転値です。単位はラジアンです。 //! self_type& SetupRotateXyz(const VEC3& rotate) { return *MTX34RotXYZRad(this, rotate.x, rotate.y, rotate.z); } //! @brief 指定した軸周りの回転行列に設定します。 //! //! @param[in] axis 基準となる軸のベクトルです。 //! @param[in] theta 回転させる角度です。単位はラジアンです。 //! self_type& SetupRotate(const VEC3& axis, f32 theta) { return *MTX34RotAxisRad(this, &axis, theta); } //! @brief クォータニオンから回転行列を設定します。 //! //! @param[in] quaternion 元となるクォータニオンです。 self_type& SetupRotate(const QUAT& quaternion) { return *QUATToMTX34(this, &quaternion); } /*!--------------------------------------------------------------------------* @brief カメラ行列を設定します。 @param[in] camPos カメラの位置を指定するベクトルへのポインタ。 @param[in] camUp カメラの上方向を指定するベクトルへのポインタ。 @param[in] target カメラの注視点を指定するベクトルへのポインタ。 *---------------------------------------------------------------------------*/ self_type& SetupLookAt(const VEC3& camPos, const VEC3& camUp, const VEC3& target) { return *MTX34LookAt(this, &camPos, &camUp, &target); } /*!--------------------------------------------------------------------------* @brief カメラ行列を設定します。 @param[in] camPos カメラの位置を指定するベクトルへのポインタ。 @param[in] twistDeg カメラの視線方向に対する回転角度。単位は Degree です。 @param[in] target カメラの注視点を指定するベクトルへのポインタ。 *---------------------------------------------------------------------------*/ self_type& SetupLookAt(const VEC3& camPos, f32 twistDeg, const VEC3& target) { return *MTX34LookAt(this, &camPos, twistDeg, &target); } /*!--------------------------------------------------------------------------* @brief カメラ行列を設定します。 @param[in] camPos カメラの位置を指定するベクトルへのポインタ。 @param[in] camRotateDeg カメラの回転量を指定するベクトルへのポインタ。単位は Degree です。 *---------------------------------------------------------------------------*/ self_type& SetupCameraRotate(const VEC3& camPos, const VEC3& camRotateDeg) { return *MTX34CameraRotate(this, &camPos, &camRotateDeg); } /*!--------------------------------------------------------------------------* @brief テクスチャマトリクス用射影行列を視錐体を元に作成します。 @param[in] l ニアクリップの左辺です。 @param[in] r ニアクリップの右辺です。 @param[in] b ニアクリップの下辺です。 @param[in] t ニアクリップの上辺です。 @param[in] n カメラからニアクリップまでの距離です。 @param[in] scaleS S軸方向のスケール値です。 @param[in] scaleT T軸方向のスケール値です。 @param[in] translateS S軸方向の移動値です。 @param[in] translateT T軸方向の移動値です。 *---------------------------------------------------------------------------*/ self_type& SetupTextureProjectionFrustum(f32 l, f32 r, f32 b, f32 t, f32 n, f32 scaleS, f32 scaleT, f32 translateS, f32 translateT) { return *MTX34TextureProjectionFrustum(this, l, r, b, t, n, scaleS, scaleT, translateS, translateT); } /*!--------------------------------------------------------------------------* @brief テクスチャマトリクス用射影行列を作成します。 @param[in] fovyRad 垂直視野角です。単位はラジアンです。 @param[in] aspect クリップ面のアスペクト比です。 @param[in] scaleS S軸方向のスケール値です。 @param[in] scaleT T軸方向のスケール値です。 @param[in] translateS S軸方向の移動値です。 @param[in] translateT T軸方向の移動値です。 *---------------------------------------------------------------------------*/ self_type& SetupTextureProjectionFrustum(f32 fovyRad, f32 aspect, f32 scaleS, f32 scaleT, f32 translateS, f32 translateT) { return *MTX34TextureProjectionPerspective(this, fovyRad, aspect, scaleS, scaleT, translateS, translateT); } /*!--------------------------------------------------------------------------* @brief 平行射影行列を作成します。 @param[out] pOut 計算結果を受け取るバッファへのポインタです。 @param[in] l ニアクリップの左辺です。 @param[in] r ニアクリップの右辺です。 @param[in] b ニアクリップの下辺です。 @param[in] t ニアクリップの上辺です。 @param[in] scaleS S軸方向のスケール値です。 @param[in] scaleT T軸方向のスケール値です。 @param[in] translateS S軸方向の移動値です。 @param[in] translateT T軸方向の移動値です。 *---------------------------------------------------------------------------*/ self_type& SetupTextureProjectionFrustum(f32 l, f32 r, f32 b, f32 t, f32 scaleS, f32 scaleT, f32 translateS, f32 translateT) { return *MTX34TextureProjectionOrtho(this, l, r, b, t, scaleS, scaleT, translateS, translateT); } //@} //---------------------------------------- //! @name 比較 //@{ //! @brief 同値であれば true を返します。 bool operator == (const self_type& rhs) const { return ::std::memcmp(this, &rhs, sizeof(MTX34)) == 0; } //! @brief 同値でなければ true を返します。 bool operator != (const self_type& rhs) const { return ::std::memcmp(this, &rhs, sizeof(MTX34)) != 0; } //! @brief 単位行列であれば true を返します。 bool IsIdentity() const { return MTX34IsIdentity(this); } //@} //! @brief 状態を出力します。 void Report(bool bNewline = true, const char* name = NULL) const; }; typedef struct MTX34 Matrix34; // inline MTX34 operator * (f32 f, const MTX34& rhs) { MTX34 tmp; (void)MTX34Mult(&tmp, &rhs, f); return tmp; } /*! @name 行列 @{ */ /*!--------------------------------------------------------------------------* @brief 行列をコピーします。 @param[out] pOut コピー先の行列へのポインタ。 @param[in] p コピー元の行列へのポインタ @return pOut を返します。 *---------------------------------------------------------------------------*/ NN_FORCE_INLINE MTX34* MTX34Copy(MTX34* pOut, const MTX34* p) { #if defined( NN_HARDWARE_CTR ) #if (MTX34COPY_CONFIG == D_ORG) return ARMv6::MTX34CopyC( pOut, p ); #elif (MTX34COPY_CONFIG == D_FAST_C) #elif (MTX34COPY_CONFIG == D_FAST_ASM) return ARMv6::MTX34CopyAsm( pOut, p ); #elif (MTX34COPY_CONFIG == D_FAST_C_ALGO) #elif (MTX34COPY_CONFIG == D_FAST_ASM_ALGO) #endif #else #endif // #if defined( NN_HARDWARE_CTR ) } /*!--------------------------------------------------------------------------* @brief 行列の積を計算します。 @param[out] pOut 計算結果を受け取るバッファへのポインタ。 p1, p2 と同じ行列を指していても構いません。 @param[in] p1 左辺値へのポインタ。 @param[in] p2 右辺値へのポインタ。 @return pOut を返します。 *---------------------------------------------------------------------------*/ NN_FORCE_INLINE MTX34* MTX34Mult(MTX34* pOut, const MTX34* p1, const MTX34* p2) { #if defined( NN_HARDWARE_CTR ) #if (MTX34MULT_34_CONFIG == D_ORG) return ARMv6::MTX34MultC( pOut, p1, p2 ); #elif (MTX34MULT_34_CONFIG == D_FAST_C) #elif (MTX34MULT_34_CONFIG == D_FAST_ASM) return ARMv6::MTX34MultAsm( pOut, p1, p2 ); #elif (MTX34MULT_34_CONFIG == D_FAST_C_ALGO) #elif (MTX34MULT_34_CONFIG == D_FAST_ASM_ALGO) #endif #else #endif // #if defined( NN_HARDWARE_CTR ) } /*!--------------------------------------------------------------------------* @brief 行列のスカラー積を計算します。 @param[out] pOut 計算結果を受け取るバッファへのポインタ。p と同じ行列を指していても構いません。 @param[in] p 元の行列のポインタ。 @param[in] f 掛ける数 @return pOut を返します。 *---------------------------------------------------------------------------*/ NN_FORCE_INLINE MTX34* MTX34Mult(MTX34* pOut, const MTX34* p, f32 f) { #if defined( NN_HARDWARE_CTR ) #if (MTX34MULT_F32_CONFIG == D_ORG) return ARMv6::MTX34MultC( pOut, p, f ); #elif (MTX34MULT_F32_CONFIG == D_FAST_C) #elif (MTX34MULT_F32_CONFIG == D_FAST_ASM) return ARMv6::MTX34MultAsm( pOut, p, f ); #elif (MTX34MULT_F32_CONFIG == D_FAST_C_ALGO) #elif (MTX34MULT_F32_CONFIG == D_FAST_ASM_ALGO) #endif #else #endif // #if defined( NN_HARDWARE_CTR ) } /*!--------------------------------------------------------------------------* @brief 行列の和を計算します。 @param[out] pOut 計算結果を受け取るバッファへのポインタ。p1, p2 と同じ行列を指していても構いません。 @param[in] p1 左辺値へのポインタ。 @param[in] p2 右辺値へのポインタ。 @return pOut を返します。 *---------------------------------------------------------------------------*/ NN_FORCE_INLINE MTX34* MTX34Add(MTX34* pOut, const MTX34* p1, const MTX34* p2) { #if defined( NN_HARDWARE_CTR ) #if (MTX34ADD_CONFIG == D_ORG) return ARMv6::MTX34AddC( pOut, p1, p2 ); #elif (MTX34ADD_CONFIG == D_FAST_C) #elif (MTX34ADD_CONFIG == D_FAST_ASM) return ARMv6::MTX34AddAsm( pOut, p1, p2 ); #elif (MTX34ADD_CONFIG == D_FAST_C_ALGO) #elif (MTX34ADD_CONFIG == D_FAST_ASM_ALGO) #endif #else #endif // #if defined( NN_HARDWARE_CTR ) } /*!--------------------------------------------------------------------------* @brief カメラ行列を設定します。 @param[out] pOut 計算結果を受け取るバッファへのポインタ。 @param[in] pCamPos カメラの位置を指定するベクトルへのポインタ。 @param[in] pCamRotateDeg カメラの回転量を指定するベクトルへのポインタ。単位は Degree です。 @return pOut を返します。 *---------------------------------------------------------------------------*/ NN_FORCE_INLINE MTX34* MTX34CameraRotate(MTX34* pOut, const VEC3* pCamPos, const VEC3* pCamRotateDeg) { #if defined( NN_HARDWARE_CTR ) #if (MTX34CAMERAROTATE_CONFIG == D_ORG) return ARMv6::MTX34CameraRotateC(pOut, pCamPos, pCamRotateDeg); #elif (MTX34CAMERAROTATE_CONFIG == D_FAST_C) return ARMv6::MTX34CameraRotateC_FAST(pOut, pCamPos, pCamRotateDeg); #elif (MTX34CAMERAROTATE_CONFIG == D_FAST_ASM) #elif (MTX34CAMERAROTATE_CONFIG == D_FAST_C_ALGO) #elif (MTX34CAMERAROTATE_CONFIG == D_FAST_ASM_ALGO) #endif #else #endif // #if defined( NN_HARDWARE_CTR ) } /*!--------------------------------------------------------------------------* @brief 行列の逆行列を計算します。 @param[out] pOut 計算結果を受け取るバッファへのポインタ。p と同じ行列を指していても構いません。 @param[in] p 元となる行列へのポインタ。 @return 逆行列が存在すれば 1 を、存在しなければ 0 を返します。 *---------------------------------------------------------------------------*/ NN_FORCE_INLINE u32 MTX34Inverse(MTX34* pOut, const MTX34* p) { #if defined( NN_HARDWARE_CTR ) #if (MTX34INVERSE_CONFIG == D_ORG) return ARMv6::MTX34InverseC( pOut, p ); #elif (MTX34INVERSE_CONFIG == D_FAST_C) #elif (MTX34INVERSE_CONFIG == D_FAST_ASM) return ARMv6::MTX34InverseAsm( pOut, p); #elif (MTX34INVERSE_CONFIG == D_FAST_C_ALGO) #elif (MTX34INVERSE_CONFIG == D_FAST_ASM_ALGO) #endif #else #endif // #if defined( NN_HARDWARE_CTR ) } /*!--------------------------------------------------------------------------* @brief 行列の逆転置行列を計算します。 @param[out] pOut 計算結果を受け取るバッファへのポインタ。p と同じ行列を指していても構いません。 @param[in] p 元となる行列へのポインタ。 @return 逆行列が存在すれば 1 を、存在しなければ 0 を返します。 *---------------------------------------------------------------------------*/ NN_FORCE_INLINE u32 MTX34InvTranspose(MTX34* pOut, const MTX34* __restrict p) { #if defined( NN_HARDWARE_CTR ) #if (MTX34INVTRANSPOSE_34TO34_CONFIG == D_ORG) return ARMv6::MTX34InvTransposeC( pOut, p ); #elif (MTX34INVTRANSPOSE_34TO34_CONFIG == D_FAST_C) #elif (MTX34INVTRANSPOSE_34TO34_CONFIG == D_FAST_ASM) return ARMv6::MTX34InvTransposeAsm( pOut, p); #elif (MTX34INVTRANSPOSE_34TO34_CONFIG == D_FAST_C_ALGO) #elif (MTX34INVTRANSPOSE_34TO34_CONFIG == D_FAST_ASM_ALGO) #endif #else #endif // #if defined( NN_HARDWARE_CTR ) } /*!--------------------------------------------------------------------------* @brief カメラ行列を設定します。 @param[out] pOut 計算結果を受け取るバッファへのポインタ。 @param[in] pCamPos カメラの位置を指定するベクトルへのポインタ。 @param[in] pCamUp カメラの上方向を指定するベクトルへのポインタ。 @param[in] pTarget カメラの注視点を指定するベクトルへのポインタ。 @return pOut を返します。 *---------------------------------------------------------------------------*/ NN_FORCE_INLINE MTX34* MTX34LookAt(MTX34* pOut, const VEC3* pCamPos, const VEC3* pCamUp, const VEC3* pTarget) { #if defined( NN_HARDWARE_CTR ) #if (MTX34LOOKAT_VEC3_CONFIG == D_ORG) return ARMv6::MTX34LookAtC(pOut, pCamPos, pCamUp, pTarget); #elif (MTX34LOOKAT_VEC3_CONFIG == D_FAST_C) return ARMv6::MTX34LookAtC_FAST(pOut, pCamPos, pCamUp, pTarget); #elif (MTX34LOOKAT_VEC3_CONFIG == D_FAST_ASM) #elif (MTX34LOOKAT_VEC3_CONFIG == D_FAST_C_ALGO) #elif (MTX34LOOKAT_VEC3_CONFIG == D_FAST_ASM_ALGO) #endif #else #endif // #if defined( NN_HARDWARE_CTR ) } /*!--------------------------------------------------------------------------* @brief カメラ行列を設定します。 @param[out] pOut 計算結果を受け取るバッファへのポインタ。 @param[in] pCamPos カメラの位置を指定するベクトルへのポインタ。 @param[in] twistDeg カメラの視線方向に対する回転角度。単位は Degree です。 @param[in] pTarget カメラの注視点を指定するベクトルへのポインタ。 @return pOut を返します。 *---------------------------------------------------------------------------*/ NN_FORCE_INLINE MTX34* MTX34LookAt(MTX34* pOut, const VEC3* pCamPos, f32 twistDeg, const VEC3* pTarget) { #if defined( NN_HARDWARE_CTR ) #if (MTX34LOOKAT_F32_CONFIG == D_ORG) return ARMv6::MTX34LookAtC(pOut, pCamPos, twistDeg, pTarget); #elif (MTX34LOOKAT_F32_CONFIG == D_FAST_C) return ARMv6::MTX34LookAtC_FAST(pOut, pCamPos, twistDeg, pTarget); #elif (MTX34LOOKAT_F32_CONFIG == D_FAST_ASM) #elif (MTX34LOOKAT_F32_CONFIG == D_FAST_C_ALGO) #elif (MTX34LOOKAT_F32_CONFIG == D_FAST_ASM_ALGO) #endif #else #endif // #if defined( NN_HARDWARE_CTR ) } /*!--------------------------------------------------------------------------* @brief 行列を実数倍して、別の行列を足します。 @param[out] pOut 計算結果を受け取るバッファへのポインタ。p1, p2 と同じ行列を指していても構いません。 @param[in] t 掛ける数。 @param[in] p1 元の行列へのポインタ。 @param[in] p2 足す行列へのポインタ。 @return pOut を返します。 *---------------------------------------------------------------------------*/ NN_FORCE_INLINE MTX34* MTX34MAdd(MTX34* pOut, f32 t, const MTX34* p1, const MTX34* p2) { #if defined( NN_HARDWARE_CTR ) #if (MTX34MADD_CONFIG == D_ORG) return ARMv6::MTX34MAddC( pOut, t, p1, p2 ); #elif (MTX34MADD_CONFIG == D_FAST_C) #elif (MTX34MADD_CONFIG == D_FAST_ASM) return ARMv6::MTX34MAddAsm( pOut, t, p1, p2 ); #elif (MTX34MADD_CONFIG == D_FAST_C_ALGO) #elif (MTX34MADD_CONFIG == D_FAST_ASM_ALGO) #endif #else #endif // #if defined( NN_HARDWARE_CTR ) } /*!--------------------------------------------------------------------------* @brief 行列にスケール変換を適用します。スケール行列を右から掛けます。 @param[out] pOut 計算結果を受け取るバッファへのポインタ。pM と同じ行列を指していても構いません。 @param[in] pM 元となる行列へのポインタ。 @param[in] pS それぞれの軸方向のスケール値が格納されたベクトルへのポインタ。 @return pOut を返します。 *---------------------------------------------------------------------------*/ NN_FORCE_INLINE MTX34* MTX34MultScale(MTX34* pOut, const MTX34* pM, const VEC3* pS) { #if defined( NN_HARDWARE_CTR ) #if (MTX34MULTSCALE_RIGHT_CONFIG == D_ORG) return ARMv6::MTX34MultScaleC( pOut, pM, pS ); #elif (MTX34MULTSCALE_RIGHT_CONFIG == D_FAST_C) #elif (MTX34MULTSCALE_RIGHT_CONFIG == D_FAST_ASM) return ARMv6::MTX34MultScaleAsm( pOut, pM, pS ); #elif (MTX34MULTSCALE_RIGHT_CONFIG == D_FAST_C_ALGO) #elif (MTX34MULTSCALE_RIGHT_CONFIG == D_FAST_ASM_ALGO) #endif #else #endif // #if defined( NN_HARDWARE_CTR ) } /*!--------------------------------------------------------------------------* @brief 行列にスケール変換を適用します。スケール行列を左から掛けます。 @param[out] pOut 計算結果を受け取るバッファへのポインタ。pM と同じ行列を指していても構いません。 @param[in] pS それぞれの軸方向のスケール値が格納されたベクトルへのポインタ。 @param[in] pM 元となる行列へのポインタ。 @return pOut を返します。 *---------------------------------------------------------------------------*/ NN_FORCE_INLINE MTX34* MTX34MultScale(MTX34* pOut, const VEC3* __restrict pS, const MTX34* pM) { #if defined( NN_HARDWARE_CTR ) #if (MTX34MULTSCALE_LEFT_CONFIG == D_ORG) return ARMv6::MTX34MultScaleC( pOut, pS, pM ); #elif (MTX34MULTSCALE_LEFT_CONFIG == D_FAST_C) #elif (MTX34MULTSCALE_LEFT_CONFIG == D_FAST_ASM) return ARMv6::MTX34MultScaleAsm( pOut, pS, pM ); #elif (MTX34MULTSCALE_LEFT_CONFIG == D_FAST_C_ALGO) #elif (MTX34MULTSCALE_LEFT_CONFIG == D_FAST_ASM_ALGO) #endif #else #endif // #if defined( NN_HARDWARE_CTR ) } /*!--------------------------------------------------------------------------* @brief 行列に平行移動を適用します。移動行列を左から掛けます。 @param[out] pOut 計算結果を受け取るバッファへのポインタ。pM と同じ行列を指していても構いません。 @param[in] pT それぞれの軸方向の移動量が格納されたベクトルへのポインタ。 @param[in] pM 元となる行列へのポインタ。 @return pOut を返します。 *---------------------------------------------------------------------------*/ NN_FORCE_INLINE MTX34* MTX34MultTranslate(MTX34* pOut, const VEC3* pT, const MTX34* pM) { #if defined( NN_HARDWARE_CTR ) #if (MTX34MULTTRANSLATE_LEFT_CONFIG == D_ORG) return ARMv6::MTX34MultTranslateC( pOut, pT, pM ); #elif (MTX34MULTTRANSLATE_LEFT_CONFIG == D_FAST_C) #elif (MTX34MULTTRANSLATE_LEFT_CONFIG == D_FAST_ASM) return ARMv6::MTX34MultTranslateAsm( pOut, pT, pM ); #elif (MTX34MULTTRANSLATE_LEFT_CONFIG == D_FAST_C_ALGO) #elif (MTX34MULTTRANSLATE_LEFT_CONFIG == D_FAST_ASM_ALGO) #endif #else #endif // #if defined( NN_HARDWARE_CTR ) } /*!--------------------------------------------------------------------------* @brief 行列に平行移動を適用します。移動行列を右から掛けます。 @param[out] pOut 計算結果を受け取るバッファへのポインタ。pM と同じ行列を指していても構いません。 @param[in] pM 元となる行列へのポインタ。 @param[in] pT それぞれの軸方向の移動量が格納されたベクトルへのポインタ。 @return pOut を返します。 *---------------------------------------------------------------------------*/ NN_FORCE_INLINE MTX34* MTX34MultTranslate(MTX34* pOut, const MTX34* pM, const VEC3* pT) { #if defined( NN_HARDWARE_CTR ) #if (MTX34MULTTRANSLATE_RIGHT_CONFIG == D_ORG) return ARMv6::MTX34MultTranslateC( pOut, pM, pT ); #elif (MTX34MULTTRANSLATE_RIGHT_CONFIG == D_FAST_C) #elif (MTX34MULTTRANSLATE_RIGHT_CONFIG == D_FAST_ASM) return ARMv6::MTX34MultTranslateAsm( pOut, pM, pT ); #elif (MTX34MULTTRANSLATE_RIGHT_CONFIG == D_FAST_C_ALGO) #elif (MTX34MULTTRANSLATE_RIGHT_CONFIG == D_FAST_ASM_ALGO) #endif #else #endif // #if defined( NN_HARDWARE_CTR ) } /*!--------------------------------------------------------------------------* @brief 指定する軸の周りを回転させる回転行列を作成します。 @param[out] pOut 計算結果を受け取るバッファへのポインタ。 @param[in] pAxis 回転軸を指定するベクトルへのポインタ。 @param[in] fRad ラジアン単位での回転量 @return pOut を返します。 *---------------------------------------------------------------------------*/ NN_FORCE_INLINE MTX34* MTX34RotAxisRad_( MTX34* pOut, const VEC3 *pAxis, f32 fRad ) { #if defined( NN_HARDWARE_CTR ) #if (MTX34ROTAXISRAD__CONFIG == D_ORG) return ARMv6::MTX34RotAxisRad_C(pOut, pAxis, fRad); #elif (MTX34ROTAXISRAD__CONFIG == D_FAST_C) return ARMv6::MTX34RotAxisRad_C_FAST(pOut, pAxis, fRad); #elif (MTX34ROTAXISRAD__CONFIG == D_FAST_ASM) #elif (MTX34ROTAXISRAD__CONFIG == D_FAST_C_ALGO) return ARMv6::MTX34RotAxisRad_C_FAST(pOut, pAxis, fRad); #elif (MTX34ROTAXISRAD__CONFIG == D_FAST_ASM_ALGO) #endif #else #endif // #if defined( NN_HARDWARE_CTR ) } /*!--------------------------------------------------------------------------* @brief 回転行列を作成します。 @param[out] pOut 計算結果を受け取るバッファへのポインタ。 @param[in] fIdxX 1 円周を 256.0 とする単位での X 軸周りの角度 @param[in] fIdxY 1 円周を 256.0 とする単位での Y 軸周りの角度 @param[in] fIdxZ 1 円周を 256.0 とする単位での Z 軸周りの角度 @return pOut を返します。 *---------------------------------------------------------------------------*/ NN_FORCE_INLINE MTX34* MTX34RotXYZFIdx(MTX34* pOut, f32 fIdxX, f32 fIdxY, f32 fIdxZ) { #if defined( NN_HARDWARE_CTR ) #if (MTX34ROTXYZFIDX_CONFIG == D_ORG) return ARMv6::MTX34RotXYZFIdxC(pOut, fIdxX, fIdxY, fIdxZ); #elif (MTX34ROTXYZFIDX_CONFIG == D_FAST_C) return ARMv6::MTX34RotXYZFIdxC_FAST(pOut, fIdxX, fIdxY, fIdxZ); #elif (MTX34ROTXYZFIDX_CONFIG == D_FAST_ASM) #elif (MTX34ROTXYZFIDX_CONFIG == D_FAST_C_ALGO) #elif (MTX34ROTXYZFIDX_CONFIG == D_FAST_ASM_ALGO) #endif #else #endif // #if defined( NN_HARDWARE_CTR ) } /*!--------------------------------------------------------------------------* @brief スケール変換用の行列を作成します。 @param[out] pOut 計算結果を受け取るバッファへのポインタ。pM と同じ行列を指していても構いません。 @param[in] pS それぞれの軸方向のスケール値が格納されたベクトルへのポインタ。 @return pOut を返します。 *---------------------------------------------------------------------------*/ NN_FORCE_INLINE MTX34* MTX34Scale(MTX34* pOut, const VEC3* pS) { #if defined( NN_HARDWARE_CTR ) #if (MTX34SCALE_CONFIG == D_ORG) return ARMv6::MTX34ScaleC(pOut, pS); #elif (MTX34SCALE_CONFIG == D_FAST_C) return ARMv6::MTX34ScaleC_FAST(pOut, pS); #elif (MTX34SCALE_CONFIG == D_FAST_ASM) return ARMv6::MTX34ScaleAsm(pOut, pS); #elif (MTX34SCALE_CONFIG == D_FAST_C_ALGO) #elif (MTX34SCALE_CONFIG == D_FAST_ASM_ALGO) #endif #else #endif // #if defined( NN_HARDWARE_CTR ) } /*!--------------------------------------------------------------------------* @brief 平行移動用の行列を作成します。 @param[out] pOut 計算結果を受け取るバッファへのポインタ。pM と同じ行列を指していても構いません。 @param[in] pT それぞれの軸方向の移動量が格納されたベクトルへのポインタ。 @return pOut を返します。 *---------------------------------------------------------------------------*/ NN_FORCE_INLINE MTX34* MTX34Translate(MTX34* pOut, const VEC3* pT) { #if defined( NN_HARDWARE_CTR ) #if (MTX34TRANSLATE_CONFIG == D_ORG) return ARMv6::MTX34TranslateC(pOut, pT); #elif (MTX34TRANSLATE_CONFIG == D_FAST_C) return ARMv6::MTX34TranslateC_FAST(pOut, pT); #elif (MTX34TRANSLATE_CONFIG == D_FAST_ASM) #elif (MTX34TRANSLATE_CONFIG == D_FAST_C_ALGO) #elif (MTX34TRANSLATE_CONFIG == D_FAST_ASM_ALGO) #endif #else #endif // #if defined( NN_HARDWARE_CTR ) } /*!--------------------------------------------------------------------------* @brief 行列の転置行列を作成します。 @param[out] pOut 計算結果を受け取るバッファへのポインタ。p と同じ行列を指していても構いません。 @param[in] p 転置する行列へのポインタ。 @return pOut を返します。 *---------------------------------------------------------------------------*/ NN_FORCE_INLINE MTX34* MTX34Transpose(MTX34* pOut, const MTX34* p) { #if defined( NN_HARDWARE_CTR ) #if (MTX34TRANSPOSE_34TO34_CONFIG == D_ORG) return ARMv6::MTX34TransposeC(pOut, p); #elif (MTX34TRANSPOSE_34TO34_CONFIG == D_FAST_C) #elif (MTX34TRANSPOSE_34TO34_CONFIG == D_FAST_ASM) return ARMv6::MTX34TransposeAsm(pOut, p); #elif (MTX34TRANSPOSE_34TO34_CONFIG == D_FAST_C_ALGO) #elif (MTX34TRANSPOSE_34TO34_CONFIG == D_FAST_ASM_ALGO) #endif #else #endif // #if defined( NN_HARDWARE_CTR ) } /*! @name クォータニオン @{ */ /*!--------------------------------------------------------------------------* @brief クォータニオンから回転行列を作成します。 @param[out] pOut 計算結果を受け取るバッファへのポインタ。 @param[in] pQ 元となるクォータニオンへのポインタ。 @return pOut を返します。 *---------------------------------------------------------------------------*/ NN_FORCE_INLINE MTX34* QUATToMTX34(MTX34* pOut, const QUAT* pQ) { #if defined( NN_HARDWARE_CTR ) #if (QUATTOMTX34_CONFIG == D_ORG) return ARMv6::QUATToMTX34C(pOut, pQ); #elif (QUATTOMTX34_CONFIG == D_FAST_C) return ARMv6::QUATToMTX34C_FAST(pOut, pQ); #elif (QUATTOMTX34_CONFIG == D_FAST_ASM) #elif (QUATTOMTX34_CONFIG == D_FAST_C_ALGO) #elif (QUATTOMTX34_CONFIG == D_FAST_ASM_ALGO) #endif #else #endif // #if defined( NN_HARDWARE_CTR ) } /*! @} */ /*! @name ユーティリティ @{ */ /*!--------------------------------------------------------------------------* @brief ベクトルを行列で変換します。ベクトルの 4 要素目を 1 として計算します。 @param[out] pOut 計算結果を受け取るバッファへのポインタ。 pV と同じベクトルを指していても構いません。 @param[in] pM 変換行列へのポインタ。 @param[in] pV 元となるベクトルへのポインタ。 @return pOut を返します。 *---------------------------------------------------------------------------*/ NN_FORCE_INLINE VEC3* VEC3Transform(VEC3* pOut, const MTX34* __restrict pM, const VEC3* __restrict pV) { #if defined( NN_HARDWARE_CTR ) #if (VEC3TRANSFORM_34XVEC3_CONFIG == D_ORG) return ARMv6::VEC3TransformC(pOut, pM, pV); #elif (VEC3TRANSFORM_34XVEC3_CONFIG == D_FAST_C) #elif (VEC3TRANSFORM_34XVEC3_CONFIG == D_FAST_ASM) return ARMv6::VEC3TransformAsm(pOut, pM, pV); #elif (VEC3TRANSFORM_34XVEC3_CONFIG == D_FAST_C_ALGO) #elif (VEC3TRANSFORM_34XVEC3_CONFIG == D_FAST_ASM_ALGO) #endif #else #endif // #if defined( NN_HARDWARE_CTR ) } /*! @} */ } // namespace math } // namespace nn namespace nn { namespace math { //-- const 引数を参照にしたオーバーロード inline bool MTX34IsIdentity(const MTX34& m) { return MTX34IsIdentity( &m ); } inline MTX34* MTX34Add(MTX34* pOut, const MTX34& m1, const MTX34& m2) { return MTX34Add( pOut, &m1, &m2 ); } inline MTX34* MTX34Sub(MTX34* pOut, const MTX34& m1, const MTX34& m2) { return MTX34Sub( pOut, &m1, &m2 ); } inline MTX34* MTX34Mult(MTX34* pOut, const MTX34& m, f32 f) { return MTX34Mult( pOut, &m, f ); } inline MTX34* MTX34Mult(MTX34* pOut, const MTX34& m1, const MTX34& m2) { return MTX34Mult( pOut, &m1, &m2 ); } inline MTX34* MTX34MAdd(MTX34* pOut, f32 t, const MTX34& m1, const MTX34& m2) { return MTX34MAdd( pOut, t, &m1, &m2 ); } inline MTX34* MTX34Copy(MTX34* pOut, const MTX34& m) { return MTX34Copy( pOut, &m ); } inline MTX34* MTX34MultArray(MTX34* pOut, const MTX34& m1, const MTX34* pSrc, s32 count) { return MTX34MultArray( pOut, m1, pSrc, count ); } inline u32 MTX34Inverse(MTX34* pOut, const MTX34& m) { return MTX34Inverse( pOut, &m ); } inline MTX34* MTX34Transpose(MTX34* pOut, const MTX34& m) { return MTX34Transpose( pOut, &m ); } inline u32 MTX34InvTranspose(MTX34* pOut, const MTX34& m) { return MTX34InvTranspose( pOut, &m ); } inline MTX34* MTX34LookAt(MTX34* pOut, const VEC3& vCamPos, const VEC3& vCamUp, const VEC3& vTarget) { return MTX34LookAt( pOut, &vCamPos, &vCamUp, &vTarget ); } inline MTX34* MTX34LookAt(MTX34* pOut, const VEC3& vCamPos, f32 twistDeg, const VEC3& vTarget) { return MTX34LookAt( pOut, &vCamPos, twistDeg, &vTarget ); } inline MTX34* MTX34CameraRotate(MTX34* pOut, const VEC3& vCamPos, const VEC3& vCamRotateDeg) { return MTX34CameraRotate( pOut, &vCamPos, &vCamRotateDeg ); } inline MTX34* MTX34RotXYZTranslateFIdx(MTX34* pOut, f32 fIdxX, f32 fIdxY, f32 fIdxZ, const VEC3& vT) { return MTX34RotXYZTranslateFIdx( pOut, fIdxX, fIdxY, fIdxZ, &vT ); } inline MTX34* MTX34RotAxisFIdx(MTX34* pOut, const VEC3& vAxis, f32 fIdx) { return MTX34RotAxisFIdx( pOut, &vAxis, fIdx ); } inline MTX34* MTX34RotAxisRad(MTX34* pOut, const VEC3& vAxis, f32 fRad) { return MTX34RotAxisRad( pOut, &vAxis, fRad ); } inline MTX34* MTX34RotAxisDeg(MTX34* pOut, const VEC3& vAxis, f32 fDeg) { return MTX34RotAxisDeg( pOut, &vAxis, fDeg ); } inline MTX34* MTX34Scale(MTX34* pOut, const VEC3& vS) { return MTX34Scale( pOut, &vS ); } inline MTX34* MTX34MultScale(MTX34* pOut, const MTX34& m, const VEC3& vS) { return MTX34MultScale( pOut, &m, &vS ); } inline MTX34* MTX34MultScale(MTX34* pOut, const VEC3& vS, const MTX34& m) { return MTX34MultScale( pOut, &vS, &m ); } inline MTX34* MTX34Translate(MTX34* pOut, const VEC3& vT) { return MTX34Translate( pOut, &vT ); } inline MTX34* MTX34MultTranslate(MTX34* pOut, const MTX34& m, const VEC3& vT) { return MTX34MultTranslate( pOut, &m, &vT ); } inline MTX34* MTX34MultTranslate(MTX34* pOut, const VEC3& vT, const MTX34& m) { return MTX34MultTranslate( pOut, &vT, &m ); } inline MTX34* QUATToMTX34(MTX34* pOut, const QUAT& q) { return QUATToMTX34( pOut, &q ); } } // namespace math } // namespace nn #if defined(NN_MATH_AS_INLINE) #include #include #endif #pragma pop #endif