projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
test version of startmenu root with big icons
[reactos.git] / reactos / lib / mesa32 / src / swrast / s_aatritemp.h
1
2 /*
3 * Mesa 3-D graphics library
4 * Version: 5.1
5 *
6 * Copyright (C) 1999-2003 Brian Paul All Rights Reserved.
7 *
8 * Permission is hereby granted, free of charge, to any person obtaining a
9 * copy of this software and associated documentation files (the "Software"),
10 * to deal in the Software without restriction, including without limitation
11 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
12 * and/or sell copies of the Software, and to permit persons to whom the
13 * Software is furnished to do so, subject to the following conditions:
14 *
15 * The above copyright notice and this permission notice shall be included
16 * in all copies or substantial portions of the Software.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
21 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
22 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
23 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
24 */
25
26
27 /*
28 * Antialiased Triangle Rasterizer Template
29 *
30 * This file is #include'd to generate custom AA triangle rasterizers.
31 * NOTE: this code hasn't been optimized yet. That'll come after it
32 * works correctly.
33 *
34 * The following macros may be defined to indicate what auxillary information
35 * must be copmuted across the triangle:
36 * DO_Z - if defined, compute Z values
37 * DO_RGBA - if defined, compute RGBA values
38 * DO_INDEX - if defined, compute color index values
39 * DO_SPEC - if defined, compute specular RGB values
40 * DO_TEX - if defined, compute unit 0 STRQ texcoords
41 * DO_MULTITEX - if defined, compute all unit's STRQ texcoords
42 */
43
44 /*void triangle( GLcontext *ctx, GLuint v0, GLuint v1, GLuint v2, GLuint pv )*/
45 {
46 const GLfloat *p0 = v0->win;
47 const GLfloat *p1 = v1->win;
48 const GLfloat *p2 = v2->win;
49 const SWvertex *vMin, *vMid, *vMax;
50 GLint iyMin, iyMax;
51 GLfloat yMin, yMax;
52 GLboolean ltor;
53 GLfloat majDx, majDy; /* major (i.e. long) edge dx and dy */
54
55 struct sw_span span;
56
57 #ifdef DO_Z
58 GLfloat zPlane[4];
59 #endif
60 #ifdef DO_FOG
61 GLfloat fogPlane[4];
62 #else
63 GLfloat *fog = NULL;
64 #endif
65 #ifdef DO_RGBA
66 GLfloat rPlane[4], gPlane[4], bPlane[4], aPlane[4];
67 #endif
68 #ifdef DO_INDEX
69 GLfloat iPlane[4];
70 #endif
71 #ifdef DO_SPEC
72 GLfloat srPlane[4], sgPlane[4], sbPlane[4];
73 #endif
74 #ifdef DO_TEX
75 GLfloat sPlane[4], tPlane[4], uPlane[4], vPlane[4];
76 GLfloat texWidth, texHeight;
77 #elif defined(DO_MULTITEX)
78 GLfloat sPlane[MAX_TEXTURE_COORD_UNITS][4]; /* texture S */
79 GLfloat tPlane[MAX_TEXTURE_COORD_UNITS][4]; /* texture T */
80 GLfloat uPlane[MAX_TEXTURE_COORD_UNITS][4]; /* texture R */
81 GLfloat vPlane[MAX_TEXTURE_COORD_UNITS][4]; /* texture Q */
82 GLfloat texWidth[MAX_TEXTURE_COORD_UNITS];
83 GLfloat texHeight[MAX_TEXTURE_COORD_UNITS];
84 #endif
85 GLfloat bf = SWRAST_CONTEXT(ctx)->_BackfaceSign;
86
87
88 INIT_SPAN(span, GL_POLYGON, 0, 0, SPAN_COVERAGE);
89
90 /* determine bottom to top order of vertices */
91 {
92 GLfloat y0 = v0->win[1];
93 GLfloat y1 = v1->win[1];
94 GLfloat y2 = v2->win[1];
95 if (y0 <= y1) {
96 if (y1 <= y2) {
97 vMin = v0; vMid = v1; vMax = v2; /* y0<=y1<=y2 */
98 }
99 else if (y2 <= y0) {
100 vMin = v2; vMid = v0; vMax = v1; /* y2<=y0<=y1 */
101 }
102 else {
103 vMin = v0; vMid = v2; vMax = v1; bf = -bf; /* y0<=y2<=y1 */
104 }
105 }
106 else {
107 if (y0 <= y2) {
108 vMin = v1; vMid = v0; vMax = v2; bf = -bf; /* y1<=y0<=y2 */
109 }
110 else if (y2 <= y1) {
111 vMin = v2; vMid = v1; vMax = v0; bf = -bf; /* y2<=y1<=y0 */
112 }
113 else {
114 vMin = v1; vMid = v2; vMax = v0; /* y1<=y2<=y0 */
115 }
116 }
117 }
118
119 majDx = vMax->win[0] - vMin->win[0];
120 majDy = vMax->win[1] - vMin->win[1];
121
122 {
123 const GLfloat botDx = vMid->win[0] - vMin->win[0];
124 const GLfloat botDy = vMid->win[1] - vMin->win[1];
125 const GLfloat area = majDx * botDy - botDx * majDy;
126 /* Do backface culling */
127 if (area * bf < 0 || area == 0 || IS_INF_OR_NAN(area))
128 return;
129 ltor = (GLboolean) (area < 0.0F);
130 }
131
132 #ifndef DO_OCCLUSION_TEST
133 ctx->OcclusionResult = GL_TRUE;
134 #endif
135
136 /* Plane equation setup:
137 * We evaluate plane equations at window (x,y) coordinates in order
138 * to compute color, Z, fog, texcoords, etc. This isn't terribly
139 * efficient but it's easy and reliable.
140 */
141 #ifdef DO_Z
142 compute_plane(p0, p1, p2, p0[2], p1[2], p2[2], zPlane);
143 span.arrayMask |= SPAN_Z;
144 #endif
145 #ifdef DO_FOG
146 compute_plane(p0, p1, p2, v0->fog, v1->fog, v2->fog, fogPlane);
147 span.arrayMask |= SPAN_FOG;
148 #endif
149 #ifdef DO_RGBA
150 if (ctx->Light.ShadeModel == GL_SMOOTH) {
151 compute_plane(p0, p1, p2, v0->color[RCOMP], v1->color[RCOMP], v2->color[RCOMP], rPlane);
152 compute_plane(p0, p1, p2, v0->color[GCOMP], v1->color[GCOMP], v2->color[GCOMP], gPlane);
153 compute_plane(p0, p1, p2, v0->color[BCOMP], v1->color[BCOMP], v2->color[BCOMP], bPlane);
154 compute_plane(p0, p1, p2, v0->color[ACOMP], v1->color[ACOMP], v2->color[ACOMP], aPlane);
155 }
156 else {
157 constant_plane(v2->color[RCOMP], rPlane);
158 constant_plane(v2->color[GCOMP], gPlane);
159 constant_plane(v2->color[BCOMP], bPlane);
160 constant_plane(v2->color[ACOMP], aPlane);
161 }
162 span.arrayMask |= SPAN_RGBA;
163 #endif
164 #ifdef DO_INDEX
165 if (ctx->Light.ShadeModel == GL_SMOOTH) {
166 compute_plane(p0, p1, p2, (GLfloat) v0->index,
167 v1->index, v2->index, iPlane);
168 }
169 else {
170 constant_plane(v2->index, iPlane);
171 }
172 span.arrayMask |= SPAN_INDEX;
173 #endif
174 #ifdef DO_SPEC
175 if (ctx->Light.ShadeModel == GL_SMOOTH) {
176 compute_plane(p0, p1, p2, v0->specular[RCOMP], v1->specular[RCOMP], v2->specular[RCOMP], srPlane);
177 compute_plane(p0, p1, p2, v0->specular[GCOMP], v1->specular[GCOMP], v2->specular[GCOMP], sgPlane);
178 compute_plane(p0, p1, p2, v0->specular[BCOMP], v1->specular[BCOMP], v2->specular[BCOMP], sbPlane);
179 }
180 else {
181 constant_plane(v2->specular[RCOMP], srPlane);
182 constant_plane(v2->specular[GCOMP], sgPlane);
183 constant_plane(v2->specular[BCOMP], sbPlane);
184 }
185 span.arrayMask |= SPAN_SPEC;
186 #endif
187 #ifdef DO_TEX
188 {
189 const struct gl_texture_object *obj = ctx->Texture.Unit[0]._Current;
190 const struct gl_texture_image *texImage = obj->Image[0][obj->BaseLevel];
191 const GLfloat invW0 = v0->win[3];
192 const GLfloat invW1 = v1->win[3];
193 const GLfloat invW2 = v2->win[3];
194 const GLfloat s0 = v0->texcoord[0][0] * invW0;
195 const GLfloat s1 = v1->texcoord[0][0] * invW1;
196 const GLfloat s2 = v2->texcoord[0][0] * invW2;
197 const GLfloat t0 = v0->texcoord[0][1] * invW0;
198 const GLfloat t1 = v1->texcoord[0][1] * invW1;
199 const GLfloat t2 = v2->texcoord[0][1] * invW2;
200 const GLfloat r0 = v0->texcoord[0][2] * invW0;
201 const GLfloat r1 = v1->texcoord[0][2] * invW1;
202 const GLfloat r2 = v2->texcoord[0][2] * invW2;
203 const GLfloat q0 = v0->texcoord[0][3] * invW0;
204 const GLfloat q1 = v1->texcoord[0][3] * invW1;
205 const GLfloat q2 = v2->texcoord[0][3] * invW2;
206 compute_plane(p0, p1, p2, s0, s1, s2, sPlane);
207 compute_plane(p0, p1, p2, t0, t1, t2, tPlane);
208 compute_plane(p0, p1, p2, r0, r1, r2, uPlane);
209 compute_plane(p0, p1, p2, q0, q1, q2, vPlane);
210 texWidth = (GLfloat) texImage->Width;
211 texHeight = (GLfloat) texImage->Height;
212 }
213 span.arrayMask |= (SPAN_TEXTURE | SPAN_LAMBDA);
214 #elif defined(DO_MULTITEX)
215 {
216 GLuint u;
217 for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
218 if (ctx->Texture.Unit[u]._ReallyEnabled) {
219 const struct gl_texture_object *obj = ctx->Texture.Unit[u]._Current;
220 const struct gl_texture_image *texImage = obj->Image[0][obj->BaseLevel];
221 const GLfloat invW0 = v0->win[3];
222 const GLfloat invW1 = v1->win[3];
223 const GLfloat invW2 = v2->win[3];
224 const GLfloat s0 = v0->texcoord[u][0] * invW0;
225 const GLfloat s1 = v1->texcoord[u][0] * invW1;
226 const GLfloat s2 = v2->texcoord[u][0] * invW2;
227 const GLfloat t0 = v0->texcoord[u][1] * invW0;
228 const GLfloat t1 = v1->texcoord[u][1] * invW1;
229 const GLfloat t2 = v2->texcoord[u][1] * invW2;
230 const GLfloat r0 = v0->texcoord[u][2] * invW0;
231 const GLfloat r1 = v1->texcoord[u][2] * invW1;
232 const GLfloat r2 = v2->texcoord[u][2] * invW2;
233 const GLfloat q0 = v0->texcoord[u][3] * invW0;
234 const GLfloat q1 = v1->texcoord[u][3] * invW1;
235 const GLfloat q2 = v2->texcoord[u][3] * invW2;
236 compute_plane(p0, p1, p2, s0, s1, s2, sPlane[u]);
237 compute_plane(p0, p1, p2, t0, t1, t2, tPlane[u]);
238 compute_plane(p0, p1, p2, r0, r1, r2, uPlane[u]);
239 compute_plane(p0, p1, p2, q0, q1, q2, vPlane[u]);
240 texWidth[u] = (GLfloat) texImage->Width;
241 texHeight[u] = (GLfloat) texImage->Height;
242 }
243 }
244 }
245 span.arrayMask |= (SPAN_TEXTURE | SPAN_LAMBDA);
246 #endif
247
248 /* Begin bottom-to-top scan over the triangle.
249 * The long edge will either be on the left or right side of the
250 * triangle. We always scan from the long edge toward the shorter
251 * edges, stopping when we find that coverage = 0. If the long edge
252 * is on the left we scan left-to-right. Else, we scan right-to-left.
253 */
254 yMin = vMin->win[1];
255 yMax = vMax->win[1];
256 iyMin = (GLint) yMin;
257 iyMax = (GLint) yMax + 1;
258
259 if (ltor) {
260 /* scan left to right */
261 const GLfloat *pMin = vMin->win;
262 const GLfloat *pMid = vMid->win;
263 const GLfloat *pMax = vMax->win;
264 const GLfloat dxdy = majDx / majDy;
265 const GLfloat xAdj = dxdy < 0.0F ? -dxdy : 0.0F;
266 GLfloat x = pMin[0] - (yMin - iyMin) * dxdy;
267 GLint iy;
268 for (iy = iyMin; iy < iyMax; iy++, x += dxdy) {
269 GLint ix, startX = (GLint) (x - xAdj);
270 GLuint count;
271 GLfloat coverage = 0.0F;
272
273 /* skip over fragments with zero coverage */
274 while (startX < MAX_WIDTH) {
275 coverage = compute_coveragef(pMin, pMid, pMax, startX, iy);
276 if (coverage > 0.0F)
277 break;
278 startX++;
279 }
280
281 /* enter interior of triangle */
282 ix = startX;
283 count = 0;
284 while (coverage > 0.0F) {
285 /* (cx,cy) = center of fragment */
286 const GLfloat cx = ix + 0.5F, cy = iy + 0.5F;
287 struct span_arrays *array = span.array;
288 #ifdef DO_INDEX
289 array->coverage[count] = (GLfloat) compute_coveragei(pMin, pMid, pMax, ix, iy);
290 #else
291 array->coverage[count] = coverage;
292 #endif
293 #ifdef DO_Z
294 array->z[count] = (GLdepth) IROUND(solve_plane(cx, cy, zPlane));
295 #endif
296 #ifdef DO_FOG
297 array->fog[count] = solve_plane(cx, cy, fogPlane);
298 #endif
299 #ifdef DO_RGBA
300 array->rgba[count][RCOMP] = solve_plane_chan(cx, cy, rPlane);
301 array->rgba[count][GCOMP] = solve_plane_chan(cx, cy, gPlane);
302 array->rgba[count][BCOMP] = solve_plane_chan(cx, cy, bPlane);
303 array->rgba[count][ACOMP] = solve_plane_chan(cx, cy, aPlane);
304 #endif
305 #ifdef DO_INDEX
306 array->index[count] = (GLint) solve_plane(cx, cy, iPlane);
307 #endif
308 #ifdef DO_SPEC
309 array->spec[count][RCOMP] = solve_plane_chan(cx, cy, srPlane);
310 array->spec[count][GCOMP] = solve_plane_chan(cx, cy, sgPlane);
311 array->spec[count][BCOMP] = solve_plane_chan(cx, cy, sbPlane);
312 #endif
313 #ifdef DO_TEX
314 {
315 const GLfloat invQ = solve_plane_recip(cx, cy, vPlane);
316 array->texcoords[0][count][0] = solve_plane(cx, cy, sPlane) * invQ;
317 array->texcoords[0][count][1] = solve_plane(cx, cy, tPlane) * invQ;
318 array->texcoords[0][count][2] = solve_plane(cx, cy, uPlane) * invQ;
319 array->lambda[0][count] = compute_lambda(sPlane, tPlane, vPlane,
320 cx, cy, invQ,
321 texWidth, texHeight);
322 }
323 #elif defined(DO_MULTITEX)
324 {
325 GLuint unit;
326 for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) {
327 if (ctx->Texture.Unit[unit]._ReallyEnabled) {
328 GLfloat invQ = solve_plane_recip(cx, cy, vPlane[unit]);
329 array->texcoords[unit][count][0] = solve_plane(cx, cy, sPlane[unit]) * invQ;
330 array->texcoords[unit][count][1] = solve_plane(cx, cy, tPlane[unit]) * invQ;
331 array->texcoords[unit][count][2] = solve_plane(cx, cy, uPlane[unit]) * invQ;
332 array->lambda[unit][count] = compute_lambda(sPlane[unit],
333 tPlane[unit], vPlane[unit], cx, cy, invQ,
334 texWidth[unit], texHeight[unit]);
335 }
336 }
337 }
338 #endif
339 ix++;
340 count++;
341 coverage = compute_coveragef(pMin, pMid, pMax, ix, iy);
342 }
343
344 if (ix <= startX)
345 continue;
346
347 span.x = startX;
348 span.y = iy;
349 span.end = (GLuint) ix - (GLuint) startX;
350 ASSERT(span.interpMask == 0);
351 #if defined(DO_MULTITEX) || defined(DO_TEX)
352 _swrast_write_texture_span(ctx, &span);
353 #elif defined(DO_RGBA)
354 _swrast_write_rgba_span(ctx, &span);
355 #elif defined(DO_INDEX)
356 _swrast_write_index_span(ctx, &span);
357 #endif
358 }
359 }
360 else {
361 /* scan right to left */
362 const GLfloat *pMin = vMin->win;
363 const GLfloat *pMid = vMid->win;
364 const GLfloat *pMax = vMax->win;
365 const GLfloat dxdy = majDx / majDy;
366 const GLfloat xAdj = dxdy > 0 ? dxdy : 0.0F;
367 GLfloat x = pMin[0] - (yMin - iyMin) * dxdy;
368 GLint iy;
369 for (iy = iyMin; iy < iyMax; iy++, x += dxdy) {
370 GLint ix, left, startX = (GLint) (x + xAdj);
371 GLuint count, n;
372 GLfloat coverage = 0.0F;
373
374 /* make sure we're not past the window edge */
375 if (startX >= ctx->DrawBuffer->_Xmax) {
376 startX = ctx->DrawBuffer->_Xmax - 1;
377 }
378
379 /* skip fragments with zero coverage */
380 while (startX >= 0) {
381 coverage = compute_coveragef(pMin, pMax, pMid, startX, iy);
382 if (coverage > 0.0F)
383 break;
384 startX--;
385 }
386
387 /* enter interior of triangle */
388 ix = startX;
389 count = 0;
390 while (coverage > 0.0F) {
391 /* (cx,cy) = center of fragment */
392 const GLfloat cx = ix + 0.5F, cy = iy + 0.5F;
393 struct span_arrays *array = span.array;
394 #ifdef DO_INDEX
395 array->coverage[ix] = (GLfloat) compute_coveragei(pMin, pMax, pMid, ix, iy);
396 #else
397 array->coverage[ix] = coverage;
398 #endif
399 #ifdef DO_Z
400 array->z[ix] = (GLdepth) IROUND(solve_plane(cx, cy, zPlane));
401 #endif
402 #ifdef DO_FOG
403 array->fog[ix] = solve_plane(cx, cy, fogPlane);
404 #endif
405 #ifdef DO_RGBA
406 array->rgba[ix][RCOMP] = solve_plane_chan(cx, cy, rPlane);
407 array->rgba[ix][GCOMP] = solve_plane_chan(cx, cy, gPlane);
408 array->rgba[ix][BCOMP] = solve_plane_chan(cx, cy, bPlane);
409 array->rgba[ix][ACOMP] = solve_plane_chan(cx, cy, aPlane);
410 #endif
411 #ifdef DO_INDEX
412 array->index[ix] = (GLint) solve_plane(cx, cy, iPlane);
413 #endif
414 #ifdef DO_SPEC
415 array->spec[ix][RCOMP] = solve_plane_chan(cx, cy, srPlane);
416 array->spec[ix][GCOMP] = solve_plane_chan(cx, cy, sgPlane);
417 array->spec[ix][BCOMP] = solve_plane_chan(cx, cy, sbPlane);
418 #endif
419 #ifdef DO_TEX
420 {
421 const GLfloat invQ = solve_plane_recip(cx, cy, vPlane);
422 array->texcoords[0][ix][0] = solve_plane(cx, cy, sPlane) * invQ;
423 array->texcoords[0][ix][1] = solve_plane(cx, cy, tPlane) * invQ;
424 array->texcoords[0][ix][2] = solve_plane(cx, cy, uPlane) * invQ;
425 array->lambda[0][ix] = compute_lambda(sPlane, tPlane, vPlane,
426 cx, cy, invQ, texWidth, texHeight);
427 }
428 #elif defined(DO_MULTITEX)
429 {
430 GLuint unit;
431 for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) {
432 if (ctx->Texture.Unit[unit]._ReallyEnabled) {
433 GLfloat invQ = solve_plane_recip(cx, cy, vPlane[unit]);
434 array->texcoords[unit][ix][0] = solve_plane(cx, cy, sPlane[unit]) * invQ;
435 array->texcoords[unit][ix][1] = solve_plane(cx, cy, tPlane[unit]) * invQ;
436 array->texcoords[unit][ix][2] = solve_plane(cx, cy, uPlane[unit]) * invQ;
437 array->lambda[unit][ix] = compute_lambda(sPlane[unit],
438 tPlane[unit],
439 vPlane[unit],
440 cx, cy, invQ,
441 texWidth[unit],
442 texHeight[unit]);
443 }
444 }
445 }
446 #endif
447 ix--;
448 count++;
449 coverage = compute_coveragef(pMin, pMax, pMid, ix, iy);
450 }
451
452 if (startX <= ix)
453 continue;
454
455 n = (GLuint) startX - (GLuint) ix;
456
457 left = ix + 1;
458
459 /* shift all values to the left */
460 /* XXX this is temporary */
461 {
462 struct span_arrays *array = span.array;
463 GLint j;
464 for (j = 0; j < (GLint) n; j++) {
465 #ifdef DO_RGBA
466 COPY_CHAN4(array->rgba[j], array->rgba[j + left]);
467 #endif
468 #ifdef DO_SPEC
469 COPY_CHAN4(array->spec[j], array->spec[j + left]);
470 #endif
471 #ifdef DO_INDEX
472 array->index[j] = array->index[j + left];
473 #endif
474 #ifdef DO_Z
475 array->z[j] = array->z[j + left];
476 #endif
477 #ifdef DO_FOG
478 array->fog[j] = array->fog[j + left];
479 #endif
480 #ifdef DO_TEX
481 COPY_4V(array->texcoords[0][j], array->texcoords[0][j + left]);
482 #endif
483 #if defined(DO_MULTITEX) || defined(DO_TEX)
484 array->lambda[0][j] = array->lambda[0][j + left];
485 #endif
486 array->coverage[j] = array->coverage[j + left];
487 }
488 }
489 #ifdef DO_MULTITEX
490 /* shift texcoords */
491 {
492 struct span_arrays *array = span.array;
493 GLuint unit;
494 for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) {
495 if (ctx->Texture.Unit[unit]._ReallyEnabled) {
496 GLint j;
497 for (j = 0; j < (GLint) n; j++) {
498 array->texcoords[unit][j][0] = array->texcoords[unit][j + left][0];
499 array->texcoords[unit][j][1] = array->texcoords[unit][j + left][1];
500 array->texcoords[unit][j][2] = array->texcoords[unit][j + left][2];
501 array->lambda[unit][j] = array->lambda[unit][j + left];
502 }
503 }
504 }
505 }
506 #endif
507
508 span.x = left;
509 span.y = iy;
510 span.end = n;
511 ASSERT(span.interpMask == 0);
512 #if defined(DO_MULTITEX) || defined(DO_TEX)
513 _swrast_write_texture_span(ctx, &span);
514 #elif defined(DO_RGBA)
515 _swrast_write_rgba_span(ctx, &span);
516 #elif defined(DO_INDEX)
517 _swrast_write_index_span(ctx, &span);
518 #endif
519 }
520 }
521 }
522
523
524 #ifdef DO_Z
525 #undef DO_Z
526 #endif
527
528 #ifdef DO_FOG
529 #undef DO_FOG
530 #endif
531
532 #ifdef DO_RGBA
533 #undef DO_RGBA
534 #endif
535
536 #ifdef DO_INDEX
537 #undef DO_INDEX
538 #endif
539
540 #ifdef DO_SPEC
541 #undef DO_SPEC
542 #endif
543
544 #ifdef DO_TEX
545 #undef DO_TEX
546 #endif
547
548 #ifdef DO_MULTITEX
549 #undef DO_MULTITEX
550 #endif
551
552 #ifdef DO_OCCLUSION_TEST
553 #undef DO_OCCLUSION_TEST
554 #endif
A free Windows-compatible Operating System