Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | Download | RSS feed

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