Details | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
58 | pj | 1 | /* $Id: t_dd_imm_primtmp.h,v 1.1 2003-02-28 11:54:02 pj 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 | * Authors: |
||
27 | * Keith Whitwell <keithw@valinux.com> |
||
28 | * Gareth Hughes <gareth@valinux.com> |
||
29 | */ |
||
30 | |||
31 | /* Template for immediate mode vertices. |
||
32 | * |
||
33 | * Probably instantiate once for each vertex format used: |
||
34 | * - TINY_VERTICES |
||
35 | * - TEX0_VERTICES |
||
36 | * - TEX1_VERTICES |
||
37 | * - PTEX_VERTICES |
||
38 | * |
||
39 | * Have to handle TEX->PTEX transition somehow. |
||
40 | */ |
||
41 | |||
42 | #define DBG 0 |
||
43 | |||
44 | |||
45 | |||
46 | /* ============================================================= |
||
47 | * GL_POINTS |
||
48 | */ |
||
49 | |||
50 | static void TAG(flush_point_0)( GLcontext *ctx, TNL_VERTEX *v0 ) |
||
51 | { |
||
52 | if ( !v0->mask ) { |
||
53 | LOCAL_VARS; |
||
54 | DRAW_POINT( v0 ); |
||
55 | } |
||
56 | } |
||
57 | |||
58 | |||
59 | /* ============================================================= |
||
60 | * GL_LINES |
||
61 | */ |
||
62 | |||
63 | static void TAG(flush_line_1)( GLcontext *ctx, TNL_VERTEX *v0 ); |
||
64 | |||
65 | static void TAG(flush_line_0)( GLcontext *ctx, TNL_VERTEX *v0 ) |
||
66 | { |
||
67 | LOCAL_VARS; |
||
68 | FLUSH_VERTEX = TAG(flush_line_1); |
||
69 | ACTIVE_VERTEX = IMM_VERTICES( 1 ); |
||
70 | } |
||
71 | |||
72 | static void TAG(flush_line_1)( GLcontext *ctx, TNL_VERTEX *v0 ) |
||
73 | { |
||
74 | LOCAL_VARS; |
||
75 | TNL_VERTEX *v1 = v0 - 1; |
||
76 | ACTIVE_VERTEX = IMM_VERTICES( 0 ); |
||
77 | FLUSH_VERTEX = TAG(flush_line_0); |
||
78 | if (FALLBACK_OR_CLIPPING) |
||
79 | CLIP_OR_DRAW_LINE( ctx, v1, v0 ); |
||
80 | else |
||
81 | DRAW_LINE( ctx, v1, v0 ); |
||
82 | } |
||
83 | |||
84 | |||
85 | /* ============================================================= |
||
86 | * GL_LINE_LOOP |
||
87 | */ |
||
88 | |||
89 | static void TAG(flush_line_loop_2)( GLcontext *ctx, TNL_VERTEX *v0 ); |
||
90 | static void TAG(flush_line_loop_1)( GLcontext *ctx, TNL_VERTEX *v0 ); |
||
91 | |||
92 | static void TAG(flush_line_loop_0)( GLcontext *ctx, TNL_VERTEX *v0 ) |
||
93 | { |
||
94 | LOCAL_VARS; |
||
95 | |||
96 | ACTIVE_VERTEX = v0 + 1; |
||
97 | FLUSH_VERTEX = TAG(flush_line_loop_1); |
||
98 | } |
||
99 | |||
100 | #define DRAW_LINELOOP_LINE( a, b ) \ |
||
101 | if (!HAVE_LINE_STRIP || FALLBACK_OR_CLIPPING) { \ |
||
102 | CLIP_OR_DRAW_LINE( ctx, a, b ); \ |
||
103 | } else if (EXTEND_PRIM( 1 )) { \ |
||
104 | EMIT_VERTEX( b ); \ |
||
105 | } else { \ |
||
106 | BEGIN_PRIM( GL_LINE_STRIP, 2 ); \ |
||
107 | EMIT_VERTEX( a ); \ |
||
108 | EMIT_VERTEX( b ); \ |
||
109 | } |
||
110 | |||
111 | static void TAG(flush_line_loop_1)( GLcontext *ctx, TNL_VERTEX *v0 ) |
||
112 | { |
||
113 | LOCAL_VARS; |
||
114 | TNL_VERTEX *v1 = v0 - 1; |
||
115 | ACTIVE_VERTEX = v1; |
||
116 | FLUSH_VERTEX = TAG(flush_line_loop_2); |
||
117 | DRAW_LINELOOP_LINE( v1, v0 ); |
||
118 | } |
||
119 | |||
120 | static void TAG(flush_line_loop_2)( GLcontext *ctx, TNL_VERTEX *v0 ) |
||
121 | { |
||
122 | LOCAL_VARS; |
||
123 | TNL_VERTEX *v1 = v0 + 1; |
||
124 | ACTIVE_VERTEX = v1; |
||
125 | FLUSH_VERTEX = TAG(flush_line_loop_1); |
||
126 | DRAW_LINELOOP_LINE( v1, v0 ); |
||
127 | } |
||
128 | |||
129 | static void TAG(end_line_loop)( GLcontext *ctx ) |
||
130 | { |
||
131 | LOCAL_VARS; |
||
132 | |||
133 | if ( FLUSH_VERTEX != TAG(flush_line_loop_0) ) { |
||
134 | TNL_VERTEX *v1 = ACTIVE_VERTEX; |
||
135 | TNL_VERTEX *v0 = IMM_VERTICES( 0 ); |
||
136 | DRAW_LINELOOP_LINE( v1, v0 ); |
||
137 | } |
||
138 | } |
||
139 | |||
140 | |||
141 | |||
142 | /* ============================================================= |
||
143 | * GL_LINE_STRIP |
||
144 | */ |
||
145 | |||
146 | static void TAG(flush_line_strip_2)( GLcontext *ctx, TNL_VERTEX *v0 ); |
||
147 | static void TAG(flush_line_strip_1)( GLcontext *ctx, TNL_VERTEX *v0 ); |
||
148 | |||
149 | static void TAG(flush_line_strip_0)( GLcontext *ctx, TNL_VERTEX *v0 ) |
||
150 | { |
||
151 | LOCAL_VARS; |
||
152 | |||
153 | ACTIVE_VERTEX = v0 + 1; |
||
154 | FLUSH_VERTEX = TAG(flush_line_strip_0b); |
||
155 | } |
||
156 | |||
157 | |||
158 | static void TAG(flush_line_strip_1)( GLcontext *ctx, TNL_VERTEX *v0 ) |
||
159 | { |
||
160 | LOCAL_VARS; |
||
161 | TNL_VERTEX *v1 = v0 - 1; |
||
162 | |||
163 | ACTIVE_VERTEX = v1; |
||
164 | FLUSH_VERTEX = TAG(flush_line_strip_2); |
||
165 | |||
166 | if (!HAVE_LINE_STRIP || FALLBACK_OR_CLIPPING) |
||
167 | CLIP_OR_DRAW_LINE( ctx, v1, v0 ); |
||
168 | else if (EXTEND_PRIM( 1 )) { |
||
169 | EMIT_VERTEX( v0 ); |
||
170 | } else { |
||
171 | BEGIN_PRIM( GL_LINE_STRIP, 2 ); |
||
172 | EMIT_VERTEX( v1 ); |
||
173 | EMIT_VERTEX( v0 ); |
||
174 | } |
||
175 | } |
||
176 | |||
177 | static void TAG(flush_line_strip_2)( GLcontext *ctx, TNL_VERTEX *v0 ) |
||
178 | { |
||
179 | LOCAL_VARS; |
||
180 | TNL_VERTEX *v1 = v0 + 1; |
||
181 | |||
182 | ACTIVE_VERTEX = v1; |
||
183 | FLUSH_VERTEX = TAG(flush_line_strip_1); |
||
184 | |||
185 | if (!HAVE_LINE_STRIP || FALLBACK_OR_CLIPPING) |
||
186 | CLIP_OR_DRAW_LINE( ctx, v1, v0 ); |
||
187 | else if (EXTEND_PRIM( 1 )) { |
||
188 | EMIT_VERTEX( v0 ); |
||
189 | } else { |
||
190 | BEGIN_PRIM( GL_LINE_STRIP, 2 ); |
||
191 | EMIT_VERTEX( v1 ); |
||
192 | EMIT_VERTEX( v0 ); |
||
193 | } |
||
194 | } |
||
195 | |||
196 | |||
197 | |||
198 | /* ============================================================= |
||
199 | * GL_TRIANGLES |
||
200 | */ |
||
201 | |||
202 | static void TAG(flush_triangle_2)( GLcontext *ctx, TNL_VERTEX *v0 ); |
||
203 | static void TAG(flush_triangle_1)( GLcontext *ctx, TNL_VERTEX *v0 ); |
||
204 | |||
205 | static void TAG(flush_triangle_0)( GLcontext *ctx, TNL_VERTEX *v0 ) |
||
206 | { |
||
207 | LOCAL_VARS; |
||
208 | |||
209 | if ( DBG ) fprintf( stderr, __FUNCTION__ "\n" ); |
||
210 | |||
211 | ACTIVE_VERTEX = v0 + 1; |
||
212 | FLUSH_VERTEX = TAG(flush_triangle_1); |
||
213 | BEGIN_PRIM( GL_TRIANGLES, 0 ); |
||
214 | } |
||
215 | |||
216 | static void TAG(flush_triangle_1)( GLcontext *ctx, TNL_VERTEX *v0 ) |
||
217 | { |
||
218 | LOCAL_VARS; |
||
219 | |||
220 | if ( DBG ) fprintf( stderr, __FUNCTION__ "\n" ); |
||
221 | |||
222 | ACTIVE_VERTEX = v0 + 1; |
||
223 | FLUSH_VERTEX = TAG(flush_triangle_2); |
||
224 | } |
||
225 | |||
226 | static void TAG(flush_triangle_2)( GLcontext *ctx, TNL_VERTEX *v0 ) |
||
227 | { |
||
228 | LOCAL_VARS; |
||
229 | TNL_VERTEX *v2 = v0 - 2; |
||
230 | TNL_VERTEX *v1 = v0 - 1; |
||
231 | |||
232 | if ( DBG ) fprintf( stderr, __FUNCTION__ "\n" ); |
||
233 | |||
234 | ACTIVE_VERTEX = v2; |
||
235 | FLUSH_VERTEX = TAG(flush_triangle_0); |
||
236 | |||
237 | /* nothing gained by trying to emit as hw primitives -- that |
||
238 | * happens normally in this case. |
||
239 | */ |
||
240 | if (FALLBACK_OR_CLIPPING) |
||
241 | CLIP_OR_DRAW_TRI( ctx, v2, v1, v0 ); |
||
242 | else |
||
243 | DRAW_TRI( ctx, v2, v1, v0 ); |
||
244 | } |
||
245 | |||
246 | |||
247 | |||
248 | |||
249 | /* ============================================================= |
||
250 | * GL_TRIANGLE_STRIP |
||
251 | */ |
||
252 | |||
253 | static void TAG(flush_tri_strip_3)( GLcontext *ctx, TNL_VERTEX *v0 ); |
||
254 | static void TAG(flush_tri_strip_2)( GLcontext *ctx, TNL_VERTEX *v0 ); |
||
255 | static void TAG(flush_tri_strip_1)( GLcontext *ctx, TNL_VERTEX *v0 ); |
||
256 | |||
257 | static void TAG(flush_tri_strip_0)( GLcontext *ctx, TNL_VERTEX *v0 ) |
||
258 | { |
||
259 | LOCAL_VARS; |
||
260 | ACTIVE_VERTEX = IMM_VERTICES( 1 ); |
||
261 | FLUSH_VERTEX = TAG(flush_tri_strip_1); |
||
262 | } |
||
263 | |||
264 | static void TAG(flush_tri_strip_1)( GLcontext *ctx, TNL_VERTEX *v0 ) |
||
265 | { |
||
266 | LOCAL_VARS; |
||
267 | ACTIVE_VERTEX = IMM_VERTICES( 2 ); |
||
268 | FLUSH_VERTEX = TAG(flush_tri_strip_2); |
||
269 | } |
||
270 | |||
271 | #define DO_TRISTRIP_TRI( vert0, vert1 ) \ |
||
272 | if (!HAVE_TRI_STRIP || FALLBACK_OR_CLIPPING) { \ |
||
273 | TNL_VERTEX *v2 = IMM_VERTICES( vert0 ); \ |
||
274 | TNL_VERTEX *v1 = IMM_VERTICES( vert1 ); \ |
||
275 | TAG(draw_tri)( ctx, v2, v1, v0 ); \ |
||
276 | } else if (EXTEND_PRIM( 1 )) { \ |
||
277 | EMIT_VERTEX( v0 ); \ |
||
278 | } else { \ |
||
279 | TNL_VERTEX *v2 = IMM_VERTICES( vert0 ); \ |
||
280 | TNL_VERTEX *v1 = IMM_VERTICES( vert1 ); \ |
||
281 | BEGIN_PRIM( GL_TRIANGLE_STRIP, 3 ); \ |
||
282 | EMIT_VERTEX( v2 ); \ |
||
283 | EMIT_VERTEX( v1 ); \ |
||
284 | EMIT_VERTEX( v0 ); \ |
||
285 | } |
||
286 | |||
287 | static void TAG(flush_tri_strip_2)( GLcontext *ctx, TNL_VERTEX *v0 ) |
||
288 | { |
||
289 | LOCAL_VARS; |
||
290 | FLUSH_VERTEX = TAG(flush_tri_strip_3); |
||
291 | ACTIVE_VERTEX = IMM_VERTICES( 3 ); |
||
292 | DO_TRISTRIP_TRI( 0, 1 ); |
||
293 | } |
||
294 | |||
295 | static void TAG(flush_tri_strip_3)( GLcontext *ctx, TNL_VERTEX *v0 ) |
||
296 | { |
||
297 | LOCAL_VARS; |
||
298 | FLUSH_VERTEX = TAG(flush_tri_strip_4); |
||
299 | ACTIVE_VERTEX = IMM_VERTICES( 0 ); |
||
300 | DO_TRISTRIP_TRI( 1, 2 ); |
||
301 | } |
||
302 | |||
303 | static void TAG(flush_tri_strip_4)( GLcontext *ctx, TNL_VERTEX *v0 ) |
||
304 | { |
||
305 | LOCAL_VARS; |
||
306 | FLUSH_VERTEX = TAG(flush_tri_strip_5); |
||
307 | ACTIVE_VERTEX = IMM_VERTICES( 1 ); |
||
308 | DO_TRISTRIP_TRI( 2, 3 ); |
||
309 | } |
||
310 | |||
311 | static void TAG(flush_tri_strip_5)( GLcontext *ctx, TNL_VERTEX *v0 ) |
||
312 | { |
||
313 | LOCAL_VARS; |
||
314 | FLUSH_VERTEX = TAG(flush_tri_strip_2); |
||
315 | ACTIVE_VERTEX = IMM_VERTICES( 2 ); |
||
316 | DO_TRISTRIP_TRI( 0, 3 ); |
||
317 | } |
||
318 | |||
319 | |||
320 | |||
321 | /* ============================================================= |
||
322 | * GL_TRIANGLE_FAN |
||
323 | */ |
||
324 | |||
325 | static void TAG(flush_tri_fan_2)( GLcontext *ctx, TNL_VERTEX *v0 ); |
||
326 | static void TAG(flush_tri_fan_1)( GLcontext *ctx, TNL_VERTEX *v0 ); |
||
327 | |||
328 | static void TAG(flush_tri_fan_0)( GLcontext *ctx, TNL_VERTEX *v0 ) |
||
329 | { |
||
330 | LOCAL_VARS; |
||
331 | |||
332 | ACTIVE_VERTEX = v0 + 1; |
||
333 | FLUSH_VERTEX = TAG(flush_tri_fan_1); |
||
334 | } |
||
335 | |||
336 | static void TAG(flush_tri_fan_1)( GLcontext *ctx, TNL_VERTEX *v0 ) |
||
337 | { |
||
338 | LOCAL_VARS; |
||
339 | |||
340 | ACTIVE_VERTEX = v0 + 1; |
||
341 | FLUSH_VERTEX = TAG(flush_tri_fan_2); |
||
342 | } |
||
343 | |||
344 | #define DO_TRIFAN_TRI( vert0, vert1 ) \ |
||
345 | if (!HAVE_TRI_FAN || FALLBACK_OR_CLIPPING) { \ |
||
346 | TNL_VERTEX *v2 = IMM_VERTICES( vert0 ); \ |
||
347 | TNL_VERTEX *v1 = IMM_VERTICES( vert1 ); \ |
||
348 | TAG(draw_tri)( ctx, v2, v1, v0 ); \ |
||
349 | } else if (EXTEND_PRIM( 1 )) { \ |
||
350 | EMIT_VERTEX( v0 ); \ |
||
351 | } else { \ |
||
352 | TNL_VERTEX *v2 = IMM_VERTICES( vert0 ); \ |
||
353 | TNL_VERTEX *v1 = IMM_VERTICES( vert1 ); \ |
||
354 | BEGIN_PRIM( GL_TRIANGLE_FAN, 3 ); \ |
||
355 | EMIT_VERTEX( v2 ); \ |
||
356 | EMIT_VERTEX( v1 ); \ |
||
357 | EMIT_VERTEX( v0 ); \ |
||
358 | } |
||
359 | |||
360 | static void TAG(flush_tri_fan_2)( GLcontext *ctx, TNL_VERTEX *v0 ) |
||
361 | { |
||
362 | LOCAL_VARS; |
||
363 | ACTIVE_VERTEX = IMM_VERTICES( 1 ); |
||
364 | FLUSH_VERTEX = TAG(flush_tri_fan_3 ); |
||
365 | DO_TRIFAN_TRI( 0, 1 ); |
||
366 | } |
||
367 | |||
368 | static void TAG(flush_tri_fan_3)( GLcontext *ctx, TNL_VERTEX *v0 ) |
||
369 | { |
||
370 | LOCAL_VARS; |
||
371 | ACTIVE_VERTEX = IMM_VERTICES( 2 ); |
||
372 | FLUSH_VERTEX = TAG(flush_tri_fan_2 ); |
||
373 | DO_TRIFAN_TRI( 0, 2 ); |
||
374 | } |
||
375 | |||
376 | |||
377 | |||
378 | /* ============================================================= |
||
379 | * GL_QUADS |
||
380 | */ |
||
381 | |||
382 | static void TAG(flush_quad_3)( GLcontext *ctx, TNL_VERTEX *v0 ); |
||
383 | static void TAG(flush_quad_2)( GLcontext *ctx, TNL_VERTEX *v0 ); |
||
384 | static void TAG(flush_quad_1)( GLcontext *ctx, TNL_VERTEX *v0 ); |
||
385 | |||
386 | static void TAG(flush_quad_0)( GLcontext *ctx, TNL_VERTEX *v0 ) |
||
387 | { |
||
388 | LOCAL_VARS; |
||
389 | IMM_VERTEX( v0 ) = v0 + 1; |
||
390 | FLUSH_VERTEX = TAG(flush_quad_1); |
||
391 | } |
||
392 | |||
393 | static void TAG(flush_quad_1)( GLcontext *ctx, TNL_VERTEX *v0 ) |
||
394 | { |
||
395 | LOCAL_VARS; |
||
396 | IMM_VERTEX( v0 ) = v0 + 1; |
||
397 | FLUSH_VERTEX = TAG(flush_quad_2); |
||
398 | } |
||
399 | |||
400 | static void TAG(flush_quad_2)( GLcontext *ctx, TNL_VERTEX *v0 ) |
||
401 | { |
||
402 | LOCAL_VARS; |
||
403 | IMM_VERTEX( v0 ) = v0 + 1; |
||
404 | FLUSH_VERTEX = TAG(flush_quad_3); |
||
405 | } |
||
406 | |||
407 | static void TAG(flush_quad_3)( GLcontext *ctx, TNL_VERTEX *v0 ) |
||
408 | { |
||
409 | LOCAL_VARS; |
||
410 | TNL_VERTEX *v3 = v0 - 3; |
||
411 | TNL_VERTEX *v2 = v0 - 2; |
||
412 | TNL_VERTEX *v1 = v0 - 1; |
||
413 | |||
414 | IMM_VERTEX( v0 ) = v3; |
||
415 | FLUSH_VERTEX = TAG(flush_quad_0); |
||
416 | |||
417 | if (!HAVE_HW_QUADS || FALLBACK_OR_CLIPPING) { |
||
418 | CLIP_OR_DRAW_TRI( ctx, v3, v2, v0 ); |
||
419 | CLIP_OR_DRAW_TRI( ctx, v2, v1, v0 ); |
||
420 | } else { |
||
421 | EXTEND_PRIM_NF( GL_QUADS, 4 ); |
||
422 | EMIT_VERTEX( v3 ); |
||
423 | EMIT_VERTEX( v2 ); |
||
424 | EMIT_VERTEX( v1 ); |
||
425 | EMIT_VERTEX( v0 ); |
||
426 | } |
||
427 | } |
||
428 | |||
429 | |||
430 | |||
431 | /* ============================================================= |
||
432 | * GL_QUAD_STRIP |
||
433 | */ |
||
434 | |||
435 | static void TAG(flush_quad_strip_3)( GLcontext *ctx, TNL_VERTEX *v0 ); |
||
436 | static void TAG(flush_quad_strip_2)( GLcontext *ctx, TNL_VERTEX *v0 ); |
||
437 | static void TAG(flush_quad_strip_1)( GLcontext *ctx, TNL_VERTEX *v0 ); |
||
438 | |||
439 | static void TAG(flush_quad_strip_0)( GLcontext *ctx, TNL_VERTEX *v0 ) |
||
440 | { |
||
441 | LOCAL_VARS; |
||
442 | |||
443 | IMM_VERTEX( v3 ) = v0; |
||
444 | IMM_VERTEX( v0 ) = v0 + 1; |
||
445 | FLUSH_VERTEX = TAG(flush_quad_strip_1); |
||
446 | } |
||
447 | |||
448 | static void TAG(flush_quad_strip_1)( GLcontext *ctx, TNL_VERTEX *v0 ) |
||
449 | { |
||
450 | LOCAL_VARS; |
||
451 | |||
452 | IMM_VERTEX( v2 ) = v0; |
||
453 | IMM_VERTEX( v0 ) = v0 + 1; |
||
454 | FLUSH_VERTEX = TAG(flush_quad_strip_2); |
||
455 | } |
||
456 | |||
457 | static void TAG(flush_quad_strip_2)( GLcontext *ctx, TNL_VERTEX *v0 ) |
||
458 | { |
||
459 | LOCAL_VARS; |
||
460 | |||
461 | IMM_VERTEX( v1 ) = v0; |
||
462 | IMM_VERTEX( v0 ) = v0 + 1; |
||
463 | FLUSH_VERTEX = TAG(flush_quad_strip_3); |
||
464 | } |
||
465 | |||
466 | static void TAG(flush_quad_strip_3)( GLcontext *ctx, TNL_VERTEX *v0 ) |
||
467 | { |
||
468 | LOCAL_VARS; |
||
469 | TNL_VERTEX *v3 = IMM_VERTEX( v3 ); |
||
470 | TNL_VERTEX *v2 = IMM_VERTEX( v2 ); |
||
471 | TNL_VERTEX *v1 = IMM_VERTEX( v1 ); |
||
472 | |||
473 | IMM_VERTEX( v0 ) = v3; |
||
474 | IMM_VERTEX( v2 ) = v0; |
||
475 | IMM_VERTEX( v3 ) = v1; |
||
476 | FLUSH_VERTEX = TAG(flush_quad_strip_2); |
||
477 | |||
478 | if (FALLBACK_OR_CLIPPING) { |
||
479 | CLIP_OR_DRAW_TRI( ctx, v3, v2, v0 ); |
||
480 | CLIP_OR_DRAW_TRI( ctx, v2, v1, v0 ); |
||
481 | } else { |
||
482 | DRAW_TRI( ctx, v3, v2, v0 ); |
||
483 | DRAW_TRI( ctx, v2, v1, v0 ); |
||
484 | } |
||
485 | } |
||
486 | |||
487 | |||
488 | |||
489 | /* ============================================================= |
||
490 | * GL_POLYGON |
||
491 | */ |
||
492 | |||
493 | static void TAG(flush_poly_2)( GLcontext *ctx, TNL_VERTEX *v0 ); |
||
494 | static void TAG(flush_poly_1)( GLcontext *ctx, TNL_VERTEX *v0 ); |
||
495 | |||
496 | static void TAG(flush_poly_0)( GLcontext *ctx, TNL_VERTEX *v0 ) |
||
497 | { |
||
498 | LOCAL_VARS; |
||
499 | ACTIVE_VERTEX = IMM_VERTICES( 1 ); |
||
500 | FLUSH_VERTEX = TAG(flush_poly_1); |
||
501 | } |
||
502 | |||
503 | static void TAG(flush_poly_1)( GLcontext *ctx, TNL_VERTEX *v0 ) |
||
504 | { |
||
505 | LOCAL_VARS; |
||
506 | ACTIVE_VERTEX = IMM_VERTICES( 2 ); |
||
507 | FLUSH_VERTEX = TAG(flush_poly_2); |
||
508 | } |
||
509 | |||
510 | #define DO_POLY_TRI( vert0, vert1 ) \ |
||
511 | if (!HAVE_POLYGONS || FALLBACK_OR_CLIPPING) { \ |
||
512 | TNL_VERTEX *v2 = IMM_VERTICES( vert0 ); \ |
||
513 | TNL_VERTEX *v1 = IMM_VERTICES( vert1 ); \ |
||
514 | TAG(draw_tri)( ctx, v1, v0, v2 ); \ |
||
515 | } else if (EXTEND_PRIM( 1 )) { \ |
||
516 | EMIT_VERTEX( v0 ); \ |
||
517 | } else { \ |
||
518 | TNL_VERTEX *v2 = IMM_VERTICES( vert0 ); \ |
||
519 | TNL_VERTEX *v1 = IMM_VERTICES( vert1 ); \ |
||
520 | BEGIN_PRIM( GL_POLYGON, 3 ); \ |
||
521 | EMIT_VERTEX( v2 ); \ |
||
522 | EMIT_VERTEX( v1 ); \ |
||
523 | EMIT_VERTEX( v0 ); \ |
||
524 | } |
||
525 | |||
526 | static void TAG(flush_poly_2)( GLcontext *ctx, TNL_VERTEX *v0 ) |
||
527 | { |
||
528 | LOCAL_VARS; |
||
529 | ACTIVE_VERTEX = IMM_VERTICES( 1 ); |
||
530 | FLUSH_VERTEX = TAG(flush_poly_3); |
||
531 | DO_POLY_TRI( 0, 1 ); |
||
532 | } |
||
533 | |||
534 | static void TAG(flush_poly_3)( GLcontext *ctx, TNL_VERTEX *v0 ) |
||
535 | { |
||
536 | LOCAL_VARS; |
||
537 | ACTIVE_VERTEX = IMM_VERTICES( 2 ); |
||
538 | FLUSH_VERTEX = TAG(flush_poly_2); |
||
539 | DO_POLY_TRI( 0, 2 ); |
||
540 | } |
||
541 | |||
542 | |||
543 | void (*TAG(flush_tab)[GL_POLYGON+1])( GLcontext *, TNL_VERTEX * ) = |
||
544 | { |
||
545 | TAG(flush_point), |
||
546 | TAG(flush_line_0), |
||
547 | TAG(flush_line_loop_0), |
||
548 | TAG(flush_line_strip_0), |
||
549 | TAG(flush_triangle_0), |
||
550 | TAG(flush_tri_strip_0), |
||
551 | TAG(flush_tri_fan_0), |
||
552 | TAG(flush_quad_0), |
||
553 | TAG(flush_quad_strip_0), |
||
554 | TAG(flush_poly_0), |
||
555 | }; |
||
556 | |||
557 | |||
558 | #ifndef PRESERVE_PRIM_DEFS |
||
559 | #undef LOCAL_VARS |
||
560 | #undef GET_INTERP_FUNC |
||
561 | #undef IMM_VERTEX |
||
562 | #undef IMM_VERTICES |
||
563 | #undef FLUSH_VERTEX |
||
564 | #endif |
||
565 | #undef PRESERVE_PRIM_DEFS |
||
566 | #undef EXTEND_PRIM |
||
567 | #undef EMIT_VERTEX |
||
568 | #undef EMIT_VERTEX_TRI |
||
569 | #undef EMIT_VERTEX_LINE |
||
570 | #undef EMIT_VERTEX_POINT |
||
571 | #undef TAG |