1/*---------------------------------------------------------------------------*
2  Project:  Horizon
3  File:     math_Matrix34.ipp
4  Copyright (C)2009-2010 Nintendo Co., Ltd.  All rights reserved.
5  These coded instructions, statements, and computer programs contain
6  proprietary information of Nintendo of America Inc. and/or Nintendo
7  Company Ltd., and are protected by Federal copyright law. They may
8  not be disclosed to third parties or copied or duplicated in any form,
9  in whole or in part, without the prior written consent of Nintendo.
10  $Revision: 24035 $
11 *---------------------------------------------------------------------------
12
13
14*/
15#include <cmath>
16#include <nn/math/math_Vector3.h>
17
18namespace nn {
19namespace math {
20
21
22/* ------------------------------------------------------------------------
23        MTX34
24   ------------------------------------------------------------------------ */
25
26/* Please see man pages for details
27
28
29*/
30
31/*
32
33
34
35
36
37*/
38NN_MATH_INLINE MTX34*
39MTX34Zero(MTX34* pOut)
40{
41    pOut->f._00 = pOut->f._01 = pOut->f._02 = pOut->f._03 =
42    pOut->f._10 = pOut->f._11 = pOut->f._12 = pOut->f._13 =
43    pOut->f._20 = pOut->f._21 = pOut->f._22 = pOut->f._23 = 0.f;
44
45    return pOut;
46}
47
48/*
49
50
51
52
53
54*/
55NN_MATH_INLINE MTX34*
56MTX34Identity(MTX34* pOut)
57{
58    NN_NULL_ASSERT( pOut );
59
60    MTX34Copy(pOut, MTX34::Identity());
61
62    return pOut;
63}
64
65
66/*
67
68
69
70
71
72*/
73NN_MATH_INLINE bool
74MTX34IsIdentity(const MTX34* p)
75{
76    return p->f._00 == 1.f && p->f._01 == 0.f && p->f._02 == 0.f && p->f._03 == 0.f &&
77           p->f._10 == 0.f && p->f._11 == 1.f && p->f._12 == 0.f && p->f._13 == 0.f &&
78           p->f._20 == 0.f && p->f._21 == 0.f && p->f._22 == 1.f && p->f._23 == 0.f;
79}
80
81/*
82
83
84
85
86
87
88
89*/
90NN_MATH_INLINE MTX34*
91MTX34Sub(MTX34* pOut, const MTX34* p1, const MTX34* p2)
92{
93    pOut->f._00 = p1->f._00 - p2->f._00;
94    pOut->f._01 = p1->f._01 - p2->f._01;
95    pOut->f._02 = p1->f._02 - p2->f._02;
96    pOut->f._03 = p1->f._03 - p2->f._03;
97
98    pOut->f._10 = p1->f._10 - p2->f._10;
99    pOut->f._11 = p1->f._11 - p2->f._11;
100    pOut->f._12 = p1->f._12 - p2->f._12;
101    pOut->f._13 = p1->f._13 - p2->f._13;
102
103    pOut->f._20 = p1->f._20 - p2->f._20;
104    pOut->f._21 = p1->f._21 - p2->f._21;
105    pOut->f._22 = p1->f._22 - p2->f._22;
106    pOut->f._23 = p1->f._23 - p2->f._23;
107
108    return pOut;
109}
110
111
112/*
113
114
115
116
117
118
119
120*/
121NN_MATH_INLINE MTX34*
122MTX34RotAxisFIdx(MTX34* pOut, const VEC3* pAxis, f32 fIdx)
123{
124    // Okay for now if it's slow
125    MTX34RotAxisRad_(pOut, pAxis, NN_MATH_FIDX_TO_RAD(fIdx));
126
127    return pOut;
128}
129
130
131/*
132
133
134
135
136
137
138
139
140
141*/
142NN_MATH_INLINE MTX34*
143MTX34RotXYZTranslateFIdx(MTX34* pOut, f32 fIdxX, f32 fIdxY, f32 fIdxZ, const VEC3* pT)
144{
145    (void)MTX34RotXYZFIdx(pOut, fIdxX, fIdxY, fIdxZ);
146    pOut->f._03 = pT->x;
147    pOut->f._13 = pT->y;
148    pOut->f._23 = pT->z;
149    return pOut;
150}
151
152/*
153
154
155
156
157
158
159*/
160NN_MATH_INLINE u32
161MTX34InvTranspose(MTX33* pOut, const MTX34* __restrict p)
162{
163    MTX34 tmp;
164    u32 rval = MTX34InvTranspose(&tmp, p);
165    (void)MTX34ToMTX33(pOut, &tmp);
166    return rval;
167}
168
169
170/*
171
172
173
174
175
176
177
178
179*/
180NN_MATH_INLINE MTX34*
181MTX34MultArray(MTX34* pOut, const MTX34* __restrict p1, const MTX34* __restrict pSrc, s32 count)
182{
183    MTX34* pOutBase = pOut;
184
185    NN_NULL_ASSERT( pOut );
186    NN_NULL_ASSERT( p1 );
187    NN_NULL_ASSERT( pSrc );
188    NN_ASSERT( count > 1 );
189
190    for ( s32 i = 0 ; i < count ; i++ )
191    {
192        MTX34Mult(pOut, p1, pSrc);
193
194        pSrc++;
195        pOut++;
196    }
197
198    return pOutBase;
199}
200
201/*
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216*/
217NN_MATH_INLINE MTX34*
218MTX34TextureProjectionFrustum(MTX34* pOut, f32 l, f32 r, f32 b, f32 t, f32 n, f32 scaleS, f32 scaleT, f32 translateS, f32 translateT)
219{
220    NN_ASSERT(t != b);
221    NN_ASSERT(l != r);
222    NN_NULL_ASSERT(pOut);
223
224    f32 reverseWidth = 1.0f / (r - l);
225
226    f32 (*const mtx)[4] = pOut->m;
227
228    mtx[0][0] = ((2.0f * n) * reverseWidth) * scaleS;
229    mtx[0][1] = 0.0f;
230    mtx[0][2] = (((r + l) * reverseWidth) * scaleS) - translateS;
231    mtx[0][3] = 0.0f;
232
233    f32 reverseHeight = 1.0f / (t - b);
234    mtx[1][0] = 0.0f;
235    mtx[1][1] = ((2.0f * n) * reverseHeight) * scaleT;
236    mtx[1][2] = (((t+ b) * reverseHeight) * scaleT) - translateT;
237    mtx[1][3] = 0.0f;
238
239    mtx[2][0] = 0.0f;
240    mtx[2][1] = 0.0f;
241    mtx[2][2] = -1.0f;
242    mtx[2][3] = 0.0f;
243    return pOut;
244}
245
246/*
247
248
249
250
251
252
253
254
255
256
257
258*/
259NN_MATH_INLINE MTX34*
260MTX34TextureProjectionPerspective(MTX34* pOut, f32 fovy, f32 aspect, f32 scaleS, f32 scaleT, f32 translateS, f32 translateT)
261{
262    NN_ASSERT((fovy > 0.0f) && (fovy < math::F_PI));
263    NN_ASSERT(aspect != 0.0f);
264    NN_NULL_ASSERT(pOut);
265
266    float angle = fovy * 0.5f;
267    float cot = 1.0f / math::TanRad(angle);
268
269    f32 (*const mtx)[4] = pOut->m;
270
271    mtx[0][0] = (cot / aspect) * scaleS;
272    mtx[0][1] = 0.0f;
273    mtx[0][2] = -translateS;
274    mtx[0][3] = 0.0f;
275
276    mtx[1][0] = 0.0f;
277    mtx[1][1] = cot * scaleT;
278    mtx[1][2] = -translateT;
279    mtx[1][3] = 0.0f;
280
281    mtx[2][0] = 0.0f;
282    mtx[2][1] = 0.0f;
283    mtx[2][2] = -1.0f;
284    mtx[2][3] = 0.0f;
285
286    return pOut;
287}
288
289/*
290
291
292
293
294
295
296
297
298
299
300
301
302
303*/
304NN_MATH_INLINE MTX34*
305MTX34TextureProjectionOrtho(MTX34* pOut, f32 l, f32 r, f32 b, f32 t, f32 scaleS, f32 scaleT, f32 translateS, f32 translateT)
306{
307    NN_ASSERT(t != b);
308    NN_ASSERT(l != r);
309    NN_NULL_ASSERT(pOut);
310
311    float reverseWidth = 1.0f / (r - l);
312
313    f32 (*const mtx)[4] = pOut->m;
314
315    mtx[0][0] = 2.0f * reverseWidth * scaleS;
316    mtx[0][1] = 0.0f;
317    mtx[0][2] = 0.0f;
318    mtx[0][3] = ((-(r + l) * reverseWidth) * scaleS) + translateS;
319
320    float reverseHeight = 1.0f / (t - b);
321    mtx[1][0] = 0.0f;
322    mtx[1][1] = (2.0f * reverseHeight) * scaleT;
323    mtx[1][2] = 0.0f;
324    mtx[1][3] = ((-(t + b) * reverseHeight) * scaleT) + translateT;
325
326    mtx[2][0] = 0.0f;
327    mtx[2][1] = 0.0f;
328    mtx[2][2] = 0.0f;
329    mtx[2][3] = 1.0f;
330    return pOut;
331}
332
333/*
334
335*/
336
337
338}  // namespace math
339}  // namespace nn
340