1 /*---------------------------------------------------------------------------*
2 Project: TwlSDK - FX -
3 File: fx.h
4
5 Copyright 2003-2008 Nintendo. 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 $Date:: 2008-09-18#$
14 $Rev: 8573 $
15 $Author: okubata_ryoma $
16 *---------------------------------------------------------------------------*/
17
18 #ifndef NITRO_FX_H_
19 #define NITRO_FX_H_
20
21 #if !(defined(SDK_WIN32) || defined(SDK_FROM_TOOL))
22 #include <nitro/misc.h>
23 #endif
24
25 #include <nitro/types.h>
26
27 #ifdef __cplusplus
28 extern "C" {
29 #endif
30
31 //----------------------------------------------------------------------------
32 // Type definition
33 //----------------------------------------------------------------------------
34
35 //#define SDK_FX_DYNAMIC_TABLE
36
37 //----------------------------------------------------------------------------
38 // fx32: s19.12 fixed point number
39 //----------------------------------------------------------------------------
40 typedef s32 fx32;
41 #define FX32_SHIFT 12
42 #define FX32_INT_SIZE 19
43 #define FX32_DEC_SIZE 12
44
45 #define FX32_INT_MASK 0x7ffff000
46 #define FX32_DEC_MASK 0x00000fff
47 #define FX32_SIGN_MASK 0x80000000
48
49 #define FX32_MAX ((fx32)0x7fffffff)
50 #define FX32_MIN ((fx32)0x80000000)
51
52 #define FX_MUL(v1, v2) FX32_CAST(((fx64)(v1) * (v2) + 0x800LL) >> FX32_SHIFT)
53 #define FX_MUL32x64C(v1, v2) FX32_CAST(((v2) * (v1) + 0x80000000LL) >> 32)
54
55 #define FX_FX32_TO_F32(x) ((f32)((x) / (f32)(1 << FX32_SHIFT)))
56 #define FX_F32_TO_FX32(x) ((fx32)(((x) > 0) ? \
57 ((x) * (1 << FX32_SHIFT) + 0.5f ) : \
58 ((x) * (1 << FX32_SHIFT) - 0.5f )))
59
60 #define FX32_CONST(x) FX_F32_TO_FX32(x)
61
62
63 //----------------------------------------------------------------------------
64 // fx64: s51.12 fixed point number
65 //----------------------------------------------------------------------------
66 typedef s64 fx64;
67 #define FX64_SHIFT 12
68 #define FX64_INT_SIZE 51
69 #define FX64_DEC_SIZE 12
70
71 #define FX64_INT_MASK ((fx64)0x7ffffffffffff000)
72 #define FX64_DEC_MASK ((fx64)0x0000000000000fff)
73 #define FX64_SIGN_MASK ((fx64)0x8000000000000000)
74
75 #define FX64_MAX ((fx64)0x7fffffffffffffff)
76 #define FX64_MIN ((fx64)0x8000000000000000)
77
78 #define FX_FX64_TO_F32(x) ((f32)((x) / (f32)(1 << FX64_SHIFT)))
79 #define FX_F32_TO_FX64(x) ((fx64)(((x) > 0) ? \
80 ((x) * (1 << FX32_SHIFT) + 0.5f ) : \
81 ((x) * (1 << FX32_SHIFT) - 0.5f )))
82
83 #define FX64_CONST(x) FX_F32_TO_FX64(x)
84
85
86 //----------------------------------------------------------------------------
87 // fx64c: s31.32 fixed point number
88 //----------------------------------------------------------------------------
89 typedef s64 fx64c;
90 #define FX64C_SHIFT 32
91 #define FX64C_INT_SIZE 31
92 #define FX64C_DEC_SIZE 32
93
94 #define FX64C_INT_MASK ((fx64c)0x7fffffff00000000)
95 #define FX64C_DEC_MASK ((fx64c)0x00000000ffffffff)
96 #define FX64C_SIGN_MASK ((fx64c)0x8000000000000000)
97
98 #define FX64C_MAX ((fx64c)0x7fffffffffffffff)
99 #define FX64C_MIN ((fx64c)0x8000000000000000)
100
101 #define FX_FX64C_TO_F32(x) ((f32)((x) / (f32)((fx64c)1 << FX64C_SHIFT)))
102 #define FX_F32_TO_FX64C(x) ((fx64c)(((x) > 0) ? \
103 ((x) * ((fx64c)1 << FX64C_SHIFT) + 0.5f ) : \
104 ((x) * ((fx64c)1 << FX64C_SHIFT) - 0.5f )))
105
106 #define FX64C_CONST(x) FX_F32_TO_FX64C(x)
107
108 // 4294967296 = 2^32
109
110 //----------------------------------------------------------------------------
111 // fx16: s3.12 fixed point number
112 //----------------------------------------------------------------------------
113 typedef s16 fx16;
114 #define FX16_SHIFT 12
115 #define FX16_INT_SIZE 3
116 #define FX16_DEC_SIZE 12
117
118 #define FX16_INT_MASK 0x7000
119 #define FX16_DEC_MASK 0x0fff
120 #define FX16_SIGN_MASK 0x8000
121
122 /* 7.999759 */
123 #define FX16_MAX ((fx16)0x7fff)
124 /* -8 */
125 #define FX16_MIN ((fx16)0x8000)
126
127 #define FX_FX16_TO_F32(x) ((f32)((x) / (f32)(1 << FX16_SHIFT)))
128 #define FX_F32_TO_FX16(x) ((fx16)(((x) > 0) ? \
129 (fx16)((x) * (1 << FX16_SHIFT) + 0.5f ) : \
130 (fx16)((x) * (1 << FX16_SHIFT) - 0.5f )))
131
132 #define FX16_CONST(x) FX_F32_TO_FX16(x)
133
134 //----------------------------------------------------------------------------
135 // VecFx32: 3D Vector of fx32
136 //----------------------------------------------------------------------------
137 typedef struct
138 {
139 fx32 x;
140 fx32 y;
141 fx32 z;
142 }
143 VecFx32;
144
145 //----------------------------------------------------------------------------
146 // VecFx16: 3D Vector of fx16
147 //----------------------------------------------------------------------------
148 typedef struct
149 {
150 fx16 x;
151 fx16 y;
152 fx16 z;
153 }
154 VecFx16;
155
156
157 //----------------------------------------------------------------------------
158 // MtxFx44: 4x4 Matrix of fx32
159 //----------------------------------------------------------------------------
160 #ifdef SDK_ADS
161 typedef struct
162 {
163 fx32 _00, _01, _02, _03;
164 fx32 _10, _11, _12, _13;
165 fx32 _20, _21, _22, _23;
166 fx32 _30, _31, _32, _33;
167 }
168 MtxFx44;
169 #else
170 typedef union
171 {
172 struct
173 {
174 fx32 _00, _01, _02, _03;
175 fx32 _10, _11, _12, _13;
176 fx32 _20, _21, _22, _23;
177 fx32 _30, _31, _32, _33;
178 };
179 fx32 m[4][4];
180 fx32 a[16];
181 }
182 MtxFx44;
183 #endif
184
185 //----------------------------------------------------------------------------
186 // MtxFx43: 4x3 Matrix of fx32
187 //----------------------------------------------------------------------------
188 #ifdef SDK_ADS
189 typedef struct
190 {
191 fx32 _00, _01, _02;
192 fx32 _10, _11, _12;
193 fx32 _20, _21, _22;
194 fx32 _30, _31, _32;
195 }
196 MtxFx43;
197 #else
198 typedef union
199 {
200 struct
201 {
202 fx32 _00, _01, _02;
203 fx32 _10, _11, _12;
204 fx32 _20, _21, _22;
205 fx32 _30, _31, _32;
206 };
207 fx32 m[4][3];
208 fx32 a[12];
209 }
210 MtxFx43;
211 #endif
212
213 //----------------------------------------------------------------------------
214 // MtxFx33: 3x3 Matrix of fx32
215 //----------------------------------------------------------------------------
216 #ifdef SDK_ADS
217 typedef struct
218 {
219 fx32 _00, _01, _02;
220 fx32 _10, _11, _12;
221 fx32 _20, _21, _22;
222 }
223 MtxFx33;
224 #else
225 typedef union
226 {
227 struct
228 {
229 fx32 _00, _01, _02;
230 fx32 _10, _11, _12;
231 fx32 _20, _21, _22;
232 };
233 fx32 m[3][3];
234 fx32 a[9];
235 }
236 MtxFx33;
237 #endif
238
239 //----------------------------------------------------------------------------
240 // MtxFx22: 2x2 Matrix of fx32
241 //----------------------------------------------------------------------------
242 #ifdef SDK_ADS
243 typedef struct
244 {
245 fx32 _00, _01;
246 fx32 _10, _11;
247 }
248 MtxFx22;
249 #else
250 typedef union
251 {
252 struct
253 {
254 fx32 _00, _01;
255 fx32 _10, _11;
256 };
257 fx32 m[2][2];
258 fx32 a[4];
259 }
260 MtxFx22;
261 #endif
262
263 /* if include from Other Environment for exsample VC or BCB, */
264 /* please define SDK_FROM_TOOL */
265 #if !(defined(SDK_WIN32) || defined(SDK_FROM_TOOL))
266
267 //----------------------------------------------------------------------------
268 // Declaration of function
269 //----------------------------------------------------------------------------
270
271 void FX_Init(void);
272
273 SDK_DECL_INLINE s32 FX_Whole(fx32 v);
274 SDK_DECL_INLINE fx32 FX_Floor(fx32 v);
275
276 fx32 FX_Modf(fx32 x, fx32 *iPtr);
277
278 //----------------------------------------------------------------------------
279 // Implementation of inline function
280 //----------------------------------------------------------------------------
281
282 /*---------------------------------------------------------------------------*
283 Name: FX_Whole
284
285 Description: Convert fx32 number to a whole number(s32)
286
287 Arguments: v fx32 variable/constant
288
289 Returns: floor of v in s32(integer)
290 *---------------------------------------------------------------------------*/
FX_Whole(fx32 v)291 SDK_INLINE s32 FX_Whole(fx32 v)
292 {
293 return (s32)(v >> FX32_SHIFT);
294 }
295
296 /*---------------------------------------------------------------------------*
297 Name: FX_Floor
298
299 Description: Convert fx32 number to a whole number(fx32)
300
301 Arguments: v fx32 variable/constant
302
303 Returns: floor of v in fx32 format
304 *---------------------------------------------------------------------------*/
FX_Floor(fx32 v)305 SDK_INLINE fx32 FX_Floor(fx32 v)
306 {
307 return (fx32)(v & (FX32_INT_MASK | FX32_SIGN_MASK));
308 }
309
310 /*---------------------------------------------------------------------------*
311 Name: FX32_CAST
312
313 Description: Overflow/Underflow check
314
315 Arguments: res s64 variable/constant
316
317 Returns: cast fx32
318 *---------------------------------------------------------------------------*/
FX32_CAST(s64 res)319 SDK_INLINE fx32 FX32_CAST(s64 res)
320 {
321 SDK_WARNING(res >= FX32_MIN && res <= FX32_MAX, "FX_Mul: Overflow/Underflow");
322 return (fx32)res;
323 }
324
325 /*---------------------------------------------------------------------------*
326 Name: FX_Mul
327
328 Description: Multiply fx32 and fx32
329
330 Arguments: v1 fx32 variable/constant to multiply
331 v2 fx32 variable/constant to multiply
332
333 Returns: v1 * v2 in fx32 format
334 *---------------------------------------------------------------------------*/
335 fx32 FX_MulFunc(fx32 v1, fx32 v2);
336 SDK_DECL_INLINE fx32 FX_MulInline(fx32 v1, fx32 v2);
337
FX_MulInline(fx32 v1,fx32 v2)338 SDK_INLINE fx32 FX_MulInline(fx32 v1, fx32 v2)
339 {
340 return FX32_CAST(((s64)(v1) * v2 + 0x800LL) >> FX32_SHIFT);
341 }
342
343 #ifndef FX_Mul
344 #ifdef SDK_CODE_ARM
345 #define FX_Mul(v1, v2) FX_MulInline(v1, v2)
346 #else
347 #define FX_Mul(v1, v2) FX_MulFunc(v1, v2)
348 #endif
349 #endif
350
351 #ifndef FX_Mul32x64c
352 #ifdef SDK_CODE_ARM
353 #define FX_Mul32x64c(v32, v64c) FX_Mul32x64cInline(v32, v64c)
354 #else
355 #define FX_Mul32x64c(v32, v64c) FX_Mul32x64cFunc(v32, v64c)
356 #endif
357 #endif
358
359
360 /*---------------------------------------------------------------------------*
361 Name: FX_Mul32x64c
362
363 Description: Multiply fx32 and fx64c
364
365 Arguments: v1 fx32 variable/constant to multiply
366 v2 fx64c variable/constant to multiply
367
368 Returns: v1 * v2 in fx32 format
369 *---------------------------------------------------------------------------*/
370 fx32 FX_Mul32x64cFunc(fx32 v32, fx64c v64c);
371 SDK_DECL_INLINE fx32 FX_Mul32x64cInline(fx32 v32, fx64c v64c);
372
FX_Mul32x64cInline(fx32 v32,fx64c v64c)373 SDK_INLINE fx32 FX_Mul32x64cInline(fx32 v32, fx64c v64c)
374 {
375 fx64c tmp = v64c * v32 + 0x80000000LL; // for better precision
376 return FX32_CAST(tmp >> FX64C_SHIFT);
377 }
378
379
380 #endif // SDK_FROM_TOOL
381
382 #ifdef __cplusplus
383 }/* extern "C" */
384 #endif
385
386 #endif
387