1/*---------------------------------------------------------------------------*
2  Project:  Horizon
3  File:     math_Vector4.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: 18015 $
11 *---------------------------------------------------------------------------
12
13
14*/
15
16namespace nn {
17namespace math {
18
19/* ------------------------------------------------------------------------
20        VEC4
21   ------------------------------------------------------------------------ */
22/* Please see man pages for details
23
24
25*/
26
27/*
28
29
30
31
32
33*/
34NN_MATH_INLINE bool
35VEC4IsZero(const VEC4* p)
36{
37    return p->x == 0.f && p->y == 0.f && p->z == 0.f && p->w == 0.f;
38}
39
40/*
41
42
43
44
45
46*/
47NN_MATH_INLINE bool
48VEC4IsZeroWOne(const VEC4* p)
49{
50    return p->x == 0.f && p->y == 0.f && p->z == 0.f && p->w == 1.f;
51}
52
53/*
54
55
56
57
58
59
60
61*/
62NN_MATH_INLINE VEC4*
63VEC4Add(VEC4* pOut, const VEC4* p1, const VEC4* p2)
64{
65    pOut->x = p1->x + p2->x;
66    pOut->y = p1->y + p2->y;
67    pOut->z = p1->z + p2->z;
68    pOut->w = p1->w + p2->w;
69
70    return pOut;
71}
72
73/*
74
75
76
77
78
79
80
81*/
82NN_MATH_INLINE VEC4*
83VEC4Sub(VEC4* pOut, const VEC4* p1, const VEC4* p2)
84{
85    pOut->x = p1->x - p2->x;
86    pOut->y = p1->y - p2->y;
87    pOut->z = p1->z - p2->z;
88    pOut->w = p1->w - p2->w;
89
90    return pOut;
91}
92
93/*
94
95
96
97
98
99
100
101*/
102NN_MATH_INLINE VEC4*
103VEC4Mult(VEC4* pOut, const VEC4* p1, const VEC4* p2)
104{
105    pOut->x = p1->x * p2->x;
106    pOut->y = p1->y * p2->y;
107    pOut->z = p1->z * p2->z;
108    pOut->w = p1->w * p2->w;
109    return pOut;
110}
111
112/*
113
114
115
116
117
118
119
120*/
121NN_MATH_INLINE VEC4*
122VEC4Scale(VEC4* pOut, const VEC4* p, f32 scale)
123{
124    pOut->x = scale * p->x;
125    pOut->y = scale * p->y;
126    pOut->z = scale * p->z;
127    pOut->w = scale * p->w;
128
129    return pOut;
130}
131
132/*
133
134
135
136
137
138
139
140
141*/
142NN_MATH_INLINE VEC4*
143VEC4Lerp(VEC4* pOut, const VEC4* __restrict p1, const VEC4* __restrict p2, f32 t)
144{
145    // (1-t)*p1 + t*p2
146    pOut->x = p1->x + t * (p2->x - p1->x);
147    pOut->y = p1->y + t * (p2->y - p1->y);
148    pOut->z = p1->z + t * (p2->z - p1->z);
149    pOut->w = p1->w + t * (p2->w - p1->w);
150
151    return pOut;
152}
153
154/*
155
156
157
158
159
160
161*/
162NN_MATH_INLINE f32
163VEC4Dot(const VEC4* p1, const VEC4* p2)
164{
165    return p1->x * p2->x + p1->y * p2->y + p1->z * p2->z + p1->w * p2->w;
166
167}
168
169/*
170
171
172
173
174
175*/
176NN_MATH_INLINE f32
177VEC4LenSq(const VEC4* __restrict p)
178{
179    return p->x * p->x + p->y * p->y + p->z * p->z + p->w * p->w;
180
181}
182
183/*
184
185
186
187
188
189*/
190f32 VEC4Len(const VEC4* p)
191{
192    return FSqrt(VEC4LenSq(p));
193
194}
195
196/*
197
198
199
200
201
202
203*/
204NN_MATH_INLINE VEC4*
205VEC4Normalize(VEC4* pOut, const VEC4* p)
206{
207    (void)VEC4Scale(pOut, p, FrSqrt(VEC4LenSq(p)));
208
209    return pOut;
210}
211
212/*
213
214
215
216
217
218
219
220
221*/
222NN_MATH_INLINE VEC4*
223VEC4SafeNormalize(VEC4* pOut, const VEC4* p, const VEC4& alt)
224{
225    NN_NULL_ASSERT(pOut);
226    NN_NULL_ASSERT(p);
227
228    f32 mag = VEC4LenSq(p);
229
230    if (mag == 0)
231    {
232        *pOut = alt;
233
234        return pOut;
235    }
236
237    (void)VEC4Scale(pOut, p, FrSqrt(mag));
238
239    return pOut;
240}
241
242/*
243
244
245
246
247
248
249*/
250NN_MATH_INLINE f32
251VEC4DistSq(const VEC4* p1, const VEC4* p2)
252{
253    VEC4 tmp;
254    return VEC4LenSq(VEC4Sub(&tmp, p1, p2));
255
256}
257
258/*
259
260
261
262
263
264
265
266*/
267NN_MATH_INLINE VEC4*
268VEC4Maximize(VEC4* pOut, const VEC4* p1, const VEC4* p2)
269{
270    pOut->x = (p1->x > p2->x) ? p1->x : p2->x;
271    pOut->y = (p1->y > p2->y) ? p1->y : p2->y;
272    pOut->z = (p1->z > p2->z) ? p1->z : p2->z;
273    pOut->w = (p1->w > p2->w) ? p1->w : p2->w;
274
275    return pOut;
276}
277
278/*
279
280
281
282
283
284
285
286*/
287NN_MATH_INLINE VEC4*
288VEC4Minimize(VEC4* pOut, const VEC4* p1, const VEC4* p2)
289{
290    pOut->x = (p1->x < p2->x) ? p1->x : p2->x;
291    pOut->y = (p1->y < p2->y) ? p1->y : p2->y;
292    pOut->z = (p1->z < p2->z) ? p1->z : p2->z;
293    pOut->w = (p1->w < p2->w) ? p1->w : p2->w;
294
295    return pOut;
296}
297
298/*
299
300*/
301
302}  // namespace math
303}  // namespace nn
304