1 /*
2 * Mesa 3-D graphics library
3 *
4 * Copyright (C) 1999-2005 Brian Paul All Rights Reserved.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the "Software"),
8 * to deal in the Software without restriction, including without limitation
9 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10 * and/or sell copies of the Software, and to permit persons to whom the
11 * Software is furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included
14 * in all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
17 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
20 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
21 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
22 * OTHER DEALINGS IN THE SOFTWARE.
23 *
24 * Authors:
25 * Keith Whitwell <keithw@vmware.com>
26 */
27
28
29 /* Template for building functions to plug into the driver interface
30 * of t_vb_render.c:
31 * ctx->Driver.QuadFunc
32 * ctx->Driver.TriangleFunc
33 * ctx->Driver.LineFunc
34 * ctx->Driver.PointsFunc
35 *
36 * DO_TWOSIDE: Plug back-color values from the VB into backfacing triangles,
37 * and restore vertices afterwards.
38 * DO_OFFSET: Calculate offset for triangles and adjust vertices. Restore
39 * vertices after rendering.
40 * DO_FLAT: For hardware without native flatshading, copy provoking colors
41 * into the other vertices. Restore after rendering.
42 * DO_UNFILLED: Decompose triangles to lines and points where appropriate.
43 * DO_TWOSTENCIL:Gross hack for two-sided stencil.
44 *
45 * HAVE_SPEC: Vertices have secondary rgba values.
46 *
47 * VERT_X(v): Alias for vertex x value.
48 * VERT_Y(v): Alias for vertex y value.
49 * VERT_Z(v): Alias for vertex z value.
50 * DEPTH_SCALE: Scale for constant offset.
51 * REVERSE_DEPTH: Viewport depth range reversed.
52 *
53 * VERTEX: Hardware vertex type.
54 * GET_VERTEX(n): Retreive vertex with index n.
55 * AREA_IS_CCW(a): Return true if triangle with signed area a is ccw.
56 *
57 * VERT_SET_RGBA: Assign vertex rgba from VB color.
58 * VERT_COPY_RGBA: Copy vertex rgba another vertex.
59 * VERT_SAVE_RGBA: Save vertex rgba to a local variable.
60 * VERT_RESTORE_RGBA: Restore vertex rgba from a local variable.
61 * --> Similar for SPEC.
62 *
63 * LOCAL_VARS(n): (At least) define local vars for save/restore rgba.
64 *
65 */
66
67 #if HAVE_BACK_COLORS
68 #define VERT_SET_RGBA( v, c )
69 #endif
70
71 #if !HAVE_SPEC
72 #define VERT_SET_SPEC( v, c ) (void) c
73 #define VERT_COPY_SPEC( v0, v1 )
74 #define VERT_SAVE_SPEC( idx )
75 #define VERT_RESTORE_SPEC( idx )
76 #if HAVE_BACK_COLORS
77 #define VERT_COPY_SPEC1( v )
78 #endif
79 #else
80 #if HAVE_BACK_COLORS
81 #define VERT_SET_SPEC( v, c )
82 #endif
83 #endif
84
85 #if !HAVE_BACK_COLORS
86 #define VERT_COPY_SPEC1( v )
87 #define VERT_COPY_RGBA1( v )
88 #endif
89
90 #ifndef INSANE_VERTICES
91 #define VERT_SET_Z(v,val) VERT_Z(v) = val
92 #define VERT_Z_ADD(v,val) VERT_Z(v) += val
93 #endif
94
95 #ifndef REVERSE_DEPTH
96 #define REVERSE_DEPTH 0
97 #endif
98
99 /* disable twostencil for un-aware drivers */
100 #ifndef HAVE_STENCIL_TWOSIDE
101 #define HAVE_STENCIL_TWOSIDE 0
102 #endif
103 #ifndef DO_TWOSTENCIL
104 #define DO_TWOSTENCIL 0
105 #endif
106 #ifndef SETUP_STENCIL
107 #define SETUP_STENCIL(f)
108 #endif
109 #ifndef UNSET_STENCIL
110 #define UNSET_STENCIL(f)
111 #endif
112
113 #if DO_TRI
TAG(triangle)114 static void TAG(triangle)( struct gl_context *ctx, GLuint e0, GLuint e1, GLuint e2 )
115 {
116 struct vertex_buffer *VB = &TNL_CONTEXT( ctx )->vb;
117 VERTEX *v[3];
118 GLfloat offset = 0;
119 GLfloat z[3] = { 0 };
120 GLenum mode = GL_FILL;
121 GLuint facing = 0;
122 LOCAL_VARS(3);
123
124 /* fprintf(stderr, "%s\n", __func__); */
125
126 v[0] = (VERTEX *)GET_VERTEX(e0);
127 v[1] = (VERTEX *)GET_VERTEX(e1);
128 v[2] = (VERTEX *)GET_VERTEX(e2);
129
130 if (DO_TWOSIDE || DO_OFFSET || DO_UNFILLED || DO_TWOSTENCIL)
131 {
132 GLfloat ex = VERT_X(v[0]) - VERT_X(v[2]);
133 GLfloat ey = VERT_Y(v[0]) - VERT_Y(v[2]);
134 GLfloat fx = VERT_X(v[1]) - VERT_X(v[2]);
135 GLfloat fy = VERT_Y(v[1]) - VERT_Y(v[2]);
136 GLfloat cc = ex*fy - ey*fx;
137
138 if (DO_TWOSIDE || DO_UNFILLED || DO_TWOSTENCIL)
139 {
140 facing = AREA_IS_CCW( cc ) ^ _mesa_polygon_get_front_bit(ctx);
141
142 if (DO_UNFILLED) {
143 if (facing) {
144 mode = ctx->Polygon.BackMode;
145 if (ctx->Polygon.CullFlag &&
146 ctx->Polygon.CullFaceMode != GL_FRONT) {
147 return;
148 }
149 } else {
150 mode = ctx->Polygon.FrontMode;
151 if (ctx->Polygon.CullFlag &&
152 ctx->Polygon.CullFaceMode != GL_BACK) {
153 return;
154 }
155 }
156 }
157
158 if (DO_TWOSIDE && facing == 1) {
159 if (HAVE_BACK_COLORS) {
160 if (!DO_FLAT) {
161 VERT_SAVE_RGBA( 0 );
162 VERT_SAVE_RGBA( 1 );
163 VERT_COPY_RGBA1( v[0] );
164 VERT_COPY_RGBA1( v[1] );
165 }
166 VERT_SAVE_RGBA( 2 );
167 VERT_COPY_RGBA1( v[2] );
168 if (HAVE_SPEC) {
169 if (!DO_FLAT) {
170 VERT_SAVE_SPEC( 0 );
171 VERT_SAVE_SPEC( 1 );
172 VERT_COPY_SPEC1( v[0] );
173 VERT_COPY_SPEC1( v[1] );
174 }
175 VERT_SAVE_SPEC( 2 );
176 VERT_COPY_SPEC1( v[2] );
177 }
178 }
179 else {
180 GLfloat (*vbcolor)[4] = VB->BackfaceColorPtr->data;
181 (void) vbcolor;
182
183 if (!DO_FLAT) {
184 VERT_SAVE_RGBA( 0 );
185 VERT_SAVE_RGBA( 1 );
186 }
187 VERT_SAVE_RGBA( 2 );
188
189 if (VB->BackfaceColorPtr->stride) {
190 assert(VB->BackfaceColorPtr->stride == 4*sizeof(GLfloat));
191
192 if (!DO_FLAT) {
193 VERT_SET_RGBA( v[0], vbcolor[e0] );
194 VERT_SET_RGBA( v[1], vbcolor[e1] );
195 }
196 VERT_SET_RGBA( v[2], vbcolor[e2] );
197 }
198 else {
199 if (!DO_FLAT) {
200 VERT_SET_RGBA( v[0], vbcolor[0] );
201 VERT_SET_RGBA( v[1], vbcolor[0] );
202 }
203 VERT_SET_RGBA( v[2], vbcolor[0] );
204 }
205
206 if (HAVE_SPEC && VB->BackfaceSecondaryColorPtr) {
207 GLfloat (*vbspec)[4] = VB->BackfaceSecondaryColorPtr->data;
208 assert(VB->BackfaceSecondaryColorPtr->stride == 4*sizeof(GLfloat));
209
210 if (!DO_FLAT) {
211 VERT_SAVE_SPEC( 0 );
212 VERT_SAVE_SPEC( 1 );
213 VERT_SET_SPEC( v[0], vbspec[e0] );
214 VERT_SET_SPEC( v[1], vbspec[e1] );
215 }
216 VERT_SAVE_SPEC( 2 );
217 VERT_SET_SPEC( v[2], vbspec[e2] );
218 }
219 }
220 }
221 }
222
223
224 if (DO_OFFSET)
225 {
226 offset = ctx->Polygon.OffsetUnits * DEPTH_SCALE;
227 z[0] = VERT_Z(v[0]);
228 z[1] = VERT_Z(v[1]);
229 z[2] = VERT_Z(v[2]);
230 if (cc * cc > 1e-16) {
231 GLfloat ic = 1.0 / cc;
232 GLfloat ez = z[0] - z[2];
233 GLfloat fz = z[1] - z[2];
234 GLfloat a = ey*fz - ez*fy;
235 GLfloat b = ez*fx - ex*fz;
236 GLfloat ac = a * ic;
237 GLfloat bc = b * ic;
238 if ( ac < 0.0f ) ac = -ac;
239 if ( bc < 0.0f ) bc = -bc;
240 offset += MAX2( ac, bc ) * ctx->Polygon.OffsetFactor / ctx->DrawBuffer->_MRD;
241 }
242 offset *= ctx->DrawBuffer->_MRD * (REVERSE_DEPTH ? -1.0 : 1.0);
243 }
244 }
245
246 if (DO_FLAT) {
247 VERT_SAVE_RGBA( 0 );
248 VERT_SAVE_RGBA( 1 );
249 VERT_COPY_RGBA( v[0], v[2] );
250 VERT_COPY_RGBA( v[1], v[2] );
251 if (HAVE_SPEC && VB->AttribPtr[_TNL_ATTRIB_COLOR1]) {
252 VERT_SAVE_SPEC( 0 );
253 VERT_SAVE_SPEC( 1 );
254 VERT_COPY_SPEC( v[0], v[2] );
255 VERT_COPY_SPEC( v[1], v[2] );
256 }
257 }
258
259 if (mode == GL_POINT) {
260 if (DO_OFFSET && ctx->Polygon.OffsetPoint) {
261 VERT_Z_ADD(v[0], offset);
262 VERT_Z_ADD(v[1], offset);
263 VERT_Z_ADD(v[2], offset);
264 }
265 if (DO_TWOSTENCIL && !HAVE_STENCIL_TWOSIDE && ctx->Stencil.TestTwoSide) {
266 SETUP_STENCIL(facing);
267 UNFILLED_TRI( ctx, GL_POINT, e0, e1, e2 );
268 UNSET_STENCIL(facing);
269 } else {
270 UNFILLED_TRI( ctx, GL_POINT, e0, e1, e2 );
271 }
272 } else if (mode == GL_LINE) {
273 if (DO_OFFSET && ctx->Polygon.OffsetLine) {
274 VERT_Z_ADD(v[0], offset);
275 VERT_Z_ADD(v[1], offset);
276 VERT_Z_ADD(v[2], offset);
277 }
278 if (DO_TWOSTENCIL && !HAVE_STENCIL_TWOSIDE && ctx->Stencil.TestTwoSide) {
279 SETUP_STENCIL(facing);
280 UNFILLED_TRI( ctx, GL_LINE, e0, e1, e2 );
281 UNSET_STENCIL(facing);
282 } else {
283 UNFILLED_TRI( ctx, GL_LINE, e0, e1, e2 );
284 }
285 } else {
286 if (DO_OFFSET && ctx->Polygon.OffsetFill) {
287 VERT_Z_ADD(v[0], offset);
288 VERT_Z_ADD(v[1], offset);
289 VERT_Z_ADD(v[2], offset);
290 }
291 if (DO_UNFILLED) {
292 RASTERIZE( GL_TRIANGLES );
293 }
294 if (DO_TWOSTENCIL && !HAVE_STENCIL_TWOSIDE && ctx->Stencil.TestTwoSide) {
295 SETUP_STENCIL(facing);
296 TRI( v[0], v[1], v[2] );
297 UNSET_STENCIL(facing);
298 } else {
299 TRI( v[0], v[1], v[2] );
300 }
301 }
302
303 if (DO_OFFSET)
304 {
305 VERT_SET_Z(v[0], z[0]);
306 VERT_SET_Z(v[1], z[1]);
307 VERT_SET_Z(v[2], z[2]);
308 }
309
310 if (DO_TWOSIDE && facing == 1) {
311 if (!DO_FLAT) {
312 VERT_RESTORE_RGBA( 0 );
313 VERT_RESTORE_RGBA( 1 );
314 }
315 VERT_RESTORE_RGBA( 2 );
316 if (HAVE_SPEC) {
317 if (!DO_FLAT) {
318 VERT_RESTORE_SPEC( 0 );
319 VERT_RESTORE_SPEC( 1 );
320 }
321 VERT_RESTORE_SPEC( 2 );
322 }
323 }
324
325
326 if (DO_FLAT) {
327 VERT_RESTORE_RGBA( 0 );
328 VERT_RESTORE_RGBA( 1 );
329 if (HAVE_SPEC && VB->AttribPtr[_TNL_ATTRIB_COLOR1]) {
330 VERT_RESTORE_SPEC( 0 );
331 VERT_RESTORE_SPEC( 1 );
332 }
333 }
334 }
335 #endif
336
337 #if DO_QUAD
338 #if DO_FULL_QUAD
TAG(quadr)339 static void TAG(quadr)( struct gl_context *ctx,
340 GLuint e0, GLuint e1, GLuint e2, GLuint e3 )
341 {
342 struct vertex_buffer *VB = &TNL_CONTEXT( ctx )->vb;
343 VERTEX *v[4];
344 GLfloat offset = 0;
345 GLfloat z[4] = { 0 };
346 GLenum mode = GL_FILL;
347 GLuint facing = 0;
348 LOCAL_VARS(4);
349
350 v[0] = (VERTEX *)GET_VERTEX(e0);
351 v[1] = (VERTEX *)GET_VERTEX(e1);
352 v[2] = (VERTEX *)GET_VERTEX(e2);
353 v[3] = (VERTEX *)GET_VERTEX(e3);
354
355 if (DO_TWOSIDE || DO_OFFSET || DO_UNFILLED || DO_TWOSTENCIL)
356 {
357 GLfloat ex = VERT_X(v[2]) - VERT_X(v[0]);
358 GLfloat ey = VERT_Y(v[2]) - VERT_Y(v[0]);
359 GLfloat fx = VERT_X(v[3]) - VERT_X(v[1]);
360 GLfloat fy = VERT_Y(v[3]) - VERT_Y(v[1]);
361 GLfloat cc = ex*fy - ey*fx;
362
363 if (DO_TWOSIDE || DO_UNFILLED || DO_TWOSTENCIL)
364 {
365 facing = AREA_IS_CCW( cc ) ^ _mesa_polygon_get_front_bit(ctx);
366
367 if (DO_UNFILLED) {
368 if (facing) {
369 mode = ctx->Polygon.BackMode;
370 if (ctx->Polygon.CullFlag &&
371 ctx->Polygon.CullFaceMode != GL_FRONT) {
372 return;
373 }
374 } else {
375 mode = ctx->Polygon.FrontMode;
376 if (ctx->Polygon.CullFlag &&
377 ctx->Polygon.CullFaceMode != GL_BACK) {
378 return;
379 }
380 }
381 }
382
383 if (DO_TWOSIDE && facing == 1) {
384 GLfloat (*vbcolor)[4] = VB->BackfaceColorPtr->data;
385 (void)vbcolor;
386
387 if (HAVE_BACK_COLORS) {
388 if (!DO_FLAT) {
389 VERT_SAVE_RGBA( 0 );
390 VERT_SAVE_RGBA( 1 );
391 VERT_SAVE_RGBA( 2 );
392 VERT_COPY_RGBA1( v[0] );
393 VERT_COPY_RGBA1( v[1] );
394 VERT_COPY_RGBA1( v[2] );
395 }
396 VERT_SAVE_RGBA( 3 );
397 VERT_COPY_RGBA1( v[3] );
398 if (HAVE_SPEC) {
399 if (!DO_FLAT) {
400 VERT_SAVE_SPEC( 0 );
401 VERT_SAVE_SPEC( 1 );
402 VERT_SAVE_SPEC( 2 );
403 VERT_COPY_SPEC1( v[0] );
404 VERT_COPY_SPEC1( v[1] );
405 VERT_COPY_SPEC1( v[2] );
406 }
407 VERT_SAVE_SPEC( 3 );
408 VERT_COPY_SPEC1( v[3] );
409 }
410 }
411 else {
412 if (!DO_FLAT) {
413 VERT_SAVE_RGBA( 0 );
414 VERT_SAVE_RGBA( 1 );
415 VERT_SAVE_RGBA( 2 );
416 }
417 VERT_SAVE_RGBA( 3 );
418
419 if (VB->BackfaceColorPtr->stride) {
420 if (!DO_FLAT) {
421 VERT_SET_RGBA( v[0], vbcolor[e0] );
422 VERT_SET_RGBA( v[1], vbcolor[e1] );
423 VERT_SET_RGBA( v[2], vbcolor[e2] );
424 }
425 VERT_SET_RGBA( v[3], vbcolor[e3] );
426 }
427 else {
428 if (!DO_FLAT) {
429 VERT_SET_RGBA( v[0], vbcolor[0] );
430 VERT_SET_RGBA( v[1], vbcolor[0] );
431 VERT_SET_RGBA( v[2], vbcolor[0] );
432 }
433 VERT_SET_RGBA( v[3], vbcolor[0] );
434 }
435
436 if (HAVE_SPEC && VB->BackfaceSecondaryColorPtr) {
437 GLfloat (*vbspec)[4] = VB->BackfaceSecondaryColorPtr->data;
438 assert(VB->BackfaceSecondaryColorPtr->stride==4*sizeof(GLfloat));
439
440 if (!DO_FLAT) {
441 VERT_SAVE_SPEC( 0 );
442 VERT_SAVE_SPEC( 1 );
443 VERT_SAVE_SPEC( 2 );
444 VERT_SET_SPEC( v[0], vbspec[e0] );
445 VERT_SET_SPEC( v[1], vbspec[e1] );
446 VERT_SET_SPEC( v[2], vbspec[e2] );
447 }
448 VERT_SAVE_SPEC( 3 );
449 VERT_SET_SPEC( v[3], vbspec[e3] );
450 }
451 }
452 }
453 }
454
455
456 if (DO_OFFSET)
457 {
458 offset = ctx->Polygon.OffsetUnits * DEPTH_SCALE;
459 z[0] = VERT_Z(v[0]);
460 z[1] = VERT_Z(v[1]);
461 z[2] = VERT_Z(v[2]);
462 z[3] = VERT_Z(v[3]);
463 if (cc * cc > 1e-16) {
464 GLfloat ez = z[2] - z[0];
465 GLfloat fz = z[3] - z[1];
466 GLfloat a = ey*fz - ez*fy;
467 GLfloat b = ez*fx - ex*fz;
468 GLfloat ic = 1.0 / cc;
469 GLfloat ac = a * ic;
470 GLfloat bc = b * ic;
471 if ( ac < 0.0f ) ac = -ac;
472 if ( bc < 0.0f ) bc = -bc;
473 offset += MAX2( ac, bc ) * ctx->Polygon.OffsetFactor / ctx->DrawBuffer->_MRD;
474 }
475 offset *= ctx->DrawBuffer->_MRD * (REVERSE_DEPTH ? -1.0 : 1.0);
476 }
477 }
478
479 if (DO_FLAT) {
480 VERT_SAVE_RGBA( 0 );
481 VERT_SAVE_RGBA( 1 );
482 VERT_SAVE_RGBA( 2 );
483 VERT_COPY_RGBA( v[0], v[3] );
484 VERT_COPY_RGBA( v[1], v[3] );
485 VERT_COPY_RGBA( v[2], v[3] );
486 if (HAVE_SPEC && VB->AttribPtr[_TNL_ATTRIB_COLOR1]) {
487 VERT_SAVE_SPEC( 0 );
488 VERT_SAVE_SPEC( 1 );
489 VERT_SAVE_SPEC( 2 );
490 VERT_COPY_SPEC( v[0], v[3] );
491 VERT_COPY_SPEC( v[1], v[3] );
492 VERT_COPY_SPEC( v[2], v[3] );
493 }
494 }
495
496 if (mode == GL_POINT) {
497 if (( DO_OFFSET) && ctx->Polygon.OffsetPoint) {
498 VERT_Z_ADD(v[0], offset);
499 VERT_Z_ADD(v[1], offset);
500 VERT_Z_ADD(v[2], offset);
501 VERT_Z_ADD(v[3], offset);
502 }
503 if (DO_TWOSTENCIL && !HAVE_STENCIL_TWOSIDE && ctx->Stencil.TestTwoSide) {
504 SETUP_STENCIL(facing);
505 UNFILLED_QUAD( ctx, GL_POINT, e0, e1, e2, e3 );
506 UNSET_STENCIL(facing);
507 } else {
508 UNFILLED_QUAD( ctx, GL_POINT, e0, e1, e2, e3 );
509 }
510 } else if (mode == GL_LINE) {
511 if (DO_OFFSET && ctx->Polygon.OffsetLine) {
512 VERT_Z_ADD(v[0], offset);
513 VERT_Z_ADD(v[1], offset);
514 VERT_Z_ADD(v[2], offset);
515 VERT_Z_ADD(v[3], offset);
516 }
517 if (DO_TWOSTENCIL && !HAVE_STENCIL_TWOSIDE && ctx->Stencil.TestTwoSide) {
518 SETUP_STENCIL(facing);
519 UNFILLED_QUAD( ctx, GL_LINE, e0, e1, e2, e3 );
520 UNSET_STENCIL(facing);
521 } else {
522 UNFILLED_QUAD( ctx, GL_LINE, e0, e1, e2, e3 );
523 }
524 } else {
525 if (DO_OFFSET && ctx->Polygon.OffsetFill) {
526 VERT_Z_ADD(v[0], offset);
527 VERT_Z_ADD(v[1], offset);
528 VERT_Z_ADD(v[2], offset);
529 VERT_Z_ADD(v[3], offset);
530 }
531 RASTERIZE( GL_QUADS );
532 if (DO_TWOSTENCIL && !HAVE_STENCIL_TWOSIDE && ctx->Stencil.TestTwoSide) {
533 SETUP_STENCIL(facing);
534 QUAD( (v[0]), (v[1]), (v[2]), (v[3]) );
535 UNSET_STENCIL(facing);
536 } else {
537 QUAD( (v[0]), (v[1]), (v[2]), (v[3]) );
538 }
539 }
540
541 if (DO_OFFSET)
542 {
543 VERT_SET_Z(v[0], z[0]);
544 VERT_SET_Z(v[1], z[1]);
545 VERT_SET_Z(v[2], z[2]);
546 VERT_SET_Z(v[3], z[3]);
547 }
548
549 if (DO_TWOSIDE && facing == 1) {
550 if (!DO_FLAT) {
551 VERT_RESTORE_RGBA( 0 );
552 VERT_RESTORE_RGBA( 1 );
553 VERT_RESTORE_RGBA( 2 );
554 }
555 VERT_RESTORE_RGBA( 3 );
556 if (HAVE_SPEC) {
557 if (!DO_FLAT) {
558 VERT_RESTORE_SPEC( 0 );
559 VERT_RESTORE_SPEC( 1 );
560 VERT_RESTORE_SPEC( 2 );
561 }
562 VERT_RESTORE_SPEC( 3 );
563 }
564 }
565
566
567 if (DO_FLAT) {
568 VERT_RESTORE_RGBA( 0 );
569 VERT_RESTORE_RGBA( 1 );
570 VERT_RESTORE_RGBA( 2 );
571 if (HAVE_SPEC && VB->AttribPtr[_TNL_ATTRIB_COLOR1]) {
572 VERT_RESTORE_SPEC( 0 );
573 VERT_RESTORE_SPEC( 1 );
574 VERT_RESTORE_SPEC( 2 );
575 }
576 }
577 }
578 #else
TAG(quadr)579 static void TAG(quadr)( struct gl_context *ctx, GLuint e0,
580 GLuint e1, GLuint e2, GLuint e3 )
581 {
582 if (DO_UNFILLED) {
583 struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
584 GLubyte ef1 = VB->EdgeFlag[e1];
585 GLubyte ef3 = VB->EdgeFlag[e3];
586 VB->EdgeFlag[e1] = 0;
587 TAG(triangle)( ctx, e0, e1, e3 );
588 VB->EdgeFlag[e1] = ef1;
589 VB->EdgeFlag[e3] = 0;
590 TAG(triangle)( ctx, e1, e2, e3 );
591 VB->EdgeFlag[e3] = ef3;
592 } else {
593 TAG(triangle)( ctx, e0, e1, e3 );
594 TAG(triangle)( ctx, e1, e2, e3 );
595 }
596 }
597 #endif
598 #endif
599
600 #if DO_LINE
TAG(line)601 static void TAG(line)( struct gl_context *ctx, GLuint e0, GLuint e1 )
602 {
603 struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
604 VERTEX *v[2];
605 LOCAL_VARS(2);
606
607 v[0] = (VERTEX *)GET_VERTEX(e0);
608 v[1] = (VERTEX *)GET_VERTEX(e1);
609
610 if (DO_FLAT) {
611 VERT_SAVE_RGBA( 0 );
612 VERT_COPY_RGBA( v[0], v[1] );
613 if (HAVE_SPEC && VB->AttribPtr[_TNL_ATTRIB_COLOR1]) {
614 VERT_SAVE_SPEC( 0 );
615 VERT_COPY_SPEC( v[0], v[1] );
616 }
617 }
618
619 LINE( v[0], v[1] );
620
621 if (DO_FLAT) {
622 VERT_RESTORE_RGBA( 0 );
623
624 if (HAVE_SPEC && VB->AttribPtr[_TNL_ATTRIB_COLOR1]) {
625 VERT_RESTORE_SPEC( 0 );
626 }
627 }
628 }
629 #endif
630
631 #if DO_POINTS
TAG(points)632 static void TAG(points)( struct gl_context *ctx, GLuint first, GLuint last )
633 {
634 struct vertex_buffer *VB = &TNL_CONTEXT( ctx )->vb;
635 GLuint i;
636 LOCAL_VARS(1);
637
638 if (VB->Elts == 0) {
639 for ( i = first ; i < last ; i++ ) {
640 if ( VB->ClipMask[i] == 0 ) {
641 VERTEX *v = (VERTEX *)GET_VERTEX(i);
642 POINT( v );
643 }
644 }
645 } else {
646 for ( i = first ; i < last ; i++ ) {
647 GLuint e = VB->Elts[i];
648 if ( VB->ClipMask[e] == 0 ) {
649 VERTEX *v = (VERTEX *)GET_VERTEX(e);
650 POINT( v );
651 }
652 }
653 }
654 }
655 #endif
656
TAG(init)657 static void TAG(init)( void )
658 {
659 #if DO_QUAD
660 TAB[IND].quad = TAG(quadr);
661 #endif
662 #if DO_TRI
663 TAB[IND].triangle = TAG(triangle);
664 #endif
665 #if DO_LINE
666 TAB[IND].line = TAG(line);
667 #endif
668 #if DO_POINTS
669 TAB[IND].points = TAG(points);
670 #endif
671 }
672
673 #undef IND
674 #undef TAG
675
676 #if HAVE_BACK_COLORS
677 #undef VERT_SET_RGBA
678 #endif
679
680 #if !HAVE_SPEC
681 #undef VERT_SET_SPEC
682 #undef VERT_COPY_SPEC
683 #undef VERT_SAVE_SPEC
684 #undef VERT_RESTORE_SPEC
685 #if HAVE_BACK_COLORS
686 #undef VERT_COPY_SPEC1
687 #endif
688 #else
689 #if HAVE_BACK_COLORS
690 #undef VERT_SET_SPEC
691 #endif
692 #endif
693
694 #if !HAVE_BACK_COLORS
695 #undef VERT_COPY_SPEC1
696 #undef VERT_COPY_RGBA1
697 #endif
698
699 #ifndef INSANE_VERTICES
700 #undef VERT_SET_Z
701 #undef VERT_Z_ADD
702 #endif
703