diff options
Diffstat (limited to 'apps/plugins/sdl/src/video/math_private.h')
-rw-r--r-- | apps/plugins/sdl/src/video/math_private.h | 173 |
1 files changed, 173 insertions, 0 deletions
diff --git a/apps/plugins/sdl/src/video/math_private.h b/apps/plugins/sdl/src/video/math_private.h new file mode 100644 index 0000000000..1087d7dea2 --- /dev/null +++ b/apps/plugins/sdl/src/video/math_private.h | |||
@@ -0,0 +1,173 @@ | |||
1 | /* | ||
2 | * ==================================================== | ||
3 | * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. | ||
4 | * | ||
5 | * Developed at SunPro, a Sun Microsystems, Inc. business. | ||
6 | * Permission to use, copy, modify, and distribute this | ||
7 | * software is freely granted, provided that this notice | ||
8 | * is preserved. | ||
9 | * ==================================================== | ||
10 | */ | ||
11 | |||
12 | /* | ||
13 | * from: @(#)fdlibm.h 5.1 93/09/24 | ||
14 | * $Id$ | ||
15 | */ | ||
16 | |||
17 | #ifndef _MATH_PRIVATE_H_ | ||
18 | #define _MATH_PRIVATE_H_ | ||
19 | |||
20 | #include "SDL_name.h" | ||
21 | #include "SDL_endian.h" | ||
22 | |||
23 | #define huge really_big /* huge is a reserved keyword in VC++ 6.0 */ | ||
24 | #define u_int32_t uint32_t | ||
25 | |||
26 | /* The original fdlibm code used statements like: | ||
27 | n0 = ((*(int*)&one)>>29)^1; * index of high word * | ||
28 | ix0 = *(n0+(int*)&x); * high word of x * | ||
29 | ix1 = *((1-n0)+(int*)&x); * low word of x * | ||
30 | to dig two 32 bit words out of the 64 bit IEEE floating point | ||
31 | value. That is non-ANSI, and, moreover, the gcc instruction | ||
32 | scheduler gets it wrong. We instead use the following macros. | ||
33 | Unlike the original code, we determine the endianness at compile | ||
34 | time, not at run time; I don't see much benefit to selecting | ||
35 | endianness at run time. */ | ||
36 | |||
37 | /* A union which permits us to convert between a double and two 32 bit | ||
38 | ints. */ | ||
39 | |||
40 | /* | ||
41 | * Math on arm is special: | ||
42 | * For FPA, float words are always big-endian. | ||
43 | * For VFP, floats words follow the memory system mode. | ||
44 | */ | ||
45 | |||
46 | #if (SDL_BYTEORDER == SDL_BIG_ENDIAN) || \ | ||
47 | (!defined(__VFP_FP__) && (defined(__arm__) || defined(__thumb__))) | ||
48 | |||
49 | typedef union | ||
50 | { | ||
51 | double value; | ||
52 | struct | ||
53 | { | ||
54 | u_int32_t msw; | ||
55 | u_int32_t lsw; | ||
56 | } parts; | ||
57 | } ieee_double_shape_type; | ||
58 | |||
59 | #else | ||
60 | |||
61 | typedef union | ||
62 | { | ||
63 | double value; | ||
64 | struct | ||
65 | { | ||
66 | u_int32_t lsw; | ||
67 | u_int32_t msw; | ||
68 | } parts; | ||
69 | } ieee_double_shape_type; | ||
70 | |||
71 | #endif | ||
72 | |||
73 | /* Get two 32 bit ints from a double. */ | ||
74 | |||
75 | #define EXTRACT_WORDS(ix0,ix1,d) \ | ||
76 | do { \ | ||
77 | ieee_double_shape_type ew_u; \ | ||
78 | ew_u.value = (d); \ | ||
79 | (ix0) = ew_u.parts.msw; \ | ||
80 | (ix1) = ew_u.parts.lsw; \ | ||
81 | } while (0) | ||
82 | |||
83 | /* Get the more significant 32 bit int from a double. */ | ||
84 | |||
85 | #define GET_HIGH_WORD(i,d) \ | ||
86 | do { \ | ||
87 | ieee_double_shape_type gh_u; \ | ||
88 | gh_u.value = (d); \ | ||
89 | (i) = gh_u.parts.msw; \ | ||
90 | } while (0) | ||
91 | |||
92 | /* Get the less significant 32 bit int from a double. */ | ||
93 | |||
94 | #define GET_LOW_WORD(i,d) \ | ||
95 | do { \ | ||
96 | ieee_double_shape_type gl_u; \ | ||
97 | gl_u.value = (d); \ | ||
98 | (i) = gl_u.parts.lsw; \ | ||
99 | } while (0) | ||
100 | |||
101 | /* Set a double from two 32 bit ints. */ | ||
102 | |||
103 | #define INSERT_WORDS(d,ix0,ix1) \ | ||
104 | do { \ | ||
105 | ieee_double_shape_type iw_u; \ | ||
106 | iw_u.parts.msw = (ix0); \ | ||
107 | iw_u.parts.lsw = (ix1); \ | ||
108 | (d) = iw_u.value; \ | ||
109 | } while (0) | ||
110 | |||
111 | /* Set the more significant 32 bits of a double from an int. */ | ||
112 | |||
113 | #define SET_HIGH_WORD(d,v) \ | ||
114 | do { \ | ||
115 | ieee_double_shape_type sh_u; \ | ||
116 | sh_u.value = (d); \ | ||
117 | sh_u.parts.msw = (v); \ | ||
118 | (d) = sh_u.value; \ | ||
119 | } while (0) | ||
120 | |||
121 | /* Set the less significant 32 bits of a double from an int. */ | ||
122 | |||
123 | #define SET_LOW_WORD(d,v) \ | ||
124 | do { \ | ||
125 | ieee_double_shape_type sl_u; \ | ||
126 | sl_u.value = (d); \ | ||
127 | sl_u.parts.lsw = (v); \ | ||
128 | (d) = sl_u.value; \ | ||
129 | } while (0) | ||
130 | |||
131 | /* A union which permits us to convert between a float and a 32 bit | ||
132 | int. */ | ||
133 | |||
134 | typedef union | ||
135 | { | ||
136 | float value; | ||
137 | u_int32_t word; | ||
138 | } ieee_float_shape_type; | ||
139 | |||
140 | /* Get a 32 bit int from a float. */ | ||
141 | |||
142 | #define GET_FLOAT_WORD(i,d) \ | ||
143 | do { \ | ||
144 | ieee_float_shape_type gf_u; \ | ||
145 | gf_u.value = (d); \ | ||
146 | (i) = gf_u.word; \ | ||
147 | } while (0) | ||
148 | |||
149 | /* Set a float from a 32 bit int. */ | ||
150 | |||
151 | #define SET_FLOAT_WORD(d,i) \ | ||
152 | do { \ | ||
153 | ieee_float_shape_type sf_u; \ | ||
154 | sf_u.word = (i); \ | ||
155 | (d) = sf_u.value; \ | ||
156 | } while (0) | ||
157 | |||
158 | |||
159 | #ifdef __STDC__ | ||
160 | static const double | ||
161 | #else | ||
162 | static double | ||
163 | #endif | ||
164 | zero = 0.0, | ||
165 | one = 1.0, | ||
166 | two = 2.0, | ||
167 | two53 = 9007199254740992.0, /* 0x43400000, 0x00000000 */ | ||
168 | two54 = 1.80143985094819840000e+16, /* 0x43500000, 0x00000000 */ | ||
169 | twom54 = 5.55111512312578270212e-17, /* 0x3C900000, 0x00000000 */ | ||
170 | huge = 1.0e+300, | ||
171 | tiny = 1.0e-300; | ||
172 | |||
173 | #endif /* _MATH_PRIVATE_H_ */ | ||