1/*---------------------------------------------------------------------------*
2  Project:  Horizon
3  File:     math_Vector4.ipp
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: 18015 $
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