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: 24035 $
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 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 // そのうち実装する
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 /*!
100 @name 行列
101 @{
102 */
103
104 /*!--------------------------------------------------------------------------*
105 @brief 回転行列を作成します。
106
107 @param[out] pOut 計算結果を受け取るバッファへのポインタ。
108 @param[in] fRadX ラジアン単位での X 軸周りの角度
109 @param[in] fRadY ラジアン単位での Y 軸周りの角度
110 @param[in] fRadZ ラジアン単位での Z 軸周りの角度
111
112 @return pOut を返します。
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 @brief 回転行列を作成します。
122
123 @param[out] pOut 計算結果を受け取るバッファへのポインタ。
124 @param[in] fDegX 1 円周を 360.0 とする単位での X 軸周りの角度
125 @param[in] fDegY 1 円周を 360.0 とする単位での Y 軸周りの角度
126 @param[in] fDegZ 1 円周を 360.0 とする単位での Z 軸周りの角度
127
128 @return pOut を返します。
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 @brief 指定する軸の周りを回転させる回転行列を作成します。
138
139 @param[out] pOut 計算結果を受け取るバッファへのポインタ。
140 @param[in] pAxis 回転軸を指定するベクトルへのポインタ。
141 @param[in] fRad ラジアン単位での回転量
142
143 @return pOut を返します。
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 @brief 指定する軸の周りを回転させる回転行列を作成します。
153
154 @param[out] pOut 計算結果を受け取るバッファへのポインタ。
155 @param[in] pAxis 回転軸を指定するベクトルへのポインタ。
156 @param[in] fDeg 1 円周を 360.0 とする単位での回転量
157
158 @return pOut を返します。
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 クラスの定義
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 @brief 3行４列の行列クラスです。
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 //! @brief 単位行列です。
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 //! @name 作成
224 //@{
225
226 //! @brief コンストラクタです。
MTX34MTX34227 MTX34() {}
228
229 //! @brief コンストラクタです。
MTX34MTX34230 MTX34(const f32* p) { (void)MTX34Copy(this, (MTX34*)p); }
231
232 //! @brief コピーコンストラクタです。
MTX34MTX34233 MTX34(const MTX34& rhs) { (void)MTX34Copy(this, &rhs); }
234
235 //! @brief コンストラクタです。
MTX34MTX34236 MTX34(const MTX33& rhs) { MTX33ToMTX34(this, &rhs); }
237
238 //! @brief コンストラクタです。
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 //! @name 変換
252 //@{
253
254 //! @brief f32 型へのキャストです。
255 operator f32*() { return this->a; }
256
257 //! @brief f32 型へのキャストです。
258 operator const f32*() const { return this->a; }
259
260 //! @brief VEC4 型として行を取得します。
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 //! @brief VEC4 型として行を取得します。
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 //! @brief VEC3 型として列を取得します。
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 //! @brief VEC3 型で列を設定します。
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 //! @name 演算
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 //! @brief 行列を右からかけた値を代入します。
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 //! @name 設定
326 //@{
327
328 //! @brief 単位行列に設定します。
SetupIdentityMTX34329 self_type& SetupIdentity() { return *MTX34Identity(this); }
330
331 //! @brief スケール変換行列に設定します。
332 //!
333 //! @param[in] scale スケール値です。
334 //!
SetupScaleMTX34335 self_type& SetupScale(const VEC3& scale) { return *MTX34Scale(this, &scale); }
336
337 //! @brief 平行移動行列に設定します。
338 //!
339 //! @param[in] translate 平行移動値です。
340 //!
SetupTranslateMTX34341 self_type& SetupTranslate(const VEC3& translate)
342 {
343 return *MTX34Translate(this, &translate);
344 }
345
346 //! @brief XYZ 順の回転行列に設定します。
347 //!
348 //! @param[in] rotate 回転値です。単位はラジアンです。
349 //!
SetupRotateXyzMTX34350 self_type& SetupRotateXyz(const VEC3& rotate)
351 {
352 return *MTX34RotXYZRad(this, rotate.x, rotate.y, rotate.z);
353 }
354
355 //! @brief 指定した軸周りの回転行列に設定します。
356 //!
357 //! @param[in] axis 基準となる軸のベクトルです。
358 //! @param[in] theta 回転させる角度です。単位はラジアンです。
359 //!
SetupRotateMTX34360 self_type& SetupRotate(const VEC3& axis, f32 theta)
361 {
362 return *MTX34RotAxisRad(this, &axis, theta);
363 }
364
365 //! @brief クォータニオンから回転行列を設定します。
366 //!
367 //! @param[in] quaternion 元となるクォータニオンです。
SetupRotateMTX34368 self_type& SetupRotate(const QUAT& quaternion)
369 {
370 return *QUATToMTX34(this, &quaternion);
371 }
372
373 /*!--------------------------------------------------------------------------*
374 @brief カメラ行列を設定します。
375
376 @param[in] camPos カメラの位置を指定するベクトルへのポインタ。
377 @param[in] camUp カメラの上方向を指定するベクトルへのポインタ。
378 @param[in] target カメラの注視点を指定するベクトルへのポインタ。
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 @brief カメラ行列を設定します。
387
388 @param[in] camPos カメラの位置を指定するベクトルへのポインタ。
389 @param[in] twistDeg カメラの視線方向に対する回転角度。単位は Degree です。
390 @param[in] target カメラの注視点を指定するベクトルへのポインタ。
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 @brief カメラ行列を設定します。
399
400 @param[in] camPos カメラの位置を指定するベクトルへのポインタ。
401 @param[in] camRotateDeg カメラの回転量を指定するベクトルへのポインタ。単位は Degree です。
402 *---------------------------------------------------------------------------*/
SetupCameraRotateMTX34403 self_type& SetupCameraRotate(const VEC3& camPos, const VEC3& camRotateDeg)
404 {
405 return *MTX34CameraRotate(this, &camPos, &camRotateDeg);
406 }
407
408 /*!--------------------------------------------------------------------------*
409 @brief テクスチャマトリクス用射影行列を視錐体を元に作成します。
410
411 @param[in] l ニアクリップの左辺です。
412 @param[in] r ニアクリップの右辺です。
413 @param[in] b ニアクリップの下辺です。
414 @param[in] t ニアクリップの上辺です。
415 @param[in] n カメラからニアクリップまでの距離です。
416 @param[in] scaleS S軸方向のスケール値です。
417 @param[in] scaleT T軸方向のスケール値です。
418 @param[in] translateS S軸方向の移動値です。
419 @param[in] translateT T軸方向の移動値です。
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 @brief テクスチャマトリクス用射影行列を作成します。
428
429 @param[in] fovyRad 垂直視野角です。単位はラジアンです。
430 @param[in] aspect クリップ面のアスペクト比です。
431 @param[in] scaleS S軸方向のスケール値です。
432 @param[in] scaleT T軸方向のスケール値です。
433 @param[in] translateS S軸方向の移動値です。
434 @param[in] translateT T軸方向の移動値です。
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 @brief 平行射影行列を作成します。
443
444 @param[out] pOut 計算結果を受け取るバッファへのポインタです。
445 @param[in] l ニアクリップの左辺です。
446 @param[in] r ニアクリップの右辺です。
447 @param[in] b ニアクリップの下辺です。
448 @param[in] t ニアクリップの上辺です。
449 @param[in] scaleS S軸方向のスケール値です。
450 @param[in] scaleT T軸方向のスケール値です。
451 @param[in] translateS S軸方向の移動値です。
452 @param[in] translateT T軸方向の移動値です。
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 //! @name 比較
463 //@{
464
465 //! @brief 同値であれば true を返します。
466 bool operator == (const self_type& rhs) const { return ::std::memcmp(this, &rhs, sizeof(MTX34)) == 0; }
467
468 //! @brief 同値でなければ true を返します。
469 bool operator != (const self_type& rhs) const { return ::std::memcmp(this, &rhs, sizeof(MTX34)) != 0; }
470
471 //! @brief 単位行列であれば true を返します。
IsIdentityMTX34472 bool IsIdentity() const { return MTX34IsIdentity(this); }
473 //@}
474
475 //! @brief 状態を出力します。
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 /*!
490 @name 行列
491 @{
492 */
493
494 /*!--------------------------------------------------------------------------*
495 @brief 行列をコピーします。
496
497 @param[out] pOut コピー先の行列へのポインタ。
498 @param[in] p コピー元の行列へのポインタ
499
500 @return pOut を返します。
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 @brief 行列の積を計算します。
521
522 @param[out] pOut 計算結果を受け取るバッファへのポインタ。
523 p1, p2 と同じ行列を指していても構いません。
524 @param[in] p1 左辺値へのポインタ。
525 @param[in] p2 右辺値へのポインタ。
526
527 @return pOut を返します。
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 @brief 行列のスカラー積を計算します。
546
547 @param[out] pOut 計算結果を受け取るバッファへのポインタ。p と同じ行列を指していても構いません。
548 @param[in] p 元の行列のポインタ。
549 @param[in] f 掛ける数
550
551 @return pOut を返します。
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 @brief 行列の和を計算します。
572
573 @param[out] pOut 計算結果を受け取るバッファへのポインタ。p1, p2 と同じ行列を指していても構いません。
574 @param[in] p1 左辺値へのポインタ。
575 @param[in] p2 右辺値へのポインタ。
576
577 @return pOut を返します。
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 @brief カメラ行列を設定します。
597
598 @param[out] pOut 計算結果を受け取るバッファへのポインタ。
599 @param[in] pCamPos カメラの位置を指定するベクトルへのポインタ。
600 @param[in] pCamRotateDeg カメラの回転量を指定するベクトルへのポインタ。単位は Degree です。
601
602 @return pOut を返します。
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 @brief 行列の逆行列を計算します。
623
624 @param[out] pOut 計算結果を受け取るバッファへのポインタ。p と同じ行列を指していても構いません。
625 @param[in] p 元となる行列へのポインタ。
626
627 @return 逆行列が存在すれば 1 を、存在しなければ 0 を返します。
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 @brief 行列の逆転置行列を計算します。
647
648 @param[out] pOut 計算結果を受け取るバッファへのポインタ。p と同じ行列を指していても構いません。
649 @param[in] p 元となる行列へのポインタ。
650
651 @return 逆行列が存在すれば 1 を、存在しなければ 0 を返します。
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 @brief カメラ行列を設定します。
671
672 @param[out] pOut 計算結果を受け取るバッファへのポインタ。
673 @param[in] pCamPos カメラの位置を指定するベクトルへのポインタ。
674 @param[in] pCamUp カメラの上方向を指定するベクトルへのポインタ。
675 @param[in] pTarget カメラの注視点を指定するベクトルへのポインタ。
676
677 @return pOut を返します。
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 @brief カメラ行列を設定します。
697
698 @param[out] pOut 計算結果を受け取るバッファへのポインタ。
699 @param[in] pCamPos カメラの位置を指定するベクトルへのポインタ。
700 @param[in] twistDeg カメラの視線方向に対する回転角度。単位は Degree です。
701 @param[in] pTarget カメラの注視点を指定するベクトルへのポインタ。
702
703 @return pOut を返します。
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 @brief 行列を実数倍して、別の行列を足します。
724
725 @param[out] pOut 計算結果を受け取るバッファへのポインタ。p1, p2 と同じ行列を指していても構いません。
726 @param[in] t 掛ける数。
727 @param[in] p1 元の行列へのポインタ。
728 @param[in] p2 足す行列へのポインタ。
729
730 @return pOut を返します。
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 @brief 行列にスケール変換を適用します。スケール行列を右から掛けます。
750
751 @param[out] pOut 計算結果を受け取るバッファへのポインタ。pM と同じ行列を指していても構いません。
752 @param[in] pM 元となる行列へのポインタ。
753 @param[in] pS それぞれの軸方向のスケール値が格納されたベクトルへのポインタ。
754
755 @return pOut を返します。
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 @brief 行列にスケール変換を適用します。スケール行列を左から掛けます。
775
776 @param[out] pOut 計算結果を受け取るバッファへのポインタ。pM と同じ行列を指していても構いません。
777 @param[in] pS それぞれの軸方向のスケール値が格納されたベクトルへのポインタ。
778 @param[in] pM 元となる行列へのポインタ。
779
780 @return pOut を返します。
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 @brief 行列に平行移動を適用します。移動行列を左から掛けます。
801
802 @param[out] pOut 計算結果を受け取るバッファへのポインタ。pM と同じ行列を指していても構いません。
803 @param[in] pT それぞれの軸方向の移動量が格納されたベクトルへのポインタ。
804 @param[in] pM 元となる行列へのポインタ。
805
806 @return pOut を返します。
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 @brief 行列に平行移動を適用します。移動行列を右から掛けます。
826
827 @param[out] pOut 計算結果を受け取るバッファへのポインタ。pM と同じ行列を指していても構いません。
828 @param[in] pM 元となる行列へのポインタ。
829 @param[in] pT それぞれの軸方向の移動量が格納されたベクトルへのポインタ。
830
831 @return pOut を返します。
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 @brief 指定する軸の周りを回転させる回転行列を作成します。
851
852 @param[out] pOut 計算結果を受け取るバッファへのポインタ。
853 @param[in] pAxis 回転軸を指定するベクトルへのポインタ。
854 @param[in] fRad ラジアン単位での回転量
855
856 @return pOut を返します。
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 @brief 回転行列を作成します。
879
880 @param[out] pOut 計算結果を受け取るバッファへのポインタ。
881 @param[in] fIdxX 1 円周を 256.0 とする単位での X 軸周りの角度
882 @param[in] fIdxY 1 円周を 256.0 とする単位での Y 軸周りの角度
883 @param[in] fIdxZ 1 円周を 256.0 とする単位での Z 軸周りの角度
884
885 @return pOut を返します。
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 @brief スケール変換用の行列を作成します。
907
908 @param[out] pOut 計算結果を受け取るバッファへのポインタ。pM と同じ行列を指していても構いません。
909 @param[in] pS それぞれの軸方向のスケール値が格納されたベクトルへのポインタ。
910
911 @return pOut を返します。
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 @brief 平行移動用の行列を作成します。
932
933 @param[out] pOut 計算結果を受け取るバッファへのポインタ。pM と同じ行列を指していても構いません。
934 @param[in] pT それぞれの軸方向の移動量が格納されたベクトルへのポインタ。
935
936 @return pOut を返します。
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 @brief 行列の転置行列を作成します。
956
957 @param[out] pOut 計算結果を受け取るバッファへのポインタ。p と同じ行列を指していても構いません。
958 @param[in] p 転置する行列へのポインタ。
959
960 @return pOut を返します。
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 /*!
979 @name クォータニオン
980 @{
981 */
982
983 /*!--------------------------------------------------------------------------*
984 @brief クォータニオンから回転行列を作成します。
985
986 @param[out] pOut 計算結果を受け取るバッファへのポインタ。
987 @param[in] pQ 元となるクォータニオンへのポインタ。
988
989 @return pOut を返します。
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 /*!
1012 @name ユーティリティ
1013 @{
1014 */
1015
1016 /*!--------------------------------------------------------------------------*
1017 @brief ベクトルを行列で変換します。ベクトルの 4 要素目を 1 として計算します。
1018
1019 @param[out] pOut 計算結果を受け取るバッファへのポインタ。
1020 pV と同じベクトルを指していても構いません。
1021 @param[in] pM 変換行列へのポインタ。
1022 @param[in] pV 元となるベクトルへのポインタ。
1023
1024 @return pOut を返します。
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 //-- const 引数を参照にしたオーバーロード
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