1 /*---------------------------------------------------------------------------*
2 Project: Horizon
3 File: math_Matrix43.h
4
5 Copyright (C)2009-2012 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 $Rev: 48334 $
14 *---------------------------------------------------------------------------*/
15
16 #ifndef NN_MATH_MATH_MATRIX43_H_
17 #define NN_MATH_MATH_MATRIX43_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 struct MTX43;
29
30 /* Please see man pages for details
31
32
33 */
34
35 /* ------------------------------------------------------------------------
36 Function for MTX43
37 ------------------------------------------------------------------------ */
38 /*
39
40
41
42
43
44
45
46 */
47 NN_FORCE_INLINE MTX43* MTX43Add(MTX43* pOut, const MTX43* p1, const MTX43* p2);
48
49 /*
50
51
52
53
54
55
56 */
57 NN_FORCE_INLINE MTX43* MTX43Copy(MTX43* pOut, const MTX43* p);
58
59 /*
60
61
62
63
64
65 */
66 NN_MATH_INLINE MTX43* MTX43Identity(MTX43* pOut);
67
68 /*
69
70
71
72
73
74 */
75 NN_MATH_INLINE bool MTX43IsIdentity(const MTX43* p);
76
77 /*
78
79
80
81
82
83
84
85 */
86 NN_FORCE_INLINE MTX43* MTX43Mult(MTX43* pOut, const MTX43* p1, const MTX43* p2);
87
88 /*
89
90
91
92
93
94
95
96 */
97 NN_FORCE_INLINE MTX43* MTX43Mult(MTX43* pOut, const MTX43* p, f32 f);
98
99 /*
100
101
102
103
104
105
106
107 */
108 NN_MATH_INLINE MTX43* MTX43Sub(MTX43* pOut, const MTX43* p1, const MTX43* p2);
109
110 /*
111
112
113
114
115
116 */
117 NN_MATH_INLINE MTX43* MTX43Zero(MTX43* pOut);
118 /*
119
120 */
121 /* =======================================================================
122 Class definitions
123 ======================================================================== */
124 /*
125
126
127 */
128 struct MTX43_
129 {
130 //
131 struct BaseData
132 {
133 f32 _00; //
134 f32 _01; //
135 f32 _02; //
136 f32 _10; //
137 f32 _11; //
138 f32 _12; //
139 f32 _20; //
140 f32 _21; //
141 f32 _22; //
142 f32 _30; //
143 f32 _31; //
144 f32 _32; //
145 };
146
147 union
148 {
149 //----------------------------------------
150 //
151 //
152 #if defined(NN_MATH_USE_ANONYMOUS_STRUCT)
153 //
154 struct
155 {
156 f32 _00, _01, _02;
157 f32 _10, _11, _12;
158 f32 _20, _21, _22;
159 f32 _30, _31, _32;
160 };
161 #endif
162 BaseData f; //
163 f32 m[4][3]; //
164 f32 a[12]; //
165 VEC3_ v[4]; //
166 //
167 };
168 };
169
170 /*
171
172
173 */
174 class MTX43 : public MTX43_
175 {
176 public:
177 static const int ROW_COUNT = 4; //
178 static const int COLUMN_COUNT = 3; //
179
180 //
Identity()181 static const MTX43& Identity()
182 {
183 static const MTX43 identity(
184 1.0f, 0.0f, 0.0f,
185 0.0f, 1.0f, 0.0f,
186 0.0f, 0.0f, 1.0f,
187 0.0f, 0.0f, 0.0f);
188
189 return identity;
190 }
191 typedef MTX43 self_type; //
192 typedef f32 value_type; //
193
194 public:
195 //----------------------------------------
196 //
197 //
198
199 //
MTX43()200 MTX43() {}
201
202 //
MTX43(const f32 * p)203 explicit MTX43(const f32* p) { (void)MTX43Copy(this, (MTX43*)p); }
204
205 //
MTX43(f32 x00,f32 x01,f32 x02,f32 x10,f32 x11,f32 x12,f32 x20,f32 x21,f32 x22,f32 x30,f32 x31,f32 x32)206 MTX43(f32 x00, f32 x01, f32 x02,
207 f32 x10, f32 x11, f32 x12,
208 f32 x20, f32 x21, f32 x22,
209 f32 x30, f32 x31, f32 x32)
210 {
211 f._00 = x00; f._01 = x01; f._02 = x02;
212 f._10 = x10; f._11 = x11; f._12 = x12;
213 f._20 = x20; f._21 = x21; f._22 = x22;
214 f._30 = x30; f._31 = x31; f._32 = x32;
215 }
216 //
217
218 //----------------------------------------
219 //
220 //
221
222 //
223 operator f32*() { return this->a; }
224 //
225 operator const f32*() const { return this->a; }
226
227 //
GetRow(int index)228 VEC3& GetRow(int index)
229 {
230 NN_MATH_MINMAXLT_ASSERT(index, 0, ROW_COUNT);
231 return *reinterpret_cast<VEC3*>(&this->v[index]);
232 }
233
234 //
GetRow(int index)235 const VEC3& GetRow(int index) const
236 {
237 NN_MATH_MINMAXLT_ASSERT(index, 0, ROW_COUNT);
238 return *reinterpret_cast<const VEC3*>(&this->v[index]);
239 }
240
241 //
GetColumn(int index)242 VEC4 GetColumn(int index) const
243 {
244 NN_MATH_MINMAXLT_ASSERT(index, 0, COLUMN_COUNT);
245 VEC4 column;
246 column.x = this->m[0][index];
247 column.y = this->m[1][index];
248 column.z = this->m[2][index];
249 column.w = this->m[3][index];
250 return column;
251 }
252
253 //
SetColumn(int index,const VEC4 & column)254 void SetColumn(int index, const VEC4& column)
255 {
256 NN_MATH_MINMAXLT_ASSERT(index, 0, COLUMN_COUNT);
257 this->m[0][index] = column.x;
258 this->m[1][index] = column.y;
259 this->m[2][index] = column.z;
260 this->m[3][index] = column.w;
261 }
262
263 //
264
265 //----------------------------------------
266 //
267 //
268
269 //
270 self_type& operator += (const self_type& rhs) { return *MTX43Add(this, this, &rhs); }
271
272 //
273 self_type& operator -= (const self_type& rhs) { return *MTX43Sub(this, this, &rhs); }
274
275 //
276 self_type& operator *= (const self_type& rhs) { return *MTX43Mult(this, this, &rhs); }
277
278 //
279 self_type& operator *= (f32 f) { return *MTX43Mult(this, this, f); }
280
281 //
282 self_type& operator /= (f32 f) { return operator*=(1.f / f); }
283
284 //
285 self_type operator + () const { return *this; }
286
287 //
288 self_type operator - () const
289 {
290 return MTX43(-f._00, -f._01, -f._02,
291 -f._10, -f._11, -f._12,
292 -f._20, -f._21, -f._22,
293 -f._30, -f._31, -f._32);
294 }
295
296 //
297 self_type operator + (const self_type& rhs) const { MTX43 tmp; return *MTX43Add(&tmp, this, &rhs); }
298
299 //
300 self_type operator - (const self_type& rhs) const { MTX43 tmp; return *MTX43Add(&tmp, this, &rhs); }
301
302 //
303 self_type operator * (f32 f) const { MTX43 tmp; return *MTX43Mult(&tmp, this, f); }
304
305 //
306 self_type operator / (f32 f) const { return *this * (1.f / f); }
307
308 //
309
310 //----------------------------------------
311 //
312 //
313
314 //
SetupIdentity()315 self_type& SetupIdentity() { return *MTX43Identity(this); }
316
317 //
318
319 //----------------------------------------
320 //
321 //
322
323 //
324 bool operator == (const self_type& rhs) const { return ::std::memcmp(this, &rhs, sizeof(MTX43)) == 0; }
325
326 //
327 bool operator != (const self_type& rhs) const { return ::std::memcmp(this, &rhs, sizeof(MTX43)) != 0; }
328
329 //
IsIdentity()330 bool IsIdentity() const { return MTX43IsIdentity(this); }
331
332 //
333
334 //
335 void Report(bool bNewline = true, const char* name = NULL) const;
336
337 private:
338 typedef void (self_type::*UnspecifiedBoolType)() const;
339 operator UnspecifiedBoolType() const;
340 operator UnspecifiedBoolType();
341 };
342 #include <nn/math/ARMv6/math_Matrix43.h>
343
344 NN_FORCE_INLINE MTX43*
MTX43Add(MTX43 * pOut,const MTX43 * p1,const MTX43 * p2)345 MTX43Add(MTX43* pOut, const MTX43* p1, const MTX43* p2)
346 {
347 #if defined( NN_HARDWARE_CTR )
348 #if (MTX43ADD_CONFIG == D_ORG)
349 return ARMv6::MTX43AddC(pOut, p1, p2);
350 #elif (MTX43ADD_CONFIG == D_FAST_C)
351 #elif (MTX43ADD_CONFIG == D_FAST_ASM)
352 return ARMv6::MTX43AddAsm(pOut, p1, p2);
353 #elif (MTX43ADD_CONFIG == D_FAST_C_ALGO)
354 #elif (MTX43ADD_CONFIG == D_FAST_ASM_ALGO)
355 #endif
356 #else
357 #endif // #if defined( NN_HARDWARE_CTR )
358
359 }
360
361 NN_FORCE_INLINE MTX43*
MTX43Copy(MTX43 * pOut,const MTX43 * p)362 MTX43Copy(MTX43* pOut, const MTX43* p)
363 {
364 #if defined( NN_HARDWARE_CTR )
365 #if (MTX43COPY_CONFIG == D_ORG)
366 return ARMv6::MTX43CopyC(pOut, p);
367 #elif (MTX43COPY_CONFIG == D_FAST_C)
368 #elif (MTX43COPY_CONFIG == D_FAST_ASM)
369 return ARMv6::MTX43CopyAsm(pOut, p);
370 #elif (MTX43COPY_CONFIG == D_FAST_C_ALGO)
371 #elif (MTX43COPY_CONFIG == D_FAST_ASM_ALGO)
372 #endif
373 #else
374 #endif // #if defined( NN_HARDWARE_CTR )
375
376 }
377
378 NN_FORCE_INLINE MTX43*
MTX43Mult(MTX43 * pOut,const MTX43 * p1,const MTX43 * p2)379 MTX43Mult(MTX43* pOut, const MTX43* p1, const MTX43* p2)
380 {
381 #if defined( NN_HARDWARE_CTR )
382 #if (MTX43MULT_43_CONFIG == D_ORG)
383 return ARMv6::MTX43MultC(pOut, p1, p2);
384 #elif (MTX43MULT_43_CONFIG == D_FAST_C)
385 #elif (MTX43MULT_43_CONFIG == D_FAST_ASM)
386 return ARMv6::MTX43MultAsm(pOut, p1, p2);
387 #elif (MTX43MULT_43_CONFIG == D_FAST_C_ALGO)
388 #elif (MTX43MULT_43_CONFIG == D_FAST_ASM_ALGO)
389 #endif
390 #else
391 #endif // #if defined( NN_HARDWARE_CTR )
392 }
393
394 NN_FORCE_INLINE MTX43*
MTX43Mult(MTX43 * pOut,const MTX43 * p,f32 f)395 MTX43Mult(MTX43* pOut, const MTX43* p, f32 f)
396 {
397 #if defined( NN_HARDWARE_CTR )
398 #if (MTX43MULT_F32_CONFIG == D_ORG)
399 return ARMv6::MTX43MultC(pOut, p, f);
400 #elif (MTX43MULT_F32_CONFIG == D_FAST_C)
401 #elif (MTX43MULT_F32_CONFIG == D_FAST_ASM)
402 return ARMv6::MTX43MultAsm(pOut, p, f);
403 #elif (MTX43MULT_F32_CONFIG == D_FAST_C_ALGO)
404 #elif (MTX43MULT_F32_CONFIG == D_FAST_ASM_ALGO)
405 #endif
406 #else
407 #endif // #if defined( NN_HARDWARE_CTR )
408 }
409
410 //
411 //
412
413 //
414 typedef class MTX43 Matrix43;
415
416 //
417
418 //Overload referencing the -- const argument
MTX44IsIdentity(const MTX43 & m)419 inline bool MTX44IsIdentity(const MTX43& m) { return MTX43IsIdentity( &m ); }
MTX43Copy(MTX43 * pOut,const MTX43 & m)420 inline MTX43* MTX43Copy(MTX43* pOut, const MTX43& m) { return MTX43Copy( pOut, &m ); }
MTX43Add(MTX43 * pOut,const MTX43 & m1,const MTX43 & m2)421 inline MTX43* MTX43Add(MTX43* pOut, const MTX43& m1, const MTX43& m2) { return MTX43Add( pOut, &m1, &m2 ); }
MTX43Sub(MTX43 * pOut,const MTX43 & m1,const MTX43 & m2)422 inline MTX43* MTX43Sub(MTX43* pOut, const MTX43& m1, const MTX43& m2) { return MTX43Sub( pOut, &m1, &m2 ); }
MTX43Mult(MTX43 * pOut,const MTX43 & m1,const MTX43 & m2)423 inline MTX43* MTX43Mult(MTX43* pOut, const MTX43& m1, const MTX43& m2) { return MTX43Mult( pOut, &m1, &m2 ); }
MTX43Mult(MTX43 * pOut,const MTX43 & m,f32 f)424 inline MTX43* MTX43Mult(MTX43* pOut, const MTX43& m, f32 f) { return MTX43Mult( pOut, &m, f); }
425
426 } // namespace math
427 } // namespace nn
428
429
430 #if defined(NN_MATH_AS_INLINE)
431 #include <nn/math/inline/math_Matrix43.ipp>
432 #include <nn/math/ARMv6/inline/math_Matrix43.ipp>
433 #endif
434
435 #pragma pop
436
437 #endif
438