1 /*---------------------------------------------------------------------------*
2 Project: Horizon
3 File: math_Matrix44.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: 24788 $
14 *---------------------------------------------------------------------------*/
15
16 #ifndef NN_MATH_MATRIX44_H_
17 #define NN_MATH_MATRIX44_H_
18
19 #include <cstring>
20 #include <nn/math/math_Config.h>
21
22 #pragma push
23 #pragma Otime
24
25 namespace nn {
26 namespace math {
27
28 /*!
29 @name 行列
30 @{
31 */
32
33 /*!--------------------------------------------------------------------------*
34 @brief 射影行列に掛ける回転行列を指定するための列挙型です。
35
36 *---------------------------------------------------------------------------*/
37 enum PivotDirection
38 {
39 PIVOT_NONE, //!< 回転処理をおこないません。
40 PIVOT_UPSIDE_TO_TOP, //!< カメラ上方向が画面上方向を向くように回転します。
41 PIVOT_UPSIDE_TO_RIGHT, //!< カメラ上方向が画面右方向を向くように回転します。
42 PIVOT_UPSIDE_TO_BOTTOM, //!< カメラ上方向が画面下方向を向くように回転します。
43 PIVOT_UPSIDE_TO_LEFT, //!< カメラ上方向が画面左方向を向くように回転します。
44 PIVOT_NUM
45 };
46
47 /*!
48 @}
49 */
50
51 /* ------------------------------------------------------------------------
52 MTX44用の関数
53 ------------------------------------------------------------------------ */
54 struct MTX44;
55
56 NN_MATH_INLINE MTX44* MTX44Zero(MTX44* pOut);
57 NN_MATH_INLINE bool MTX44IsIdentity(const MTX44* p);
58 NN_MATH_INLINE MTX44* MTX44Identity(MTX44* pOut);
59 NN_MATH_INLINE MTX44* MTX44Copy(MTX44* pOut, const MTX44* p);
60
61 NN_MATH_INLINE MTX44* MTX44Add(MTX44* pOut, const MTX44* p1, const MTX44* p2);
62 NN_MATH_INLINE MTX44* MTX44Sub(MTX44* pOut, const MTX44* p1, const MTX44* p2);
63 NN_MATH_INLINE MTX44* MTX44Mult(MTX44* pOut, const MTX44* p, f32 f);
64 NN_MATH_INLINE MTX44* MTX44Mult(MTX44* pOut, const MTX44* p1, const MTX44* p2);
65
66 NN_MATH_INLINE MTX44* MTX44Frustum(MTX44* pOut, f32 l, f32 r, f32 b, f32 t, f32 n, f32 f);
67 NN_MATH_INLINE MTX44* MTX44Ortho(MTX44* pOut, f32 l, f32 r, f32 b, f32 t, f32 n, f32 f);
68 NN_MATH_INLINE MTX44* MTX44PerspectiveRad(MTX44* pOut, f32 fovy, f32 aspect, f32 n, f32 f);
69 NN_MATH_INLINE MTX44* MTX44Transpose(MTX44* pOut, const MTX44 *pSrc);
70 NN_MATH_INLINE MTX44* MTX44MultArray(MTX44* pOut, const MTX44* p1, const MTX44* pSrc, s32 count);
71 NN_MATH_INLINE u32 MTX44Inverse(MTX44* pOut, const MTX44* p);
72
73 NN_MATH_INLINE MTX44* MTX44RotXYZFIdx(MTX44* pOut, f32 fIdxX, f32 fIdxY, f32 fIdxZ);
74 NN_MATH_INLINE MTX44* MTX44RotAxisFIdx(MTX44* pOut, const VEC3* pAxis, f32 fIdx);
75
76 NN_MATH_INLINE MTX44* MTX44Scale(MTX44* pOut, const VEC3* pS);
77 NN_MATH_INLINE MTX44* MTX44MultScale(MTX44* pOut, const MTX44* pM, const VEC3* pS);
78 NN_MATH_INLINE MTX44* MTX44MultScale(MTX44* pOut, const VEC3* pS, const MTX44* pM);
79
80 NN_MATH_INLINE MTX44* MTX44Translate(MTX44* pOut, const VEC3* pT);
81 NN_MATH_INLINE MTX44* MTX44MultTranslate(MTX44* pOut, const MTX44* pM, const VEC3* pT);
82 NN_MATH_INLINE MTX44* MTX44MultTranslate(MTX44* pOut, const VEC3* pT, const MTX44* pM);
83
84 NN_MATH_INLINE MTX44* MTX44FrustumPivot(MTX44* pOut, f32 l, f32 r, f32 b, f32 t, f32 n, f32 f, PivotDirection pivot = PIVOT_NONE);
85 NN_MATH_INLINE MTX44* MTX44OrthoPivot(MTX44* pOut, f32 l, f32 r, f32 b, f32 t, f32 n, f32 f, PivotDirection pivot = PIVOT_NONE);
86 NN_MATH_INLINE MTX44* MTX44PerspectivePivotRad(MTX44* pOut, f32 fovy, f32 aspect, f32 n, f32 f, PivotDirection pivot = PIVOT_NONE);
87
88 NN_FORCE_INLINE MTX44* MTX44Add(MTX44* pOut, const MTX44* p1, const MTX44* p2);
89 NN_FORCE_INLINE MTX44* MTX44Copy(MTX44* pOut, const MTX44* p);
90 NN_FORCE_INLINE MTX44* MTX44Frustum(MTX44* pOut, f32 l, f32 r, f32 b, f32 t, f32 n, f32 f);
91 NN_FORCE_INLINE u32 MTX44Inverse(MTX44* pOut, const MTX44* p);
92 NN_FORCE_INLINE MTX44* MTX44Mult(MTX44* pOut, const MTX44* __restrict p1, const MTX44* __restrict p2);
93 NN_FORCE_INLINE MTX44* MTX44Mult(MTX44* pOut, const MTX44* p, f32 f);
94 NN_FORCE_INLINE MTX44* MTX44MultScale(MTX44* pOut, const MTX44* pM, const VEC3* pS);
95 NN_FORCE_INLINE MTX44* MTX44MultScale(MTX44* pOut, const VEC3* pS, const MTX44* pM);
96 NN_FORCE_INLINE MTX44* MTX44MultTranslate(MTX44* pOut, const VEC3* pT, const MTX44* pM);
97 NN_FORCE_INLINE MTX44* MTX44MultTranslate(MTX44* pOut, const MTX44* pM, const VEC3* pT);
98 NN_FORCE_INLINE MTX44* MTX44Ortho(MTX44* pOut, f32 l, f32 r, f32 b, f32 t, f32 n, f32 f);
99 NN_FORCE_INLINE MTX44* MTX44PerspectiveRad(MTX44* pOut, f32 fovy, f32 aspect, f32 n, f32 f);
100 NN_FORCE_INLINE MTX44* MTX44RotAxisRad_( MTX44* pOut, const VEC3 *pAxis, f32 fRad );
101 NN_FORCE_INLINE MTX44* MTX44RotXYZFIdx(MTX44* pOut, f32 fIdxX, f32 fIdxY, f32 fIdxZ);
102 NN_FORCE_INLINE MTX44* MTX44Scale(MTX44* pOut, const VEC3* pS);
103 NN_FORCE_INLINE MTX44* MTX44Translate(MTX44* pOut, const VEC3* pT);
104 NN_FORCE_INLINE MTX44* MTX44Transpose(MTX44* pOut, const MTX44 *pSrc);
105
106 NN_FORCE_INLINE VEC4* VEC3Transform(VEC4* pOut, const MTX44* pM, const VEC3* pV);
107
108 NN_FORCE_INLINE MTX44* MTX44Pivot( MTX44* pOut, PivotDirection pivot );
109
110 /*!
111 @name 行列
112 @{
113 */
114
115 /*!--------------------------------------------------------------------------*
116 @brief 射影行列を視野角とアスペクト比から作成します。
117
118 @param[out] pOut 射影行列を格納する行列へのポインタ。
119 @param[in] fovy 縦方向の視野角（Degree）
120 @param[in] aspect 視野のアスペクト比(幅/高さ)
121 @param[in] n ニアクリッピング面までの距離。
122 @param[in] f ファークリッピング面までの距離。
123
124 @return pOut を返します。
125 *---------------------------------------------------------------------------*/
126 inline MTX44*
MTX44PerspectiveDeg(MTX44 * pOut,f32 fovy,f32 aspect,f32 n,f32 f)127 MTX44PerspectiveDeg(MTX44* pOut, f32 fovy, f32 aspect, f32 n, f32 f)
128 {
129 return MTX44PerspectiveRad(pOut, NN_MATH_DEG_TO_RAD(fovy), aspect, n, f);
130 }
131
132
133 // MTX44PerspectiveDeg 関数の別名です。
134 // 互換性の為に接尾語の無い Perspective 関数を degree 版としています。
135 inline MTX44*
MTX44Perspective(MTX44 * pOut,f32 fovy,f32 aspect,f32 n,f32 f)136 MTX44Perspective(MTX44* pOut, f32 fovy, f32 aspect, f32 n, f32 f)
137 {
138 return MTX44PerspectiveDeg(pOut, fovy, aspect, n, f);
139 }
140
141 /*!--------------------------------------------------------------------------*
142 @brief 射影行列を視野角とアスペクト比から作成します。
143
144 @param[out] pOut 射影行列を格納する行列へのポインタ。
145 @param[in] fovy 縦方向の視野角（Degree）
146 @param[in] aspect 視野のアスペクト比(幅/高さ)
147 @param[in] n ニアクリッピング面までの距離。
148 @param[in] f ファークリッピング面までの距離。
149
150 @return pOut を返します。
151 *---------------------------------------------------------------------------*/
152 inline MTX44*
153 MTX44PerspectivePivotDeg(MTX44* pOut, f32 fovy, f32 aspect, f32 n, f32 f, PivotDirection pivot = PIVOT_NONE )
154 {
155 return MTX44PerspectivePivotRad(pOut, NN_MATH_DEG_TO_RAD(fovy), aspect, n, f, pivot);
156 }
157
158
159 /*!--------------------------------------------------------------------------*
160 @brief 回転行列を作成します。
161
162 @param[out] pOut 計算結果を受け取るバッファへのポインタ。
163 @param[in] fRadX ラジアン単位での X 軸周りの角度
164 @param[in] fRadY ラジアン単位での Y 軸周りの角度
165 @param[in] fRadZ ラジアン単位での Z 軸周りの角度
166
167 @return pOut を返します。
168 *---------------------------------------------------------------------------*/
169 inline MTX44*
MTX44RotXYZRad(MTX44 * pOut,f32 fRadX,f32 fRadY,f32 fRadZ)170 MTX44RotXYZRad(MTX44* pOut, f32 fRadX, f32 fRadY, f32 fRadZ)
171 {
172 return MTX44RotXYZFIdx(pOut, NN_MATH_RAD_TO_FIDX(fRadX), NN_MATH_RAD_TO_FIDX(fRadY), NN_MATH_RAD_TO_FIDX(fRadZ));
173 }
174
175 /*!--------------------------------------------------------------------------*
176 @brief 回転行列を作成します。
177
178 @param[out] pOut 計算結果を受け取るバッファへのポインタ。
179 @param[in] fDegX 1 円周を 360.0 とする単位での X 軸周りの角度
180 @param[in] fDegY 1 円周を 360.0 とする単位での Y 軸周りの角度
181 @param[in] fDegZ 1 円周を 360.0 とする単位での Z 軸周りの角度
182
183 @return pOut を返します。
184 *---------------------------------------------------------------------------*/
185 inline MTX44*
MTX44RotXYZDeg(MTX44 * pOut,f32 fDegX,f32 fDegY,f32 fDegZ)186 MTX44RotXYZDeg(MTX44* pOut, f32 fDegX, f32 fDegY, f32 fDegZ)
187 {
188 return MTX44RotXYZFIdx(pOut, NN_MATH_DEG_TO_FIDX(fDegX), NN_MATH_DEG_TO_FIDX(fDegY), NN_MATH_DEG_TO_FIDX(fDegZ));
189 }
190
191 /*!--------------------------------------------------------------------------*
192 @brief 指定する軸の周りを回転させる回転行列を作成します。
193
194 @param[out] pOut 計算結果を受け取るバッファへのポインタ。
195 @param[in] pAxis 回転軸を指定するベクトルへのポインタ。
196 @param[in] fRad ラジアン単位での回転量
197
198 @return pOut を返します。
199 *---------------------------------------------------------------------------*/
200 inline MTX44*
MTX44RotAxisRad(MTX44 * pOut,const VEC3 * pAxis,f32 fRad)201 MTX44RotAxisRad(MTX44* pOut, const VEC3* pAxis, f32 fRad)
202 {
203 return MTX44RotAxisFIdx(pOut, pAxis, NN_MATH_RAD_TO_FIDX(fRad));
204 }
205
206 /*!--------------------------------------------------------------------------*
207 @brief 指定する軸の周りを回転させる回転行列を作成します。
208
209 @param[out] pOut 計算結果を受け取るバッファへのポインタ。
210 @param[in] pAxis 回転軸を指定するベクトルへのポインタ。
211 @param[in] fDeg 1 円周を 360.0 とする単位での回転量
212
213 @return pOut を返します。
214 *---------------------------------------------------------------------------*/
215 inline MTX44*
MTX44RotAxisDeg(MTX44 * pOut,const VEC3 * pAxis,f32 fDeg)216 MTX44RotAxisDeg(MTX44* pOut, const VEC3* pAxis, f32 fDeg)
217 {
218 return MTX44RotAxisFIdx(pOut, pAxis, NN_MATH_DEG_TO_FIDX(fDeg));
219 }
220
221 /* =======================================================================
222 クラスの定義
223 ======================================================================== */
224 struct MTX34;
225
226 struct MTX44_
227 {
228 struct BaseData
229 {
230 f32 _00, _01, _02, _03;
231 f32 _10, _11, _12, _13;
232 f32 _20, _21, _22, _23;
233 f32 _30, _31, _32, _33;
234 };
235
236 union
237 {
238 #if defined(NN_MATH_USE_ANONYMOUS_STRUCT)
239 struct
240 {
241 f32 _00, _01, _02, _03;
242 f32 _10, _11, _12, _13;
243 f32 _20, _21, _22, _23;
244 f32 _30, _31, _32, _33;
245 };
246 #endif
247 BaseData f;
248 f32 m[4][4];
249 f32 a[16];
250 VEC4_ v[4];
251 };
252 };
253
254 /*!--------------------------------------------------------------------------*
255 @brief ４行４列の行列クラスです。
256 *---------------------------------------------------------------------------*/
257 struct MTX44 : public MTX44_
258 {
259 public:
260 static const int ROW_COUNT = 4; //!< 行数です。
261 static const int COLUMN_COUNT = 4; //!< 列数です。
262
263 //! @brief 単位行列です。
IdentityMTX44264 static const MTX44& Identity()
265 {
266 static const MTX44 identity(
267 1.0f, 0.0f, 0.0f, 0.0f,
268 0.0f, 1.0f, 0.0f, 0.0f,
269 0.0f, 0.0f, 1.0f, 0.0f,
270 0.0f, 0.0f, 0.0f, 1.0f);
271
272 return identity;
273 }
274 typedef MTX44 self_type; //!< 自分の型です。
275 typedef f32 value_type; //!< 要素の型です。
276
277 public:
278 //----------------------------------------
279 //! @name 作成
280 //@{
281
282 //! @brief コンストラクタです。
MTX44MTX44283 MTX44() {}
284
285 //! @brief コンストラクタです。
MTX44MTX44286 MTX44(const f32* p) { (void)MTX44Copy(this, (MTX44*)p); }
287
288 //! @brief コンストラクタです。
MTX44MTX44289 MTX44(const MTX34& rhs)
290 {
291 (void)MTX34Copy((MTX34*)this, (MTX34*)&rhs);
292 f._30 = f._31 = f._32 = 0.f; f._33 = 1.f;
293 }
294
295 //! @brief コピーコンストラクタです。
MTX44MTX44296 MTX44(const MTX44& rhs) { (void)MTX44Copy(this, &rhs); }
297
298 //! @brief コンストラクタです。
MTX44MTX44299 MTX44(f32 x00, f32 x01, f32 x02, f32 x03,
300 f32 x10, f32 x11, f32 x12, f32 x13,
301 f32 x20, f32 x21, f32 x22, f32 x23,
302 f32 x30, f32 x31, f32 x32, f32 x33)
303 {
304 f._00 = x00; f._01 = x01; f._02 = x02; f._03 = x03;
305 f._10 = x10; f._11 = x11; f._12 = x12; f._13 = x13;
306 f._20 = x20; f._21 = x21; f._22 = x22; f._23 = x23;
307 f._30 = x30; f._31 = x31; f._32 = x32; f._33 = x33;
308 }
309
310 //@}
311
312 //----------------------------------------
313 //! @name 変換
314 //@{
315
316 //! @brief f32 型へのキャストです。
317 operator f32*() { return this->a; }
318
319 //! @brief f32 型へのキャストです。
320 operator const f32*() const { return this->a; }
321
322 //! @brief VEC4 型として行を取得します。
GetRowMTX44323 VEC4& GetRow(int index)
324 {
325 NN_MATH_MINMAXLT_ASSERT(index, 0, ROW_COUNT);
326 return *reinterpret_cast<VEC4*>(&this->v[index]);
327 }
328
329 //! @brief VEC4 型として行を取得します。
GetRowMTX44330 const VEC4& GetRow(int index) const
331 {
332 NN_MATH_MINMAXLT_ASSERT(index, 0, ROW_COUNT);
333 return *reinterpret_cast<const VEC4*>(&this->v[index]);
334 }
335
336 //! @brief VEC4 型として列を取得します。
GetColumnMTX44337 VEC4 GetColumn(int index) const
338 {
339 NN_MATH_MINMAXLT_ASSERT(index, 0, COLUMN_COUNT);
340 VEC4 column;
341 column.x = this->m[0][index];
342 column.y = this->m[1][index];
343 column.z = this->m[2][index];
344 column.w = this->m[3][index];
345 return column;
346 }
347
348 //! @brief VEC4 型で列を設定します。
SetColumnMTX44349 void SetColumn(int index, const VEC4& column)
350 {
351 NN_MATH_MINMAXLT_ASSERT(index, 0, COLUMN_COUNT);
352 this->m[0][index] = column.x;
353 this->m[1][index] = column.y;
354 this->m[2][index] = column.z;
355 this->m[3][index] = column.w;
356 }
357 //@}
358
359 //----------------------------------------
360 //! @name 演算
361 //@{
362
363 //! @brief 行列を右からかけた値を代入します。
364 self_type& operator *= (const self_type& rhs) { return *MTX44Mult(this, this, &rhs); }
365
366 self_type& operator += (const self_type& rhs) { return *MTX44Add(this, this, &rhs); }
367 self_type& operator -= (const self_type& rhs) { return *MTX44Sub(this, this, &rhs); }
368
369 self_type& operator *= (f32 f) { return *MTX44Mult(this, this, f); }
370 self_type& operator /= (f32 f) { return operator*=(1.f / f); }
371
372 self_type operator + () const { return *this; }
373 self_type operator - () const
374 {
375 return MTX44(-f._00, -f._01, -f._02, -f._03,
376 -f._10, -f._11, -f._12, -f._13,
377 -f._20, -f._21, -f._22, -f._23,
378 -f._30, -f._31, -f._32, -f._33);
379 }
380
381 self_type operator + (const self_type& rhs) const { MTX44 tmp; return *MTX44Add(&tmp, this, &rhs); }
382 self_type operator - (const self_type& rhs) const { MTX44 tmp; return *MTX44Sub(&tmp, this, &rhs); }
383
384 self_type operator * (f32 f) const { MTX44 tmp; return *MTX44Mult(&tmp, this, f); }
385 self_type operator / (f32 f) const { return *this * (1.f / f); }
386
387 //! 転置を行います。
TransposeMTX44388 self_type& Transpose() { return *MTX44Transpose(this, this); }
389 //@}
390
391 //----------------------------------------
392 //! @name 設定
393 //@{
394
395 //! @brief 単位行列に設定します。
SetupIdentityMTX44396 self_type& SetupIdentity() { return *MTX44Identity(this); }
397
398 //! @brief スケール変換行列に設定します。
399 //!
400 //! @param[in] scale スケール値です。
401 //!
SetupScaleMTX44402 self_type& SetupScale(const VEC3& scale) { return *MTX44Scale(this, &scale); }
403
404 //! @brief 平行移動行列に設定します。
405 //!
406 //! @param[in] translate 平行移動値です。
407 //!
SetupTranslateMTX44408 self_type& SetupTranslate(const VEC3& translate)
409 {
410 return *MTX44Translate(this, &translate);
411 }
412
413 //! @brief XYZ 順の回転行列に設定します。
414 //!
415 //! @param[in] rotateRad 回転値です。単位はラジアンです。
416 //!
SetupRotateXyzMTX44417 self_type& SetupRotateXyz(const VEC3& rotateRad)
418 {
419 return *MTX44RotXYZRad(this, rotateRad.x, rotateRad.y, rotateRad.z);
420 }
421
422 //! @brief 指定した軸周りの回転行列に設定します。
423 //!
424 //! @param[in] axis 基準となる軸のベクトルです。
425 //! @param[in] theta 回転させる角度です。単位はラジアンです。
426 //!
SetupRotateMTX44427 self_type& SetupRotate(const VEC3& axis, f32 thetaRad)
428 {
429 return *MTX44RotAxisRad(this, &axis, thetaRad);
430 }
431
432 //! @brief 射影行列をニアクリッピング面での視錐台を元に設定します。
433 //! 引数の順序が OpenGL 準拠になっているので注意してください。
434 //!
435 //! @param[in] l ニアクリッピング面での視錐台左辺の X 座標です。
436 //! @param[in] r ニアクリッピング面での視錐台右辺の X 座標です。
437 //! @param[in] b ニアクリッピング面での視錐台下辺の Y 座標です。
438 //! @param[in] t ニアクリッピング面での視錐台上辺の Y 座標です。
439 //! @param[in] n ニアクリッピング面までの距離です。
440 //! @param[in] f ファークリッピング面までの距離です。
441 //! @param[in] pivot 画面の回転方向です。
442 //!
443 self_type& SetupFrustum(f32 l, f32 r, f32 b, f32 t, f32 n, f32 f, PivotDirection pivot = PIVOT_NONE)
444 {
445 return *MTX44FrustumPivot(this, l, r, b, t, n, f, pivot);
446 }
447
448 //! @brief 正射影行列を設定します。
449 //! 引数の順序が OpenGL 準拠になっているので注意してください。
450 //!
451 //! @param[in] l ニアクリッピング面での視錐台左辺の X 座標です。
452 //! @param[in] r ニアクリッピング面での視錐台右辺の X 座標です。
453 //! @param[in] b ニアクリッピング面での視錐台下辺の Y 座標です。
454 //! @param[in] t ニアクリッピング面での視錐台上辺の Y 座標です。
455 //! @param[in] n ニアクリッピング面までの距離です。
456 //! @param[in] f ファークリッピング面までの距離です。
457 //! @param[in] pivot 画面の回転方向です。
458 //!
459 self_type& SetupOrtho(f32 l, f32 r, f32 b, f32 t, f32 n, f32 f, PivotDirection pivot = PIVOT_NONE)
460 {
461 return *MTX44OrthoPivot(this, l, r, b, t, n, f, pivot);
462 }
463
464 //! @brief 射影行列を視野角とアスペクト比から設定します。
465 //!
466 //! @param[in] fovyRad 縦方向の視野角（Radian）です。
467 //! @param[in] aspect 視野のアスペクト比(幅/高さ)です。
468 //! @param[in] n ニアクリッピング面までの距離です。
469 //! @param[in] f ファークリッピング面までの距離です。
470 //! @param[in] pivot 画面の回転方向です。
471 //!
472 self_type& SetupPerspective(f32 fovyRad, f32 aspect, f32 n, f32 f, PivotDirection pivot = PIVOT_NONE)
473 {
474 return *MTX44PerspectivePivotRad(this, fovyRad, aspect, n, f, pivot);
475 }
476
477 //@}
478
479 //----------------------------------------
480 //! @name 比較
481 //@{
482
483 //! @brief 同値であれば true を返します。
484 bool operator == (const self_type& rhs) const { return ::std::memcmp(this, &rhs, sizeof(MTX44)) == 0; }
485
486 //! @brief 同値でなければ true を返します。
487 bool operator != (const self_type& rhs) const { return ::std::memcmp(this, &rhs, sizeof(MTX44)) != 0; }
488
489 //! @brief 単位行列であれば true を返します。
IsIdentityMTX44490 bool IsIdentity() const { return MTX44IsIdentity(this); }
491 //@}
492
493 //! @brief 状態を出力します。
494 void Report(bool bNewline = true, const char* name = NULL) const;
495 };
496
497 typedef struct MTX44 Matrix44;
498
499 /*!
500 @}
501 */
502
503 } // namespace math
504 } // namespace nn
505
506 #include <nn/math/ARMv6/math_Matrix44.h>
507
508 namespace nn {
509 namespace math {
510
511 /*!
512 @name 行列
513 @{
514 */
515
516 /*!--------------------------------------------------------------------------*
517 @brief 行列の和を計算します。
518
519 @param[out] pOut 計算結果を受け取るバッファへのポインタ。p1, p2 と同じ行列を指していても構いません。
520 @param[in] p1 左辺値へのポインタ。
521 @param[in] p2 右辺値へのポインタ。
522
523 @return pOut を返します。
524 *---------------------------------------------------------------------------*/
525 NN_FORCE_INLINE MTX44*
MTX44Add(MTX44 * pOut,const MTX44 * p1,const MTX44 * p2)526 MTX44Add(MTX44* pOut, const MTX44* p1, const MTX44* p2)
527 {
528
529 #if defined( NN_HARDWARE_CTR )
530 #if (MTX44ADD_ASM_CONFIG == D_ORG)
531 return ARMv6::MTX44AddC(pOut, p1, p2);
532 #elif (MTX44ADD_ASM_CONFIG == D_FAST_C)
533 #elif (MTX44ADD_ASM_CONFIG == D_FAST_ASM)
534 return ARMv6::MTX44AddAsm(pOut, p1, p2);
535 #elif (MTX44ADD_ASM_CONFIG == D_FAST_C_ALGO)
536 #elif (MTX44ADD_ASM_CONFIG == D_FAST_ASM_ALGO)
537 #endif
538 #else
539 #endif // #if defined( NN_HARDWARE_CTR )
540 }
541
542
543 /*!--------------------------------------------------------------------------*
544 @brief 行列をコピーします。
545
546 @param[out] pOut コピー先の行列へのポインタ。
547 @param[in] p コピー元の行列へのポインタ
548
549 @return pOut を返します。
550 *---------------------------------------------------------------------------*/
551 NN_FORCE_INLINE MTX44*
MTX44Copy(MTX44 * pOut,const MTX44 * p)552 MTX44Copy(MTX44* pOut, const MTX44* p)
553 {
554 #if defined( NN_HARDWARE_CTR )
555 #if (MTX44COPY_CONFIG == D_ORG)
556 return ARMv6::MTX44CopyC(pOut, p);
557 #elif (MTX44COPY_CONFIG == D_FAST_C)
558 #elif (MTX44COPY_CONFIG == D_FAST_ASM)
559 return ARMv6::MTX44CopyAsm(pOut, p);
560 #elif (MTX44COPY_CONFIG == D_FAST_C_ALGO)
561 #elif (MTX44COPY_CONFIG == D_FAST_ASM_ALGO)
562 #endif
563 #else
564 #endif // #if defined( NN_HARDWARE_CTR )
565 }
566
567 /*!--------------------------------------------------------------------------*
568 @brief 射影行列をニアクリッピング面での視錐台を元に作成します。
569 引数の順序が OpenGL 準拠になっているので注意。
570
571 @param[out] pOut 射影行列を格納する行列へのポインタ。
572 @param[in] l ニアクリッピング面での視錐台左辺の X 座標
573 @param[in] r ニアクリッピング面での視錐台右辺の X 座標
574 @param[in] b ニアクリッピング面での視錐台下辺の Y 座標
575 @param[in] t ニアクリッピング面での視錐台上辺の Y 座標
576 @param[in] n ニアクリッピング面までの距離。
577 @param[in] f ファークリッピング面までの距離。
578
579 @return pOut を返します。
580 *---------------------------------------------------------------------------*/
581 NN_FORCE_INLINE MTX44*
MTX44Frustum(MTX44 * pOut,f32 l,f32 r,f32 b,f32 t,f32 n,f32 f)582 MTX44Frustum(MTX44* pOut, f32 l, f32 r, f32 b, f32 t, f32 n, f32 f)
583 {
584 #if defined( NN_HARDWARE_CTR )
585 #if (MTX44FRUSTUM_CONFIG == D_ORG)
586 return ARMv6::MTX44FrustumC(pOut, l, r, b, t, n, f);
587 #elif (MTX44FRUSTUM_CONFIG == D_FAST_C)
588 return ARMv6::MTX44FrustumC_FAST(pOut, l, r, b, t, n, f);
589 #elif (MTX44FRUSTUM_CONFIG == D_FAST_ASM)
590 #elif (MTX44FRUSTUM_CONFIG == D_FAST_C_ALGO)
591 #elif (MTX44FRUSTUM_CONFIG == D_FAST_ASM_ALGO)
592 #endif
593 #else
594 #endif // #if defined( NN_HARDWARE_CTR )
595 }
596
597 /*!--------------------------------------------------------------------------*
598 @brief 行列の逆行列を計算します。
599
600 @param[out] pOut 計算結果を受け取るバッファへのポインタ。p と同じ行列を指していても構いません。
601 @param[in] p 元となる行列へのポインタ。
602
603 @return 逆行列が存在すれば 1 を、存在しなければ 0 を返します。
604 *---------------------------------------------------------------------------*/
605 NN_FORCE_INLINE u32
MTX44Inverse(MTX44 * pOut,const MTX44 * p)606 MTX44Inverse(MTX44* pOut, const MTX44* p)
607 {
608 #if defined( NN_HARDWARE_CTR )
609 #if (MTX44INVERSE_CONFIG == D_ORG)
610 return ARMv6::MTX44InverseC(pOut, p);
611 #elif (MTX44INVERSE_CONFIG == D_FAST_C)
612 #elif (MTX44INVERSE_CONFIG == D_FAST_ASM)
613 #elif (MTX44INVERSE_CONFIG == D_FAST_C_ALGO)
614 return ARMv6::MTX44InverseC_FAST_ALGO(pOut, p);
615 #elif (MTX44INVERSE_CONFIG == D_FAST_ASM_ALGO)
616 #endif
617 #else
618 #endif // #if defined( NN_HARDWARE_CTR )
619 }
620
621 /*!--------------------------------------------------------------------------*
622 @brief 行列の積を計算します。
623
624 @param[out] pOut 計算結果を受け取るバッファへのポインタ。p1, p2 と同じ行列を指していても構いません。
625 @param[in] p1 左辺値へのポインタ。
626 @param[in] p2 右辺値へのポインタ。
627
628 @return pOut を返します。
629 *---------------------------------------------------------------------------*/
630 NN_FORCE_INLINE MTX44*
MTX44Mult(MTX44 * pOut,const MTX44 * __restrict p1,const MTX44 * __restrict p2)631 MTX44Mult(MTX44* pOut, const MTX44* __restrict p1, const MTX44* __restrict p2)
632 {
633 #if defined( NN_HARDWARE_CTR )
634 #if (MTX44MULT_44_CONFIG == D_ORG)
635 return ARMv6::MTX44MultC(pOut, p1, p2);
636 #elif (MTX44MULT_44_CONFIG == D_FAST_C)
637 #elif (MTX44MULT_44_CONFIG == D_FAST_ASM)
638 return ARMv6::MTX44MultAsm(pOut, p1, p2);
639 #elif (MTX44MULT_44_CONFIG == D_FAST_C_ALGO)
640 #elif (MTX44MULT_44_CONFIG == D_FAST_ASM_ALGO)
641 #endif
642 #else
643 #endif // #if defined( NN_HARDWARE_CTR )
644 }
645
646 /*!--------------------------------------------------------------------------*
647 @brief 行列のスカラー積を計算します。
648
649 @param[out] pOut 計算結果を受け取るバッファへのポインタ。p と同じ行列を指していても構いません。
650 @param[in] p 元の行列のポインタ。
651 @param[in] f 掛ける数
652
653 @return pOut を返します。
654 *---------------------------------------------------------------------------*/
655 NN_FORCE_INLINE MTX44*
MTX44Mult(MTX44 * pOut,const MTX44 * p,f32 f)656 MTX44Mult(MTX44* pOut, const MTX44* p, f32 f)
657 {
658 #if defined( NN_HARDWARE_CTR )
659 #if (MTX44MULT_F32_CONFIG == D_ORG)
660 return ARMv6::MTX44MultC(pOut, p, f);
661 #elif (MTX44MULT_F32_CONFIG == D_FAST_C)
662 #elif (MTX44MULT_F32_CONFIG == D_FAST_ASM)
663 return ARMv6::MTX44MultAsm(pOut, p, f);
664 #elif (MTX44MULT_F32_CONFIG == D_FAST_C_ALGO)
665 #elif (MTX44MULT_F32_CONFIG == D_FAST_ASM_ALGO)
666 #endif
667 #else
668 #endif // #if defined( NN_HARDWARE_CTR )
669
670 }
671 /*!--------------------------------------------------------------------------*
672 @brief 行列にスケール変換を適用します。スケール行列を右から掛けます。
673
674 @param[out] pOut 計算結果を受け取るバッファへのポインタ。pM と同じ行列を指していても構いません。
675 @param[in] pM 元となる行列へのポインタ。
676 @param[in] pS それぞれの軸方向のスケール値が格納されたベクトルへのポインタ。
677
678 @return pOut を返します。
679 *---------------------------------------------------------------------------*/
680 NN_FORCE_INLINE MTX44*
MTX44MultScale(MTX44 * pOut,const MTX44 * pM,const VEC3 * pS)681 MTX44MultScale(MTX44* pOut, const MTX44* pM, const VEC3* pS)
682 {
683 #if defined( NN_HARDWARE_CTR )
684 #if (MTX44MULTSCALE_RIGHT_CONFIG == D_ORG)
685 return ARMv6::MTX44MultScaleC(pOut, pM, pS);
686 #elif (MTX44MULTSCALE_RIGHT_CONFIG == D_FAST_C)
687 #elif (MTX44MULTSCALE_RIGHT_CONFIG == D_FAST_ASM)
688 return ARMv6::MTX44MultScaleAsm(pOut, pM, pS);
689 #elif (MTX44MULTSCALE_RIGHT_CONFIG == D_FAST_C_ALGO)
690 #elif (MTX44MULTSCALE_RIGHT_CONFIG == D_FAST_ASM_ALGO)
691 #endif
692 #else
693 #endif // #if defined( NN_HARDWARE_CTR )
694 }
695
696
697 /*!--------------------------------------------------------------------------*
698 @brief 行列にスケール変換を適用します。スケール行列を左から掛けます。
699
700 @param[out] pOut 計算結果を受け取るバッファへのポインタ。pM と同じ行列を指していても構いません。
701 @param[in] pS それぞれの軸方向のスケール値が格納されたベクトルへのポインタ。
702 @param[in] pM 元となる行列へのポインタ。
703
704 @return pOut を返します。
705 *---------------------------------------------------------------------------*/
706 NN_FORCE_INLINE MTX44*
MTX44MultScale(MTX44 * pOut,const VEC3 * pS,const MTX44 * pM)707 MTX44MultScale(MTX44* pOut, const VEC3* pS, const MTX44* pM)
708 {
709 #if defined( NN_HARDWARE_CTR )
710 #if (MTX44MULTSCALE_LEFT_CONFIG == D_ORG)
711 return ARMv6::MTX44MultScaleC(pOut, pS, pM);
712 #elif (MTX44MULTSCALE_LEFT_CONFIG == D_FAST_C)
713 #elif (MTX44MULTSCALE_LEFT_CONFIG == D_FAST_ASM)
714 return ARMv6::MTX44MultScaleAsm(pOut, pS, pM);
715 #elif (MTX44MULTSCALE_LEFT_CONFIG == D_FAST_C_ALGO)
716 #elif (MTX44MULTSCALE_LEFT_CONFIG == D_FAST_ASM_ALGO)
717 #endif
718 #else
719 #endif // #if defined( NN_HARDWARE_CTR )
720 }
721
722 /*!--------------------------------------------------------------------------*
723 @brief 行列に平行移動を適用します。移動行列を左から掛けます。
724
725 @param[out] pOut 計算結果を受け取るバッファへのポインタ。pM と同じ行列を指していても構いません。
726 @param[in] pT それぞれの軸方向の移動量が格納されたベクトルへのポインタ。
727 @param[in] pM 元となる行列へのポインタ。
728
729 @return pOut を返します。
730 *---------------------------------------------------------------------------*/
731 NN_FORCE_INLINE MTX44*
MTX44MultTranslate(MTX44 * pOut,const VEC3 * pT,const MTX44 * pM)732 MTX44MultTranslate(MTX44* pOut, const VEC3* pT, const MTX44* pM)
733 {
734 #if defined( NN_HARDWARE_CTR )
735 #if (MTX44MULTTRANSLATE_LEFT_CONFIG == D_ORG)
736 return ARMv6::MTX44MultTranslateC(pOut, pT, pM);
737 #elif (MTX44MULTTRANSLATE_LEFT_CONFIG == D_FAST_C)
738 #elif (MTX44MULTTRANSLATE_LEFT_CONFIG == D_FAST_ASM)
739 return ARMv6::MTX44MultTranslateAsm(pOut, pT, pM);
740 #elif (MTX44MULTTRANSLATE_LEFT_CONFIG == D_FAST_C_ALGO)
741 #elif (MTX44MULTTRANSLATE_LEFT_CONFIG == D_FAST_ASM_ALGO)
742 #endif
743 #else
744 #endif // #if defined( NN_HARDWARE_CTR )
745 }
746
747 /*!--------------------------------------------------------------------------*
748 @brief 行列に平行移動を適用します。移動行列を右から掛けます。
749
750 @param[out] pOut 計算結果を受け取るバッファへのポインタ。pM と同じ行列を指していても構いません。
751 @param[in] pM 元となる行列へのポインタ。
752 @param[in] pT それぞれの軸方向の移動量が格納されたベクトルへのポインタ。
753
754 @return pOut を返します。
755 *---------------------------------------------------------------------------*/
756 NN_FORCE_INLINE MTX44*
MTX44MultTranslate(MTX44 * pOut,const MTX44 * pM,const VEC3 * pT)757 MTX44MultTranslate(MTX44* pOut, const MTX44* pM, const VEC3* pT)
758 {
759 #if defined( NN_HARDWARE_CTR )
760 #if (MTX44MULTTRANSLATE_RIGHT_CONFIG == D_ORG)
761 return ARMv6::MTX44MultTranslateC(pOut, pM, pT);
762 #elif (MTX44MULTTRANSLATE_RIGHT_CONFIG == D_FAST_C)
763 #elif (MTX44MULTTRANSLATE_RIGHT_CONFIG == D_FAST_ASM)
764 return ARMv6::MTX44MultTranslateAsm(pOut, pM, pT);
765 #elif (MTX44MULTTRANSLATE_RIGHT_CONFIG == D_FAST_C_ALGO)
766 #elif (MTX44MULTTRANSLATE_RIGHT_CONFIG == D_FAST_ASM_ALGO)
767 #endif
768 #else
769 #endif // #if defined( NN_HARDWARE_CTR )
770 }
771 /*!--------------------------------------------------------------------------*
772 @brief 正射影行列を作成します。
773 引数の順序が OpenGL 準拠になっているので注意。
774
775 @param[out] pOut 射影行列を格納する行列へのポインタ。
776 @param[in] l ニアクリッピング面での視錐台左辺の X 座標
777 @param[in] r ニアクリッピング面での視錐台右辺の X 座標
778 @param[in] b ニアクリッピング面での視錐台下辺の Y 座標
779 @param[in] t ニアクリッピング面での視錐台上辺の Y 座標
780 @param[in] n ニアクリッピング面までの距離。
781 @param[in] f ファークリッピング面までの距離。
782
783 @return pOut を返します。
784 *---------------------------------------------------------------------------*/
785 NN_FORCE_INLINE MTX44*
MTX44Ortho(MTX44 * pOut,f32 l,f32 r,f32 b,f32 t,f32 n,f32 f)786 MTX44Ortho(MTX44* pOut, f32 l, f32 r, f32 b, f32 t, f32 n, f32 f)
787 {
788 #if defined( NN_HARDWARE_CTR )
789 #if (MTX44ORTHO_CONFIG == D_ORG)
790 return ARMv6::MTX44OrthoC(pOut, l, r, b, t, n, f);
791 #elif (MTX44ORTHO_CONFIG == D_FAST_C)
792 return ARMv6::MTX44OrthoC_FAST(pOut, l, r, b, t, n, f);
793 #elif (MTX44ORTHO_CONFIG == D_FAST_ASM)
794 #elif (MTX44ORTHO_CONFIG == D_FAST_C_ALGO)
795 #elif (MTX44ORTHO_CONFIG == D_FAST_ASM_ALGO)
796 #endif
797 #else
798 #endif // #if defined( NN_HARDWARE_CTR )
799 }
800
801 /*!--------------------------------------------------------------------------*
802 @brief 射影行列を視野角とアスペクト比から作成します。
803
804 @param[out] pOut 射影行列を格納する行列へのポインタ。
805 @param[in] fovy 縦方向の視野角（Radian）
806 @param[in] aspect 視野のアスペクト比(幅/高さ)
807 @param[in] n ニアクリッピング面までの距離。
808 @param[in] f ファークリッピング面までの距離。
809
810 @return pOut を返します。
811 *---------------------------------------------------------------------------*/
812 NN_FORCE_INLINE MTX44*
MTX44PerspectiveRad(MTX44 * pOut,f32 fovy,f32 aspect,f32 n,f32 f)813 MTX44PerspectiveRad(MTX44* pOut, f32 fovy, f32 aspect, f32 n, f32 f)
814 {
815 #if defined( NN_HARDWARE_CTR )
816 #if (MTX44PERSPECTIVERAD_CONFIG == D_ORG)
817 return ARMv6::MTX44PerspectiveRadC(pOut, fovy, aspect, n, f);
818 #elif (MTX44PERSPECTIVERAD_CONFIG == D_FAST_C)
819 return ARMv6::MTX44PerspectiveRadC_FAST(pOut, fovy, aspect, n, f);
820 #elif (MTX44PERSPECTIVERAD_CONFIG == D_FAST_ASM)
821 #elif (MTX44PERSPECTIVERAD_CONFIG == D_FAST_C_ALGO)
822 return ARMv6::MTX44PerspectiveRadC_FAST(pOut, fovy, aspect, n, f);
823 #elif (MTX44PERSPECTIVERAD_CONFIG == D_FAST_ASM_ALGO)
824 #endif
825 #else
826 #endif // #if defined( NN_HARDWARE_CTR )
827 }
828
829 /*!--------------------------------------------------------------------------*
830 @brief 指定する軸の周りを回転させる回転行列を作成します。
831
832 @param[out] pOut 計算結果を受け取るバッファへのポインタ。
833 @param[in] pAxis 回転軸を指定するベクトルへのポインタ。
834 @param[in] fRad ラジアン単位での回転量
835
836 @return pOut を返します。
837 *---------------------------------------------------------------------------*/
838 NN_FORCE_INLINE MTX44*
MTX44RotAxisRad_(MTX44 * pOut,const VEC3 * pAxis,f32 fRad)839 MTX44RotAxisRad_( MTX44* pOut, const VEC3 *pAxis, f32 fRad )
840 {
841 #if defined( NN_HARDWARE_CTR )
842 #if (MTX44ROTAXISRAD__CONFIG == D_ORG)
843 return ARMv6::MTX44RotAxisRad_C(pOut, pAxis, fRad);
844 #elif (MTX44ROTAXISRAD__CONFIG == D_FAST_C)
845 return ARMv6::MTX44RotAxisRad_C_FAST(pOut, pAxis, fRad);
846 #elif (MTX44ROTAXISRAD__CONFIG == D_FAST_ASM)
847 #elif (MTX44ROTAXISRAD__CONFIG == D_FAST_C_ALGO)
848 return ARMv6::MTX44RotAxisRad_C_FAST(pOut, pAxis, fRad);
849 #elif (MTX44ROTAXISRAD__CONFIG == D_FAST_ASM_ALGO)
850 #endif
851 #else
852 #endif // #if defined( NN_HARDWARE_CTR )
853 }
854
855 /*!--------------------------------------------------------------------------*
856 @brief 回転行列を作成します。
857
858 @param[out] pOut 計算結果を受け取るバッファへのポインタ。
859 @param[in] fIdxX 1 円周を 256.0 とする単位での X 軸周りの角度
860 @param[in] fIdxY 1 円周を 256.0 とする単位での Y 軸周りの角度
861 @param[in] fIdxZ 1 円周を 256.0 とする単位での Z 軸周りの角度
862
863 @return pOut を返します。
864 *---------------------------------------------------------------------------*/
865 NN_FORCE_INLINE MTX44*
MTX44RotXYZFIdx(MTX44 * pOut,f32 fIdxX,f32 fIdxY,f32 fIdxZ)866 MTX44RotXYZFIdx(MTX44* pOut, f32 fIdxX, f32 fIdxY, f32 fIdxZ)
867 {
868 #if defined( NN_HARDWARE_CTR )
869 #if (MTX44ROTXYZFIDX_CONFIG == D_ORG)
870 return ARMv6::MTX44RotXYZFIdxC(pOut, fIdxX, fIdxY, fIdxZ);
871 #elif (MTX44ROTXYZFIDX_CONFIG == D_FAST_C)
872 return ARMv6::MTX44RotXYZFIdxC_FAST(pOut, fIdxX, fIdxY, fIdxZ);
873 #elif (MTX44ROTXYZFIDX_CONFIG == D_FAST_ASM)
874 #elif (MTX44ROTXYZFIDX_CONFIG == D_FAST_C_ALGO)
875 #elif (MTX44ROTXYZFIDX_CONFIG == D_FAST_ASM_ALGO)
876 #endif
877 #else
878 #endif // #if defined( NN_HARDWARE_CTR )
879 }
880
881 /*!--------------------------------------------------------------------------*
882 @brief スケール変換用の行列を作成します。
883
884 @param[out] pOut 計算結果を受け取るバッファへのポインタ。pM と同じ行列を指していても構いません。
885 @param[in] pS それぞれの軸方向のスケール値が格納されたベクトルへのポインタ。
886
887 @return pOut を返します。
888 *---------------------------------------------------------------------------*/
889 NN_FORCE_INLINE MTX44*
MTX44Scale(MTX44 * pOut,const VEC3 * pS)890 MTX44Scale(MTX44* pOut, const VEC3* pS)
891 {
892 #if defined( NN_HARDWARE_CTR )
893 #if (MTX44SCALE_CONFIG == D_ORG)
894 return ARMv6::MTX44ScaleC(pOut, pS);
895 #elif (MTX44SCALE_CONFIG == D_FAST_C)
896 return ARMv6::MTX44ScaleC_FAST(pOut, pS);
897 #elif (MTX44SCALE_CONFIG == D_FAST_ASM)
898 #elif (MTX44SCALE_CONFIG == D_FAST_C_ALGO)
899 #elif (MTX44SCALE_CONFIG == D_FAST_ASM_ALGO)
900 #endif
901 #else
902 #endif // #if defined( NN_HARDWARE_CTR )
903 }
904 /*!--------------------------------------------------------------------------*
905 @brief 平行移動用の行列を作成します。
906
907 @param[out] pOut 計算結果を受け取るバッファへのポインタ。pM と同じ行列を指していても構いません。
908 @param[in] pT それぞれの軸方向の移動量が格納されたベクトルへのポインタ。
909
910 @return pOut を返します。
911 *---------------------------------------------------------------------------*/
912 NN_FORCE_INLINE MTX44*
MTX44Translate(MTX44 * pOut,const VEC3 * pT)913 MTX44Translate(MTX44* pOut, const VEC3* pT)
914 {
915 #if defined( NN_HARDWARE_CTR )
916 #if (MTX44TRANSLATE_CONFIG == D_ORG)
917 return ARMv6::MTX44TranslateC(pOut, pT);
918 #elif (MTX44TRANSLATE_CONFIG == D_FAST_C)
919 return ARMv6::MTX44TranslateC_FAST(pOut, pT);
920 #elif (MTX44TRANSLATE_CONFIG == D_FAST_ASM)
921 #elif (MTX44TRANSLATE_CONFIG == D_FAST_C_ALGO)
922 #elif (MTX44TRANSLATE_CONFIG == D_FAST_ASM_ALGO)
923 #endif
924 #else
925 #endif // #if defined( NN_HARDWARE_CTR )
926
927 }
928 /*!--------------------------------------------------------------------------*
929 @brief 行列の転置を取得します。
930
931 @param[in] pOut 計算結果を受け取るバッファへのポインタ。pSrcと同じ行列を指していても構いません。
932 @param[in] pSrc 元となる行列へのポインタ。
933
934 @return pOut を返します。
935 *---------------------------------------------------------------------------*/
936 NN_FORCE_INLINE MTX44*
MTX44Transpose(MTX44 * pOut,const MTX44 * pSrc)937 MTX44Transpose(MTX44* pOut, const MTX44 *pSrc)
938 {
939 #if defined( NN_HARDWARE_CTR )
940 #if (MTX44TRANSPOSE_44_CONFIG == D_ORG)
941 return ARMv6::MTX44TransposeC(pOut, pSrc);
942 #elif (MTX44TRANSPOSE_44_CONFIG == D_FAST_C)
943 #elif (MTX44TRANSPOSE_44_CONFIG == D_FAST_ASM)
944 return ARMv6::MTX44TransposeAsm(pOut, pSrc);
945 #elif (MTX44TRANSPOSE_44_CONFIG == D_FAST_C_ALGO)
946 #elif (MTX44TRANSPOSE_44_CONFIG == D_FAST_ASM_ALGO)
947 #endif
948 #else
949 #endif // #if defined( NN_HARDWARE_CTR )
950
951 }
952 /*!
953 @}
954 */
955
956 /*!
957 @name ユーティリティ
958 @{
959 */
960
961 /*!--------------------------------------------------------------------------*
962 @brief ベクトルを行列で変換します。ベクトルの 4 要素目を 1 として計算します。
963
964 @param[out] pOut 計算結果を受け取るバッファへのポインタ。pV と同じベクトルを指していても構いません。
965 @param[in] pM 変換行列へのポインタ。
966 @param[in] pV 元となるベクトルへのポインタ。
967
968 @return pOut を返します。
969 *---------------------------------------------------------------------------*/
970 NN_FORCE_INLINE VEC4*
VEC3Transform(VEC4 * pOut,const MTX44 * pM,const VEC3 * pV)971 VEC3Transform(VEC4* pOut, const MTX44* pM, const VEC3* pV)
972 {
973 #if defined( NN_HARDWARE_CTR )
974 #if (VEC3TRANSFORM_44XVEC3_CONFIG == D_ORG)
975 return ARMv6::VEC3TransformC(pOut, pM, pV);
976 #elif (VEC3TRANSFORM_44XVEC3_CONFIG == D_FAST_C)
977 #elif (VEC3TRANSFORM_44XVEC3_CONFIG == D_FAST_ASM)
978 return ARMv6::VEC3TransformAsm(pOut, pM, pV);
979 #elif (VEC3TRANSFORM_44XVEC3_CONFIG == D_FAST_C_ALGO)
980 #elif (VEC3TRANSFORM_44XVEC3_CONFIG == D_FAST_ASM_ALGO)
981 #endif
982 #else
983 #endif // #if defined( NN_HARDWARE_CTR )
984 }
985
986 /*!
987 @}
988 */
989
990 /*!
991 @name 行列
992 @{
993 */
994
995 /*---------------------------------------------------------------------------*
996 Description: 画面方向に向けて射影行列を回転します。
997
998 Arguments: pOut 回転をおこなう行列へのポインタ
999 pivot
1000
1001 Returns:
1002 *---------------------------------------------------------------------------*/
1003 NN_FORCE_INLINE MTX44*
MTX44Pivot(MTX44 * pOut,PivotDirection pivot)1004 MTX44Pivot( MTX44* pOut, PivotDirection pivot )
1005 {
1006 #if defined( NN_HARDWARE_CTR )
1007 #if (MTX44PIVOT_CONFIG == D_ORG)
1008 return ARMv6::MTX44PivotC(pOut, pivot);
1009 #elif (MTX44PIVOT_CONFIG == D_FAST_C)
1010 return ARMv6::MTX44PivotC_FAST(pOut, pivot);
1011 #elif (MTX44PIVOT_CONFIG == D_FAST_ASM)
1012 #elif (MTX44PIVOT_CONFIG == D_FAST_C_ALGO)
1013 #elif (MTX44PIVOT_CONFIG == D_FAST_ASM_ALGO)
1014 #endif
1015 #else
1016 #endif // #if defined( NN_HARDWARE_CTR )
1017
1018 }
1019
1020 /*!
1021 @}
1022 */
1023
1024 //-- const 引数を参照にしたオーバーロード
MTX44Copy(MTX44 * pOut,const MTX44 & m)1025 inline MTX44* MTX44Copy(MTX44* pOut, const MTX44& m) { return MTX44Copy( pOut, &m ); }
MTX44IsIdentity(const MTX44 & m)1026 inline bool MTX44IsIdentity(const MTX44& m) { return MTX44IsIdentity( &m ); }
1027
MTX44Add(MTX44 * pOut,const MTX44 & m1,const MTX44 & m2)1028 inline MTX44* MTX44Add(MTX44* pOut, const MTX44& m1, const MTX44& m2) { return MTX44Add( pOut, &m1, &m2 ); }
MTX44Sub(MTX44 * pOut,const MTX44 & m1,const MTX44 & m2)1029 inline MTX44* MTX44Sub(MTX44* pOut, const MTX44& m1, const MTX44& m2) { return MTX44Sub( pOut, &m1, &m2 ); }
MTX44Mult(MTX44 * pOut,const MTX44 & m,f32 f)1030 inline MTX44* MTX44Mult(MTX44* pOut, const MTX44& m, f32 f) { return MTX44Mult( pOut, &m, f ); }
MTX44Mult(MTX44 * pOut,const MTX44 & m1,const MTX44 & m2)1031 inline MTX44* MTX44Mult(MTX44* pOut, const MTX44& m1, const MTX44& m2) { return MTX44Mult( pOut, &m1, &m2 ); }
1032
MTX44Transpose(MTX44 * pOut,const MTX44 & m)1033 inline MTX44* MTX44Transpose(MTX44* pOut, const MTX44& m) { return MTX44Transpose( pOut, &m ); }
MTX44MultArray(MTX44 * pOut,const MTX44 & m1,const MTX44 * pSrc,s32 count)1034 inline MTX44* MTX44MultArray(MTX44* pOut, const MTX44& m1, const MTX44* pSrc, s32 count) { return MTX44MultArray( pOut, &m1, pSrc, count ); }
MTX44Inverse(MTX44 * pOut,const MTX44 & m)1035 inline u32 MTX44Inverse(MTX44* pOut, const MTX44& m) { return MTX44Inverse( pOut, &m ); }
1036
MTX44RotAxisFIdx(MTX44 * pOut,const VEC3 & vAxis,f32 fIdx)1037 inline MTX44* MTX44RotAxisFIdx(MTX44* pOut, const VEC3& vAxis, f32 fIdx) { return MTX44RotAxisFIdx( pOut, &vAxis, fIdx ); }
MTX44RotAxisRad(MTX44 * pOut,const VEC3 & vAxis,f32 fRad)1038 inline MTX44* MTX44RotAxisRad(MTX44* pOut, const VEC3& vAxis, f32 fRad) { return MTX44RotAxisRad( pOut, &vAxis, fRad ); }
MTX44RotAxisDeg(MTX44 * pOut,const VEC3 & vAxis,f32 fDeg)1039 inline MTX44* MTX44RotAxisDeg(MTX44* pOut, const VEC3& vAxis, f32 fDeg) { return MTX44RotAxisDeg( pOut, &vAxis, fDeg ); }
1040
MTX44Scale(MTX44 * pOut,const VEC3 & S)1041 inline MTX44* MTX44Scale(MTX44* pOut, const VEC3& S) { return MTX44Scale(pOut, &S); }
MTX44MultScale(MTX44 * pOut,const MTX44 & M,const VEC3 & S)1042 inline MTX44* MTX44MultScale(MTX44* pOut, const MTX44& M, const VEC3& S) { return MTX44MultScale(pOut, &M, &S); }
MTX44MultScale(MTX44 * pOut,const VEC3 & S,const MTX44 & M)1043 inline MTX44* MTX44MultScale(MTX44* pOut, const VEC3& S, const MTX44& M) { return MTX44MultScale(pOut, &S, &M); }
1044
MTX44Translate(MTX44 * pOut,const VEC3 & T)1045 inline MTX44* MTX44Translate(MTX44* pOut, const VEC3& T) { return MTX44Translate(pOut, &T); }
MTX44MultTranslate(MTX44 * pOut,const MTX44 & M,const VEC3 & T)1046 inline MTX44* MTX44MultTranslate(MTX44* pOut, const MTX44& M, const VEC3& T) { return MTX44MultTranslate(pOut, &M, &T); }
MTX44MultTranslate(MTX44 * pOut,const VEC3 & T,const MTX44 & M)1047 inline MTX44* MTX44MultTranslate(MTX44* pOut, const VEC3& T, const MTX44& M) { return MTX44MultTranslate(pOut, &T, &M); }
1048
1049 } // namespace math
1050 } // namespace nn
1051
1052 #if defined(NN_MATH_AS_INLINE)
1053 #include <nn/math/inline/math_Matrix44.ipp>
1054 #include <nn/math/ARMv6/inline/math_Matrix44.ipp>
1055 #endif
1056
1057 #pragma pop
1058
1059 #endif
1060