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