source: trunk/src/opengl/mesa/aatritemp.h

Last change on this file was 3582, checked in by jeroen, 25 years ago

* empty log message *
File size: 18.1 KB
RevLine 
[3582]1/* $Id: aatritemp.h,v 1.1 2000-05-21 19:56:12 jeroen Exp $ */
2
3/*
4 * Mesa 3-D graphics library
5 * Version: 3.3
6 *
7 * Copyright (C) 1999-2000 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_STUV0 - if defined, compute unit 0 STRQ texcoords
42 * DO_STUV1 - if defined, compute unit 1 STRQ texcoords
43 */
44
45/*void triangle( GLcontext *ctx, GLuint v0, GLuint v1, GLuint v2, GLuint pv )*/
46{
47 const struct vertex_buffer *VB = ctx->VB;
48 const GLfloat *p0 = VB->Win.data[v0];
49 const GLfloat *p1 = VB->Win.data[v1];
50 const GLfloat *p2 = VB->Win.data[v2];
51 GLint vMin, vMid, vMax;
52 GLint iyMin, iyMax;
53 GLfloat yMin, yMax;
54 GLboolean ltor;
55 GLfloat majDx, majDy;
56#ifdef DO_Z
57 GLfloat zPlane[4]; /* Z (depth) */
58 GLdepth z[MAX_WIDTH];
59#endif
60#ifdef DO_RGBA
61 GLfloat rPlane[4], gPlane[4], bPlane[4], aPlane[4]; /* color */
62 GLubyte rgba[MAX_WIDTH][4];
63#endif
64#ifdef DO_INDEX
65 GLfloat iPlane[4]; /* color index */
66 GLuint index[MAX_WIDTH];
67#endif
68#ifdef DO_SPEC
69 GLfloat srPlane[4], sgPlane[4], sbPlane[4]; /* spec color */
70 GLubyte spec[MAX_WIDTH][4];
71#endif
72#ifdef DO_STUV0
73 GLfloat s0Plane[4], t0Plane[4], u0Plane[4], v0Plane[4]; /* texture 0 */
74 GLfloat width0, height0;
75 GLfloat s[MAX_TEXTURE_UNITS][MAX_WIDTH];
76 GLfloat t[MAX_TEXTURE_UNITS][MAX_WIDTH];
77 GLfloat u[MAX_TEXTURE_UNITS][MAX_WIDTH];
78 GLfloat lambda[MAX_TEXTURE_UNITS][MAX_WIDTH];
79#endif
80#ifdef DO_STUV1
81 GLfloat s1Plane[4], t1Plane[4], u1Plane[4], v1Plane[4]; /* texture 1 */
82 GLfloat width1, height1;
83#endif
84 GLfloat bf = ctx->backface_sign;
85
86 /* determine bottom to top order of vertices */
87 {
88 GLfloat y0 = VB->Win.data[v0][1];
89 GLfloat y1 = VB->Win.data[v1][1];
90 GLfloat y2 = VB->Win.data[v2][1];
91 if (y0 <= y1) {
92 if (y1 <= y2) {
93 vMin = v0; vMid = v1; vMax = v2; /* y0<=y1<=y2 */
94 }
95 else if (y2 <= y0) {
96 vMin = v2; vMid = v0; vMax = v1; /* y2<=y0<=y1 */
97 }
98 else {
99 vMin = v0; vMid = v2; vMax = v1; bf = -bf; /* y0<=y2<=y1 */
100 }
101 }
102 else {
103 if (y0 <= y2) {
104 vMin = v1; vMid = v0; vMax = v2; bf = -bf; /* y1<=y0<=y2 */
105 }
106 else if (y2 <= y1) {
107 vMin = v2; vMid = v1; vMax = v0; bf = -bf; /* y2<=y1<=y0 */
108 }
109 else {
110 vMin = v1; vMid = v2; vMax = v0; /* y1<=y2<=y0 */
111 }
112 }
113 }
114
115 majDx = VB->Win.data[vMax][0] - VB->Win.data[vMin][0];
116 majDy = VB->Win.data[vMax][1] - VB->Win.data[vMin][1];
117
118 {
119 const GLfloat botDx = VB->Win.data[vMid][0] - VB->Win.data[vMin][0];
120 const GLfloat botDy = VB->Win.data[vMid][1] - VB->Win.data[vMin][1];
121 const GLfloat area = majDx * botDy - botDx * majDy;
122 ltor = (GLboolean) (area < 0.0F);
123 /* Do backface culling */
124 if (area * bf < 0 || area * area < .0025)
125 return;
126 }
127
128 /* plane setup */
129#ifdef DO_Z
130 compute_plane(p0, p1, p2, p0[2], p1[2], p2[2], zPlane);
131#endif
132#ifdef DO_RGBA
133 if (ctx->Light.ShadeModel == GL_SMOOTH) {
134 GLubyte (*rgba)[4] = VB->ColorPtr->data;
135 compute_plane(p0, p1, p2, rgba[v0][0], rgba[v1][0], rgba[v2][0], rPlane);
136 compute_plane(p0, p1, p2, rgba[v0][1], rgba[v1][1], rgba[v2][1], gPlane);
137 compute_plane(p0, p1, p2, rgba[v0][2], rgba[v1][2], rgba[v2][2], bPlane);
138 compute_plane(p0, p1, p2, rgba[v0][3], rgba[v1][3], rgba[v2][3], aPlane);
139 }
140 else {
141 constant_plane(VB->ColorPtr->data[pv][RCOMP], rPlane);
142 constant_plane(VB->ColorPtr->data[pv][GCOMP], gPlane);
143 constant_plane(VB->ColorPtr->data[pv][BCOMP], bPlane);
144 constant_plane(VB->ColorPtr->data[pv][ACOMP], aPlane);
145 }
146#endif
147#ifdef DO_INDEX
148 if (ctx->Light.ShadeModel == GL_SMOOTH) {
149 compute_plane(p0, p1, p2, VB->IndexPtr->data[v0],
150 VB->IndexPtr->data[v1], VB->IndexPtr->data[v2], iPlane);
151 }
152 else {
153 constant_plane(VB->IndexPtr->data[pv], iPlane);
154 }
155#endif
156#ifdef DO_SPEC
157 {
158 GLubyte (*spec)[4] = VB->Specular;
159 compute_plane(p0, p1, p2, spec[v0][0], spec[v1][0], spec[v2][0],srPlane);
160 compute_plane(p0, p1, p2, spec[v0][1], spec[v1][1], spec[v2][1],sgPlane);
161 compute_plane(p0, p1, p2, spec[v0][2], spec[v1][2], spec[v2][2],sbPlane);
162 }
163#endif
164#ifdef DO_STUV0
165 {
166 const struct gl_texture_object *obj = ctx->Texture.Unit[0].Current;
167 const struct gl_texture_image *texImage = obj->Image[obj->BaseLevel];
168 const GLint tSize = 3;
169 const GLfloat invW0 = VB->Win.data[v0][3];
170 const GLfloat invW1 = VB->Win.data[v1][3];
171 const GLfloat invW2 = VB->Win.data[v2][3];
172 GLfloat (*texCoord)[4] = VB->TexCoordPtr[0]->data;
173 const GLfloat s0 = texCoord[v0][0] * invW0;
174 const GLfloat s1 = texCoord[v1][0] * invW1;
175 const GLfloat s2 = texCoord[v2][0] * invW2;
176 const GLfloat t0 = (tSize > 1) ? texCoord[v0][1] * invW0 : 0.0F;
177 const GLfloat t1 = (tSize > 1) ? texCoord[v1][1] * invW1 : 0.0F;
178 const GLfloat t2 = (tSize > 1) ? texCoord[v2][1] * invW2 : 0.0F;
179 const GLfloat r0 = (tSize > 2) ? texCoord[v0][2] * invW0 : 0.0F;
180 const GLfloat r1 = (tSize > 2) ? texCoord[v1][2] * invW1 : 0.0F;
181 const GLfloat r2 = (tSize > 2) ? texCoord[v2][2] * invW2 : 0.0F;
182 const GLfloat q0 = (tSize > 3) ? texCoord[v0][3] * invW0 : invW0;
183 const GLfloat q1 = (tSize > 3) ? texCoord[v1][3] * invW1 : invW1;
184 const GLfloat q2 = (tSize > 3) ? texCoord[v2][3] * invW2 : invW2;
185 compute_plane(p0, p1, p2, s0, s1, s2, s0Plane);
186 compute_plane(p0, p1, p2, t0, t1, t2, t0Plane);
187 compute_plane(p0, p1, p2, r0, r1, r2, u0Plane);
188 compute_plane(p0, p1, p2, q0, q1, q2, v0Plane);
189 width0 = (GLfloat) texImage->Width;
190 height0 = (GLfloat) texImage->Height;
191 }
192#endif
193#ifdef DO_STUV1
194 {
195 const struct gl_texture_object *obj = ctx->Texture.Unit[1].Current;
196 const struct gl_texture_image *texImage = obj->Image[obj->BaseLevel];
197 const GLint tSize = VB->TexCoordPtr[1]->size;
198 const GLfloat invW0 = VB->Win.data[v0][3];
199 const GLfloat invW1 = VB->Win.data[v1][3];
200 const GLfloat invW2 = VB->Win.data[v2][3];
201 GLfloat (*texCoord)[4] = VB->TexCoordPtr[1]->data;
202 const GLfloat s0 = texCoord[v0][0] * invW0;
203 const GLfloat s1 = texCoord[v1][0] * invW1;
204 const GLfloat s2 = texCoord[v2][0] * invW2;
205 const GLfloat t0 = (tSize > 1) ? texCoord[v0][1] * invW0 : 0.0F;
206 const GLfloat t1 = (tSize > 1) ? texCoord[v1][1] * invW1 : 0.0F;
207 const GLfloat t2 = (tSize > 1) ? texCoord[v2][1] * invW2 : 0.0F;
208 const GLfloat r0 = (tSize > 2) ? texCoord[v0][2] * invW0 : 0.0F;
209 const GLfloat r1 = (tSize > 2) ? texCoord[v1][2] * invW1 : 0.0F;
210 const GLfloat r2 = (tSize > 2) ? texCoord[v2][2] * invW2 : 0.0F;
211 const GLfloat q0 = (tSize > 3) ? texCoord[v0][3] * invW0 : invW0;
212 const GLfloat q1 = (tSize > 3) ? texCoord[v1][3] * invW1 : invW1;
213 const GLfloat q2 = (tSize > 3) ? texCoord[v2][3] * invW2 : invW2;
214 compute_plane(p0, p1, p2, s0, s1, s2, s1Plane);
215 compute_plane(p0, p1, p2, t0, t1, t2, t1Plane);
216 compute_plane(p0, p1, p2, r0, r1, r2, u1Plane);
217 compute_plane(p0, p1, p2, q0, q1, q2, v1Plane);
218 width1 = (GLfloat) texImage->Width;
219 height1 = (GLfloat) texImage->Height;
220 }
221#endif
222
223 yMin = VB->Win.data[vMin][1];
224 yMax = VB->Win.data[vMax][1];
225 iyMin = (int) yMin;
226 iyMax = (int) yMax + 1;
227
228 if (ltor) {
229 /* scan left to right */
230 const float *pMin = VB->Win.data[vMin];
231 const float *pMid = VB->Win.data[vMid];
232 const float *pMax = VB->Win.data[vMax];
233 const float dxdy = majDx / majDy;
234 const float xAdj = dxdy < 0.0F ? -dxdy : 0.0F;
235 float x = VB->Win.data[vMin][0] - (yMin - iyMin) * dxdy;
236 int iy;
237 for (iy = iyMin; iy < iyMax; iy++, x += dxdy) {
238 GLint ix, startX = (GLint) (x - xAdj);
239 GLuint count, n;
240 GLfloat coverage;
241 /* skip over fragments with zero coverage */
242 while (startX < MAX_WIDTH) {
243 coverage = compute_coveragef(pMin, pMid, pMax, startX, iy);
244 if (coverage > 0.0F)
245 break;
246 startX++;
247 }
248
249 /* enter interior of triangle */
250 ix = startX;
251 count = 0;
252 while (coverage > 0.0F) {
253#ifdef DO_Z
254 z[count] = (GLdepth) solve_plane(ix, iy, zPlane);
255#endif
256#ifdef DO_RGBA
257 rgba[count][RCOMP] = solve_plane_0_255(ix, iy, rPlane);
258 rgba[count][GCOMP] = solve_plane_0_255(ix, iy, gPlane);
259 rgba[count][BCOMP] = solve_plane_0_255(ix, iy, bPlane);
260 rgba[count][ACOMP] = (GLubyte) (solve_plane_0_255(ix, iy, aPlane) * coverage);
261#endif
262#ifdef DO_INDEX
263 {
264 GLint frac = compute_coveragei(pMin, pMid, pMax, ix, iy);
265 GLint indx = (GLint) solve_plane(ix, iy, iPlane);
266 index[count] = (indx & ~0xf) | frac;
267 }
268#endif
269#ifdef DO_SPEC
270 spec[count][RCOMP] = solve_plane_0_255(ix, iy, srPlane);
271 spec[count][GCOMP] = solve_plane_0_255(ix, iy, sgPlane);
272 spec[count][BCOMP] = solve_plane_0_255(ix, iy, sbPlane);
273#endif
274#ifdef DO_STUV0
275 {
276 GLfloat invQ = solve_plane_recip(ix, iy, v0Plane);
277 s[0][count] = solve_plane(ix, iy, s0Plane) * invQ;
278 t[0][count] = solve_plane(ix, iy, t0Plane) * invQ;
279 u[0][count] = solve_plane(ix, iy, u0Plane) * invQ;
280 lambda[0][count] = compute_lambda(s0Plane, t0Plane, invQ,
281 width0, height0);
282 }
283#endif
284#ifdef DO_STUV1
285 {
286 GLfloat invQ = solve_plane_recip(ix, iy, v1Plane);
287 s[1][count] = solve_plane(ix, iy, s1Plane) * invQ;
288 t[1][count] = solve_plane(ix, iy, t1Plane) * invQ;
289 u[1][count] = solve_plane(ix, iy, u1Plane) * invQ;
290 lambda[1][count] = compute_lambda(s1Plane, t1Plane, invQ,
291 width1, height1);
292 }
293#endif
294 ix++;
295 count++;
296 coverage = compute_coveragef(pMin, pMid, pMax, ix, iy);
297 }
298
299 n = (GLuint) ix - (GLuint) startX;
300#ifdef DO_STUV1
301# ifdef DO_SPEC
302 gl_write_multitexture_span(ctx, 2, n, startX, iy, z,
303 (const GLfloat (*)[MAX_WIDTH]) s,
304 (const GLfloat (*)[MAX_WIDTH]) t,
305 (const GLfloat (*)[MAX_WIDTH]) u,
306 (GLfloat (*)[MAX_WIDTH]) lambda,
307 rgba, (const GLubyte (*)[4]) spec,
308 GL_POLYGON);
309# else
310 gl_write_multitexture_span(ctx, 2, n, startX, iy, z,
311 (const GLfloat (*)[MAX_WIDTH]) s,
312 (const GLfloat (*)[MAX_WIDTH]) t,
313 (const GLfloat (*)[MAX_WIDTH]) u,
314 lambda, rgba, NULL, GL_POLYGON);
315# endif
316#elif defined(DO_STUV0)
317# ifdef DO_SPEC
318 gl_write_texture_span(ctx, n, startX, iy, z,
319 s[0], t[0], u[0], lambda[0], rgba,
320 (const GLubyte (*)[4]) spec, GL_POLYGON);
321# else
322 gl_write_texture_span(ctx, n, startX, iy, z,
323 s[0], t[0], u[0], lambda[0],
324 rgba, NULL, GL_POLYGON);
325# endif
326#elif defined(DO_RGBA)
327 gl_write_rgba_span(ctx, n, startX, iy, z, rgba, GL_POLYGON);
328#elif defined(DO_INDEX)
329 gl_write_index_span(ctx, n, startX, iy, z, index, GL_POLYGON);
330#endif
331 }
332 }
333 else {
334 /* scan right to left */
335 const GLfloat *pMin = VB->Win.data[vMin];
336 const GLfloat *pMid = VB->Win.data[vMid];
337 const GLfloat *pMax = VB->Win.data[vMax];
338 const GLfloat dxdy = majDx / majDy;
339 const GLfloat xAdj = dxdy > 0 ? dxdy : 0.0F;
340 GLfloat x = VB->Win.data[vMin][0] - (yMin - iyMin) * dxdy;
341 GLint iy;
342 for (iy = iyMin; iy < iyMax; iy++, x += dxdy) {
343 GLint ix, left, startX = (GLint) (x + xAdj);
344 GLuint count, n;
345 GLfloat coverage;
346 /* skip fragments with zero coverage */
347 while (startX >= 0) {
348 coverage = compute_coveragef(pMin, pMax, pMid, startX, iy);
349 if (coverage > 0.0F)
350 break;
351 startX--;
352 }
353
354 /* enter interior of triangle */
355 ix = startX;
356 count = 0;
357 while (coverage > 0.0F) {
358#ifdef DO_Z
359 z[ix] = (GLdepth) solve_plane(ix, iy, zPlane);
360#endif
361#ifdef DO_RGBA
362 rgba[ix][RCOMP] = solve_plane_0_255(ix, iy, rPlane);
363 rgba[ix][GCOMP] = solve_plane_0_255(ix, iy, gPlane);
364 rgba[ix][BCOMP] = solve_plane_0_255(ix, iy, bPlane);
365 rgba[ix][ACOMP] = (GLubyte) (solve_plane_0_255(ix, iy, aPlane) * coverage);
366#endif
367#ifdef DO_INDEX
368 {
369 GLint frac = compute_coveragei(pMin, pMax, pMid, ix, iy);
370 GLint indx = (GLint) solve_plane(ix, iy, iPlane);
371 index[ix] = (indx & ~0xf) | frac;
372 }
373#endif
374#ifdef DO_SPEC
375 spec[ix][RCOMP] = solve_plane_0_255(ix, iy, srPlane);
376 spec[ix][GCOMP] = solve_plane_0_255(ix, iy, sgPlane);
377 spec[ix][BCOMP] = solve_plane_0_255(ix, iy, sbPlane);
378#endif
379#ifdef DO_STUV0
380 {
381 GLfloat invQ = solve_plane_recip(ix, iy, v0Plane);
382 s[0][ix] = solve_plane(ix, iy, s0Plane) * invQ;
383 t[0][ix] = solve_plane(ix, iy, t0Plane) * invQ;
384 u[0][ix] = solve_plane(ix, iy, u0Plane) * invQ;
385 lambda[0][ix] = compute_lambda(s0Plane, t0Plane, invQ,
386 width0, height0);
387 }
388#endif
389#ifdef DO_STUV1
390 {
391 GLfloat invQ = solve_plane_recip(ix, iy, v1Plane);
392 s[1][ix] = solve_plane(ix, iy, s1Plane) * invQ;
393 t[1][ix] = solve_plane(ix, iy, t1Plane) * invQ;
394 u[1][ix] = solve_plane(ix, iy, u1Plane) * invQ;
395 lambda[1][ix] = compute_lambda(s1Plane, t1Plane, invQ,
396 width1, height1);
397 }
398#endif
399 ix--;
400 count++;
401 coverage = compute_coveragef(pMin, pMax, pMid, ix, iy);
402 }
403
404 n = (GLuint) startX - (GLuint) ix;
405 left = ix + 1;
406#ifdef DO_STUV1
407 {
408 int j;
409 for (j = 0; j < n; j++) {
410 s[0][j] = s[0][j + left];
411 t[0][j] = t[0][j + left];
412 u[0][j] = u[0][j + left];
413 s[1][j] = s[1][j + left];
414 t[1][j] = t[1][j + left];
415 u[1][j] = u[1][j + left];
416 lambda[0][j] = lambda[0][j + left];
417 lambda[1][j] = lambda[1][j + left];
418 }
419 }
420# ifdef DO_SPEC
421 gl_write_multitexture_span(ctx, 2, n, left, iy, z + left,
422 (const GLfloat (*)[MAX_WIDTH]) s,
423 (const GLfloat (*)[MAX_WIDTH]) t,
424 (const GLfloat (*)[MAX_WIDTH]) u,
425 lambda, rgba + left,
426 (const GLubyte (*)[4]) (spec + left),
427 GL_POLYGON);
428# else
429 gl_write_multitexture_span(ctx, 2, n, left, iy, z + left,
430 (const GLfloat (*)[MAX_WIDTH]) s,
431 (const GLfloat (*)[MAX_WIDTH]) t,
432 (const GLfloat (*)[MAX_WIDTH]) u,
433 lambda,
434 rgba + left, NULL, GL_POLYGON);
435# endif
436#elif defined(DO_STUV0)
437# ifdef DO_SPEC
438 gl_write_texture_span(ctx, n, left, iy, z + left,
439 s[0] + left, t[0] + left, u[0] + left,
440 lambda[0] + left, rgba + left,
441 (const GLubyte (*)[4]) (spec + left),
442 GL_POLYGON);
443# else
444 gl_write_texture_span(ctx, n, left, iy, z + left,
445 s[0] + left, t[0] + left,
446 u[0] + left, lambda[0] + left,
447 rgba + left, NULL, GL_POLYGON);
448# endif
449#elif defined(DO_RGBA)
450 gl_write_rgba_span(ctx, n, left, iy, z + left,
451 rgba + left, GL_POLYGON);
452#elif defined(DO_INDEX)
453 gl_write_index_span(ctx, n, left, iy, z + left,
454 index + left, GL_POLYGON);
455#endif
456 }
457 }
458}
459
460
461#ifdef DO_Z
462#undef DO_Z
463#endif
464
465#ifdef DO_RGBA
466#undef DO_RGBA
467#endif
468
469#ifdef DO_INDEX
470#undef DO_INDEX
471#endif
472
473#ifdef DO_SPEC
474#undef DO_SPEC
475#endif
476
477#ifdef DO_STUV0
478#undef DO_STUV0
479#endif
480
481#ifdef DO_STUV1
482#undef DO_STUV1
483#endif
Note: See TracBrowser for help on using the repository browser.