projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
added missing \'s
[mesa.git] / src / mesa / swrast / s_aatritemp.h
1 /* $Id: s_aatritemp.h,v 1.18 2001/06/05 21:41:05 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; /* major (i.e. long) edge dx and dy */
55
56 #ifdef DO_Z
57 GLfloat zPlane[4];
58 GLdepth z[MAX_WIDTH];
59 #endif
60 #ifdef DO_FOG
61 GLfloat fogPlane[4];
62 GLfloat fog[MAX_WIDTH];
63 #else
64 GLfloat *fog = NULL;
65 #endif
66 #ifdef DO_RGBA
67 GLfloat rPlane[4], gPlane[4], bPlane[4], aPlane[4];
68 DEFMARRAY(GLchan, rgba, MAX_WIDTH, 4); /* mac 32k limitation */
69 #endif
70 #ifdef DO_INDEX
71 GLfloat iPlane[4];
72 GLuint index[MAX_WIDTH];
73 GLint icoverageSpan[MAX_WIDTH];
74 #else
75 GLfloat coverageSpan[MAX_WIDTH];
76 #endif
77 #ifdef DO_SPEC
78 GLfloat srPlane[4], sgPlane[4], sbPlane[4];
79 DEFMARRAY(GLchan, spec, MAX_WIDTH, 4);
80 #endif
81 #ifdef DO_TEX
82 GLfloat sPlane[4], tPlane[4], uPlane[4], vPlane[4];
83 GLfloat texWidth, texHeight;
84 DEFARRAY(GLfloat, s, MAX_WIDTH); /* mac 32k limitation */
85 DEFARRAY(GLfloat, t, MAX_WIDTH);
86 DEFARRAY(GLfloat, u, MAX_WIDTH);
87 DEFARRAY(GLfloat, lambda, MAX_WIDTH);
88 #elif defined(DO_MULTITEX)
89 GLfloat sPlane[MAX_TEXTURE_UNITS][4];
90 GLfloat tPlane[MAX_TEXTURE_UNITS][4];
91 GLfloat uPlane[MAX_TEXTURE_UNITS][4];
92 GLfloat vPlane[MAX_TEXTURE_UNITS][4];
93 GLfloat texWidth[MAX_TEXTURE_UNITS], texHeight[MAX_TEXTURE_UNITS];
94 DEFMARRAY(GLfloat, s, MAX_TEXTURE_UNITS, MAX_WIDTH); /* mac 32k limit */
95 DEFMARRAY(GLfloat, t, MAX_TEXTURE_UNITS, MAX_WIDTH);
96 DEFMARRAY(GLfloat, u, MAX_TEXTURE_UNITS, MAX_WIDTH);
97 DEFMARRAY(GLfloat, lambda, MAX_TEXTURE_UNITS, MAX_WIDTH);
98 #endif
99 GLfloat bf = SWRAST_CONTEXT(ctx)->_backface_sign;
100
101 #ifdef DO_RGBA
102 CHECKARRAY(rgba, return); /* mac 32k limitation */
103 #endif
104 #ifdef DO_SPEC
105 CHECKARRAY(spec, return);
106 #endif
107 #if defined(DO_TEX) || defined(DO_MULTITEX)
108 CHECKARRAY(s, return);
109 CHECKARRAY(t, return);
110 CHECKARRAY(u, return);
111 CHECKARRAY(lambda, return);
112 #endif
113
114 /* determine bottom to top order of vertices */
115 {
116 GLfloat y0 = v0->win[1];
117 GLfloat y1 = v1->win[1];
118 GLfloat y2 = v2->win[1];
119 if (y0 <= y1) {
120 if (y1 <= y2) {
121 vMin = v0; vMid = v1; vMax = v2; /* y0<=y1<=y2 */
122 }
123 else if (y2 <= y0) {
124 vMin = v2; vMid = v0; vMax = v1; /* y2<=y0<=y1 */
125 }
126 else {
127 vMin = v0; vMid = v2; vMax = v1; bf = -bf; /* y0<=y2<=y1 */
128 }
129 }
130 else {
131 if (y0 <= y2) {
132 vMin = v1; vMid = v0; vMax = v2; bf = -bf; /* y1<=y0<=y2 */
133 }
134 else if (y2 <= y1) {
135 vMin = v2; vMid = v1; vMax = v0; bf = -bf; /* y2<=y1<=y0 */
136 }
137 else {
138 vMin = v1; vMid = v2; vMax = v0; /* y1<=y2<=y0 */
139 }
140 }
141 }
142
143 majDx = vMax->win[0] - vMin->win[0];
144 majDy = vMax->win[1] - vMin->win[1];
145
146 {
147 const GLfloat botDx = vMid->win[0] - vMin->win[0];
148 const GLfloat botDy = vMid->win[1] - vMin->win[1];
149 const GLfloat area = majDx * botDy - botDx * majDy;
150 ltor = (GLboolean) (area < 0.0F);
151 /* Do backface culling */
152 if (area * bf < 0 || area * area < .0025)
153 return;
154 }
155
156 #ifndef DO_OCCLUSION_TEST
157 ctx->OcclusionResult = GL_TRUE;
158 #endif
159
160 /* Plane equation setup:
161 * We evaluate plane equations at window (x,y) coordinates in order
162 * to compute color, Z, fog, texcoords, etc. This isn't terribly
163 * efficient but it's easy and reliable.
164 */
165 #ifdef DO_Z
166 compute_plane(p0, p1, p2, p0[2], p1[2], p2[2], zPlane);
167 #endif
168 #ifdef DO_FOG
169 compute_plane(p0, p1, p2, v0->fog, v1->fog, v2->fog, fogPlane);
170 #endif
171 #ifdef DO_RGBA
172 if (ctx->Light.ShadeModel == GL_SMOOTH) {
173 compute_plane(p0, p1, p2, v0->color[0], v1->color[0], v2->color[0], rPlane);
174 compute_plane(p0, p1, p2, v0->color[1], v1->color[1], v2->color[1], gPlane);
175 compute_plane(p0, p1, p2, v0->color[2], v1->color[2], v2->color[2], bPlane);
176 compute_plane(p0, p1, p2, v0->color[3], v1->color[3], v2->color[3], aPlane);
177 }
178 else {
179 constant_plane(v2->color[RCOMP], rPlane);
180 constant_plane(v2->color[GCOMP], gPlane);
181 constant_plane(v2->color[BCOMP], bPlane);
182 constant_plane(v2->color[ACOMP], aPlane);
183 }
184 #endif
185 #ifdef DO_INDEX
186 if (ctx->Light.ShadeModel == GL_SMOOTH) {
187 compute_plane(p0, p1, p2, v0->index,
188 v1->index, v2->index, iPlane);
189 }
190 else {
191 constant_plane(v2->index, iPlane);
192 }
193 #endif
194 #ifdef DO_SPEC
195 if (ctx->Light.ShadeModel == GL_SMOOTH) {
196 compute_plane(p0, p1, p2, v0->specular[0], v1->specular[0], v2->specular[0],srPlane);
197 compute_plane(p0, p1, p2, v0->specular[1], v1->specular[1], v2->specular[1],sgPlane);
198 compute_plane(p0, p1, p2, v0->specular[2], v1->specular[2], v2->specular[2],sbPlane);
199 }
200 else {
201 constant_plane(v2->specular[RCOMP], srPlane);
202 constant_plane(v2->specular[GCOMP], sgPlane);
203 constant_plane(v2->specular[BCOMP], sbPlane);
204 }
205 #endif
206 #ifdef DO_TEX
207 {
208 const struct gl_texture_object *obj = ctx->Texture.Unit[0]._Current;
209 const struct gl_texture_image *texImage = obj->Image[obj->BaseLevel];
210 const GLfloat invW0 = v0->win[3];
211 const GLfloat invW1 = v1->win[3];
212 const GLfloat invW2 = v2->win[3];
213 const GLfloat s0 = v0->texcoord[0][0] * invW0;
214 const GLfloat s1 = v1->texcoord[0][0] * invW1;
215 const GLfloat s2 = v2->texcoord[0][0] * invW2;
216 const GLfloat t0 = v0->texcoord[0][1] * invW0;
217 const GLfloat t1 = v1->texcoord[0][1] * invW1;
218 const GLfloat t2 = v2->texcoord[0][1] * invW2;
219 const GLfloat r0 = v0->texcoord[0][2] * invW0;
220 const GLfloat r1 = v1->texcoord[0][2] * invW1;
221 const GLfloat r2 = v2->texcoord[0][2] * invW2;
222 const GLfloat q0 = v0->texcoord[0][3] * invW0;
223 const GLfloat q1 = v1->texcoord[0][3] * invW1;
224 const GLfloat q2 = v2->texcoord[0][3] * invW2;
225 compute_plane(p0, p1, p2, s0, s1, s2, sPlane);
226 compute_plane(p0, p1, p2, t0, t1, t2, tPlane);
227 compute_plane(p0, p1, p2, r0, r1, r2, uPlane);
228 compute_plane(p0, p1, p2, q0, q1, q2, vPlane);
229 texWidth = (GLfloat) texImage->Width;
230 texHeight = (GLfloat) texImage->Height;
231 }
232 #elif defined(DO_MULTITEX)
233 {
234 GLuint u;
235 for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
236 if (ctx->Texture.Unit[u]._ReallyEnabled) {
237 const struct gl_texture_object *obj = ctx->Texture.Unit[u]._Current;
238 const struct gl_texture_image *texImage = obj->Image[obj->BaseLevel];
239 const GLfloat invW0 = v0->win[3];
240 const GLfloat invW1 = v1->win[3];
241 const GLfloat invW2 = v2->win[3];
242 const GLfloat s0 = v0->texcoord[u][0] * invW0;
243 const GLfloat s1 = v1->texcoord[u][0] * invW1;
244 const GLfloat s2 = v2->texcoord[u][0] * invW2;
245 const GLfloat t0 = v0->texcoord[u][1] * invW0;
246 const GLfloat t1 = v1->texcoord[u][1] * invW1;
247 const GLfloat t2 = v2->texcoord[u][1] * invW2;
248 const GLfloat r0 = v0->texcoord[u][2] * invW0;
249 const GLfloat r1 = v1->texcoord[u][2] * invW1;
250 const GLfloat r2 = v2->texcoord[u][2] * invW2;
251 const GLfloat q0 = v0->texcoord[u][3] * invW0;
252 const GLfloat q1 = v1->texcoord[u][3] * invW1;
253 const GLfloat q2 = v2->texcoord[u][3] * invW2;
254 compute_plane(p0, p1, p2, s0, s1, s2, sPlane[u]);
255 compute_plane(p0, p1, p2, t0, t1, t2, tPlane[u]);
256 compute_plane(p0, p1, p2, r0, r1, r2, uPlane[u]);
257 compute_plane(p0, p1, p2, q0, q1, q2, vPlane[u]);
258 texWidth[u] = (GLfloat) texImage->Width;
259 texHeight[u] = (GLfloat) texImage->Height;
260 }
261 }
262 }
263 #endif
264
265 /* Begin bottom-to-top scan over the triangle.
266 * The long edge will either be on the left or right side of the
267 * triangle. We always scan from the long edge toward the shorter
268 * edges, stopping when we find that coverage = 0. If the long edge
269 * is on the left we scan left-to-right. Else, we scan right-to-left.
270 */
271 yMin = vMin->win[1];
272 yMax = vMax->win[1];
273 iyMin = (GLint) yMin;
274 iyMax = (GLint) yMax + 1;
275
276 if (ltor) {
277 /* scan left to right */
278 const GLfloat *pMin = vMin->win;
279 const GLfloat *pMid = vMid->win;
280 const GLfloat *pMax = vMax->win;
281 const GLfloat dxdy = majDx / majDy;
282 const GLfloat xAdj = dxdy < 0.0F ? -dxdy : 0.0F;
283 GLfloat x = pMin[0] - (yMin - iyMin) * dxdy;
284 GLint iy;
285 for (iy = iyMin; iy < iyMax; iy++, x += dxdy) {
286 GLint ix, startX = (GLint) (x - xAdj);
287 GLuint count, n;
288 GLfloat coverage = 0.0F;
289 /* skip over fragments with zero coverage */
290 while (startX < MAX_WIDTH) {
291 coverage = compute_coveragef(pMin, pMid, pMax, startX, iy);
292 if (coverage > 0.0F)
293 break;
294 startX++;
295 }
296
297 /* enter interior of triangle */
298 ix = startX;
299 count = 0;
300 while (coverage > 0.0F) {
301 /* (cx,cy) = center of fragment */
302 const GLfloat cx = ix + 0.5F, cy = iy + 0.5F;
303 #ifdef DO_INDEX
304 icoverageSpan[count] = compute_coveragei(pMin, pMid, pMax, ix, iy);
305 #else
306 coverageSpan[count] = coverage;
307 #endif
308 #ifdef DO_Z
309 z[count] = (GLdepth) solve_plane(cx, cy, zPlane);
310 #endif
311 #ifdef DO_FOG
312 fog[count] = solve_plane(cx, cy, fogPlane);
313 #endif
314 #ifdef DO_RGBA
315 rgba[count][RCOMP] = solve_plane_chan(cx, cy, rPlane);
316 rgba[count][GCOMP] = solve_plane_chan(cx, cy, gPlane);
317 rgba[count][BCOMP] = solve_plane_chan(cx, cy, bPlane);
318 rgba[count][ACOMP] = solve_plane_chan(cx, cy, aPlane);
319 #endif
320 #ifdef DO_INDEX
321 index[count] = (GLint) solve_plane(cx, cy, iPlane);
322 #endif
323 #ifdef DO_SPEC
324 spec[count][RCOMP] = solve_plane_chan(cx, cy, srPlane);
325 spec[count][GCOMP] = solve_plane_chan(cx, cy, sgPlane);
326 spec[count][BCOMP] = solve_plane_chan(cx, cy, sbPlane);
327 #endif
328 #ifdef DO_TEX
329 {
330 const GLfloat invQ = solve_plane_recip(cx, cy, vPlane);
331 s[count] = solve_plane(cx, cy, sPlane) * invQ;
332 t[count] = solve_plane(cx, cy, tPlane) * invQ;
333 u[count] = solve_plane(cx, cy, uPlane) * invQ;
334 lambda[count] = compute_lambda(sPlane, tPlane, invQ,
335 texWidth, texHeight);
336 }
337 #elif defined(DO_MULTITEX)
338 {
339 GLuint unit;
340 for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) {
341 if (ctx->Texture.Unit[unit]._ReallyEnabled) {
342 GLfloat invQ = solve_plane_recip(cx, cy, vPlane[unit]);
343 s[unit][count] = solve_plane(cx, cy, sPlane[unit]) * invQ;
344 t[unit][count] = solve_plane(cx, cy, tPlane[unit]) * invQ;
345 u[unit][count] = solve_plane(cx, cy, uPlane[unit]) * invQ;
346 lambda[unit][count] = compute_lambda(sPlane[unit],
347 tPlane[unit], invQ, texWidth[unit], texHeight[unit]);
348 }
349 }
350 }
351 #endif
352 ix++;
353 count++;
354 coverage = compute_coveragef(pMin, pMid, pMax, ix, iy);
355 }
356
357 if (ix <= startX)
358 continue;
359
360 n = (GLuint) ix - (GLuint) startX;
361
362 #ifdef DO_MULTITEX
363 # ifdef DO_SPEC
364 _mesa_write_multitexture_span(ctx, n, startX, iy, z, fog,
365 (const GLfloat (*)[MAX_WIDTH]) s,
366 (const GLfloat (*)[MAX_WIDTH]) t,
367 (const GLfloat (*)[MAX_WIDTH]) u,
368 (GLfloat (*)[MAX_WIDTH]) lambda,
369 rgba, (const GLchan (*)[4]) spec,
370 coverageSpan, GL_POLYGON);
371 # else
372 _mesa_write_multitexture_span(ctx, n, startX, iy, z, fog,
373 (const GLfloat (*)[MAX_WIDTH]) s,
374 (const GLfloat (*)[MAX_WIDTH]) t,
375 (const GLfloat (*)[MAX_WIDTH]) u,
376 lambda, rgba, NULL, coverageSpan,
377 GL_POLYGON);
378 # endif
379 #elif defined(DO_TEX)
380 # ifdef DO_SPEC
381 _mesa_write_texture_span(ctx, n, startX, iy, z, fog,
382 s, t, u, lambda, rgba,
383 (const GLchan (*)[4]) spec,
384 coverageSpan, GL_POLYGON);
385 # else
386 _mesa_write_texture_span(ctx, n, startX, iy, z, fog,
387 s, t, u, lambda,
388 rgba, NULL, coverageSpan, GL_POLYGON);
389 # endif
390 #elif defined(DO_RGBA)
391 _mesa_write_rgba_span(ctx, n, startX, iy, z, fog, rgba,
392 coverageSpan, GL_POLYGON);
393 #elif defined(DO_INDEX)
394 _mesa_write_index_span(ctx, n, startX, iy, z, fog, index,
395 icoverageSpan, GL_POLYGON);
396 #endif
397 }
398 }
399 else {
400 /* scan right to left */
401 const GLfloat *pMin = vMin->win;
402 const GLfloat *pMid = vMid->win;
403 const GLfloat *pMax = vMax->win;
404 const GLfloat dxdy = majDx / majDy;
405 const GLfloat xAdj = dxdy > 0 ? dxdy : 0.0F;
406 GLfloat x = pMin[0] - (yMin - iyMin) * dxdy;
407 GLint iy;
408 for (iy = iyMin; iy < iyMax; iy++, x += dxdy) {
409 GLint ix, left, startX = (GLint) (x + xAdj);
410 GLuint count, n;
411 GLfloat coverage = 0.0F;
412
413 /* make sure we're not past the window edge */
414 if (startX >= ctx->DrawBuffer->_Xmax) {
415 startX = ctx->DrawBuffer->_Xmax - 1;
416 }
417
418 /* skip fragments with zero coverage */
419 while (startX >= 0) {
420 coverage = compute_coveragef(pMin, pMax, pMid, startX, iy);
421 if (coverage > 0.0F)
422 break;
423 startX--;
424 }
425
426 /* enter interior of triangle */
427 ix = startX;
428 count = 0;
429 while (coverage > 0.0F) {
430 /* (cx,cy) = center of fragment */
431 const GLfloat cx = ix + 0.5F, cy = iy + 0.5F;
432 #ifdef DO_INDEX
433 icoverageSpan[ix] = compute_coveragei(pMin, pMid, pMax, ix, iy);
434 #else
435 coverageSpan[ix] = coverage;
436 #endif
437 #ifdef DO_Z
438 z[ix] = (GLdepth) solve_plane(cx, cy, zPlane);
439 #endif
440 #ifdef DO_FOG
441 fog[ix] = solve_plane(cx, cy, fogPlane);
442 #endif
443 #ifdef DO_RGBA
444 rgba[ix][RCOMP] = solve_plane_chan(cx, cy, rPlane);
445 rgba[ix][GCOMP] = solve_plane_chan(cx, cy, gPlane);
446 rgba[ix][BCOMP] = solve_plane_chan(cx, cy, bPlane);
447 rgba[ix][ACOMP] = solve_plane_chan(cx, cy, aPlane);
448 #endif
449 #ifdef DO_INDEX
450 index[ix] = (GLint) solve_plane(cx, cy, iPlane);
451 #endif
452 #ifdef DO_SPEC
453 spec[ix][RCOMP] = solve_plane_chan(cx, cy, srPlane);
454 spec[ix][GCOMP] = solve_plane_chan(cx, cy, sgPlane);
455 spec[ix][BCOMP] = solve_plane_chan(cx, cy, sbPlane);
456 #endif
457 #ifdef DO_TEX
458 {
459 const GLfloat invQ = solve_plane_recip(cx, cy, vPlane);
460 s[ix] = solve_plane(cx, cy, sPlane) * invQ;
461 t[ix] = solve_plane(cx, cy, tPlane) * invQ;
462 u[ix] = solve_plane(cx, cy, uPlane) * invQ;
463 lambda[ix] = compute_lambda(sPlane, tPlane, invQ,
464 texWidth, texHeight);
465 }
466 #elif defined(DO_MULTITEX)
467 {
468 GLuint unit;
469 for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) {
470 if (ctx->Texture.Unit[unit]._ReallyEnabled) {
471 GLfloat invQ = solve_plane_recip(cx, cy, vPlane[unit]);
472 s[unit][ix] = solve_plane(cx, cy, sPlane[unit]) * invQ;
473 t[unit][ix] = solve_plane(cx, cy, tPlane[unit]) * invQ;
474 u[unit][ix] = solve_plane(cx, cy, uPlane[unit]) * invQ;
475 lambda[unit][ix] = compute_lambda(sPlane[unit],
476 tPlane[unit], invQ, texWidth[unit], texHeight[unit]);
477 }
478 }
479 }
480 #endif
481 ix--;
482 count++;
483 coverage = compute_coveragef(pMin, pMax, pMid, ix, iy);
484 }
485
486 if (startX <= ix)
487 continue;
488
489 n = (GLuint) startX - (GLuint) ix;
490
491 left = ix + 1;
492 #ifdef DO_MULTITEX
493 {
494 GLuint unit;
495 for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) {
496 if (ctx->Texture.Unit[unit]._ReallyEnabled) {
497 GLint j;
498 for (j = 0; j < (GLint) n; j++) {
499 s[unit][j] = s[unit][j + left];
500 t[unit][j] = t[unit][j + left];
501 u[unit][j] = u[unit][j + left];
502 lambda[unit][j] = lambda[unit][j + left];
503 }
504 }
505 }
506 }
507 # ifdef DO_SPEC
508 _mesa_write_multitexture_span(ctx, n, left, iy, z + left, fog + left,
509 (const GLfloat (*)[MAX_WIDTH]) s,
510 (const GLfloat (*)[MAX_WIDTH]) t,
511 (const GLfloat (*)[MAX_WIDTH]) u,
512 lambda, rgba + left,
513 (const GLchan (*)[4]) (spec + left),
514 coverageSpan + left,
515 GL_POLYGON);
516 # else
517 _mesa_write_multitexture_span(ctx, n, left, iy, z + left, fog + left,
518 (const GLfloat (*)[MAX_WIDTH]) s,
519 (const GLfloat (*)[MAX_WIDTH]) t,
520 (const GLfloat (*)[MAX_WIDTH]) u,
521 lambda,
522 rgba + left, NULL, coverageSpan + left,
523 GL_POLYGON);
524 # endif
525 #elif defined(DO_TEX)
526 # ifdef DO_SPEC
527 _mesa_write_texture_span(ctx, n, left, iy, z + left, fog + left,
528 s + left, t + left, u + left,
529 lambda + left, rgba + left,
530 (const GLchan (*)[4]) (spec + left),
531 coverageSpan + left,
532 GL_POLYGON);
533 # else
534 _mesa_write_texture_span(ctx, n, left, iy, z + left, fog + left,
535 s + left, t + left,
536 u + left, lambda + left,
537 rgba + left, NULL,
538 coverageSpan + left, GL_POLYGON);
539 # endif
540 #elif defined(DO_RGBA)
541 _mesa_write_rgba_span(ctx, n, left, iy, z + left, fog + left,
542 rgba + left, coverageSpan + left, GL_POLYGON);
543 #elif defined(DO_INDEX)
544 _mesa_write_index_span(ctx, n, left, iy, z + left, fog + left,
545 index + left, icoverageSpan + left, GL_POLYGON);
546 #endif
547 }
548 }
549
550 #ifdef DO_RGBA
551 UNDEFARRAY(rgba); /* mac 32k limitation */
552 #endif
553 #ifdef DO_SPEC
554 UNDEFARRAY(spec);
555 #endif
556 #if defined(DO_TEX) || defined(DO_MULTITEX)
557 UNDEFARRAY(s);
558 UNDEFARRAY(t);
559 UNDEFARRAY(u);
560 UNDEFARRAY(lambda);
561 #endif
562 }
563
564
565 #ifdef DO_Z
566 #undef DO_Z
567 #endif
568
569 #ifdef DO_FOG
570 #undef DO_FOG
571 #endif
572
573 #ifdef DO_RGBA
574 #undef DO_RGBA
575 #endif
576
577 #ifdef DO_INDEX
578 #undef DO_INDEX
579 #endif
580
581 #ifdef DO_SPEC
582 #undef DO_SPEC
583 #endif
584
585 #ifdef DO_TEX
586 #undef DO_TEX
587 #endif
588
589 #ifdef DO_MULTITEX
590 #undef DO_MULTITEX
591 #endif
592
593 #ifdef DO_OCCLUSION_TEST
594 #undef DO_OCCLUSION_TEST
595 #endif