/[pkgs]/devel/Glide3/Glide3-warn.patch
ViewVC logotype

Contents of /devel/Glide3/Glide3-warn.patch

Parent Directory Parent Directory | Revision Log Revision Log

Revision 1.2 - (show annotations) (download) (as text)
Mon Jan 16 20:39:33 2006 UTC (3 years, 10 months ago) by jwrdegoede
Branch: MAIN
CVS Tags: Glide3-20050815-6_fc8, Glide3-20050815-2, F-12-split, Glide3-20050815-8_fc11, FC-6-split, Glide3-20050815-5_fc6, Glide3-20050815-9_fc12, F-7-split, Glide3-20050815-4_fc6, F-11-split, F-8-split, F-10-split, Glide3-20050815-3_fc5, F-9-split, Glide3-20050815-7_fc9, FC-5-split, HEAD
Changes since 1.1: +40 -3 lines
File MIME type: text/x-patch 
Fix non-asm compile in Glide3-warn.patch
1 diff -ur Glide3.orig/cvg/glide3/src/fxgasm.c Glide3/cvg/glide3/src/fxgasm.c
2 --- Glide3.orig/cvg/glide3/src/fxgasm.c 2005-08-08 14:27:26.000000000 +0200
3 +++ Glide3/cvg/glide3/src/fxgasm.c 2006-01-16 16:43:14.000000000 +0100
4 @@ -210,8 +210,8 @@
5 OFFSET (gr, pool.f1, "pool_f1");
6 OFFSET (gr, pool.f255, "pool_f255");
7
8 - OFFSET (gr, pool.ftemp1, "pool_fTemp1");
9 - OFFSET (gr, pool.ftemp2, "pool_fTemp2");
10 + OFFSET (gr, pool.temp1.f, "pool_fTemp1");
11 + OFFSET (gr, pool.temp2.f, "pool_fTemp2");
12
13 SIZEOF (gr,"GlideRoot");
14 NEWLINE;
15 Only in Glide3/cvg/glide3/src: fxgasm.c.warn
16 diff -ur Glide3.orig/cvg/glide3/src/fxglide.h Glide3/cvg/glide3/src/fxglide.h
17 --- Glide3.orig/cvg/glide3/src/fxglide.h 2005-08-13 23:06:56.000000000 +0200
18 +++ Glide3/cvg/glide3/src/fxglide.h 2006-01-16 16:43:14.000000000 +0100
19 @@ -1370,7 +1370,9 @@
20 float fHalf;
21 float f1;
22 float f255;
23 - float ftemp1, ftemp2; /* temps to convert floats to ints */
24 + /* temps to convert floats to ints */
25 + union { float f; FxI32 i; FxU32 u; } temp1;
26 + union { float f; FxI32 i; FxU32 u; } temp2;
27 float fIntTruncBias;
28
29 #if GLIDE_PACKED_RGB
30 @@ -2702,10 +2704,10 @@
31 */
32 #if GLIDE_PACKED_RGB
33 #define RGBA_COMP(__fpVal, __fpBias, __fpShift, __fpMask) \
34 -((_GlideRoot.pool.ftemp1 = (float)((float)(__fpVal) + (float)(__fpBias))), \
35 +((_GlideRoot.pool.temp1.f = (float)((float)(__fpVal) + (float)(__fpBias))), \
36 GR_ASSERT((__fpVal) >= 0.0f), \
37 GR_ASSERT((__fpVal) < 256.0f), \
38 - (((*(const FxU32*)&_GlideRoot.pool.ftemp1) & (__fpMask)) << (__fpShift)))
39 + ((_GlideRoot.pool.temp1.u & (__fpMask)) << (__fpShift)))
40
41 #define RGBA_COMP_CLAMP(__fpVal, __compToken) \
42 RGBA_COMP(__fpVal, kPackBias##__compToken, kPackShift##__compToken, kPackMask##__compToken)
43 Only in Glide3/cvg/glide3/src: fxglide.h.warn
44 diff -ur Glide3.orig/cvg/glide3/src/gaa.c Glide3/cvg/glide3/src/gaa.c
45 --- Glide3.orig/cvg/glide3/src/gaa.c 2005-08-13 23:06:57.000000000 +0200
46 +++ Glide3/cvg/glide3/src/gaa.c 2006-01-16 16:43:14.000000000 +0100
47 @@ -273,34 +273,30 @@
48
49 GR_BEGIN_NOFIFOCHECK(FN_NAME, 91);
50
51 -#define DX _GlideRoot.pool.ftemp1
52 -#define ADY _GlideRoot.pool.ftemp2
53 +#define DX _GlideRoot.pool.temp1
54 +#define ADY _GlideRoot.pool.temp2
55
56 GR_FLUSH_STATE();
57
58 {
59 - FxI32 i, j;
60 - FxU32 dataElem;
61 - FxU32 vSize;
62 + int i;
63 + FxU32 vSize, dataElem;
64
65 /*
66 ** compute absolute deltas and draw from low Y to high Y
67 */
68 - ADY = FARRAY(b, 4) - FARRAY(a, 4);
69 - i = *(int *)&ADY;
70 - if (i < 0) {
71 + ADY.f = FARRAY(b, 4) - FARRAY(a, 4);
72 + if (ADY.i < 0) {
73 const void *tv;
74 tv = a; a = b; b = tv;
75 - i ^= 0x80000000; /* ady = -ady; */
76 - /* (*(long *)&ADY) = i; */
77 + ADY.i ^= 0x80000000; /* ady = -ady; */
78 }
79
80 - DX = FARRAY(b, 0) - FARRAY(a, 0);
81 - j = *(int *)&DX;
82 - j &= 0x7fffffffL; /* abs(adx) */
83 + DX.f = FARRAY(b, 0) - FARRAY(a, 0);
84 + DX.i &= 0x7fffffff; /* abs(adx) */
85
86 /* check for zero-length lines */
87 - if ((j >= i) && (j == 0))
88 + if ((DX.i >= ADY.i) && (DX.i == 0))
89 return;
90
91 vSize = gc->state.vData.vSize + 8;
92 @@ -308,7 +304,7 @@
93 TRI_STRIP_BEGIN(kSetupCullDisable | kSetupStrip, 4, vSize,
94 SSTCP_PKT3_BDDDDD | (1<<15));
95 /* x major */
96 - if (j >= i) {
97 + if (DX.i >= ADY.i) {
98 TRI_SETF(FARRAY(b, 0));
99 dataElem = 0;
100 TRI_SETF(FARRAY(b, 4) - _GlideRoot.pool.fHalf);
101 @@ -1391,35 +1387,31 @@
102 dyBC = fb[yindex] - fc[yindex];
103
104 /* Stash the area in the float pool for easy access */
105 - _GlideRoot.pool.ftemp1 = dxAB * dyBC - dxBC * dyAB;
106 + _GlideRoot.pool.temp1.f = dxAB * dyBC - dxBC * dyAB;
107
108 #define FloatVal(__f) (((__f) < 786432.875) ? (__f) : ((__f) - 786432.875))
109 - {
110 - const FxI32 j = *(FxI32*)&_GlideRoot.pool.ftemp1;
111 -
112 - /* Zero-area triangles are BAD!! */
113 - if ((j & 0x7FFFFFFF) == 0) {
114 - GDBG_INFO(291, FN_NAME": Culling (%g %g) (%g %g) (%g %g) : (%g : 0x%X : 0x%X)\n",
115 - FloatVal(fa[xindex]), FloatVal(fa[yindex]),
116 - FloatVal(fb[xindex]), FloatVal(fb[yindex]),
117 - FloatVal(fc[xindex]), FloatVal(fc[yindex]),
118 - _GlideRoot.pool.ftemp1, gc->state.cull_mode, culltest);
119 + /* Zero-area triangles are BAD!! */
120 + if ((_GlideRoot.pool.temp1.i & 0x7FFFFFFF) == 0) {
121 + GDBG_INFO(291, FN_NAME": Culling (%g %g) (%g %g) (%g %g) : (%g : 0x%X : 0x%X)\n",
122 + FloatVal(fa[xindex]), FloatVal(fa[yindex]),
123 + FloatVal(fb[xindex]), FloatVal(fb[yindex]),
124 + FloatVal(fc[xindex]), FloatVal(fc[yindex]),
125 + _GlideRoot.pool.temp1.f, gc->state.cull_mode, culltest);
126
127 - goto done;
128 - }
129 + goto done;
130 + }
131 +
132 + /* Backface culling, use sign bit as test */
133 + if ((gc->state.cull_mode != GR_CULL_DISABLE) &&
134 + ((_GlideRoot.pool.temp1.i ^ (culltest << 31)) >= 0)) {
135 +
136 + GDBG_INFO(291, FN_NAME": Culling (%g %g) (%g %g) (%g %g) : (%g : 0x%X : 0x%X)\n",
137 + FloatVal(fa[xindex]), FloatVal(fa[yindex]),
138 + FloatVal(fb[xindex]), FloatVal(fb[yindex]),
139 + FloatVal(fc[xindex]), FloatVal(fc[yindex]),
140 + _GlideRoot.pool.temp1.f, gc->state.cull_mode, culltest);
141
142 - /* Backface culling, use sign bit as test */
143 - if ((gc->state.cull_mode != GR_CULL_DISABLE) &&
144 - ((j ^ (culltest << 31)) >= 0)) {
145 -
146 - GDBG_INFO(291, FN_NAME": Culling (%g %g) (%g %g) (%g %g) : (%g : 0x%X : 0x%X)\n",
147 - FloatVal(fa[xindex]), FloatVal(fa[yindex]),
148 - FloatVal(fb[xindex]), FloatVal(fb[yindex]),
149 - FloatVal(fc[xindex]), FloatVal(fc[yindex]),
150 - _GlideRoot.pool.ftemp1, gc->state.cull_mode, culltest);
151 -
152 - goto done;
153 - }
154 + goto done;
155 }
156 }
157 } /* end culling test */
158 @@ -1718,35 +1710,31 @@
159 dyBC = fb[yindex] - fc[yindex];
160
161 /* Stash the area in the float pool for easy access */
162 - _GlideRoot.pool.ftemp1 = dxAB * dyBC - dxBC * dyAB;
163 + _GlideRoot.pool.temp1.f = dxAB * dyBC - dxBC * dyAB;
164
165 #define FloatVal(__f) (((__f) < 786432.875) ? (__f) : ((__f) - 786432.875))
166 - {
167 - const FxI32 j = *(FxI32*)&_GlideRoot.pool.ftemp1;
168 -
169 - /* Zero-area triangles are BAD!! */
170 - if ((j & 0x7FFFFFFF) == 0) {
171 - GDBG_INFO(291, FN_NAME": Culling (%g %g) (%g %g) (%g %g) : (%g : 0x%X : 0x%X)\n",
172 - FloatVal(fa[xindex]), FloatVal(fa[yindex]),
173 - FloatVal(fb[xindex]), FloatVal(fb[yindex]),
174 - FloatVal(fc[xindex]), FloatVal(fc[yindex]),
175 - _GlideRoot.pool.ftemp1, gc->state.cull_mode, culltest);
176 + /* Zero-area triangles are BAD!! */
177 + if ((_GlideRoot.pool.temp1.i & 0x7FFFFFFF) == 0) {
178 + GDBG_INFO(291, FN_NAME": Culling (%g %g) (%g %g) (%g %g) : (%g : 0x%X : 0x%X)\n",
179 + FloatVal(fa[xindex]), FloatVal(fa[yindex]),
180 + FloatVal(fb[xindex]), FloatVal(fb[yindex]),
181 + FloatVal(fc[xindex]), FloatVal(fc[yindex]),
182 + _GlideRoot.pool.temp1.f, gc->state.cull_mode, culltest);
183
184 - goto done;
185 - }
186 + goto done;
187 + }
188 +
189 + /* Backface culling, use sign bit as test */
190 + if ((gc->state.cull_mode != GR_CULL_DISABLE) &&
191 + ((_GlideRoot.pool.temp1.i ^ (culltest << 31)) >= 0)) {
192 +
193 + GDBG_INFO(291, FN_NAME": Culling (%g %g) (%g %g) (%g %g) : (%g : 0x%X : 0x%X)\n",
194 + FloatVal(fa[xindex]), FloatVal(fa[yindex]),
195 + FloatVal(fb[xindex]), FloatVal(fb[yindex]),
196 + FloatVal(fc[xindex]), FloatVal(fc[yindex]),
197 + _GlideRoot.pool.temp1.f, gc->state.cull_mode, culltest);
198
199 - /* Backface culling, use sign bit as test */
200 - if ((gc->state.cull_mode != GR_CULL_DISABLE) &&
201 - ((j ^ (culltest << 31)) >= 0)) {
202 -
203 - GDBG_INFO(291, FN_NAME": Culling (%g %g) (%g %g) (%g %g) : (%g : 0x%X : 0x%X)\n",
204 - FloatVal(fa[xindex]), FloatVal(fa[yindex]),
205 - FloatVal(fb[xindex]), FloatVal(fb[yindex]),
206 - FloatVal(fc[xindex]), FloatVal(fc[yindex]),
207 - _GlideRoot.pool.ftemp1, gc->state.cull_mode, culltest);
208 -
209 - goto done;
210 - }
211 + goto done;
212 }
213 }
214 } /* end culling test */
215 Only in Glide3/cvg/glide3/src: gaa.c.warn
216 diff -ur Glide3.orig/cvg/glide3/src/gdraw.c Glide3/cvg/glide3/src/gdraw.c
217 --- Glide3.orig/cvg/glide3/src/gdraw.c 2005-08-13 23:06:57.000000000 +0200
218 +++ Glide3/cvg/glide3/src/gdraw.c 2006-01-16 16:43:14.000000000 +0100
219 @@ -496,8 +496,8 @@
220 0x02, sizeof(FxU32) << 1, SSTCP_PKT3_BDDDDD);
221
222 /* Convert to 32-bit representation */
223 - _GlideRoot.pool.ftemp1 = FARRAY(vPtr, gc->state.vData.vertexInfo.offset) + bias;
224 - _GlideRoot.pool.ftemp2 = FARRAY(vPtr, gc->state.vData.vertexInfo.offset + 4) + bias;
225 + _GlideRoot.pool.temp1.f = FARRAY(vPtr, gc->state.vData.vertexInfo.offset) + bias;
226 + _GlideRoot.pool.temp2.f = FARRAY(vPtr, gc->state.vData.vertexInfo.offset + 4) + bias;
227
228 /* draw a little triangle, with the lower left corner at pixel center. */
229
230 @@ -511,9 +511,9 @@
231 */
232
233 /* Mask off the real fractional bits from the mantissa */
234 - x = ((*(FxU32*)&_GlideRoot.pool.ftemp1 & (0xFFFFFFFFUL << (22UL - kNumMantissaBits))) +
235 + x = ((_GlideRoot.pool.temp1.u & (0xFFFFFFFFUL << (22UL - kNumMantissaBits))) +
236 (0x01UL << (22UL - kNumMantissaBits)));
237 - y = ((*(FxU32*)&_GlideRoot.pool.ftemp2 & (0xFFFFFFFFUL << (22UL - kNumMantissaBits))) +
238 + y = ((_GlideRoot.pool.temp2.u & (0xFFFFFFFFUL << (22UL - kNumMantissaBits))) +
239 (0x01UL << (22UL - kNumMantissaBits)));
240
241 /* Lower right corner */
242 @@ -580,21 +580,21 @@
243 0x02, sizeof(FxU32) << 1, SSTCP_PKT3_BDDDDD);
244
245 /* Convert to 32-bit representation */
246 - _GlideRoot.pool.ftemp1 = (FARRAY(vPtr, gc->state.vData.vertexInfo.offset) *
247 + _GlideRoot.pool.temp1.f = (FARRAY(vPtr, gc->state.vData.vertexInfo.offset) *
248 oow *
249 gc->state.Viewport.hwidth +
250 gc->state.Viewport.ox +
251 bias);
252 - _GlideRoot.pool.ftemp2 = (FARRAY(vPtr, gc->state.vData.vertexInfo.offset + 4) *
253 + _GlideRoot.pool.temp2.f = (FARRAY(vPtr, gc->state.vData.vertexInfo.offset + 4) *
254 oow *
255 gc->state.Viewport.hheight +
256 gc->state.Viewport.oy +
257 bias);
258
259 /* Mask off the real fractional bits from the mantissa */
260 - x = ((*(FxU32*)&_GlideRoot.pool.ftemp1 & (0xFFFFFFFFUL << (22UL - kNumMantissaBits))) +
261 + x = ((_GlideRoot.pool.temp1.u & (0xFFFFFFFFUL << (22UL - kNumMantissaBits))) +
262 (0x01UL << (22UL - kNumMantissaBits)));
263 - y = ((*(FxU32*)&_GlideRoot.pool.ftemp2 & (0xFFFFFFFFUL << (22UL - kNumMantissaBits))) +
264 + y = ((_GlideRoot.pool.temp2.u & (0xFFFFFFFFUL << (22UL - kNumMantissaBits))) +
265 (0x01UL << (22UL - kNumMantissaBits)));
266
267 /* Lower right cornder */
268 @@ -653,13 +653,11 @@
269 * except the data set up is from the pointer array and
270 * its data layout
271 */
272 - int j;
273 - FxI32 sCount;
274 FxU32 vertexParamOffset;
275 - FxI32 stride;
276 + FxI32 sCount, stride;
277
278 -#define DX _GlideRoot.pool.ftemp1
279 -#define ADY _GlideRoot.pool.ftemp2
280 +#define DX _GlideRoot.pool.temp1
281 +#define ADY _GlideRoot.pool.temp2
282
283 GR_BEGIN_NOFIFOCHECK("_grDrawLineStrip", 91);
284
285 @@ -682,8 +680,7 @@
286
287 if (gc->state.grCoordinateSpaceArgs.coordinate_space_mode == GR_WINDOW_COORDS) {
288 while (sCount > 0) {
289 - FxI32 k, i;
290 - FxI32 vcount = sCount >= LINES_BUFFER ? LINES_BUFFER : sCount;
291 + FxI32 k, vcount = sCount >= LINES_BUFFER ? LINES_BUFFER : sCount;
292
293 GR_SET_EXPECTED_SIZE((gc->state.vData.vSize << 2) * vcount, vcount);
294 DA_BEGIN;
295 @@ -701,23 +698,18 @@
296 /*
297 ** compute absolute deltas and draw from low Y to high Y
298 */
299 - ADY = FARRAY(b, gc->state.vData.vertexInfo.offset+4) - FARRAY(a, gc->state.vData.vertexInfo.offset+4);
300 - i = *(int *)&ADY;
301 - if (i < 0) {
302 + ADY.f = FARRAY(b, gc->state.vData.vertexInfo.offset+4) - FARRAY(a, gc->state.vData.vertexInfo.offset+4);
303 + if (ADY.i < 0) {
304 float *tv;
305 tv = a; a = b; b = tv;
306 - i ^= 0x80000000; /* ady = -ady; */
307 - (*(int *)&ADY) = i;
308 - }
309 -
310 - DX = FARRAY(b, gc->state.vData.vertexInfo.offset) - FARRAY(a, gc->state.vData.vertexInfo.offset);
311 - j = *(int *)&DX;
312 - if (j < 0) {
313 - j ^= 0x80000000; /* adx = -adx; */
314 + ADY.i ^= 0x80000000; /* ady = -ady; */
315 }
316
317 + DX.f = FARRAY(b, gc->state.vData.vertexInfo.offset) - FARRAY(a, gc->state.vData.vertexInfo.offset);
318 + DX.i &= 0x7fffffff; /* abs(adx) */
319 +
320 /* check for zero-length lines */
321 - if ((j >= i) && (j == 0)) {
322 + if ((DX.i >= ADY.i) && (DX.i == 0)) {
323 #ifdef GLIDE_DEBUG
324 gc->expected_counter -= (gc->state.vData.vSize << 2 );
325 gc->checkCounter -= ((gc->state.vData.vSize+1) << 2 );
326 @@ -734,10 +726,11 @@
327 */
328 DA_CONT(kSetupCullDisable | kSetupStrip, gc->cmdTransportInfo.paramMask,
329 0x04UL, vertexParamOffset, SSTCP_PKT3_BDDDDD);
330 - {
331 + {
332 + int i;
333 FxU32 dataElem;
334 /* x major */
335 - if (j >= i) {
336 + if (DX.i >= ADY.i) {
337 DA_SETF(FARRAY(b, gc->state.vData.vertexInfo.offset));
338 dataElem = 0;
339 DA_SETF(FARRAY(b, gc->state.vData.vertexInfo.offset+4) - _GlideRoot.pool.fHalf);
340 @@ -836,8 +829,7 @@
341 float oowa, oowb = 0.0f, owa, owb, tmp1, tmp2, fax, fay, fbx, fby;
342
343 while (sCount > 0) {
344 - FxI32 k, i;
345 - FxI32 vcount = sCount >= LINES_BUFFER ? LINES_BUFFER : sCount;
346 + FxI32 k, vcount = sCount >= LINES_BUFFER ? LINES_BUFFER : sCount;
347 float *a,*b;
348 GR_SET_EXPECTED_SIZE((gc->state.vData.vSize << 2) * vcount, vcount);
349 DA_BEGIN;
350 @@ -872,30 +864,25 @@
351 /*
352 ** compute absolute deltas and draw from low Y to high Y
353 */
354 - ADY = tmp2 - tmp1;
355 - i = *(int *)&ADY;
356 - if (i < 0) {
357 + ADY.f = tmp2 - tmp1;
358 + if (ADY.i < 0) {
359 float *tv;
360 owa = oowb; owb = oowa;
361 fay = tmp2;
362 fby = tmp1;
363 tv = a; a = b; b = tv;
364 - i ^= 0x80000000; /* ady = -ady; */
365 - (*(int *)&ADY) = i;
366 + ADY.i ^= 0x80000000; /* ady = -ady; */
367 }
368 fax = FARRAY(a, gc->state.vData.vertexInfo.offset)
369 *owa*gc->state.Viewport.hwidth+gc->state.Viewport.ox;
370 fbx = FARRAY(b, gc->state.vData.vertexInfo.offset)
371 *owb*gc->state.Viewport.hwidth+gc->state.Viewport.ox;
372
373 - DX = fbx - fax;
374 - j = *(int *)&DX;
375 - if (j < 0) {
376 - j ^= 0x80000000; /* adx = -adx; */
377 - }
378 + DX.f = fbx - fax;
379 + DX.i &= 0x7fffffff; /* abs(adx) */
380
381 /* check for zero-length lines */
382 - if ((j >= i) && (j == 0)) {
383 + if ((DX.i >= ADY.i) && (DX.i == 0)) {
384 #ifdef GLIDE_DEBUG
385 gc->expected_counter -= (gc->state.vData.vSize << 2 );
386 gc->checkCounter -= ((gc->state.vData.vSize+1) << 2 );
387 @@ -907,7 +894,7 @@
388 0x04UL, vertexParamOffset, SSTCP_PKT3_BDDDDD);
389 {
390 /* x major */
391 - if (j >= i) {
392 + if (DX.i >= ADY.i) {
393 DA_SETF(fbx);
394 DA_SETF(fby - _GlideRoot.pool.fHalf);
395 DA_VP_SETFS(b,oowb);
396 --- Glide3/cvg/glide3/src/gxdraw.c~ 2006-01-16 21:33:38.000000000 +0100
397 +++ Glide3/cvg/glide3/src/gxdraw.c 2006-01-16 21:33:38.000000000 +0100
398 @@ -213,31 +213,31 @@
399 dyBC = fb[yindex] - fc[yindex];
400
401 /* Stash the area in the float pool for easy access */
402 - _GlideRoot.pool.ftemp1 = dxAB * dyBC - dxBC * dyAB;
403 + _GlideRoot.pool.temp1.f = dxAB * dyBC - dxBC * dyAB;
404
405 #define FloatVal(__f) (((__f) < 786432.875) ? (__f) : ((__f) - 786432.875))
406 {
407 - const FxI32 j = *(FxI32*)&_GlideRoot.pool.ftemp1;
408 const FxU32 culltest = (gc->state.cull_mode << 31UL);
409
410 /* Zero-area triangles are BAD!! */
411 - if ((j & 0x7FFFFFFF) == 0) {
412 + if ((_GlideRoot.pool.temp1.i & 0x7FFFFFFF) == 0) {
413 GDBG_INFO(291, FN_NAME": Culling (%g %g) (%g %g) (%g %g) : (%g : 0x%X : 0x%X)\n",
414 FloatVal(fa[0]), FloatVal(fa[1]),
415 FloatVal(fb[0]), FloatVal(fb[1]),
416 FloatVal(fc[0]), FloatVal(fc[1]),
417 - _GlideRoot.pool.ftemp1, gc->state.cull_mode, culltest);
418 + _GlideRoot.pool.temp1.f, gc->state.cull_mode, culltest);
419
420 return 0;
421 }
422
423 /* Backface culling, use sign bit as test */
424 - if ((gc->state.cull_mode != GR_CULL_DISABLE) && (((FxI32)(j ^ culltest)) >= 0)) {
425 + if ((gc->state.cull_mode != GR_CULL_DISABLE) &&
426 + (((FxI32)(_GlideRoot.pool.temp1.i ^ culltest)) >= 0)) {
427 GDBG_INFO(291, FN_NAME": Culling (%g %g) (%g %g) (%g %g) : (%g : 0x%X : 0x%X)\n",
428 FloatVal(fa[0]), FloatVal(fa[1]),
429 FloatVal(fb[0]), FloatVal(fb[1]),
430 FloatVal(fc[0]), FloatVal(fc[1]),
431 - _GlideRoot.pool.ftemp1, gc->state.cull_mode, culltest);
432 + _GlideRoot.pool.temp1.f, gc->state.cull_mode, culltest);
433
434 return -1;
435 }
436 diff -ur Glide3.orig/h3/glide3/src/fxcmd.h Glide3/h3/glide3/src/fxcmd.h
437 --- Glide3.orig/h3/glide3/src/fxcmd.h 2005-06-09 20:32:28.000000000 +0200
438 +++ Glide3/h3/glide3/src/fxcmd.h 2006-01-16 16:43:14.000000000 +0100
439 @@ -991,10 +991,10 @@
440 */
441 #if GLIDE_PACKED_RGB
442 #define RGBA_COMP(__fpVal, __fpBias, __fpShift, __fpMask) \
443 -((gc->pool.ftemp1 = (float)((float)(__fpVal + (float)(__fpBias))), \
444 +((gc->pool.temp1.f = (float)((float)(__fpVal + (float)(__fpBias))), \
445 GR_ASSERT((__fpVal) >= 0.0f), \
446 GR_ASSERT((__fpVal) < 256.0f), \
447 - (((*(const FxU32*)&gc->pool.ftemp1) & (__fpMask)) << (__fpShift)))
448 + ((gc->pool.temp1.u & (__fpMask)) << (__fpShift)))
449
450 #define RGBA_COMP_CLAMP(__fpVal, __compToken) \
451 RGBA_COMP(__fpVal, kPackBias##__compToken, kPackShift##__compToken, kPackMask##__compToken)
452 Only in Glide3/h3/glide3/src: fxcmd.h.warn
453 diff -ur Glide3.orig/h3/glide3/src/fxgasm.c Glide3/h3/glide3/src/fxgasm.c
454 --- Glide3.orig/h3/glide3/src/fxgasm.c 2005-06-16 20:58:31.000000000 +0200
455 +++ Glide3/h3/glide3/src/fxgasm.c 2006-01-16 16:43:14.000000000 +0100
456 @@ -183,8 +183,8 @@
457 #endif
458
459 #if GLIDE_PACKED_RGB
460 - OFFSET (gc, pool.ftemp1, "fTemp1");
461 - OFFSET (gc, pool.ftemp2, "fTemp2");
462 + OFFSET (gc, pool.temp1.f, "fTemp1");
463 + OFFSET (gc, pool.temp2.f, "fTemp2");
464 #endif
465
466 HEADER ("GlideRoot");
467 Only in Glide3/h3/glide3/src: fxgasm.c.warn
468 diff -ur Glide3.orig/h3/glide3/src/fxglide.h Glide3/h3/glide3/src/fxglide.h
469 --- Glide3.orig/h3/glide3/src/fxglide.h 2005-06-10 16:17:54.000000000 +0200
470 +++ Glide3/h3/glide3/src/fxglide.h 2006-01-16 16:43:14.000000000 +0100
471 @@ -1014,7 +1014,9 @@
472 } stats;
473
474 struct {
475 - float ftemp1, ftemp2; /* temps to convert floats to ints */
476 + /* temps to convert floats to ints */
477 + union { float f; FxI32 i; FxU32 u; } temp1;
478 + union { float f; FxI32 i; FxU32 u; } temp2;
479 } pool;
480
481 #if GLIDE_HW_TRI_SETUP
482 Only in Glide3/h3/glide3/src: fxglide.h.warn
483 diff -ur Glide3.orig/h3/glide3/src/gaa.c Glide3/h3/glide3/src/gaa.c
484 --- Glide3.orig/h3/glide3/src/gaa.c 2005-08-13 23:07:02.000000000 +0200
485 +++ Glide3/h3/glide3/src/gaa.c 2006-01-16 16:43:14.000000000 +0100
486 @@ -1456,35 +1456,32 @@
487 dyBC = fb[yindex] - fc[yindex];
488
489 /* Stash the area in the float pool for easy access */
490 - gc->pool.ftemp1 = dxAB * dyBC - dxBC * dyAB;
491 + gc->pool.temp1.f = dxAB * dyBC - dxBC * dyAB;
492
493 #define FloatVal(__f) (((__f) < 786432.875) ? (__f) : ((__f) - 786432.875))
494 - {
495 - const FxI32 j = *(FxI32*)&gc->pool.ftemp1;
496 -
497 - /* Zero-area triangles are BAD!! */
498 - if ((j & 0x7FFFFFFF) == 0) {
499 - GDBG_INFO(291, FN_NAME": Culling (%g %g) (%g %g) (%g %g) : (%g : 0x%X : 0x%X)\n",
500 - FloatVal(fa[xindex]), FloatVal(fa[yindex]),
501 - FloatVal(fb[xindex]), FloatVal(fb[yindex]),
502 - FloatVal(fc[xindex]), FloatVal(fc[yindex]),
503 - gc->pool.ftemp1, gc->state.cull_mode, culltest);
504
505 - goto done;
506 - }
507 + /* Zero-area triangles are BAD!! */
508 + if ((gc->pool.temp1.i & 0x7FFFFFFF) == 0) {
509 + GDBG_INFO(291, FN_NAME": Culling (%g %g) (%g %g) (%g %g) : (%g : 0x%X : 0x%X)\n",
510 + FloatVal(fa[xindex]), FloatVal(fa[yindex]),
511 + FloatVal(fb[xindex]), FloatVal(fb[yindex]),
512 + FloatVal(fc[xindex]), FloatVal(fc[yindex]),
513 + gc->pool.temp1.f, gc->state.cull_mode, culltest);
514 +
515 + goto done;
516 + }
517 +
518 + /* Backface culling, use sign bit as test */
519 + if ((gc->state.cull_mode != GR_CULL_DISABLE) &&
520 + ((gc->pool.temp1.i ^ (culltest << 31)) >= 0)) {
521 +
522 + GDBG_INFO(291, FN_NAME": Culling (%g %g) (%g %g) (%g %g) : (%g : 0x%X : 0x%X)\n",
523 + FloatVal(fa[xindex]), FloatVal(fa[yindex]),
524 + FloatVal(fb[xindex]), FloatVal(fb[yindex]),
525 + FloatVal(fc[xindex]), FloatVal(fc[yindex]),
526 + gc->pool.temp1.f, gc->state.cull_mode, culltest);
527
528 - /* Backface culling, use sign bit as test */
529 - if ((gc->state.cull_mode != GR_CULL_DISABLE) &&
530 - ((j ^ (culltest << 31)) >= 0)) {
531 -
532 - GDBG_INFO(291, FN_NAME": Culling (%g %g) (%g %g) (%g %g) : (%g : 0x%X : 0x%X)\n",
533 - FloatVal(fa[xindex]), FloatVal(fa[yindex]),
534 - FloatVal(fb[xindex]), FloatVal(fb[yindex]),
535 - FloatVal(fc[xindex]), FloatVal(fc[yindex]),
536 - gc->pool.ftemp1, gc->state.cull_mode, culltest);
537 -
538 - goto done;
539 - }
540 + goto done;
541 }
542 }
543 } /* end culling test */
544 @@ -1644,35 +1641,31 @@
545 dyBC = fb[yindex] - fc[yindex];
546
547 /* Stash the area in the float pool for easy access */
548 - gc->pool.ftemp1 = dxAB * dyBC - dxBC * dyAB;
549 + gc->pool.temp1.f = dxAB * dyBC - dxBC * dyAB;
550
551 #define FloatVal(__f) (((__f) < 786432.875) ? (__f) : ((__f) - 786432.875))
552 - {
553 - const FxI32 j = *(FxI32*)&gc->pool.ftemp1;
554 -
555 - /* Zero-area triangles are BAD!! */
556 - if ((j & 0x7FFFFFFF) == 0) {
557 - GDBG_INFO(291, FN_NAME": Culling (%g %g) (%g %g) (%g %g) : (%g : 0x%X : 0x%X)\n",
558 - FloatVal(fa[xindex]), FloatVal(fa[yindex]),
559 - FloatVal(fb[xindex]), FloatVal(fb[yindex]),
560 - FloatVal(fc[xindex]), FloatVal(fc[yindex]),
561 - gc->pool.ftemp1, gc->state.cull_mode, culltest);
562 + /* Zero-area triangles are BAD!! */
563 + if ((gc->pool.temp1.i & 0x7FFFFFFF) == 0) {
564 + GDBG_INFO(291, FN_NAME": Culling (%g %g) (%g %g) (%g %g) : (%g : 0x%X : 0x%X)\n",
565 + FloatVal(fa[xindex]), FloatVal(fa[yindex]),
566 + FloatVal(fb[xindex]), FloatVal(fb[yindex]),
567 + FloatVal(fc[xindex]), FloatVal(fc[yindex]),
568 + gc->pool.temp1.f, gc->state.cull_mode, culltest);
569
570 - goto done;
571 - }
572 + goto done;
573 + }
574 +
575 + /* Backface culling, use sign bit as test */
576 + if ((gc->state.cull_mode != GR_CULL_DISABLE) &&
577 + ((gc->pool.temp1.i ^ (culltest << 31)) >= 0)) {
578 +
579 + GDBG_INFO(291, FN_NAME": Culling (%g %g) (%g %g) (%g %g) : (%g : 0x%X : 0x%X)\n",
580 + FloatVal(fa[xindex]), FloatVal(fa[yindex]),
581 + FloatVal(fb[xindex]), FloatVal(fb[yindex]),
582 + FloatVal(fc[xindex]), FloatVal(fc[yindex]),
583 + gc->pool.temp1.f, gc->state.cull_mode, culltest);
584
585 - /* Backface culling, use sign bit as test */
586 - if ((gc->state.cull_mode != GR_CULL_DISABLE) &&
587 - ((j ^ (culltest << 31)) >= 0)) {
588 -
589 - GDBG_INFO(291, FN_NAME": Culling (%g %g) (%g %g) (%g %g) : (%g : 0x%X : 0x%X)\n",
590 - FloatVal(fa[xindex]), FloatVal(fa[yindex]),
591 - FloatVal(fb[xindex]), FloatVal(fb[yindex]),
592 - FloatVal(fc[xindex]), FloatVal(fc[yindex]),
593 - gc->pool.ftemp1, gc->state.cull_mode, culltest);
594 -
595 - goto done;
596 - }
597 + goto done;
598 }
599 }
600 } /* end culling test */
601 Only in Glide3/h3/glide3/src: gaa.c.warn
602 diff -ur Glide3.orig/h3/glide3/src/gdraw.c Glide3/h3/glide3/src/gdraw.c
603 --- Glide3.orig/h3/glide3/src/gdraw.c 2005-06-09 20:32:28.000000000 +0200
604 +++ Glide3/h3/glide3/src/gdraw.c 2006-01-16 16:43:14.000000000 +0100
605 @@ -445,8 +445,8 @@
606 0x02, sizeof(FxU32) << 1, SSTCP_PKT3_BDDDDD);
607
608 /* Convert to 32-bit representation */
609 - gc->pool.ftemp1 = FARRAY(vPtr, gc->state.vData.vertexInfo.offset) + bias;
610 - gc->pool.ftemp2 = FARRAY(vPtr, gc->state.vData.vertexInfo.offset + 4) + bias;
611 + gc->pool.temp1.f = FARRAY(vPtr, gc->state.vData.vertexInfo.offset) + bias;
612 + gc->pool.temp2.f = FARRAY(vPtr, gc->state.vData.vertexInfo.offset + 4) + bias;
613
614 /* draw a little triangle, with the lower left corner at pixel center. */
615
616 @@ -461,9 +461,9 @@
617
618 /* Mask off the real fractional bits from the mantissa */
619 /* [dBorca] Hack alert: bad type-punning with gcc -O2 */
620 - x = ((*(FxU32*)&gc->pool.ftemp1 & (0xFFFFFFFFUL << (22UL - kNumMantissaBits))) +
621 + x = ((gc->pool.temp1.u & (0xFFFFFFFFUL << (22UL - kNumMantissaBits))) +
622 (0x01UL << (22UL - kNumMantissaBits)));
623 - y = ((*(FxU32*)&gc->pool.ftemp2 & (0xFFFFFFFFUL << (22UL - kNumMantissaBits))) +
624 + y = ((gc->pool.temp2.u & (0xFFFFFFFFUL << (22UL - kNumMantissaBits))) +
625 (0x01UL << (22UL - kNumMantissaBits)));
626
627 /* Lower right corner */
628 @@ -530,21 +530,21 @@
629 0x02, sizeof(FxU32) << 1, SSTCP_PKT3_BDDDDD);
630
631 /* Convert to 32-bit representation */
632 - gc->pool.ftemp1 = (FARRAY(vPtr, gc->state.vData.vertexInfo.offset) *
633 + gc->pool.temp1.f = (FARRAY(vPtr, gc->state.vData.vertexInfo.offset) *
634 oow *
635 gc->state.Viewport.hwidth +
636 gc->state.Viewport.ox +
637 bias);
638 - gc->pool.ftemp2 = (FARRAY(vPtr, gc->state.vData.vertexInfo.offset + 4) *
639 + gc->pool.temp2.f = (FARRAY(vPtr, gc->state.vData.vertexInfo.offset + 4) *
640 oow *
641 gc->state.Viewport.hheight +
642 gc->state.Viewport.oy +
643 bias);
644
645 /* Mask off the real fractional bits from the mantissa */
646 - x = ((*(FxU32*)&gc->pool.ftemp1 & (0xFFFFFFFFUL << (22UL - kNumMantissaBits))) +
647 + x = ((gc->pool.temp1.u & (0xFFFFFFFFUL << (22UL - kNumMantissaBits))) +
648 (0x01UL << (22UL - kNumMantissaBits)));
649 - y = ((*(FxU32*)&gc->pool.ftemp2 & (0xFFFFFFFFUL << (22UL - kNumMantissaBits))) +
650 + y = ((gc->pool.temp2.u & (0xFFFFFFFFUL << (22UL - kNumMantissaBits))) +
651 (0x01UL << (22UL - kNumMantissaBits)));
652
653 /* Lower right cornder */
654 @@ -603,13 +603,11 @@
655 * except the data set up is from the pointer array and
656 * its data layout
657 */
658 - int j;
659 - FxI32 sCount;
660 + FxI32 stride, sCount;
661 FxU32 vertexParamOffset;
662 - FxI32 stride;
663
664 -#define DX gc->pool.ftemp1
665 -#define ADY gc->pool.ftemp2
666 +#define DX gc->pool.temp1
667 +#define ADY gc->pool.temp2
668
669 GR_BEGIN_NOFIFOCHECK("_grDrawLineStrip", 91);
670
671 @@ -634,8 +632,7 @@
672
673 if (gc->state.grCoordinateSpaceArgs.coordinate_space_mode == GR_WINDOW_COORDS) {
674 while (sCount > 0) {
675 - FxI32 k, i;
676 - FxI32 vcount = sCount >= LINES_BUFFER ? LINES_BUFFER : sCount;
677 + FxI32 k, vcount = sCount >= LINES_BUFFER ? LINES_BUFFER : sCount;
678
679 GR_SET_EXPECTED_SIZE((gc->state.vData.vSize << 2) * vcount, vcount);
680 DA_BEGIN;
681 @@ -653,23 +650,18 @@
682 /*
683 ** compute absolute deltas and draw from low Y to high Y
684 */
685 - ADY = FARRAY(b, gc->state.vData.vertexInfo.offset+4) - FARRAY(a, gc->state.vData.vertexInfo.offset+4);
686 - i = *(int *)&ADY;
687 - if (i < 0) {
688 + ADY.f = FARRAY(b, gc->state.vData.vertexInfo.offset+4) - FARRAY(a, gc->state.vData.vertexInfo.offset+4);
689 + if (ADY.i < 0) {
690 float *tv;
691 tv = a; a = b; b = tv;
692 - i ^= 0x80000000; /* ady = -ady; */
693 - (*(int *)&ADY) = i;
694 + ADY.i ^= 0x80000000; /* ady = -ady; */
695 }
696
697 - DX = FARRAY(b, gc->state.vData.vertexInfo.offset) - FARRAY(a, gc->state.vData.vertexInfo.offset);
698 - j = *(int *)&DX;
699 - if (j < 0) {
700 - j ^= 0x80000000; /* adx = -adx; */
701 - }
702 + DX.f = FARRAY(b, gc->state.vData.vertexInfo.offset) - FARRAY(a, gc->state.vData.vertexInfo.offset);
703 + DX.i &= 0x7fffffff; /* abs(adx) */
704
705 /* check for zero-length lines */
706 - if ((j >= i) && (j == 0)) {
707 + if ((DX.i >= ADY.i) && (DX.i == 0)) {
708 #ifdef GLIDE_DEBUG
709 gc->expected_counter -= (gc->state.vData.vSize << 2 );
710 gc->checkCounter -= ((gc->state.vData.vSize+1) << 2 );
711 @@ -686,10 +678,11 @@
712 */
713 DA_CONT(kSetupCullDisable | kSetupStrip, gc->cmdTransportInfo.paramMask,
714 0x04UL, vertexParamOffset, SSTCP_PKT3_BDDDDD);
715 - {
716 + {
717 + int i;
718 FxU32 dataElem;
719 /* x major */
720 - if (j >= i) {
721 + if (DX.i >= ADY.i) {
722 DA_SETF(FARRAY(b, gc->state.vData.vertexInfo.offset));
723 dataElem = 0;
724 DA_SETF(FARRAY(b, gc->state.vData.vertexInfo.offset+4) - _GlideRoot.pool.fHalf);
725 @@ -788,8 +781,7 @@
726 float oowa, oowb = 0.0f, owa, owb, tmp1, tmp2, fax, fay, fbx, fby;
727
728 while (sCount > 0) {
729 - FxI32 k, i;
730 - FxI32 vcount = sCount >= LINES_BUFFER ? LINES_BUFFER : sCount;
731 + FxI32 k, vcount = sCount >= LINES_BUFFER ? LINES_BUFFER : sCount;
732 float *a,*b;
733 GR_SET_EXPECTED_SIZE((gc->state.vData.vSize << 2) * vcount, vcount);
734 DA_BEGIN;
735 @@ -824,36 +816,31 @@
736 /*
737 ** compute absolute deltas and draw from low Y to high Y
738 */
739 - ADY = tmp2 - tmp1;
740 - i = *(int *)&ADY;
741 - if (i < 0) {
742 + ADY.f = tmp2 - tmp1;
743 + if (ADY.i < 0) {
744 float *tv;
745 owa = oowb; owb = oowa;
746 fay = tmp2;
747 fby = tmp1;
748 tv = a; a = b; b = tv;
749 - i ^= 0x80000000; /* ady = -ady; */
750 - (*(int *)&ADY) = i;
751 + ADY.i ^= 0x80000000; /* ady = -ady; */
752 }
753 fax = FARRAY(a, gc->state.vData.vertexInfo.offset)
754 *owa*gc->state.Viewport.hwidth+gc->state.Viewport.ox;
755 fbx = FARRAY(b, gc->state.vData.vertexInfo.offset)
756 *owb*gc->state.Viewport.hwidth+gc->state.Viewport.ox;
757
758 - DX = fbx - fax;
759 - j = *(int *)&DX;
760 - if (j < 0) {
761 - j ^= 0x80000000; /* adx = -adx; */
762 - }
763 + DX.f = fbx - fax;
764 + DX.i &= 0x7fffffff; /* abs(adx) */
765
766 /* check for zero-length lines */
767 - if ((j >= i) && (j == 0)) goto all_done_vp;
768 + if ((DX.i >= ADY.i) && (DX.i == 0)) goto all_done_vp;
769
770 DA_CONT(kSetupCullDisable | kSetupStrip, gc->cmdTransportInfo.paramMask,
771 0x04UL, vertexParamOffset, SSTCP_PKT3_BDDDDD);
772 {
773 /* x major */
774 - if (j >= i) {
775 + if (DX.i >= ADY.i) {
776 DA_SETF(fbx);
777 DA_SETF(fby - _GlideRoot.pool.fHalf);
778 DA_VP_SETFS(b,oowb);
779 Only in Glide3/h3/glide3/src: gdraw.c.warn
780 diff -ur Glide3.orig/h5/glide3/src/fxcmd.h Glide3/h5/glide3/src/fxcmd.h
781 --- Glide3.orig/h5/glide3/src/fxcmd.h 2005-06-09 20:32:31.000000000 +0200
782 +++ Glide3/h5/glide3/src/fxcmd.h 2006-01-16 16:43:14.000000000 +0100
783 @@ -1119,10 +1119,10 @@
784 */
785 #if GLIDE_PACKED_RGB
786 #define RGBA_COMP(__fpVal, __fpBias, __fpShift, __fpMask) \
787 -((gc->pool.ftemp1 = (float)((float)(__fpVal + (float)(__fpBias))), \
788 +((gc->pool.temp1.f = (float)((float)(__fpVal + (float)(__fpBias))), \
789 GR_ASSERT((__fpVal) >= 0.0f), \
790 GR_ASSERT((__fpVal) < 256.0f), \
791 - (((*(const FxU32*)&gc->pool.ftemp1) & (__fpMask)) << (__fpShift)))
792 + ((gc->pool.temp1.u & (__fpMask)) << (__fpShift)))
793
794 #define RGBA_COMP_CLAMP(__fpVal, __compToken) \
795 RGBA_COMP(__fpVal, kPackBias##__compToken, kPackShift##__compToken, kPackMask##__compToken)
796 Only in Glide3/h5/glide3/src: fxcmd.h.warn
797 diff -ur Glide3.orig/h5/glide3/src/fxgasm.c Glide3/h5/glide3/src/fxgasm.c
798 --- Glide3.orig/h5/glide3/src/fxgasm.c 2005-06-16 20:58:32.000000000 +0200
799 +++ Glide3/h5/glide3/src/fxgasm.c 2006-01-16 16:43:14.000000000 +0100
800 @@ -186,8 +186,8 @@
801 #endif
802
803 #if GLIDE_PACKED_RGB
804 - OFFSET (gc, pool.ftemp1, "fTemp1");
805 - OFFSET (gc, pool.ftemp2, "fTemp2");
806 + OFFSET (gc, pool.temp1.f, "fTemp1");
807 + OFFSET (gc, pool.temp2.f, "fTemp2");
808 #endif
809
810 HEADER ("GlideRoot");
811 Only in Glide3/h5/glide3/src: fxgasm.c.warn
812 diff -ur Glide3.orig/h5/glide3/src/fxglide.h Glide3/h5/glide3/src/fxglide.h
813 --- Glide3.orig/h5/glide3/src/fxglide.h 2005-06-10 16:17:55.000000000 +0200
814 +++ Glide3/h5/glide3/src/fxglide.h 2006-01-16 16:43:14.000000000 +0100
815 @@ -1547,7 +1547,9 @@
816 } stats;
817
818 struct {
819 - float ftemp1, ftemp2; /* temps to convert floats to ints */
820 + /* temps to convert floats to ints */
821 + union { float f; FxI32 i; FxU32 u; } temp1;
822 + union { float f; FxI32 i; FxU32 u; } temp2;
823 } pool;
824
825 #if GLIDE_HW_TRI_SETUP
826 Only in Glide3/h5/glide3/src: fxglide.h.warn
827 diff -ur Glide3.orig/h5/glide3/src/gaa.c Glide3/h5/glide3/src/gaa.c
828 --- Glide3.orig/h5/glide3/src/gaa.c 2005-08-13 23:07:03.000000000 +0200
829 +++ Glide3/h5/glide3/src/gaa.c 2006-01-16 16:43:14.000000000 +0100
830 @@ -1458,35 +1458,32 @@
831 dyBC = fb[yindex] - fc[yindex];
832
833 /* Stash the area in the float pool for easy access */
834 - gc->pool.ftemp1 = dxAB * dyBC - dxBC * dyAB;
835 + gc->pool.temp1.f = dxAB * dyBC - dxBC * dyAB;
836
837 #define FloatVal(__f) (((__f) < 786432.875) ? (__f) : ((__f) - 786432.875))
838 - {
839 - const FxI32 j = *(FxI32*)&gc->pool.ftemp1;
840 -
841 - /* Zero-area triangles are BAD!! */
842 - if ((j & 0x7FFFFFFF) == 0) {
843 - GDBG_INFO(291, FN_NAME": Culling (%g %g) (%g %g) (%g %g) : (%g : 0x%X : 0x%X)\n",
844 - FloatVal(fa[xindex]), FloatVal(fa[yindex]),
845 - FloatVal(fb[xindex]), FloatVal(fb[yindex]),
846 - FloatVal(fc[xindex]), FloatVal(fc[yindex]),
847 - gc->pool.ftemp1, gc->state.cull_mode, culltest);
848
849 - goto done;
850 - }
851 + /* Zero-area triangles are BAD!! */
852 + if ((gc->pool.temp1.i & 0x7FFFFFFF) == 0) {
853 + GDBG_INFO(291, FN_NAME": Culling (%g %g) (%g %g) (%g %g) : (%g : 0x%X : 0x%X)\n",
854 + FloatVal(fa[xindex]), FloatVal(fa[yindex]),
855 + FloatVal(fb[xindex]), FloatVal(fb[yindex]),
856 + FloatVal(fc[xindex]), FloatVal(fc[yindex]),
857 + gc->pool.temp1.f, gc->state.cull_mode, culltest);
858 +
859 + goto done;
860 + }
861 +
862 + /* Backface culling, use sign bit as test */
863 + if ((gc->state.cull_mode != GR_CULL_DISABLE) &&
864 + ((gc->pool.temp1.i ^ (culltest << 31)) >= 0)) {
865 +
866 + GDBG_INFO(291, FN_NAME": Culling (%g %g) (%g %g) (%g %g) : (%g : 0x%X : 0x%X)\n",
867 + FloatVal(fa[xindex]), FloatVal(fa[yindex]),
868 + FloatVal(fb[xindex]), FloatVal(fb[yindex]),
869 + FloatVal(fc[xindex]), FloatVal(fc[yindex]),
870 + gc->pool.temp1.f, gc->state.cull_mode, culltest);
871
872 - /* Backface culling, use sign bit as test */
873 - if ((gc->state.cull_mode != GR_CULL_DISABLE) &&
874 - ((j ^ (culltest << 31)) >= 0)) {
875 -
876 - GDBG_INFO(291, FN_NAME": Culling (%g %g) (%g %g) (%g %g) : (%g : 0x%X : 0x%X)\n",
877 - FloatVal(fa[xindex]), FloatVal(fa[yindex]),
878 - FloatVal(fb[xindex]), FloatVal(fb[yindex]),
879 - FloatVal(fc[xindex]), FloatVal(fc[yindex]),
880 - gc->pool.ftemp1, gc->state.cull_mode, culltest);
881 -
882 - goto done;
883 - }
884 + goto done;
885 }
886 }
887 } /* end culling test */
888 @@ -1646,35 +1643,31 @@
889 dyBC = fb[yindex] - fc[yindex];
890
891 /* Stash the area in the float pool for easy access */
892 - gc->pool.ftemp1 = dxAB * dyBC - dxBC * dyAB;
893 + gc->pool.temp1.f = dxAB * dyBC - dxBC * dyAB;
894
895 #define FloatVal(__f) (((__f) < 786432.875) ? (__f) : ((__f) - 786432.875))
896 - {
897 - const FxI32 j = *(FxI32*)&gc->pool.ftemp1;
898 -
899 - /* Zero-area triangles are BAD!! */
900 - if ((j & 0x7FFFFFFF) == 0) {
901 - GDBG_INFO(291, FN_NAME": Culling (%g %g) (%g %g) (%g %g) : (%g : 0x%X : 0x%X)\n",
902 - FloatVal(fa[xindex]), FloatVal(fa[yindex]),
903 - FloatVal(fb[xindex]), FloatVal(fb[yindex]),
904 - FloatVal(fc[xindex]), FloatVal(fc[yindex]),
905 - gc->pool.ftemp1, gc->state.cull_mode, culltest);
906 + /* Zero-area triangles are BAD!! */
907 + if ((gc->pool.temp1.i & 0x7FFFFFFF) == 0) {
908 + GDBG_INFO(291, FN_NAME": Culling (%g %g) (%g %g) (%g %g) : (%g : 0x%X : 0x%X)\n",
909 + FloatVal(fa[xindex]), FloatVal(fa[yindex]),
910 + FloatVal(fb[xindex]), FloatVal(fb[yindex]),
911 + FloatVal(fc[xindex]), FloatVal(fc[yindex]),
912 + gc->pool.temp1.f, gc->state.cull_mode, culltest);
913
914 - goto done;
915 - }
916 + goto done;
917 + }
918 +
919 + /* Backface culling, use sign bit as test */
920 + if ((gc->state.cull_mode != GR_CULL_DISABLE) &&
921 + ((gc->pool.temp1.i ^ (culltest << 31)) >= 0)) {
922 +
923 + GDBG_INFO(291, FN_NAME": Culling (%g %g) (%g %g) (%g %g) : (%g : 0x%X : 0x%X)\n",
924 + FloatVal(fa[xindex]), FloatVal(fa[yindex]),
925 + FloatVal(fb[xindex]), FloatVal(fb[yindex]),
926 + FloatVal(fc[xindex]), FloatVal(fc[yindex]),
927 + gc->pool.temp1.f, gc->state.cull_mode, culltest);
928
929 - /* Backface culling, use sign bit as test */
930 - if ((gc->state.cull_mode != GR_CULL_DISABLE) &&
931 - ((j ^ (culltest << 31)) >= 0)) {
932 -
933 - GDBG_INFO(291, FN_NAME": Culling (%g %g) (%g %g) (%g %g) : (%g : 0x%X : 0x%X)\n",
934 - FloatVal(fa[xindex]), FloatVal(fa[yindex]),
935 - FloatVal(fb[xindex]), FloatVal(fb[yindex]),
936 - FloatVal(fc[xindex]), FloatVal(fc[yindex]),
937 - gc->pool.ftemp1, gc->state.cull_mode, culltest);
938 -
939 - goto done;
940 - }
941 + goto done;
942 }
943 }
944 } /* end culling test */
945 Only in Glide3/h5/glide3/src: gaa.c.warn
946 diff -ur Glide3.orig/h5/glide3/src/gdraw.c Glide3/h5/glide3/src/gdraw.c
947 --- Glide3.orig/h5/glide3/src/gdraw.c 2005-08-13 23:07:03.000000000 +0200
948 +++ Glide3/h5/glide3/src/gdraw.c 2006-01-16 16:43:14.000000000 +0100
949 @@ -496,8 +496,8 @@
950 0x02, sizeof(FxU32) << 1, SSTCP_PKT3_BDDDDD);
951
952 /* Convert to 32-bit representation */
953 - gc->pool.ftemp1 = FARRAY(vPtr, gc->state.vData.vertexInfo.offset) + bias;
954 - gc->pool.ftemp2 = FARRAY(vPtr, gc->state.vData.vertexInfo.offset + 4) + bias;
955 + gc->pool.temp1.f = FARRAY(vPtr, gc->state.vData.vertexInfo.offset) + bias;
956 + gc->pool.temp2.f = FARRAY(vPtr, gc->state.vData.vertexInfo.offset + 4) + bias;
957
958 /* draw a little triangle, with the lower left corner at pixel center. */
959
960 @@ -511,9 +511,9 @@
961 */
962
963 /* Mask off the real fractional bits from the mantissa */
964 - x = ((*(FxU32*)&gc->pool.ftemp1 & (0xFFFFFFFFUL << (22UL - kNumMantissaBits))) +
965 + x = ((gc->pool.temp1.u & (0xFFFFFFFFUL << (22UL - kNumMantissaBits))) +
966 (0x01UL << (22UL - kNumMantissaBits)));
967 - y = ((*(FxU32*)&gc->pool.ftemp2 & (0xFFFFFFFFUL << (22UL - kNumMantissaBits))) +
968 + y = ((gc->pool.temp2.u & (0xFFFFFFFFUL << (22UL - kNumMantissaBits))) +
969 (0x01UL << (22UL - kNumMantissaBits)));
970
971 /* Lower right corner */
972 @@ -585,12 +585,12 @@
973 y += lbias;
974
975 /* Convert to 32-bit representation */
976 - gc->pool.ftemp1 = (const float)x;
977 - gc->pool.ftemp2 = (const float)y;
978 + gc->pool.temp1.f = (const float)x;
979 + gc->pool.temp2.f = (const float)y;
980
981 /* Correct the bias to get rid of the fractional bits */
982 - x = /*(volatile float)*/gc->pool.ftemp1 - lbias;
983 - y = /*(volatile float)*/gc->pool.ftemp2 - lbias;
984 + x = /*(volatile float)*/gc->pool.temp1.f - lbias;
985 + y = /*(volatile float)*/gc->pool.temp2.f - lbias;
986
987 /* Lower right corner */
988 DA_SETF(x);
989 @@ -686,25 +686,25 @@
990
991 /* Convert to 32-bit representation */
992
993 - gc->pool.ftemp1 = (FARRAY(vPtr, gc->state.vData.vertexInfo.offset) *
994 + gc->pool.temp1.f = (FARRAY(vPtr, gc->state.vData.vertexInfo.offset) *
995 oow *
996 gc->state.Viewport.hwidth +
997 gc->state.Viewport.ox +
998 0.5f);
999 - gc->pool.ftemp2 = (FARRAY(vPtr, gc->state.vData.vertexInfo.offset + 4) *
1000 + gc->pool.temp2.f = (FARRAY(vPtr, gc->state.vData.vertexInfo.offset + 4) *
1001 oow *
1002 gc->state.Viewport.hheight +
1003 gc->state.Viewport.oy +
1004 0.5f);
1005
1006 - fx = gc->pool.ftemp1;
1007 - fy = gc->pool.ftemp2;
1008 + fx = gc->pool.temp1.f;
1009 + fy = gc->pool.temp2.f;
1010
1011 - gc->pool.ftemp1 += lbias;
1012 - gc->pool.ftemp2 += lbias;
1013 + gc->pool.temp1.f += lbias;
1014 + gc->pool.temp2.f += lbias;
1015
1016 - fx = gc->pool.ftemp1 - lbias;
1017 - fy = gc->pool.ftemp2 - lbias;
1018 + fx = gc->pool.temp1.f - lbias;
1019 + fy = gc->pool.temp2.f - lbias;
1020
1021 /* Lower right corner */
1022 DA_SETF(fx);
1023 @@ -770,13 +770,11 @@
1024 * except the data set up is from the pointer array and
1025 * its data layout
1026 */
1027 - int j;
1028 - FxI32 sCount;
1029 + FxI32 stride, sCount;
1030 FxU32 vertexParamOffset;
1031 - FxI32 stride;
1032
1033 -#define DX gc->pool.ftemp1
1034 -#define ADY gc->pool.ftemp2
1035 +#define DX gc->pool.temp1
1036 +#define ADY gc->pool.temp2
1037
1038 GR_BEGIN_NOFIFOCHECK("_grDrawLineStrip", 91);
1039
1040 @@ -801,8 +799,7 @@
1041
1042 if (gc->state.grCoordinateSpaceArgs.coordinate_space_mode == GR_WINDOW_COORDS) {
1043 while (sCount > 0) {
1044 - FxI32 k, i;
1045 - FxI32 vcount = sCount >= LINES_BUFFER ? LINES_BUFFER : sCount;
1046 + FxI32 k, vcount = sCount >= LINES_BUFFER ? LINES_BUFFER : sCount;
1047
1048 GR_SET_EXPECTED_SIZE((gc->state.vData.vSize << 2) * vcount, vcount);
1049 DA_BEGIN;
1050 @@ -820,23 +817,18 @@
1051 /*
1052 ** compute absolute deltas and draw from low Y to high Y
1053 */
1054 - ADY = FARRAY(b, gc->state.vData.vertexInfo.offset+4) - FARRAY(a, gc->state.vData.vertexInfo.offset+4);
1055 - i = *(int *)&ADY;
1056 - if (i < 0) {
1057 + ADY.f = FARRAY(b, gc->state.vData.vertexInfo.offset+4) - FARRAY(a, gc->state.vData.vertexInfo.offset+4);
1058 + if (ADY.i < 0) {
1059 float *tv;
1060 tv = a; a = b; b = tv;
1061 - i ^= 0x80000000; /* ady = -ady; */
1062 - (*(int *)&ADY) = i;
1063 + ADY.i ^= 0x80000000; /* ady = -ady; */
1064 }
1065
1066 - DX = FARRAY(b, gc->state.vData.vertexInfo.offset) - FARRAY(a, gc->state.vData.vertexInfo.offset);
1067 - j = *(int *)&DX;
1068 - if (j < 0) {
1069 - j ^= 0x80000000; /* adx = -adx; */
1070 - }
1071 + DX.f = FARRAY(b, gc->state.vData.vertexInfo.offset) - FARRAY(a, gc->state.vData.vertexInfo.offset);
1072 + DX.i &= 0x7fffffff; /* abs(adx) */
1073
1074 /* check for zero-length lines */
1075 - if ((j >= i) && (j == 0)) {
1076 + if ((DX.i >= ADY.i) && (DX.i == 0)) {
1077 #ifdef GLIDE_DEBUG
1078 gc->expected_counter -= (gc->state.vData.vSize << 2 );
1079 gc->checkCounter -= ((gc->state.vData.vSize+1) << 2 );
1080 @@ -853,10 +845,11 @@
1081 */
1082 DA_CONT(kSetupCullDisable | kSetupStrip, gc->cmdTransportInfo.paramMask,
1083 0x04UL, vertexParamOffset, SSTCP_PKT3_BDDDDD);
1084 - {
1085 + {
1086 + int i;
1087 FxU32 dataElem;
1088 /* x major */
1089 - if (j >= i) {
1090 + if (DX.i >= ADY.i) {
1091 DA_SETF(FARRAY(b, gc->state.vData.vertexInfo.offset));
1092 dataElem = 0;
1093 DA_SETF(FARRAY(b, gc->state.vData.vertexInfo.offset+4) - _GlideRoot.pool.fHalf);
1094 @@ -955,8 +948,7 @@
1095 float oowa, oowb = 0.0f, owa, owb, tmp1, tmp2, fax, fay, fbx, fby;
1096
1097 while (sCount > 0) {
1098 - FxI32 k, i;
1099 - FxI32 vcount = sCount >= LINES_BUFFER ? LINES_BUFFER : sCount;
1100 + FxI32 k, vcount = sCount >= LINES_BUFFER ? LINES_BUFFER : sCount;
1101 float *a,*b;
1102 GR_SET_EXPECTED_SIZE((gc->state.vData.vSize << 2) * vcount, vcount);
1103 DA_BEGIN;
1104 @@ -991,36 +983,31 @@
1105 /*
1106 ** compute absolute deltas and draw from low Y to high Y
1107 */
1108 - ADY = tmp2 - tmp1;
1109 - i = *(int *)&ADY;
1110 - if (i < 0) {
1111 + ADY.f = tmp2 - tmp1;
1112 + if (ADY.i < 0) {
1113 float *tv;
1114 owa = oowb; owb = oowa;
1115 fay = tmp2;
1116 fby = tmp1;
1117 tv = a; a = b; b = tv;
1118 - i ^= 0x80000000; /* ady = -ady; */
1119 - (*(int *)&ADY) = i;
1120 + ADY.i ^= 0x80000000; /* ady = -ady; */
1121 }
1122 fax = FARRAY(a, gc->state.vData.vertexInfo.offset)
1123 *owa*gc->state.Viewport.hwidth+gc->state.Viewport.ox;
1124 fbx = FARRAY(b, gc->state.vData.vertexInfo.offset)
1125 *owb*gc->state.Viewport.hwidth+gc->state.Viewport.ox;
1126
1127 - DX = fbx - fax;
1128 - j = *(int *)&DX;
1129 - if (j < 0) {
1130 - j ^= 0x80000000; /* adx = -adx; */
1131 - }
1132 + DX.f = fbx - fax;
1133 + DX.i &= 0x7fffffff; /* abs(adx) */
1134
1135 /* check for zero-length lines */
1136 - if ((j >= i) && (j == 0)) goto all_done_vp;
1137 + if ((DX.i >= ADY.i) && (DX.i == 0)) goto all_done_vp;
1138
1139 DA_CONT(kSetupCullDisable | kSetupStrip, gc->cmdTransportInfo.paramMask,
1140 0x04UL, vertexParamOffset, SSTCP_PKT3_BDDDDD);
1141 {
1142 /* x major */
1143 - if (j >= i) {
1144 + if (DX.i >= ADY.i) {
1145 DA_SETF(fbx);
1146 DA_SETF(fby - _GlideRoot.pool.fHalf);
1147 DA_VP_SETFS(b,oowb);
1148 Only in Glide3/h5/glide3/src: gdraw.c.warn
1149 Only in Glide3: libglide3-v1.so
1150 Only in Glide3: libglide3-v2.so
1151 Only in Glide3: libglide3-v3.so
1152 Only in Glide3: libglide3-v5.so
1153 diff -ur Glide3.orig/sst1/glide3/src/fxglide.h Glide3/sst1/glide3/src/fxglide.h
1154 --- Glide3.orig/sst1/glide3/src/fxglide.h 2005-06-10 16:17:56.000000000 +0200
1155 +++ Glide3/sst1/glide3/src/fxglide.h 2006-01-16 16:43:14.000000000 +0100
1156 @@ -923,7 +923,9 @@
1157 float f1;
1158 float f255;
1159 float f256;
1160 - float ftemp1, ftemp2; /* temps to convert floats to ints */
1161 + /* temps to convert floats to ints */
1162 + union { float f; FxI32 i; FxU32 u; } temp1;
1163 + union { float f; FxI32 i; FxU32 u; } temp2;
1164 } pool;
1165
1166 struct { /* environment data */
1167 Only in Glide3/sst1/glide3/src: fxglide.h.warn
1168 diff -ur Glide3.orig/sst1/glide3/src/gaa.c Glide3/sst1/glide3/src/gaa.c
1169 --- Glide3.orig/sst1/glide3/src/gaa.c 2005-06-16 20:58:32.000000000 +0200
1170 +++ Glide3/sst1/glide3/src/gaa.c 2006-01-16 16:43:14.000000000 +0100
1171 @@ -1973,35 +1973,31 @@
1172 dyBC = fb[1] - fc[1];
1173
1174 /* Stash the area in the float pool for easy access */
1175 - _GlideRoot.pool.ftemp1 = dxAB * dyBC - dxBC * dyAB;
1176 + _GlideRoot.pool.temp1.f = dxAB * dyBC - dxBC * dyAB;
1177
1178 #define FloatVal(__f) (((__f) < 786432.875) ? (__f) : ((__f) - 786432.875))
1179 - {
1180 - const FxI32 j = *(FxI32*)&_GlideRoot.pool.ftemp1;
1181 -
1182 - /* Zero-area triangles are BAD!! */
1183 - if ((j & 0x7FFFFFFF) == 0) {
1184 - GDBG_INFO((291, FN_NAME": Culling (%g %g) (%g %g) (%g %g) : (%g : 0x%X : 0x%X)\n",
1185 - FloatVal(fa[0]), FloatVal(fa[1]),
1186 - FloatVal(fb[0]), FloatVal(fb[1]),
1187 - FloatVal(fc[0]), FloatVal(fc[1]),
1188 - _GlideRoot.pool.ftemp1, gc->state.cull_mode, culltest));
1189 + /* Zero-area triangles are BAD!! */
1190 + if ((_GlideRoot.pool.temp1.i & 0x7FFFFFFF) == 0) {
1191 + GDBG_INFO((291, FN_NAME": Culling (%g %g) (%g %g) (%g %g) : (%g : 0x%X : 0x%X)\n",
1192 + FloatVal(fa[0]), FloatVal(fa[1]),
1193 + FloatVal(fb[0]), FloatVal(fb[1]),
1194 + FloatVal(fc[0]), FloatVal(fc[1]),
1195 + _GlideRoot.pool.temp1.f, gc->state.cull_mode, culltest));
1196
1197 - goto done;
1198 - }
1199 + goto done;
1200 + }
1201 +
1202 + /* Backface culling, use sign bit as test */
1203 + if ((gc->state.cull_mode != GR_CULL_DISABLE) &&
1204 + ((_GlideRoot.pool.temp1.i ^ (culltest << 31)) >= 0)) {
1205
1206 - /* Backface culling, use sign bit as test */
1207 - if ((gc->state.cull_mode != GR_CULL_DISABLE) &&
1208 - ((j ^ (culltest << 31)) >= 0)) {
1209 -
1210 - GDBG_INFO((291, FN_NAME": Culling (%g %g) (%g %g) (%g %g) : (%g : 0x%X : 0x%X)\n",
1211 - FloatVal(fa[0]), FloatVal(fa[1]),
1212 - FloatVal(fb[0]), FloatVal(fb[1]),
1213 - FloatVal(fc[0]), FloatVal(fc[1]),
1214 - _GlideRoot.pool.ftemp1, gc->state.cull_mode, culltest));
1215 -
1216 - goto done;
1217 - }
1218 + GDBG_INFO((291, FN_NAME": Culling (%g %g) (%g %g) (%g %g) : (%g : 0x%X : 0x%X)\n",
1219 + FloatVal(fa[0]), FloatVal(fa[1]),
1220 + FloatVal(fb[0]), FloatVal(fb[1]),
1221 + FloatVal(fc[0]), FloatVal(fc[1]),
1222 + _GlideRoot.pool.temp1.f, gc->state.cull_mode, culltest));
1223 +
1224 + goto done;
1225 }
1226 }
1227 } /* end culling test */
1228 Only in Glide3/sst1/glide3/src: gaa.c.warn
1229 diff -ur Glide3.orig/sst1/glide3/src/gdraw.c Glide3/sst1/glide3/src/gdraw.c
1230 --- Glide3.orig/sst1/glide3/src/gdraw.c 2005-06-16 20:58:32.000000000 +0200
1231 +++ Glide3/sst1/glide3/src/gdraw.c 2006-01-16 16:43:14.000000000 +0100
1232 @@ -218,7 +218,7 @@
1233 const float *fb = (const float *)vb + xindex;
1234 const float *fc = (const float *)vc + xindex;
1235 float ooa, dxAB, dxBC, dyAB, dyBC;
1236 - int i,j,culltest;
1237 + int i,culltest;
1238 union { float f; int i; } ay;
1239 union { float f; int i; } by;
1240 union { float f; int i; } cy;
1241 @@ -319,16 +319,15 @@
1242 dyBC = snap_yb - snap_yc;
1243
1244 /* this is where we store the area */
1245 - _GlideRoot.pool.ftemp1 = dxAB * dyBC - dxBC * dyAB;
1246 + _GlideRoot.pool.temp1.f = dxAB * dyBC - dxBC * dyAB;
1247
1248 /* Zero-area triangles are BAD!! */
1249 - j = *(long *)&_GlideRoot.pool.ftemp1;
1250 - if ((j & 0x7FFFFFFF) == 0)
1251 + if ((_GlideRoot.pool.temp1.i & 0x7FFFFFFF) == 0)
1252 return 0;
1253
1254 /* Backface culling, use sign bit as test */
1255 if (gc->state.cull_mode != GR_CULL_DISABLE) {
1256 - if ((j ^ (culltest<<31)) >= 0) {
1257 + if ((_GlideRoot.pool.temp1.i ^ (culltest<<31)) >= 0) {
1258 return -1;
1259 }
1260 }
1261 @@ -371,7 +370,7 @@
1262 SET_GW_CMD( fifoPtr, 0, gc->hwDep.sst96Dep.gwCommand );
1263 SET_GW_HEADER( fifoPtr, 1, gc->hwDep.sst96Dep.gwHeaders[0] );
1264
1265 - ooa = _GlideRoot.pool.f1 / _GlideRoot.pool.ftemp1;
1266 + ooa = _GlideRoot.pool.f1 / _GlideRoot.pool.temp1.f;
1267 /* GMT: note that we spread out our PCI writes */
1268 /* write out X & Y for vertex A */
1269 FSET_GW_ENTRY( fifoPtr, 2, snap_xa );
1270 @@ -682,7 +681,7 @@
1271
1272 /* write triangle command */
1273 triangle_command:
1274 - FSET_GW_ENTRY( fifoPtr, 0, _GlideRoot.pool.ftemp1 );
1275 + FSET_GW_ENTRY( fifoPtr, 0, _GlideRoot.pool.temp1.f );
1276 fifoPtr+=1;
1277
1278 if (((FxU32)fifoPtr) & 0x7) {
1279 @@ -923,7 +922,7 @@
1280 const float *fb = (const float *)vb + xindex;
1281 const float *fc = (const float *)vc + xindex;
1282 float ooa, dxAB, dxBC, dyAB, dyBC;
1283 - int i,j,culltest;
1284 + int i,culltest;
1285 union { float f; int i; } ay;
1286 union { float f; int i; } by;
1287 union { float f; int i; } cy;
1288 @@ -1022,16 +1021,15 @@
1289 dyBC = snap_yb - snap_yc;
1290
1291 /* this is where we store the area */
1292 - _GlideRoot.pool.ftemp1 = dxAB * dyBC - dxBC * dyAB;
1293 + _GlideRoot.pool.temp1.f = dxAB * dyBC - dxBC * dyAB;
1294
1295 /* Zero-area triangles are BAD!! */
1296 - j = *(long *)&_GlideRoot.pool.ftemp1;
1297 - if ((j & 0x7FFFFFFF) == 0)
1298 + if ((_GlideRoot.pool.temp1.i & 0x7FFFFFFF) == 0)
1299 return 0;
1300
1301 /* Backface culling, use sign bit as test */
1302 if (gc->state.cull_mode != GR_CULL_DISABLE) {
1303 - if ((j ^ (culltest<<31)) >= 0) {
1304 + if ((_GlideRoot.pool.temp1.i ^ (culltest<<31)) >= 0) {
1305 return -1;
1306 }
1307 }
1308 @@ -1040,7 +1038,7 @@
1309
1310 GR_SET_EXPECTED_SIZE(_GlideRoot.curTriSize);
1311
1312 - ooa = _GlideRoot.pool.f1 / _GlideRoot.pool.ftemp1;
1313 + ooa = _GlideRoot.pool.f1 / _GlideRoot.pool.temp1.f;
1314 /* GMT: note that we spread out our PCI writes */
1315 /* write out X & Y for vertex A */
1316 GR_SETF( hw->FvA.x, snap_xa);
1317 @@ -1362,7 +1360,7 @@
1318 }
1319
1320 /* Draw the triangle by writing the area to the triangleCMD register */
1321 - P6FENCE_CMD( GR_SETF( hw->FtriangleCMD, _GlideRoot.pool.ftemp1 ) );
1322 + P6FENCE_CMD( GR_SETF( hw->FtriangleCMD, _GlideRoot.pool.temp1.f ) );
1323 _GlideRoot.stats.trisDrawn++;
1324
1325 GR_CHECK_SIZE_SLOPPY();
1326 @@ -1454,10 +1452,10 @@
1327 #endif
1328 fx = *vPtr + bias;
1329 fy = *(vPtr+1) + bias;
1330 - _GlideRoot.pool.ftemp1 = (float)fx;
1331 - _GlideRoot.pool.ftemp2 = (float)fy;
1332 - x = *(int *)&_GlideRoot.pool.ftemp1;
1333 - y = *(int *)&_GlideRoot.pool.ftemp2;
1334 + _GlideRoot.pool.temp1.f = (float)fx;
1335 + _GlideRoot.pool.temp2.f = (float)fy;
1336 + x = _GlideRoot.pool.temp1.i;
1337 + y = _GlideRoot.pool.temp2.i;
1338 x <<= SST_XY_FRACBITS; /* convert to fixed point */
1339 x += SST_XY_HALF; /* and center within pixel */
1340
1341 @@ -1528,10 +1526,10 @@
1342 fy = FARRAY(vPtr, 4)*oow*gc->state.Viewport.hheight
1343 + gc->state.Viewport.oy + bias;
1344
1345 - _GlideRoot.pool.ftemp1 = (float)fx;
1346 - _GlideRoot.pool.ftemp2 = (float)fy;
1347 - x = *(int *)&_GlideRoot.pool.ftemp1;
1348 - y = *(int *)&_GlideRoot.pool.ftemp2;
1349 + _GlideRoot.pool.temp1.f = (float)fx;
1350 + _GlideRoot.pool.temp2.f = (float)fy;
1351 + x = _GlideRoot.pool.temp1.i;
1352 + y = _GlideRoot.pool.temp2.i;
1353 x <<= SST_XY_FRACBITS; /* convert to fixed point */
1354 x += SST_XY_HALF; /* and center within pixel */
1355
1356 @@ -1705,11 +1703,11 @@
1357 {
1358 #define FN_NAME "_grDrawLineStrip"
1359
1360 + int i;
1361 float m, dp;
1362 - #define DX _GlideRoot.pool.ftemp1
1363 - #define ADY _GlideRoot.pool.ftemp2
1364 + #define DX _GlideRoot.pool.temp1
1365 + #define ADY _GlideRoot.pool.temp2
1366
1367 - int i,j;
1368 float *fp;
1369 struct dataList_s *dlp;
1370 FxI32 index;
1371 @@ -1759,30 +1757,25 @@
1372 /*
1373 ** compute absolute deltas and draw from low Y to high Y
1374 */
1375 - ADY = snap_yb - snap_ya;
1376 - i = *(long *)&ADY;
1377 - if ( i < 0 ) {
1378 + ADY.f = snap_yb - snap_ya;
1379 + if ( ADY.i < 0 ) {
1380 float *tv, ts;
1381 tv = a; a = b; b = tv;
1382 - i ^= 0x80000000; /* ady = -ady; */
1383 - (*(long *)&ADY) = i;
1384 + ADY.i ^= 0x80000000; /* ady = -ady; */
1385 ts = snap_xa; snap_xa = snap_xb; snap_xb = ts;
1386 ts = snap_ya; snap_ya = snap_yb; snap_yb = ts;
1387 }
1388
1389 - DX = snap_xb - snap_xa;
1390 - j = *(long *)&DX;
1391 - if (j < 0 ) {
1392 - j ^= 0x80000000; /* adx = -adx; */
1393 - }
1394 + DX.f = snap_xb - snap_xa;
1395 + DX.i &= 0x7fffffff; /* abs(adx) */
1396
1397 /*
1398 ** X major line
1399 */
1400 - if (j >= i ) { /* if (adx > ady) */
1401 - if (j == 0) goto all_done; /* check for zero-length lines */
1402 + if (DX.i >= ADY.i) { /* if (adx > ady) */
1403 + if (DX.i == 0) goto all_done; /* check for zero-length lines */
1404 /* start up divide and overlap with as much integer stuff as possible*/
1405 - m = _GlideRoot.pool.f1 / DX;
1406 + m = _GlideRoot.pool.f1 / DX.f;
1407 dlp = gc->dataList;
1408 GR_SETF(hw->FvA.x, snap_xa);
1409 dp = snap_xb;
1410 @@ -1827,18 +1820,18 @@
1411 GR_SETF( fp[DPDY_OFFSET>>2] , _GlideRoot.pool.f0 );
1412 }
1413 }
1414 - P6FENCE_CMD( GR_SETF(hw->FtriangleCMD,_GlideRoot.pool.ftemp1) );
1415 + P6FENCE_CMD( GR_SETF(hw->FtriangleCMD, DX.f) );
1416
1417 GR_SETF(hw->FvB.x, snap_xa);
1418 GR_SETF(hw->FvB.y, snap_ya + _GlideRoot.pool.fHalf);
1419 - P6FENCE_CMD( GR_SETF(hw->FtriangleCMD,-_GlideRoot.pool.ftemp1));
1420 + P6FENCE_CMD( GR_SETF(hw->FtriangleCMD, -DX.f));
1421 }
1422
1423 /*
1424 ** Y major line
1425 */
1426 else {
1427 - m = _GlideRoot.pool.f1 / ADY;
1428 + m = _GlideRoot.pool.f1 / ADY.f;
1429 dlp = gc->dataList;
1430 GR_SETF(hw->FvA.y, snap_ya);
1431 dp = snap_yb;
1432 @@ -1944,31 +1937,26 @@
1433 /*
1434 ** compute absolute deltas and draw from low Y to high Y
1435 */
1436 - ADY = tmp2 - tmp1;
1437 - i = *(long *)&ADY;
1438 - if ( i < 0 ) {
1439 + ADY.f = tmp2 - tmp1;
1440 + if ( ADY.i < 0 ) {
1441 float *tv, ts;
1442 owa = oowb; owb = oowa;
1443 tv = a; a = b; b = tv;
1444 - i ^= 0x80000000; /* ady = -ady; */
1445 - (*(long *)&ADY) = i;
1446 + ADY.i ^= 0x80000000; /* ady = -ady; */
1447 ts = fax; fax = fbx; fbx = ts;
1448 ts = fay; fay = fby; fby = ts;
1449 }
1450
1451 - DX = fbx - fax;
1452 - j = *(long *)&DX;
1453 - if (j < 0 ) {
1454 - j ^= 0x80000000; /* adx = -adx; */
1455 - }
1456 + DX.f = fbx - fax;
1457 + DX.i &= 0x7fffffff; /* abs(adx) */
1458
1459 /*
1460 ** X major line
1461 */
1462 - if (j >= i ) { /* if (adx > ady) */
1463 - if (j == 0) goto all_done_vp; /* check for zero-length lines */
1464 + if (DX.i >= ADY.i ) { /* if (adx > ady) */
1465 + if (DX.i == 0) goto all_done_vp; /* check for zero-length lines */
1466 /* start up divide and overlap with as much integer stuff as possible*/
1467 - m = _GlideRoot.pool.f1 / DX;
1468 + m = _GlideRoot.pool.f1 / DX.f;
1469 dlp = gc->dataList;
1470 GR_SETF(hw->FvA.x, fax);
1471 GR_SETF(hw->FvB.x, fbx);
1472 @@ -2177,18 +2165,18 @@
1473 }
1474 }
1475
1476 - P6FENCE_CMD( GR_SETF(hw->FtriangleCMD,_GlideRoot.pool.ftemp1) );
1477 + P6FENCE_CMD( GR_SETF(hw->FtriangleCMD, DX.f) );
1478
1479 GR_SETF(hw->FvB.x, fax);
1480 GR_SETF(hw->FvB.y, fay + _GlideRoot.pool.fHalf);
1481 - P6FENCE_CMD( GR_SETF(hw->FtriangleCMD,-_GlideRoot.pool.ftemp1));
1482 + P6FENCE_CMD( GR_SETF(hw->FtriangleCMD, -DX.f) );
1483 }
1484
1485 /*
1486 ** Y major line
1487 */
1488 else {
1489 - m = _GlideRoot.pool.f1 / ADY;
1490 + m = _GlideRoot.pool.f1 / ADY.f;
1491 dlp = gc->dataList;
1492 GR_SETF(hw->FvA.y, fay);
1493 GR_SETF(hw->FvB.y, fby);
1494 Only in Glide3/sst1/glide3/src: gdraw.c.warn
1495 diff -ur Glide3.orig/sst1/glide3/src/gglide.c Glide3/sst1/glide3/src/gglide.c
1496 --- Glide3.orig/sst1/glide3/src/gglide.c 2005-05-25 10:51:52.000000000 +0200
1497 +++ Glide3/sst1/glide3/src/gglide.c 2006-01-16 16:48:01.000000000 +0100
1498 @@ -1758,13 +1758,13 @@
1499 /* non packed color */
1500 /* add 9 to size array for r,drdx,drdy,g,dgdx,dgdy,b,dbdx,dbdy */
1501 gc->dataList[curTriSize + 0].i = gc->state.vData.rgbInfo.offset;
1502 - gc->dataList[curTriSize + 0].addr = (float *)&hw->RED;
1503 + gc->dataList[curTriSize + 0].addr = (float *)(void *)&hw->RED;
1504 gc->dataList[curTriSize + 0].bddr = 0;
1505 gc->dataList[curTriSize + 1].i = gc->state.vData.rgbInfo.offset+GR_COLOR_OFFSET_GREEN;
1506 - gc->dataList[curTriSize + 1].addr = (float *)&hw->GRN;
1507 + gc->dataList[curTriSize + 1].addr = (float *)(void *)&hw->GRN;
1508 gc->dataList[curTriSize + 1].bddr = 0;
1509 gc->dataList[curTriSize + 2].i = gc->state.vData.rgbInfo.offset+GR_COLOR_OFFSET_BLUE;
1510 - gc->dataList[curTriSize + 2].addr = (float *)&hw->BLU;
1511 + gc->dataList[curTriSize + 2].addr = (float *)(void *)&hw->BLU;
1512 gc->dataList[curTriSize + 2].bddr = 0;
1513 curTriSize += 3;
1514 params += 3;
1515 @@ -1776,13 +1776,13 @@
1516 /* packed color, argb */
1517 /* add 9 to size array for r,drdx,drdy,g,dgdx,dgdy,b,dbdx,dbdy */
1518 gc->dataList[curTriSize + 0].i = gc->state.vData.pargbInfo.offset;
1519 - gc->dataList[curTriSize + 0].addr = (float *)&hw->RED;
1520 + gc->dataList[curTriSize + 0].addr = (float *)(void *)&hw->RED;
1521 gc->dataList[curTriSize + 0].bddr = gc->state.vData.pargbInfo.offset + GR_PARGB_R;
1522 gc->dataList[curTriSize + 1].i = gc->state.vData.pargbInfo.offset;
1523 - gc->dataList[curTriSize + 1].addr = (float *)&hw->GRN;
1524 + gc->dataList[curTriSize + 1].addr = (float *)(void *)&hw->GRN;
1525 gc->dataList[curTriSize + 1].bddr = gc->state.vData.pargbInfo.offset + GR_PARGB_G;
1526 gc->dataList[curTriSize + 2].i = gc->state.vData.pargbInfo.offset;
1527 - gc->dataList[curTriSize + 2].addr = (float *)&hw->BLU;
1528 + gc->dataList[curTriSize + 2].addr = (float *)(void *)&hw->BLU;
1529 gc->dataList[curTriSize + 2].bddr = gc->state.vData.pargbInfo.offset + GR_PARGB_B;
1530 curTriSize += 3;
1531 params += 3;
1532 @@ -1794,7 +1794,7 @@
1533
1534 if (i & STATE_REQUIRES_OOZ) {
1535 gc->dataList[curTriSize + 0].i = gc->state.vData.zInfo.offset;
1536 - gc->dataList[curTriSize + 0].addr = (float *)&hw->Z;
1537 + gc->dataList[curTriSize + 0].addr = (float *)(void *)&hw->Z;
1538 gc->dataList[curTriSize + 0].bddr = 0;
1539 curTriSize += 1;
1540 params += 1;
1541 @@ -1806,7 +1806,7 @@
1542 if (i & STATE_REQUIRES_IT_ALPHA) {
1543 if (gc->state.vData.colorType == GR_FLOAT) {
1544 gc->dataList[curTriSize + 0].i = gc->state.vData.aInfo.offset;
1545 - gc->dataList[curTriSize + 0].addr = (float *)&hw->ALF;
1546 + gc->dataList[curTriSize + 0].addr = (float *)(void *)&hw->ALF;
1547 gc->dataList[curTriSize + 0].bddr = 0;
1548 curTriSize += 1;
1549 params += 1;
1550 @@ -1817,7 +1817,7 @@
1551 else {
1552 /* packed color, argb */
1553 gc->dataList[curTriSize + 0].i = gc->state.vData.pargbInfo.offset;
1554 - gc->dataList[curTriSize + 0].addr = (float *)&hw->ALF;
1555 + gc->dataList[curTriSize + 0].addr = (float *)(void *)&hw->ALF;
1556 gc->dataList[curTriSize + 0].bddr = gc->state.vData.pargbInfo.offset + GR_PARGB_A;
1557 curTriSize += 1;
1558 params += 1;
1559 @@ -1831,10 +1831,10 @@
1560 /* always output to ALL chips, saves from having to change CHIP field */
1561 if (i & STATE_REQUIRES_ST_TMU0) {
1562 gc->dataList[curTriSize + 0].i = gc->state.vData.st0Info.offset;
1563 - gc->dataList[curTriSize + 0].addr = (float *)&hw->S;
1564 + gc->dataList[curTriSize + 0].addr = (float *)(void *)&hw->S;
1565 gc->dataList[curTriSize + 0].bddr = 0;
1566 gc->dataList[curTriSize + 1].i = gc->state.vData.st0Info.offset + GR_TEXTURE_OFFSET_T;
1567 - gc->dataList[curTriSize + 1].addr = (float *)&hw->T;
1568 + gc->dataList[curTriSize + 1].addr = (float *)(void *)&hw->T;
1569 gc->dataList[curTriSize + 1].bddr = 0;
1570 curTriSize += 2;
1571 params += 2;
1572 @@ -1846,7 +1846,7 @@
1573 /* we squeeze FBI.OOW in here for sequential writes in the simple case */
1574 if (i & STATE_REQUIRES_OOW_FBI) {
1575 gc->dataList[curTriSize + 0].i = gc->state.vData.qInfo.offset;
1576 - gc->dataList[curTriSize + 0].addr = (float *)&hw->W;
1577 + gc->dataList[curTriSize + 0].addr = (float *)(void *)&hw->W;
1578 gc->dataList[curTriSize + 0].bddr = 0;
1579 curTriSize += 1;
1580 params += 1;
1581 @@ -1860,7 +1860,7 @@
1582 /* We do this a bit differently for grouped writes */
1583 gc->dataList[curTriSize + 0].i = packMask;
1584 gc->dataList[curTriSize + 0].addr =
1585 - (float *) GWH_GEN_ADDRESS(&tmu0->FvA.x);
1586 + (float *)(void *) GWH_GEN_ADDRESS(&tmu0->FvA.x);
1587 gc->dataList[curTriSize + 0].bddr = 0;
1588 if (gc->state.vData.q0Info.mode == GR_PARAM_ENABLE)
1589 gc->dataList[curTriSize + 1].i = gc->state.vData.q0Info.offset;
1590 @@ -1870,7 +1870,7 @@
1591 else
1592 gc->dataList[curTriSize + 1].i = gc->state.vData.wInfo.offset;
1593 }
1594 - gc->dataList[curTriSize + 1].addr = 0L;
1595 + gc->dataList[curTriSize + 1].addr = NULL;
1596 gc->dataList[curTriSize + 1].bddr = 0;
1597
1598 if (gwpSize & 1)
1599 @@ -1886,7 +1886,7 @@
1600 gc->dataList[curTriSize++].i = 0; /* terminate the list with 0,* */
1601 /* followed by the FtriangleCMD reg */
1602 gc->dataList[curTriSize].i = packMask;/* encode P6 flag here for asm code */
1603 - gc->dataList[curTriSize].addr = (float *)&hw->FtriangleCMD;
1604 + gc->dataList[curTriSize].addr = (float *)(void *)&hw->FtriangleCMD;
1605
1606 /* 6 X,Y values plus AREA = 7, plus parameters */
1607 if (gwHeaderNum) {
1608 @@ -1961,13 +1961,13 @@
1609 /* non packed color */
1610 /* add 9 to size array for r,drdx,drdy,g,dgdx,dgdy,b,dbdx,dbdy */
1611 gc->dataList[curTriSize + 0].i = gc->state.vData.rgbInfo.offset;
1612 - gc->dataList[curTriSize + 0].addr = (float *)&hw->RED;
1613 + gc->dataList[curTriSize + 0].addr = (float *)(void *)&hw->RED;
1614 gc->dataList[curTriSize + 0].bddr = 0;
1615 gc->dataList[curTriSize + 1].i = gc->state.vData.rgbInfo.offset+GR_COLOR_OFFSET_GREEN;
1616 - gc->dataList[curTriSize + 1].addr = (float *)&hw->GRN;
1617 + gc->dataList[curTriSize + 1].addr = (float *)(void *)&hw->GRN;
1618 gc->dataList[curTriSize + 1].bddr = 0;
1619 gc->dataList[curTriSize + 2].i = gc->state.vData.rgbInfo.offset+GR_COLOR_OFFSET_BLUE;
1620 - gc->dataList[curTriSize + 2].addr = (float *)&hw->BLU;
1621 + gc->dataList[curTriSize + 2].addr = (float *)(void *)&hw->BLU;
1622 gc->dataList[curTriSize + 2].bddr = 0;
1623 curTriSize += 3;
1624 params += 3;
1625 @@ -1976,13 +1976,13 @@
1626 /* packed color, argb */
1627 /* add 9 to size array for r,drdx,drdy,g,dgdx,dgdy,b,dbdx,dbdy */
1628 gc->dataList[curTriSize + 0].i = gc->state.vData.pargbInfo.offset;
1629 - gc->dataList[curTriSize + 0].addr = (float *)&hw->RED;
1630 + gc->dataList[curTriSize + 0].addr = (float *)(void *)&hw->RED;
1631 gc->dataList[curTriSize + 0].bddr = gc->state.vData.pargbInfo.offset + GR_PARGB_R;
1632 gc->dataList[curTriSize + 1].i = gc->state.vData.pargbInfo.offset;
1633 - gc->dataList[curTriSize + 1].addr = (float *)&hw->GRN;
1634 + gc->dataList[curTriSize + 1].addr = (float *)(void *)&hw->GRN;
1635 gc->dataList[curTriSize + 1].bddr = gc->state.vData.pargbInfo.offset + GR_PARGB_G;
1636 gc->dataList[curTriSize + 2].i = gc->state.vData.pargbInfo.offset;
1637 - gc->dataList[curTriSize + 2].addr = (float *)&hw->BLU;
1638 + gc->dataList[curTriSize + 2].addr = (float *)(void *)&hw->BLU;
1639 gc->dataList[curTriSize + 2].bddr = gc->state.vData.pargbInfo.offset + GR_PARGB_B;
1640 curTriSize += 3;
1641 params += 3;
1642 @@ -1991,7 +1991,7 @@
1643
1644 if (i & STATE_REQUIRES_OOZ) {
1645 gc->dataList[curTriSize + 0].i = gc->state.vData.zInfo.offset;
1646 - gc->dataList[curTriSize + 0].addr = (float *)&hw->Z;
1647 + gc->dataList[curTriSize + 0].addr = (float *)(void *)&hw->Z;
1648 gc->dataList[curTriSize + 0].bddr = 0;
1649 curTriSize += 1;
1650 params += 1;
1651 @@ -2000,7 +2000,7 @@
1652 if (i & STATE_REQUIRES_IT_ALPHA) {
1653 if (gc->state.vData.colorType == GR_FLOAT) {
1654 gc->dataList[curTriSize + 0].i = gc->state.vData.aInfo.offset;
1655 - gc->dataList[curTriSize + 0].addr = (float *)&hw->ALF;
1656 + gc->dataList[curTriSize + 0].addr = (float *)(void *)&hw->ALF;
1657 gc->dataList[curTriSize + 0].bddr = 0;
1658 curTriSize += 1;
1659 params += 1;
1660 @@ -2008,7 +2008,7 @@
1661 else {
1662 /* packed color, argb */
1663 gc->dataList[curTriSize + 0].i = gc->state.vData.pargbInfo.offset;
1664 - gc->dataList[curTriSize + 0].addr = (float *)&hw->ALF;
1665 + gc->dataList[curTriSize + 0].addr = (float *)(void *)&hw->ALF;
1666 gc->dataList[curTriSize + 0].bddr = gc->state.vData.pargbInfo.offset + GR_PARGB_A;
1667 curTriSize += 1;
1668 params += 1;
1669 @@ -2019,11 +2019,11 @@
1670 /* always output to ALL chips, saves from having to change CHIP field */
1671 if (i & STATE_REQUIRES_ST_TMU0) {
1672 gc->dataList[curTriSize + 0].i = gc->state.vData.st0Info.offset;
1673 - gc->dataList[curTriSize + 0].addr = (float *)&hw->S;
1674 + gc->dataList[curTriSize + 0].addr = (float *)(void *)&hw->S;
1675 gc->dataList[curTriSize + 0].bddr = 0;
1676 gc->dataList[curTriSize + 1].i = gc->state.vData.st0Info.offset
1677 + GR_TEXTURE_OFFSET_T;
1678 - gc->dataList[curTriSize + 1].addr = (float *)&hw->T;
1679 + gc->dataList[curTriSize + 1].addr = (float *)(void *)&hw->T;
1680 gc->dataList[curTriSize + 1].bddr = 0;
1681 curTriSize += 2;
1682 params += 2;
1683 @@ -2032,7 +2032,7 @@
1684 /* we squeeze FBI.OOW in here for sequential writes in the simple case */
1685 if (i & STATE_REQUIRES_OOW_FBI) {
1686 gc->dataList[curTriSize + 0].i = gc->state.vData.qInfo.offset;
1687 - gc->dataList[curTriSize + 0].addr = (float *)&hw->W;
1688 + gc->dataList[curTriSize + 0].addr = (float *)(void *)&hw->W;
1689 gc->dataList[curTriSize + 0].bddr = 0;
1690 curTriSize += 1;
1691 params += 1;
1692 @@ -2050,7 +2050,7 @@
1693 else
1694 gc->dataList[curTriSize + 1].i = gc->state.vData.wInfo.offset;
1695 }
1696 - gc->dataList[curTriSize + 1].addr = (float *)&tmu0->W;
1697 + gc->dataList[curTriSize + 1].addr = (float *)(void *)&tmu0->W;
1698 gc->dataList[curTriSize + 1].bddr = 0;
1699 curTriSize += 2;
1700 params += 1;
1701 @@ -2063,10 +2063,10 @@
1702 packerFlag = 0;
1703 gc->dataList[curTriSize + 0].bddr = 0;
1704 gc->dataList[curTriSize + 1].i = gc->state.vData.st1Info.offset;
1705 - gc->dataList[curTriSize + 1].addr = (float *)&tmu1->S;
1706 + gc->dataList[curTriSize + 1].addr = (float *)(void *)&tmu1->S;
1707 gc->dataList[curTriSize + 1].bddr = 0;
1708 gc->dataList[curTriSize + 2].i = gc->state.vData.st1Info.offset + GR_TEXTURE_OFFSET_T;
1709 - gc->dataList[curTriSize + 2].addr = (float *)&tmu1->T;
1710 + gc->dataList[curTriSize + 2].addr = (float *)(void *)&tmu1->T;
1711 gc->dataList[curTriSize + 2].bddr = 0;
1712 curTriSize += 3;
1713 params += 2;
1714 @@ -2088,7 +2088,7 @@
1715 else
1716 gc->dataList[curTriSize + 0].i = gc->state.vData.wInfo.offset;
1717 }
1718 - gc->dataList[curTriSize + 0].addr = (float *)&tmu1->W;
1719 + gc->dataList[curTriSize + 0].addr = (float *)(void *)&tmu1->W;
1720 gc->dataList[curTriSize + 0].bddr = 0;
1721 curTriSize += 1;
1722 params += 1;
1723 @@ -2110,7 +2110,7 @@
1724 gc->dataList[curTriSize++].i = 0; /* terminate the list with 0,* */
1725 /* followed by the FtriangleCMD reg */
1726 gc->dataList[curTriSize].i = packMask;/* encode P6 flag here for asm code */
1727 - gc->dataList[curTriSize].addr = (float *)&hw->FtriangleCMD;
1728 + gc->dataList[curTriSize].addr = (float *)(void *)&hw->FtriangleCMD;
1729
1730 /* 6 X,Y values plus AREA = 7, plus parameters */
1731 _GlideRoot.curTriSize = (6 + curTriSize + (params<<1)) <<2;
1732 Only in Glide3/sst1/glide3/src: gglide.c.warn
1733 Only in Glide3/sst1/glide3/src: gglide.c~
1734 diff -ur Glide3.orig/sst1/glide3/src/gstrip.c Glide3/sst1/glide3/src/gstrip.c
1735 --- Glide3.orig/sst1/glide3/src/gstrip.c 2005-06-09 20:32:35.000000000 +0200
1736 +++ Glide3/sst1/glide3/src/gstrip.c 2006-01-16 16:43:14.000000000 +0100
1737 @@ -620,7 +620,7 @@
1738 const float *fb = (const float *)vb;
1739 const float *fc = (const float *)vc;
1740 float ooa, dxAB, dxBC, dyAB, dyBC;
1741 - int i,j,culltest;
1742 + int i,culltest;
1743 int ii, ia, ib, ic;
1744 union { float f; int i; } ay;
1745 union { float f; int i; } by;
1746 @@ -716,16 +716,15 @@
1747 dyBC = snap_yb - snap_yc;
1748
1749 /* this is where we store the area */
1750 - _GlideRoot.pool.ftemp1 = dxAB * dyBC - dxBC * dyAB;
1751 + _GlideRoot.pool.temp1.f = dxAB * dyBC - dxBC * dyAB;
1752
1753 /* Zero-area triangles are BAD!! */
1754 - j = *(long *)&_GlideRoot.pool.ftemp1;
1755 - if ((j & 0x7FFFFFFF) == 0)
1756 + if ((_GlideRoot.pool.temp1.i & 0x7FFFFFFF) == 0)
1757 return 0;
1758
1759 /* Backface culling, use sign bit as test */
1760 if (gc->state.cull_mode != GR_CULL_DISABLE) {
1761 - if ((j ^ (culltest<<31)) >= 0) {
1762 + if ((_GlideRoot.pool.temp1.i ^ (culltest<<31)) >= 0) {
1763 return -1;
1764 }
1765 }
1766 @@ -734,7 +733,7 @@
1767
1768 GR_SET_EXPECTED_SIZE(_GlideRoot.curTriSize);
1769
1770 - ooa = _GlideRoot.pool.f1 / _GlideRoot.pool.ftemp1;
1771 + ooa = _GlideRoot.pool.f1 / _GlideRoot.pool.temp1.f;
1772 /* GMT: note that we spread out our PCI writes */
1773 /* write out X & Y for vertex A */
1774 GR_SETF( hw->FvA.x, snap_xa );
1775 @@ -814,7 +813,7 @@
1776 }
1777
1778 /* Draw the triangle by writing the area to the triangleCMD register */
1779 - P6FENCE_CMD( GR_SETF( hw->FtriangleCMD, _GlideRoot.pool.ftemp1 ) );
1780 + P6FENCE_CMD( GR_SETF( hw->FtriangleCMD, _GlideRoot.pool.temp1.f ) );
1781 _GlideRoot.stats.trisDrawn++;
1782
1783 GR_CHECK_SIZE();
1784 @@ -834,7 +833,7 @@
1785 const float *fb = (const float *)vb + xindex;
1786 const float *fc = (const float *)vc + xindex;
1787 float ooa, dxAB, dxBC, dyAB, dyBC;
1788 - int i,j,culltest;
1789 + int i,culltest;
1790 int ii, ia, ib, ic;
1791 union { float f; int i; } ay;
1792 union { float f; int i; } by;
1793 @@ -931,16 +930,15 @@
1794 dyBC = snap_yb - snap_yc;
1795
1796 /* this is where we store the area */
1797 - _GlideRoot.pool.ftemp1 = dxAB * dyBC - dxBC * dyAB;
1798 + _GlideRoot.pool.temp1.f = dxAB * dyBC - dxBC * dyAB;
1799
1800 /* Zero-area triangles are BAD!! */
1801 - j = *(long *)&_GlideRoot.pool.ftemp1;
1802 - if ((j & 0x7FFFFFFF) == 0)
1803 + if ((_GlideRoot.pool.temp1.i & 0x7FFFFFFF) == 0)
1804 return 0;
1805
1806 /* Backface culling, use sign bit as test */
1807 if (gc->state.cull_mode != GR_CULL_DISABLE) {
1808 - if ((j ^ (culltest<<31)) >= 0) {
1809 + if ((_GlideRoot.pool.temp1.i ^ (culltest<<31)) >= 0) {
1810 return -1;
1811 }
1812 }
1813 @@ -983,7 +981,7 @@
1814 SET_GW_CMD( fifoPtr, 0, gc->hwDep.sst96Dep.gwCommand );
1815 SET_GW_HEADER( fifoPtr, 1, gc->hwDep.sst96Dep.gwHeaders[0] );
1816
1817 - ooa = _GlideRoot.pool.f1 / _GlideRoot.pool.ftemp1;
1818 + ooa = _GlideRoot.pool.f1 / _GlideRoot.pool.temp1.f;
1819 /* GMT: note that we spread out our PCI writes */
1820 /* write out X & Y for vertex A */
1821 FSET_GW_ENTRY( fifoPtr, 2, snap_xa );
1822 @@ -1052,7 +1050,7 @@
1823
1824 /* write triangle command */
1825 triangle_command:
1826 - FSET_GW_ENTRY( fifoPtr, 0, _GlideRoot.pool.ftemp1 );
1827 + FSET_GW_ENTRY( fifoPtr, 0, _GlideRoot.pool.temp1.f );
1828 fifoPtr+=1;
1829
1830 if (((FxU32)fifoPtr) & 0x7) {
1831 @@ -1154,7 +1152,7 @@
1832 const float *fb = (const float *)vb;
1833 const float *fc = (const float *)vc;
1834 float ooa, dxAB, dxBC, dyAB, dyBC;
1835 - int i,j,culltest;
1836 + int i,culltest;
1837 int ii, ia, ib, ic;
1838 union { float f; int i; } ay;
1839 union { float f; int i; } by;
1840 @@ -1276,16 +1274,15 @@
1841 dyBC = snap_yb - snap_yc;
1842
1843 /* this is where we store the area */
1844 - _GlideRoot.pool.ftemp1 = dxAB * dyBC - dxBC * dyAB;
1845 + _GlideRoot.pool.temp1.f = dxAB * dyBC - dxBC * dyAB;
1846
1847 /* Zero-area triangles are BAD!! */
1848 - j = *(long *)&_GlideRoot.pool.ftemp1;
1849 - if ((j & 0x7FFFFFFF) == 0)
1850 + if ((_GlideRoot.pool.temp1.i & 0x7FFFFFFF) == 0)
1851 return 0;
1852
1853 /* Backface culling, use sign bit as test */
1854 if (gc->state.cull_mode != GR_CULL_DISABLE) {
1855 - if ((j ^ (culltest<<31)) >= 0) {
1856 + if ((_GlideRoot.pool.temp1.i ^ (culltest<<31)) >= 0) {
1857 return -1;
1858 }
1859 }
1860 @@ -1328,7 +1325,7 @@
1861 SET_GW_CMD( fifoPtr, 0, gc->hwDep.sst96Dep.gwCommand );
1862 SET_GW_HEADER( fifoPtr, 1, gc->hwDep.sst96Dep.gwHeaders[0] );
1863
1864 - ooa = _GlideRoot.pool.f1 / _GlideRoot.pool.ftemp1;
1865 + ooa = _GlideRoot.pool.f1 / _GlideRoot.pool.temp1.f;
1866 /* GMT: note that we spread out our PCI writes */
1867 /* write out X & Y for vertex A */
1868 FSET_GW_ENTRY( fifoPtr, 2, snap_xa );
1869 @@ -1663,7 +1660,7 @@
1870
1871 /* write triangle command */
1872 triangle_command:
1873 - FSET_GW_ENTRY( fifoPtr, 0, _GlideRoot.pool.ftemp1 );
1874 + FSET_GW_ENTRY( fifoPtr, 0, _GlideRoot.pool.temp1.f );
1875 fifoPtr+=1;
1876
1877 if (((FxU32)fifoPtr) & 0x7) {
1878 @@ -1934,7 +1931,7 @@
1879 const float *fb = (const float *)vb;
1880 const float *fc = (const float *)vc;
1881 float ooa, dxAB, dxBC, dyAB, dyBC;
1882 - int i,j,culltest;
1883 + int i,culltest;
1884 int ii, ia, ib, ic;
1885 union { float f; int i; } ay;
1886 union { float f; int i; } by;
1887 @@ -2054,16 +2051,15 @@
1888 dyBC = snap_yb - snap_yc;
1889
1890 /* this is where we store the area */
1891 - _GlideRoot.pool.ftemp1 = dxAB * dyBC - dxBC * dyAB;
1892 + _GlideRoot.pool.temp1.f = dxAB * dyBC - dxBC * dyAB;
1893
1894 /* Zero-area triangles are BAD!! */
1895 - j = *(long *)&_GlideRoot.pool.ftemp1;
1896 - if ((j & 0x7FFFFFFF) == 0)
1897 + if ((_GlideRoot.pool.temp1.i & 0x7FFFFFFF) == 0)
1898 return 0;
1899
1900 /* Backface culling, use sign bit as test */
1901 if (gc->state.cull_mode != GR_CULL_DISABLE) {
1902 - if ((j ^ (culltest<<31)) >= 0) {
1903 + if ((_GlideRoot.pool.temp1.i ^ (culltest<<31)) >= 0) {
1904 return -1;
1905 }
1906 }
1907 @@ -2072,7 +2068,7 @@
1908
1909 GR_SET_EXPECTED_SIZE(_GlideRoot.curTriSize);
1910
1911 - ooa = _GlideRoot.pool.f1 / _GlideRoot.pool.ftemp1;
1912 + ooa = _GlideRoot.pool.f1 / _GlideRoot.pool.temp1.f;
1913 /* GMT: note that we spread out our PCI writes */
1914 /* write out X & Y for vertex A */
1915 GR_SETF( hw->FvA.x, snap_xa);
1916 @@ -2424,7 +2420,7 @@
1917 }
1918
1919 /* Draw the triangle by writing the area to the triangleCMD register */
1920 - P6FENCE_CMD( GR_SETF( hw->FtriangleCMD, _GlideRoot.pool.ftemp1 ) );
1921 + P6FENCE_CMD( GR_SETF( hw->FtriangleCMD, _GlideRoot.pool.temp1.f ) );
1922 _GlideRoot.stats.trisDrawn++;
1923
1924 GR_CHECK_SIZE_SLOPPY();
1925 Only in Glide3/sst1/glide3/src: gstrip.c.warn
1926 diff -ur Glide3.orig/sst1/glide3/src/gxdraw.c Glide3/sst1/glide3/src/gxdraw.c
1927 --- Glide3.orig/sst1/glide3/src/gxdraw.c 2005-06-09 20:32:35.000000000 +0200
1928 +++ Glide3/sst1/glide3/src/gxdraw.c 2006-01-16 16:43:14.000000000 +0100
1929 @@ -159,7 +159,7 @@
1930 const float *fb = (const float *)vb + xindex;
1931 const float *fc = (const float *)vc + xindex;
1932 float ooa, dxAB, dxBC, dyAB, dyBC;
1933 - int i,j,culltest;
1934 + int i,culltest;
1935 union { float f; int i; } ay;
1936 union { float f; int i; } by;
1937 union { float f; int i; } cy;
1938 @@ -239,16 +239,15 @@
1939 dyBC = snap_yb - snap_yc;
1940
1941 /* this is where we store the area */
1942 - _GlideRoot.pool.ftemp1 = dxAB * dyBC - dxBC * dyAB;
1943 + _GlideRoot.pool.temp1.1 = dxAB * dyBC - dxBC * dyAB;
1944
1945 /* Zero-area triangles are BAD!! */
1946 - j = *(long *)&_GlideRoot.pool.ftemp1;
1947 - if ((j & 0x7FFFFFFF) == 0)
1948 + if ((_GlideRoot.pool.temp1.i & 0x7FFFFFFF) == 0)
1949 return 0;
1950
1951 /* Backface culling, use sign bit as test */
1952 if (gc->state.cull_mode != GR_CULL_DISABLE) {