reactos/dll/opengl/mesa/src/mesa/tnl/t_vb_rendertmp.h

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  6.5
   4  *
   5  * Copyright (C) 1999-2005  Brian Paul   All Rights Reserved.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the "Software"),
   9  * to deal in the Software without restriction, including without limitation
  10  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  11  * and/or sell copies of the Software, and to permit persons to whom the
  12  * Software is furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included
  15  * in all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  21  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  22  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23  *
  24  * Authors:
  25  *    Keith Whitwell <keith@tungstengraphics.com>
  26  */
  27
  28
  29 #ifndef POSTFIX
  30 #define POSTFIX
  31 #endif
  32
  33 #ifndef INIT
  34 #define INIT(x)
  35 #endif
  36
  37 #ifndef NEED_EDGEFLAG_SETUP
  38 #define NEED_EDGEFLAG_SETUP 0
  39 #define EDGEFLAG_GET(a) 0
  40 #define EDGEFLAG_SET(a,b) (void)b
  41 #endif
  42
  43 #ifndef RESET_STIPPLE
  44 #define RESET_STIPPLE
  45 #endif
  46
  47 #ifndef TEST_PRIM_END
  48 #define TEST_PRIM_END(prim) (flags & PRIM_END)
  49 #define TEST_PRIM_BEGIN(prim) (flags & PRIM_BEGIN)
  50 #endif
  51
  52 #ifndef ELT
  53 #define ELT(x) x
  54 #endif
  55
  56 #ifndef RENDER_TAB_QUALIFIER
  57 #define RENDER_TAB_QUALIFIER static
  58 #endif
  59
  60 static void TAG(render_points)( struct gl_context *ctx,
  61                                 GLuint start,
  62                                 GLuint count,
  63                                 GLuint flags )
  64 {
  65    LOCAL_VARS;
  66    (void) flags;
  67
  68    INIT(GL_POINTS);
  69    RENDER_POINTS( start, count );
  70    POSTFIX;
  71 }
  72
  73 static void TAG(render_lines)( struct gl_context *ctx,
  74                                GLuint start,
  75                                GLuint count,
  76                                GLuint flags )
  77 {
  78    GLuint j;
  79    LOCAL_VARS;
  80    (void) flags;
  81
  82    INIT(GL_LINES);
  83    for (j=start+1; j<count; j+=2 ) {
  84       RESET_STIPPLE;
  85       if (ctx->Light.ProvokingVertex == GL_LAST_VERTEX_CONVENTION_EXT)
  86          RENDER_LINE( ELT(j-1), ELT(j) );
  87       else
  88          RENDER_LINE( ELT(j), ELT(j-1) );
  89    }
  90    POSTFIX;
  91 }
  92
  93
  94 static void TAG(render_line_strip)( struct gl_context *ctx,
  95                                     GLuint start,
  96                                     GLuint count,
  97                                     GLuint flags )
  98 {
  99    GLuint j;
 100    LOCAL_VARS;
 101    (void) flags;
 102
 103    INIT(GL_LINE_STRIP);
 104
 105    if (TEST_PRIM_BEGIN(flags)) {
 106       RESET_STIPPLE;
 107    }
 108
 109    for (j=start+1; j<count; j++ ) {
 110       if (ctx->Light.ProvokingVertex == GL_LAST_VERTEX_CONVENTION_EXT)
 111          RENDER_LINE( ELT(j-1), ELT(j) );
 112       else
 113          RENDER_LINE( ELT(j), ELT(j-1) );
 114    }
 115    POSTFIX;
 116 }
 117
 118
 119 static void TAG(render_line_loop)( struct gl_context *ctx,
 120                                    GLuint start,
 121                                    GLuint count,
 122                                    GLuint flags )
 123 {
 124    GLuint i;
 125    LOCAL_VARS;
 126
 127    (void) flags;
 128
 129    INIT(GL_LINE_LOOP);
 130
 131    if (start+1 < count) {
 132       if (TEST_PRIM_BEGIN(flags)) {
 133          RESET_STIPPLE;
 134          if (ctx->Light.ProvokingVertex == GL_LAST_VERTEX_CONVENTION_EXT)
 135             RENDER_LINE( ELT(start), ELT(start+1) );
 136          else
 137             RENDER_LINE( ELT(start+1), ELT(start) );
 138       }
 139
 140       for ( i = start+2 ; i < count ; i++) {
 141          if (ctx->Light.ProvokingVertex == GL_LAST_VERTEX_CONVENTION_EXT)
 142             RENDER_LINE( ELT(i-1), ELT(i) );
 143          else
 144             RENDER_LINE( ELT(i), ELT(i-1) );
 145       }
 146
 147       if ( TEST_PRIM_END(flags)) {
 148          if (ctx->Light.ProvokingVertex == GL_LAST_VERTEX_CONVENTION_EXT)
 149             RENDER_LINE( ELT(count-1), ELT(start) );
 150          else
 151             RENDER_LINE( ELT(start), ELT(count-1) );
 152       }
 153    }
 154
 155    POSTFIX;
 156 }
 157
 158
 159 static void TAG(render_triangles)( struct gl_context *ctx,
 160                                    GLuint start,
 161                                    GLuint count,
 162                                    GLuint flags )
 163 {
 164    GLuint j;
 165    LOCAL_VARS;
 166    (void) flags;
 167
 168    INIT(GL_TRIANGLES);
 169    if (NEED_EDGEFLAG_SETUP) {
 170       for (j=start+2; j<count; j+=3) {
 171          /* Leave the edgeflags as supplied by the user.
 172           */
 173          RESET_STIPPLE;
 174          if (ctx->Light.ProvokingVertex == GL_LAST_VERTEX_CONVENTION_EXT)
 175             RENDER_TRI( ELT(j-2), ELT(j-1), ELT(j) );
 176          else
 177             RENDER_TRI( ELT(j-1), ELT(j), ELT(j-2) );
 178       }
 179    } else {
 180       for (j=start+2; j<count; j+=3) {
 181          if (ctx->Light.ProvokingVertex == GL_LAST_VERTEX_CONVENTION_EXT)
 182             RENDER_TRI( ELT(j-2), ELT(j-1), ELT(j) );
 183          else
 184             RENDER_TRI( ELT(j-1), ELT(j), ELT(j-2) );
 185       }
 186    }
 187    POSTFIX;
 188 }
 189
 190
 191
 192 static void TAG(render_tri_strip)( struct gl_context *ctx,
 193                                    GLuint start,
 194                                    GLuint count,
 195                                    GLuint flags )
 196 {
 197    GLuint j;
 198    GLuint parity = 0;
 199    LOCAL_VARS;
 200
 201    INIT(GL_TRIANGLE_STRIP);
 202    if (NEED_EDGEFLAG_SETUP) {
 203       for (j=start+2;j<count;j++,parity^=1) {
 204          GLuint ej2, ej1, ej;
 205          GLboolean ef2, ef1, ef;
 206          if (ctx->Light.ProvokingVertex == GL_LAST_VERTEX_CONVENTION_EXT) {
 207             ej2 = ELT(j-2+parity);
 208             ej1 = ELT(j-1-parity);
 209             ej = ELT(j);
 210          }
 211          else {
 212             ej2 = ELT(j-1+parity);
 213             ej1 = ELT(j-parity);
 214             ej = ELT(j-2);
 215          }
 216          ef2 = EDGEFLAG_GET( ej2 );
 217          ef1 = EDGEFLAG_GET( ej1 );
 218          ef = EDGEFLAG_GET( ej );
 219          if (TEST_PRIM_BEGIN(flags)) {
 220             RESET_STIPPLE;
 221          }
 222          EDGEFLAG_SET( ej2, GL_TRUE );
 223          EDGEFLAG_SET( ej1, GL_TRUE );
 224          EDGEFLAG_SET( ej, GL_TRUE );
 225          RENDER_TRI( ej2, ej1, ej );
 226          EDGEFLAG_SET( ej2, ef2 );
 227          EDGEFLAG_SET( ej1, ef1 );
 228          EDGEFLAG_SET( ej, ef );
 229       }
 230    } else {
 231       for (j=start+2; j<count ; j++, parity^=1) {
 232          if (ctx->Light.ProvokingVertex == GL_LAST_VERTEX_CONVENTION_EXT)
 233             RENDER_TRI( ELT(j-2+parity), ELT(j-1-parity), ELT(j) );
 234          else
 235             RENDER_TRI( ELT(j-1+parity), ELT(j-parity), ELT(j-2) );
 236       }
 237    }
 238    POSTFIX;
 239 }
 240
 241
 242 static void TAG(render_tri_fan)( struct gl_context *ctx,
 243                                  GLuint start,
 244                                  GLuint count,
 245                                  GLuint flags )
 246 {
 247    GLuint j;
 248    LOCAL_VARS;
 249    (void) flags;
 250
 251    INIT(GL_TRIANGLE_FAN);
 252    if (NEED_EDGEFLAG_SETUP) {
 253       for (j=start+2;j<count;j++) {
 254          /* For trifans, all edges are boundary.
 255           */
 256          GLuint ejs = ELT(start);
 257          GLuint ej1 = ELT(j-1);
 258          GLuint ej = ELT(j);
 259          GLboolean efs = EDGEFLAG_GET( ejs );
 260          GLboolean ef1 = EDGEFLAG_GET( ej1 );
 261          GLboolean ef = EDGEFLAG_GET( ej );
 262          if (TEST_PRIM_BEGIN(flags)) {
 263             RESET_STIPPLE;
 264          }
 265          EDGEFLAG_SET( ejs, GL_TRUE );
 266          EDGEFLAG_SET( ej1, GL_TRUE );
 267          EDGEFLAG_SET( ej, GL_TRUE );
 268          if (ctx->Light.ProvokingVertex == GL_LAST_VERTEX_CONVENTION_EXT)
 269             RENDER_TRI( ejs, ej1, ej);
 270          else
 271             RENDER_TRI( ej, ejs, ej1);
 272          EDGEFLAG_SET( ejs, efs );
 273          EDGEFLAG_SET( ej1, ef1 );
 274          EDGEFLAG_SET( ej, ef );
 275       }
 276    } else {
 277       for (j=start+2;j<count;j++) {
 278          if (ctx->Light.ProvokingVertex == GL_LAST_VERTEX_CONVENTION_EXT)
 279             RENDER_TRI( ELT(start), ELT(j-1), ELT(j) );
 280          else
 281             RENDER_TRI( ELT(j), ELT(start), ELT(j-1) );
 282       }
 283    }
 284
 285    POSTFIX;
 286 }
 287
 288
 289 static void TAG(render_poly)( struct gl_context *ctx,
 290                               GLuint start,
 291                               GLuint count,
 292                               GLuint flags )
 293 {
 294    GLuint j = start+2;
 295    LOCAL_VARS;
 296    (void) flags;
 297
 298    INIT(GL_POLYGON);
 299    if (NEED_EDGEFLAG_SETUP) {
 300       GLboolean efstart = EDGEFLAG_GET( ELT(start) );
 301       GLboolean efcount = EDGEFLAG_GET( ELT(count-1) );
 302
 303       /* If the primitive does not begin here, the first edge
 304        * is non-boundary.
 305        */
 306       if (!TEST_PRIM_BEGIN(flags))
 307          EDGEFLAG_SET( ELT(start), GL_FALSE );
 308       else {
 309          RESET_STIPPLE;
 310       }
 311
 312       /* If the primitive does not end here, the final edge is
 313        * non-boundary.
 314        */
 315       if (!TEST_PRIM_END(flags))
 316          EDGEFLAG_SET( ELT(count-1), GL_FALSE );
 317
 318       /* Draw the first triangles (possibly zero)
 319        */
 320       if (j+1<count) {
 321          GLboolean ef = EDGEFLAG_GET( ELT(j) );
 322          EDGEFLAG_SET( ELT(j), GL_FALSE );
 323          RENDER_TRI( ELT(j-1), ELT(j), ELT(start) );
 324          EDGEFLAG_SET( ELT(j), ef );
 325          j++;
 326
 327          /* Don't render the first edge again:
 328           */
 329          EDGEFLAG_SET( ELT(start), GL_FALSE );
 330
 331          for (;j+1<count;j++) {
 332             GLboolean efj = EDGEFLAG_GET( ELT(j) );
 333             EDGEFLAG_SET( ELT(j), GL_FALSE );
 334             RENDER_TRI( ELT(j-1), ELT(j), ELT(start) );
 335             EDGEFLAG_SET( ELT(j), efj );
 336          }
 337       }
 338
 339       /* Draw the last or only triangle
 340        */
 341       if (j < count)
 342          RENDER_TRI( ELT(j-1), ELT(j), ELT(start) );
 343
 344       /* Restore the first and last edgeflags:
 345        */
 346       EDGEFLAG_SET( ELT(count-1), efcount );
 347       EDGEFLAG_SET( ELT(start), efstart );
 348
 349    }
 350    else {
 351       for (j=start+2;j<count;j++) {
 352          RENDER_TRI( ELT(j-1), ELT(j), ELT(start) );
 353       }
 354    }
 355    POSTFIX;
 356 }
 357
 358 static void TAG(render_quads)( struct gl_context *ctx,
 359                                GLuint start,
 360                                GLuint count,
 361                                GLuint flags )
 362 {
 363    GLuint j;
 364    LOCAL_VARS;
 365    (void) flags;
 366
 367    INIT(GL_QUADS);
 368    if (NEED_EDGEFLAG_SETUP) {
 369       for (j=start+3; j<count; j+=4) {
 370          /* Use user-specified edgeflags for quads.
 371           */
 372          RESET_STIPPLE;
 373          if (ctx->Light.ProvokingVertex == GL_LAST_VERTEX_CONVENTION_EXT ||
 374              !ctx->Const.QuadsFollowProvokingVertexConvention)
 375             RENDER_QUAD( ELT(j-3), ELT(j-2), ELT(j-1), ELT(j) );
 376          else
 377             RENDER_QUAD( ELT(j-2), ELT(j-1), ELT(j), ELT(j-3) );
 378       }
 379    } else {
 380       for (j=start+3; j<count; j+=4) {
 381          if (ctx->Light.ProvokingVertex == GL_LAST_VERTEX_CONVENTION_EXT ||
 382              !ctx->Const.QuadsFollowProvokingVertexConvention)
 383             RENDER_QUAD( ELT(j-3), ELT(j-2), ELT(j-1), ELT(j) );
 384          else
 385             RENDER_QUAD( ELT(j-2), ELT(j-1), ELT(j), ELT(j-3) );
 386       }
 387    }
 388    POSTFIX;
 389 }
 390
 391 static void TAG(render_quad_strip)( struct gl_context *ctx,
 392                                     GLuint start,
 393                                     GLuint count,
 394                                     GLuint flags )
 395 {
 396    GLuint j;
 397    LOCAL_VARS;
 398    (void) flags;
 399
 400    INIT(GL_QUAD_STRIP);
 401    if (NEED_EDGEFLAG_SETUP) {
 402       for (j=start+3;j<count;j+=2) {
 403          /* All edges are boundary.  Set edgeflags to 1, draw the
 404           * quad, and restore them to the original values.
 405           */
 406          GLboolean ef3 = EDGEFLAG_GET( ELT(j-3) );
 407          GLboolean ef2 = EDGEFLAG_GET( ELT(j-2) );
 408          GLboolean ef1 = EDGEFLAG_GET( ELT(j-1) );
 409          GLboolean ef = EDGEFLAG_GET( ELT(j) );
 410          if (TEST_PRIM_BEGIN(flags)) {
 411             RESET_STIPPLE;
 412          }
 413          EDGEFLAG_SET( ELT(j-3), GL_TRUE );
 414          EDGEFLAG_SET( ELT(j-2), GL_TRUE );
 415          EDGEFLAG_SET( ELT(j-1), GL_TRUE );
 416          EDGEFLAG_SET( ELT(j), GL_TRUE );
 417          if (ctx->Light.ProvokingVertex == GL_LAST_VERTEX_CONVENTION_EXT ||
 418              !ctx->Const.QuadsFollowProvokingVertexConvention)
 419             RENDER_QUAD( ELT(j-1), ELT(j-3), ELT(j-2), ELT(j) );
 420          else
 421             RENDER_QUAD( ELT(j-2), ELT(j), ELT(j-1), ELT(j-3) );
 422          EDGEFLAG_SET( ELT(j-3), ef3 );
 423          EDGEFLAG_SET( ELT(j-2), ef2 );
 424          EDGEFLAG_SET( ELT(j-1), ef1 );
 425          EDGEFLAG_SET( ELT(j), ef );
 426       }
 427    } else {
 428       for (j=start+3;j<count;j+=2) {
 429          if (ctx->Light.ProvokingVertex == GL_LAST_VERTEX_CONVENTION_EXT ||
 430              !ctx->Const.QuadsFollowProvokingVertexConvention)
 431             RENDER_QUAD( ELT(j-1), ELT(j-3), ELT(j-2), ELT(j) );
 432          else
 433             RENDER_QUAD( ELT(j-2), ELT(j), ELT(j-1), ELT(j-3) );
 434       }
 435    }
 436    POSTFIX;
 437 }
 438
 439 static void TAG(render_noop)( struct gl_context *ctx,
 440                               GLuint start,
 441                               GLuint count,
 442                               GLuint flags )
 443 {
 444    (void)(ctx && start && count && flags);
 445 }
 446
 447 RENDER_TAB_QUALIFIER void (*TAG(render_tab)[GL_POLYGON+2])(struct gl_context *,
 448                                                            GLuint,
 449                                                            GLuint,
 450                                                            GLuint) =
 451 {
 452    TAG(render_points),
 453    TAG(render_lines),
 454    TAG(render_line_loop),
 455    TAG(render_line_strip),
 456    TAG(render_triangles),
 457    TAG(render_tri_strip),
 458    TAG(render_tri_fan),
 459    TAG(render_quads),
 460    TAG(render_quad_strip),
 461    TAG(render_poly),
 462    TAG(render_noop),
 463 };
 464
 465
 466
 467 #ifndef PRESERVE_VB_DEFS
 468 #undef RENDER_TRI
 469 #undef RENDER_QUAD
 470 #undef RENDER_LINE
 471 #undef RENDER_POINTS
 472 #undef LOCAL_VARS
 473 #undef INIT
 474 #undef POSTFIX
 475 #undef RESET_STIPPLE
 476 #undef DBG
 477 #undef ELT
 478 #undef RENDER_TAB_QUALIFIER
 479 #endif
 480
 481 #ifndef PRESERVE_TAG
 482 #undef TAG
 483 #endif
 484
 485 #undef PRESERVE_VB_DEFS
 486 #undef PRESERVE_TAG