src/mesa/drivers/dri/sis/sis_tris.c

   1 /* $XFree86*/ /* -*- c-basic-offset: 3 -*- */
   2 /**************************************************************************
   3
   4 Copyright 2000 Silicon Integrated Systems Corp, Inc., HsinChu, Taiwan.
   5 Copyright 2003 Eric Anholt
   6 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 on the rights to use, copy, modify, merge, publish, distribute, sub
  12 license, and/or sell copies of the Software, and to permit persons to whom
  13 the Software is furnished to do so, subject to the following conditions:
  14
  15 The above copyright notice and this permission notice (including the next
  16 paragraph) shall be included in all copies or substantial portions of the
  17 Software.
  18
  19 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  20 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21 FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  22 ERIC ANHOLT OR SILICON INTEGRATED SYSTEMS CORP BE LIABLE FOR ANY CLAIM,
  23 DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  24 OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  25 USE OR OTHER DEALINGS IN THE SOFTWARE.
  26
  27 **************************************************************************/
  28
  29 /*
  30  * Authors:
  31  *   Sung-Ching Lin <sclin@sis.com.tw>
  32  *   Eric Anholt <anholt@FreeBSD.org>
  33  */
  34
  35 #include "main/glheader.h"
  36 #include "main/mtypes.h"
  37 #include "main/colormac.h"
  38 #include "main/macros.h"
  39
  40 #include "swrast/swrast.h"
  41 #include "swrast_setup/swrast_setup.h"
  42 #include "tnl/t_context.h"
  43 #include "tnl/t_pipeline.h"
  44
  45 #include "sis_context.h"
  46 #include "sis_tris.h"
  47 #include "sis_state.h"
  48 #include "sis_lock.h"
  49 #include "sis_span.h"
  50 #include "sis_alloc.h"
  51 #include "sis_tex.h"
  52
  53 /* 6326 and 300-series shared */
  54 static const GLuint hw_prim[GL_POLYGON+1] = {
  55    OP_3D_POINT_DRAW,            /* GL_POINTS */
  56    OP_3D_LINE_DRAW,             /* GL_LINES */
  57    OP_3D_LINE_DRAW,             /* GL_LINE_LOOP */
  58    OP_3D_LINE_DRAW,             /* GL_LINE_STRIP */
  59    OP_3D_TRIANGLE_DRAW,         /* GL_TRIANGLES */
  60    OP_3D_TRIANGLE_DRAW,         /* GL_TRIANGLE_STRIP */
  61    OP_3D_TRIANGLE_DRAW,         /* GL_TRIANGLE_FAN */
  62    OP_3D_TRIANGLE_DRAW,         /* GL_QUADS */
  63    OP_3D_TRIANGLE_DRAW,         /* GL_QUAD_STRIP */
  64    OP_3D_TRIANGLE_DRAW          /* GL_POLYGON */
  65 };
  66
  67 static const GLuint hw_prim_mmio_fire[OP_3D_TRIANGLE_DRAW+1] = {
  68    OP_3D_FIRE_TSARGBa,
  69    OP_3D_FIRE_TSARGBb,
  70    OP_3D_FIRE_TSARGBc
  71 };
  72 static const GLuint hw_prim_6326_mmio_fire[OP_3D_TRIANGLE_DRAW+1] = {
  73    OP_6326_3D_FIRE_TSARGBa,
  74    OP_6326_3D_FIRE_TSARGBb,
  75    OP_6326_3D_FIRE_TSARGBc
  76 };
  77
  78 static const GLuint hw_prim_mmio_shade[OP_3D_TRIANGLE_DRAW+1] = {
  79    SHADE_FLAT_VertexA,
  80    SHADE_FLAT_VertexB,
  81    SHADE_FLAT_VertexC
  82 };
  83
  84 static const GLuint hw_prim_agp_type[OP_3D_TRIANGLE_DRAW+1] = {
  85    MASK_PsPointList,
  86    MASK_PsLineList,
  87    MASK_PsTriangleList
  88 };
  89
  90 static const GLuint hw_prim_agp_shade[OP_3D_TRIANGLE_DRAW+1] = {
  91    MASK_PsShadingFlatA,
  92    MASK_PsShadingFlatB,
  93    MASK_PsShadingFlatC
  94 };
  95
  96 static void sisRasterPrimitive( GLcontext *ctx, GLuint hwprim );
  97 static void sisRenderPrimitive( GLcontext *ctx, GLenum prim );
  98
  99 /***********************************************************************
 100  *                    Emit primitives as inline vertices               *
 101  ***********************************************************************/
 102
 103 #define HAVE_QUADS 0
 104 #define HAVE_LINES 1
 105 #define HAVE_POINTS 1
 106 #define CTX_ARG sisContextPtr smesa
 107 #define GET_VERTEX_DWORDS() smesa->vertex_size
 108 #define ALLOC_VERTS( n, size ) sisAllocDmaLow( smesa, n * size * sizeof(int) )
 109 #undef LOCAL_VARS
 110 #define LOCAL_VARS                                              \
 111    sisContextPtr smesa = SIS_CONTEXT(ctx);                      \
 112    const char *vertptr = smesa->verts;
 113 #define VERT(x) (sisVertex *)(vertptr + (x * vertsize * sizeof(int)))
 114 #define VERTEX sisVertex
 115 #undef TAG
 116 #define TAG(x) sis_##x
 117 #include "tnl_dd/t_dd_triemit.h"
 118 #undef TAG
 119 #undef LOCAL_VARS
 120
 121 /***********************************************************************
 122  *             Dispatch vertices to hardware through MMIO              *
 123  ***********************************************************************/
 124
 125 /* The ARGB write of the last vertex of the primitive fires the 3d engine, so
 126  * save it until the end.
 127  */
 128 #define SIS_MMIO_WRITE_VERTEX(_v, i, lastvert)                  \
 129 do {                                                            \
 130    GLuint __color, __i = 0;                                     \
 131    MMIO(REG_3D_TSXa+(i)*0x30, _v->ui[__i++]);                   \
 132    MMIO(REG_3D_TSYa+(i)*0x30, _v->ui[__i++]);                   \
 133    MMIO(REG_3D_TSZa+(i)*0x30, _v->ui[__i++]);                   \
 134    if (SIS_STATES & VERT_W)                                     \
 135       MMIO(REG_3D_TSWGa+(i)*0x30, _v->ui[__i++]);               \
 136    __color = _v->ui[__i++];                                     \
 137    if (SIS_STATES & VERT_SPEC)                                  \
 138       MMIO(REG_3D_TSFSa+(i)*0x30, _v->ui[__i++]);               \
 139    if (SIS_STATES & VERT_UV0) {                                 \
 140       MMIO(REG_3D_TSUAa+(i)*0x30, _v->ui[__i++]);               \
 141       MMIO(REG_3D_TSVAa+(i)*0x30, _v->ui[__i++]);               \
 142    }                                                            \
 143    if (SIS_STATES & VERT_UV1) {                                 \
 144       MMIO(REG_3D_TSUBa+(i)*0x30, _v->ui[__i++]);               \
 145       MMIO(REG_3D_TSVBa+(i)*0x30, _v->ui[__i++]);               \
 146    }                                                            \
 147    if (lastvert || (SIS_STATES & VERT_SMOOTH))                  \
 148       MMIO(REG_3D_TSARGBa+(i)*0x30, __color);                   \
 149 } while (0)
 150
 151 #define SIS6326_MMIO_WRITE_VERTEX(_v, i, lastvert)              \
 152 do {                                                            \
 153    GLuint __color, __i = 0;                                     \
 154    MMIO(REG_6326_3D_TSXa+(i)*0x20, _v->ui[__i++]);              \
 155    MMIO(REG_6326_3D_TSYa+(i)*0x20, _v->ui[__i++]);              \
 156    MMIO(REG_6326_3D_TSZa+(i)*0x20, _v->ui[__i++]);              \
 157    if (SIS_STATES & VERT_W)                                     \
 158       MMIO(REG_6326_3D_TSWa+(i)*0x20, _v->ui[__i++]);           \
 159    __color = _v->ui[__i++];                                     \
 160    if (SIS_STATES & VERT_SPEC)                                  \
 161       MMIO(REG_6326_3D_TSFSa+(i)*0x20, _v->ui[__i++]);          \
 162    if (SIS_STATES & VERT_UV0) {                                 \
 163       MMIO(REG_6326_3D_TSUa+(i)*0x20, _v->ui[__i++]);           \
 164       MMIO(REG_6326_3D_TSVa+(i)*0x20, _v->ui[__i++]);           \
 165    }                                                            \
 166    if (lastvert || (SIS_STATES & VERT_SMOOTH))                  \
 167       MMIO(REG_6326_3D_TSARGBa+(i)*0x30, __color);              \
 168 } while (0)
 169
 170 #define MMIO_VERT_REG_COUNT 10
 171
 172 #define VERT_SMOOTH     0x01
 173 #define VERT_W          0x02
 174 #define VERT_SPEC       0x04
 175 #define VERT_UV0        0x08
 176 #define VERT_UV1        0x10
 177 #define VERT_6326       0x20    /* Right after UV1, but won't have a UV1 set */
 178
 179 typedef void (*mmio_draw_func)(sisContextPtr smesa, char *verts);
 180 static mmio_draw_func sis_tri_func_mmio[48];
 181 static mmio_draw_func sis_line_func_mmio[48];
 182 static mmio_draw_func sis_point_func_mmio[48];
 183
 184 #define SIS_STATES (0)
 185 #define TAG(x) x##_none
 186 #include "sis_tritmp.h"
 187
 188 #define SIS_STATES (VERT_SMOOTH)
 189 #define TAG(x) x##_g
 190 #include "sis_tritmp.h"
 191
 192 #define SIS_STATES (VERT_W)
 193 #define TAG(x) x##_w
 194 #include "sis_tritmp.h"
 195
 196 #define SIS_STATES (VERT_SMOOTH | VERT_W)
 197 #define TAG(x) x##_gw
 198 #include "sis_tritmp.h"
 199
 200 #define SIS_STATES (VERT_SPEC)
 201 #define TAG(x) x##_s
 202 #include "sis_tritmp.h"
 203
 204 #define SIS_STATES (VERT_SMOOTH | VERT_SPEC)
 205 #define TAG(x) x##_gs
 206 #include "sis_tritmp.h"
 207
 208 #define SIS_STATES (VERT_W | VERT_SPEC)
 209 #define TAG(x) x##_ws
 210 #include "sis_tritmp.h"
 211
 212 #define SIS_STATES (VERT_SMOOTH | VERT_W | VERT_SPEC)
 213 #define TAG(x) x##_gws
 214 #include "sis_tritmp.h"
 215
 216 #define SIS_STATES (VERT_UV0)
 217 #define TAG(x) x##_t0
 218 #include "sis_tritmp.h"
 219
 220 #define SIS_STATES (VERT_SMOOTH | VERT_UV0)
 221 #define TAG(x) x##_gt0
 222 #include "sis_tritmp.h"
 223
 224 #define SIS_STATES (VERT_W | VERT_UV0)
 225 #define TAG(x) x##_wt0
 226 #include "sis_tritmp.h"
 227
 228 #define SIS_STATES (VERT_SMOOTH | VERT_W | VERT_UV0)
 229 #define TAG(x) x##_gwt0
 230 #include "sis_tritmp.h"
 231
 232 #define SIS_STATES (VERT_SPEC | VERT_UV0)
 233 #define TAG(x) x##_st0
 234 #include "sis_tritmp.h"
 235
 236 #define SIS_STATES (VERT_SMOOTH | VERT_SPEC | VERT_UV0)
 237 #define TAG(x) x##_gst0
 238 #include "sis_tritmp.h"
 239
 240 #define SIS_STATES (VERT_W | VERT_SPEC | VERT_UV0)
 241 #define TAG(x) x##_wst0
 242 #include "sis_tritmp.h"
 243
 244 #define SIS_STATES (VERT_SMOOTH | VERT_W | VERT_SPEC | VERT_UV0)
 245 #define TAG(x) x##_gwst0
 246 #include "sis_tritmp.h"
 247
 248 #define SIS_STATES (VERT_UV1)
 249 #define TAG(x) x##_t1
 250 #include "sis_tritmp.h"
 251
 252 #define SIS_STATES (VERT_SMOOTH | VERT_UV1)
 253 #define TAG(x) x##_gt1
 254 #include "sis_tritmp.h"
 255
 256 #define SIS_STATES (VERT_W | VERT_UV1)
 257 #define TAG(x) x##_wt1
 258 #include "sis_tritmp.h"
 259
 260 #define SIS_STATES (VERT_SMOOTH | VERT_W | VERT_UV1)
 261 #define TAG(x) x##_gwt1
 262 #include "sis_tritmp.h"
 263
 264 #define SIS_STATES (VERT_SPEC | VERT_UV1)
 265 #define TAG(x) x##_st1
 266 #include "sis_tritmp.h"
 267
 268 #define SIS_STATES (VERT_SMOOTH | VERT_SPEC | VERT_UV1)
 269 #define TAG(x) x##_gst1
 270 #include "sis_tritmp.h"
 271
 272 #define SIS_STATES (VERT_W | VERT_SPEC | VERT_UV1)
 273 #define TAG(x) x##_wst1
 274 #include "sis_tritmp.h"
 275
 276 #define SIS_STATES (VERT_SMOOTH | VERT_W | VERT_SPEC | VERT_UV1)
 277 #define TAG(x) x##_gwst1
 278 #include "sis_tritmp.h"
 279
 280 #define SIS_STATES (VERT_UV0 | VERT_UV1)
 281 #define TAG(x) x##_t0t1
 282 #include "sis_tritmp.h"
 283
 284 #define SIS_STATES (VERT_SMOOTH | VERT_UV0 | VERT_UV1)
 285 #define TAG(x) x##_gt0t1
 286 #include "sis_tritmp.h"
 287
 288 #define SIS_STATES (VERT_W | VERT_UV0 | VERT_UV1)
 289 #define TAG(x) x##_wt0t1
 290 #include "sis_tritmp.h"
 291
 292 #define SIS_STATES (VERT_SMOOTH | VERT_W | VERT_UV0 | VERT_UV1)
 293 #define TAG(x) x##_gwt0t1
 294 #include "sis_tritmp.h"
 295
 296 #define SIS_STATES (VERT_SPEC | VERT_UV0 | VERT_UV1)
 297 #define TAG(x) x##_st0t1
 298 #include "sis_tritmp.h"
 299
 300 #define SIS_STATES (VERT_SMOOTH | VERT_SPEC | VERT_UV0 | VERT_UV1)
 301 #define TAG(x) x##_gst0t1
 302 #include "sis_tritmp.h"
 303
 304 #define SIS_STATES (VERT_W | VERT_SPEC | VERT_UV0 | VERT_UV1)
 305 #define TAG(x) x##_wst0t1
 306 #include "sis_tritmp.h"
 307
 308 #define SIS_STATES (VERT_SMOOTH | VERT_W | VERT_SPEC | VERT_UV0 | VERT_UV1)
 309 #define TAG(x) x##_gwst0t1
 310 #include "sis_tritmp.h"
 311
 312 /***********************************************************************
 313  *          Macros for t_dd_tritmp.h to draw basic primitives          *
 314  ***********************************************************************/
 315
 316 #define TRI( a, b, c )                          \
 317 do {                                            \
 318    if (DO_FALLBACK)                             \
 319       smesa->draw_tri( smesa, a, b, c );        \
 320    else                                         \
 321       sis_triangle( smesa, a, b, c );           \
 322 } while (0)
 323
 324 #define QUAD( a, b, c, d )                      \
 325 do {                                            \
 326    if (DO_FALLBACK) {                           \
 327       smesa->draw_tri( smesa, a, b, d );        \
 328       smesa->draw_tri( smesa, b, c, d );        \
 329    } else                                       \
 330       sis_quad( smesa, a, b, c, d );            \
 331 } while (0)
 332
 333 #define LINE( v0, v1 )                          \
 334 do {                                            \
 335    if (DO_FALLBACK)                             \
 336       smesa->draw_line( smesa, v0, v1 );        \
 337    else                                         \
 338       sis_line( smesa, v0, v1 );                \
 339 } while (0)
 340
 341 #define POINT( v0 )                             \
 342 do {                                            \
 343    if (DO_FALLBACK)                             \
 344       smesa->draw_point( smesa, v0 );           \
 345    else                                         \
 346       sis_point( smesa, v0 );                   \
 347 } while (0)
 348
 349 /***********************************************************************
 350  *              Build render functions from dd templates               *
 351  ***********************************************************************/
 352
 353 #define SIS_OFFSET_BIT          0x01
 354 #define SIS_TWOSIDE_BIT         0x02
 355 #define SIS_UNFILLED_BIT        0x04
 356 #define SIS_FALLBACK_BIT        0x08
 357 #define SIS_MAX_TRIFUNC         0x10
 358
 359
 360 static struct {
 361    tnl_points_func              points;
 362    tnl_line_func                line;
 363    tnl_triangle_func    triangle;
 364    tnl_quad_func                quad;
 365 } rast_tab[SIS_MAX_TRIFUNC];
 366
 367
 368 #define DO_FALLBACK (IND & SIS_FALLBACK_BIT)
 369 #define DO_OFFSET   (IND & SIS_OFFSET_BIT)
 370 #define DO_UNFILLED (IND & SIS_UNFILLED_BIT)
 371 #define DO_TWOSIDE  (IND & SIS_TWOSIDE_BIT)
 372 #define DO_FLAT      0
 373 #define DO_TRI       1
 374 #define DO_QUAD      1
 375 #define DO_LINE      1
 376 #define DO_POINTS    1
 377 #define DO_FULL_QUAD 1
 378
 379 #define HAVE_RGBA   1
 380 #define HAVE_SPEC   1
 381 #define HAVE_BACK_COLORS  0
 382 #define HAVE_HW_FLATSHADE 1
 383 #define VERTEX sisVertex
 384 #define TAB rast_tab
 385
 386 #define DEPTH_SCALE smesa->depth_scale
 387 #define UNFILLED_TRI unfilled_tri
 388 #define UNFILLED_QUAD unfilled_quad
 389 #define VERT_X(_v) _v->v.x
 390 #define VERT_Y(_v) _v->v.y
 391 #define VERT_Z(_v) _v->v.z
 392 #define AREA_IS_CCW( a ) (a > 0)
 393 #define GET_VERTEX(e) (smesa->verts + (e * smesa->vertex_size * sizeof(int)))
 394
 395 #define VERT_SET_RGBA( v, c )                                   \
 396 do {                                                            \
 397    sis_color_t *color = (sis_color_t *)&((v)->ui[coloroffset]); \
 398    UNCLAMPED_FLOAT_TO_UBYTE(color->red, (c)[0]);                \
 399    UNCLAMPED_FLOAT_TO_UBYTE(color->green, (c)[1]);              \
 400    UNCLAMPED_FLOAT_TO_UBYTE(color->blue, (c)[2]);               \
 401    UNCLAMPED_FLOAT_TO_UBYTE(color->alpha, (c)[3]);              \
 402 } while (0)
 403
 404 #define VERT_COPY_RGBA( v0, v1 ) v0->ui[coloroffset] = v1->ui[coloroffset]
 405
 406 #define VERT_SET_SPEC( v, c )                                   \
 407 do {                                                            \
 408    if (specoffset != 0) {                                       \
 409       sis_color_t *spec = (sis_color_t *)&((v)->ui[specoffset]); \
 410       UNCLAMPED_FLOAT_TO_UBYTE(spec->red, (c)[0]);              \
 411       UNCLAMPED_FLOAT_TO_UBYTE(spec->green, (c)[1]);            \
 412       UNCLAMPED_FLOAT_TO_UBYTE(spec->blue, (c)[2]);             \
 413    }                                                            \
 414 } while (0)
 415 #define VERT_COPY_SPEC( v0, v1 )                                \
 416 do {                                                            \
 417    if (specoffset != 0) {                                       \
 418       sis_color_t *spec0 = (sis_color_t *)&((v0)->ui[specoffset]); \
 419       sis_color_t *spec1 = (sis_color_t *)&((v1)->ui[specoffset]); \
 420       spec0->red   = spec1->red;                                \
 421       spec0->green = spec1->green;                              \
 422       spec0->blue  = spec1->blue;                               \
 423    }                                                            \
 424 } while (0)
 425
 426 #define VERT_SAVE_RGBA( idx )    color[idx] = v[idx]->ui[coloroffset]
 427 #define VERT_RESTORE_RGBA( idx ) v[idx]->ui[coloroffset] = color[idx]
 428 #define VERT_SAVE_SPEC( idx )    if (specoffset != 0) spec[idx] = v[idx]->ui[specoffset]
 429 #define VERT_RESTORE_SPEC( idx ) if (specoffset != 0) v[idx]->ui[specoffset] = spec[idx]
 430
 431 #define LOCAL_VARS(n)                                           \
 432    sisContextPtr smesa = SIS_CONTEXT(ctx);                      \
 433    GLuint color[n], spec[n];                                    \
 434    GLuint coloroffset = smesa->coloroffset;                     \
 435    GLuint specoffset = smesa->specoffset;                       \
 436    (void) color; (void) spec; (void) coloroffset; (void) specoffset;
 437
 438 /***********************************************************************
 439  *                Helpers for rendering unfilled primitives            *
 440  ***********************************************************************/
 441
 442 #define RASTERIZE(x) if (smesa->hw_primitive != hw_prim[x]) \
 443                         sisRasterPrimitive( ctx, hw_prim[x] )
 444 #define RENDER_PRIMITIVE smesa->render_primitive
 445 #define IND SIS_FALLBACK_BIT
 446 #define TAG(x) x
 447 #include "tnl_dd/t_dd_unfilled.h"
 448 #undef IND
 449
 450
 451 /***********************************************************************
 452  *                      Generate GL render functions                   *
 453  ***********************************************************************/
 454
 455
 456 #define IND (0)
 457 #define TAG(x) x
 458 #include "tnl_dd/t_dd_tritmp.h"
 459
 460 #define IND (SIS_OFFSET_BIT)
 461 #define TAG(x) x##_offset
 462 #include "tnl_dd/t_dd_tritmp.h"
 463
 464 #define IND (SIS_TWOSIDE_BIT)
 465 #define TAG(x) x##_twoside
 466 #include "tnl_dd/t_dd_tritmp.h"
 467
 468 #define IND (SIS_TWOSIDE_BIT|SIS_OFFSET_BIT)
 469 #define TAG(x) x##_twoside_offset
 470 #include "tnl_dd/t_dd_tritmp.h"
 471
 472 #define IND (SIS_UNFILLED_BIT)
 473 #define TAG(x) x##_unfilled
 474 #include "tnl_dd/t_dd_tritmp.h"
 475
 476 #define IND (SIS_OFFSET_BIT|SIS_UNFILLED_BIT)
 477 #define TAG(x) x##_offset_unfilled
 478 #include "tnl_dd/t_dd_tritmp.h"
 479
 480 #define IND (SIS_TWOSIDE_BIT|SIS_UNFILLED_BIT)
 481 #define TAG(x) x##_twoside_unfilled
 482 #include "tnl_dd/t_dd_tritmp.h"
 483
 484 #define IND (SIS_TWOSIDE_BIT|SIS_OFFSET_BIT|SIS_UNFILLED_BIT)
 485 #define TAG(x) x##_twoside_offset_unfilled
 486 #include "tnl_dd/t_dd_tritmp.h"
 487
 488 #define IND (SIS_FALLBACK_BIT)
 489 #define TAG(x) x##_fallback
 490 #include "tnl_dd/t_dd_tritmp.h"
 491
 492 #define IND (SIS_OFFSET_BIT|SIS_FALLBACK_BIT)
 493 #define TAG(x) x##_offset_fallback
 494 #include "tnl_dd/t_dd_tritmp.h"
 495
 496 #define IND (SIS_TWOSIDE_BIT|SIS_FALLBACK_BIT)
 497 #define TAG(x) x##_twoside_fallback
 498 #include "tnl_dd/t_dd_tritmp.h"
 499
 500 #define IND (SIS_TWOSIDE_BIT|SIS_OFFSET_BIT|SIS_FALLBACK_BIT)
 501 #define TAG(x) x##_twoside_offset_fallback
 502 #include "tnl_dd/t_dd_tritmp.h"
 503
 504 #define IND (SIS_UNFILLED_BIT|SIS_FALLBACK_BIT)
 505 #define TAG(x) x##_unfilled_fallback
 506 #include "tnl_dd/t_dd_tritmp.h"
 507
 508 #define IND (SIS_OFFSET_BIT|SIS_UNFILLED_BIT|SIS_FALLBACK_BIT)
 509 #define TAG(x) x##_offset_unfilled_fallback
 510 #include "tnl_dd/t_dd_tritmp.h"
 511
 512 #define IND (SIS_TWOSIDE_BIT|SIS_UNFILLED_BIT|SIS_FALLBACK_BIT)
 513 #define TAG(x) x##_twoside_unfilled_fallback
 514 #include "tnl_dd/t_dd_tritmp.h"
 515
 516 #define IND (SIS_TWOSIDE_BIT|SIS_OFFSET_BIT|SIS_UNFILLED_BIT| \
 517              SIS_FALLBACK_BIT)
 518 #define TAG(x) x##_twoside_offset_unfilled_fallback
 519 #include "tnl_dd/t_dd_tritmp.h"
 520
 521
 522 static void init_rast_tab( void )
 523 {
 524    init();
 525    init_offset();
 526    init_twoside();
 527    init_twoside_offset();
 528    init_unfilled();
 529    init_offset_unfilled();
 530    init_twoside_unfilled();
 531    init_twoside_offset_unfilled();
 532    init_fallback();
 533    init_offset_fallback();
 534    init_twoside_fallback();
 535    init_twoside_offset_fallback();
 536    init_unfilled_fallback();
 537    init_offset_unfilled_fallback();
 538    init_twoside_unfilled_fallback();
 539    init_twoside_offset_unfilled_fallback();
 540 }
 541
 542
 543
 544 /***********************************************************************
 545  *                    Rasterization fallback helpers                   *
 546  ***********************************************************************/
 547
 548
 549 /* This code is hit only when a mix of accelerated and unaccelerated
 550  * primitives are being drawn, and only for the unaccelerated
 551  * primitives.
 552  */
 553
 554 static void
 555 sis_fallback_tri( sisContextPtr smesa,
 556                   sisVertex *v0,
 557                   sisVertex *v1,
 558                   sisVertex *v2 )
 559 {
 560    GLcontext *ctx = smesa->glCtx;
 561    SWvertex v[3];
 562    _swsetup_Translate( ctx, v0, &v[0] );
 563    _swsetup_Translate( ctx, v1, &v[1] );
 564    _swsetup_Translate( ctx, v2, &v[2] );
 565    sisSpanRenderStart( ctx );
 566    _swrast_Triangle( ctx, &v[0], &v[1], &v[2] );
 567    sisSpanRenderFinish( ctx );
 568    _swrast_flush( ctx );
 569 }
 570
 571
 572 static void
 573 sis_fallback_line( sisContextPtr smesa,
 574                    sisVertex *v0,
 575                    sisVertex *v1 )
 576 {
 577    GLcontext *ctx = smesa->glCtx;
 578    SWvertex v[2];
 579    _swsetup_Translate( ctx, v0, &v[0] );
 580    _swsetup_Translate( ctx, v1, &v[1] );
 581    sisSpanRenderStart( ctx );
 582    _swrast_Line( ctx, &v[0], &v[1] );
 583    sisSpanRenderFinish( ctx );
 584    _swrast_flush( ctx );
 585 }
 586
 587
 588 static void
 589 sis_fallback_point( sisContextPtr smesa,
 590                     sisVertex *v0 )
 591 {
 592    GLcontext *ctx = smesa->glCtx;
 593    SWvertex v[1];
 594    _swsetup_Translate( ctx, v0, &v[0] );
 595    sisSpanRenderStart( ctx );
 596    _swrast_Point( ctx, &v[0] );
 597    sisSpanRenderFinish( ctx );
 598    _swrast_flush( ctx );
 599 }
 600
 601
 602
 603 /**********************************************************************/
 604 /*               Render unclipped begin/end objects                   */
 605 /**********************************************************************/
 606
 607 #define IND 0
 608 #define V(x) (sisVertex *)(vertptr + (x * vertsize * sizeof(int)))
 609 #define RENDER_POINTS( start, count )           \
 610    for ( ; start < count ; start++)             \
 611       POINT( V(ELT(start)) )
 612 #define RENDER_LINE( v0, v1 )         LINE( V(v0), V(v1) )
 613 #define RENDER_TRI(  v0, v1, v2 )     TRI(  V(v0), V(v1), V(v2) )
 614 #define RENDER_QUAD( v0, v1, v2, v3 ) QUAD( V(v0), V(v1), V(v2), V(v3) )
 615 #define INIT(x) sisRenderPrimitive( ctx, x )
 616 #undef LOCAL_VARS
 617 #define LOCAL_VARS                              \
 618     sisContextPtr smesa = SIS_CONTEXT(ctx);     \
 619     const GLuint vertsize = smesa->vertex_size;         \
 620     const char *vertptr = (char *)smesa->verts;         \
 621     const GLuint * const elt = TNL_CONTEXT(ctx)->vb.Elts;       \
 622     (void) elt;
 623 #define RESET_STIPPLE
 624 #define RESET_OCCLUSION
 625 #define PRESERVE_VB_DEFS
 626 #define ELT(x) (x)
 627 #define TAG(x) sis_##x##_verts
 628 #include "tnl/t_vb_rendertmp.h"
 629 #undef ELT
 630 #undef TAG
 631 #define TAG(x) sis_##x##_elts
 632 #define ELT(x) elt[x]
 633 #include "tnl/t_vb_rendertmp.h"
 634
 635
 636 /**********************************************************************/
 637 /*                    Choose render functions                         */
 638 /**********************************************************************/
 639
 640 #define POINT_FALLBACK (DD_POINT_SMOOTH)
 641 #define LINE_FALLBACK (DD_LINE_STIPPLE|DD_LINE_SMOOTH)
 642 #define TRI_FALLBACK (DD_TRI_STIPPLE|DD_TRI_SMOOTH)
 643 #define ANY_FALLBACK_FLAGS (POINT_FALLBACK|LINE_FALLBACK|TRI_FALLBACK)
 644 #define ANY_RASTER_FLAGS (DD_TRI_LIGHT_TWOSIDE|DD_TRI_OFFSET|DD_TRI_UNFILLED)
 645 #define _SIS_NEW_RENDER_STATE (ANY_RASTER_FLAGS | ANY_FALLBACK_FLAGS)
 646
 647 static void sisChooseRenderState(GLcontext *ctx)
 648 {
 649    TNLcontext *tnl = TNL_CONTEXT(ctx);
 650    sisContextPtr smesa = SIS_CONTEXT( ctx );
 651    GLuint flags = ctx->_TriangleCaps;
 652    GLuint index = 0;
 653
 654    if (smesa->Fallback)
 655       return;
 656
 657    if (flags & (ANY_RASTER_FLAGS|ANY_FALLBACK_FLAGS)) {
 658
 659       if (flags & ANY_RASTER_FLAGS) {
 660          if (flags & DD_TRI_LIGHT_TWOSIDE) index |= SIS_TWOSIDE_BIT;
 661          if (flags & DD_TRI_OFFSET)        index |= SIS_OFFSET_BIT;
 662          if (flags & DD_TRI_UNFILLED)      index |= SIS_UNFILLED_BIT;
 663       }
 664
 665       smesa->draw_point = sis_point;
 666       smesa->draw_line = sis_line;
 667       smesa->draw_tri = sis_triangle;
 668       /* Hook in fallbacks for specific primitives.
 669        */
 670       if (flags & ANY_FALLBACK_FLAGS) {
 671          if (flags & POINT_FALLBACK)
 672             smesa->draw_point = sis_fallback_point;
 673          if (flags & LINE_FALLBACK)
 674             smesa->draw_line = sis_fallback_line;
 675          if (flags & TRI_FALLBACK)
 676             smesa->draw_tri = sis_fallback_tri;
 677          index |= SIS_FALLBACK_BIT;
 678       }
 679    }
 680
 681    if (index != smesa->RenderIndex) {
 682       smesa->RenderIndex = index;
 683
 684       tnl->Driver.Render.Points = rast_tab[index].points;
 685       tnl->Driver.Render.Line = rast_tab[index].line;
 686       tnl->Driver.Render.ClippedLine = rast_tab[index].line;
 687       tnl->Driver.Render.Triangle = rast_tab[index].triangle;
 688       tnl->Driver.Render.Quad = rast_tab[index].quad;
 689
 690       if (index == 0) {
 691          tnl->Driver.Render.PrimTabVerts = sis_render_tab_verts;
 692          tnl->Driver.Render.PrimTabElts = sis_render_tab_elts;
 693          tnl->Driver.Render.ClippedPolygon = sis_fast_clipped_poly;
 694       } else {
 695          tnl->Driver.Render.PrimTabVerts = _tnl_render_tab_verts;
 696          tnl->Driver.Render.PrimTabElts = _tnl_render_tab_elts;
 697          tnl->Driver.Render.ClippedPolygon = _tnl_RenderClippedPolygon;
 698       }
 699    }
 700 }
 701
 702 /**********************************************************************/
 703 /*                Multipass rendering for front buffering             */
 704 /**********************************************************************/
 705 static GLboolean multipass_cliprect( GLcontext *ctx, GLuint pass )
 706 {
 707    sisContextPtr smesa = SIS_CONTEXT( ctx );
 708
 709    if (pass >= smesa->driDrawable->numClipRects) {
 710       return GL_FALSE;
 711    } else {
 712       GLint x1, y1, x2, y2;
 713
 714       x1 = smesa->driDrawable->pClipRects[pass].x1 - smesa->driDrawable->x;
 715       y1 = smesa->driDrawable->pClipRects[pass].y1 - smesa->driDrawable->y;
 716       x2 = smesa->driDrawable->pClipRects[pass].x2 - smesa->driDrawable->x;
 717       y2 = smesa->driDrawable->pClipRects[pass].y2 - smesa->driDrawable->y;
 718
 719       if (ctx->Scissor.Enabled) {
 720          GLint scisy1 = Y_FLIP(ctx->Scissor.Y + ctx->Scissor.Height - 1);
 721          GLint scisy2 = Y_FLIP(ctx->Scissor.Y);
 722
 723          if (ctx->Scissor.X > x1)
 724             x1 = ctx->Scissor.X;
 725          if (scisy1 > y1)
 726             y1 = scisy1;
 727          if (ctx->Scissor.X + ctx->Scissor.Width - 1 < x2)
 728             x2 = ctx->Scissor.X + ctx->Scissor.Width - 1;
 729          if (scisy2 < y2)
 730             y2 = scisy2;
 731       }
 732
 733       MMIO(REG_3D_ClipTopBottom, y1 << 13 | y2);
 734       MMIO(REG_3D_ClipLeftRight, x1 << 13 | x2);
 735       /* Mark that we clobbered these registers */
 736       smesa->GlobalFlag |= GFLAG_CLIPPING;
 737       return GL_TRUE;
 738    }
 739 }
 740
 741
 742
 743 /**********************************************************************/
 744 /*                 Validate state at pipeline start                   */
 745 /**********************************************************************/
 746
 747 static void sisRunPipeline( GLcontext *ctx )
 748 {
 749    sisContextPtr smesa = SIS_CONTEXT( ctx );
 750
 751    if (smesa->NewGLState) {
 752       SIS_FIREVERTICES(smesa);
 753       if (smesa->NewGLState & _NEW_TEXTURE) {
 754          sisUpdateTextureState(ctx);
 755       }
 756
 757       if (smesa->NewGLState & _SIS_NEW_RENDER_STATE)
 758          sisChooseRenderState( ctx );
 759
 760       smesa->NewGLState = 0;
 761    }
 762
 763    _tnl_run_pipeline( ctx );
 764
 765    /* XXX: If we put flushing in sis_state.c and friends, we can avoid this.
 766     * Is it worth it?
 767     */
 768    SIS_FIREVERTICES(smesa);
 769 }
 770
 771 /**********************************************************************/
 772 /*                 High level hooks for t_vb_render.c                 */
 773 /**********************************************************************/
 774
 775 /* This is called when Mesa switches between rendering triangle
 776  * primitives (such as GL_POLYGON, GL_QUADS, GL_TRIANGLE_STRIP, etc),
 777  * and lines, points and bitmaps.
 778  */
 779
 780 static void sisRasterPrimitive( GLcontext *ctx, GLuint hwprim )
 781 {
 782    sisContextPtr smesa = SIS_CONTEXT(ctx);
 783    if (smesa->hw_primitive != hwprim) {
 784       SIS_FIREVERTICES(smesa);
 785       smesa->hw_primitive = hwprim;
 786
 787       smesa->AGPParseSet &= ~(MASK_PsDataType | MASK_PsShadingMode);
 788       smesa->AGPParseSet |= hw_prim_agp_type[hwprim];
 789
 790       if (smesa->is6326) {
 791          smesa->dwPrimitiveSet &= ~(MASK_6326_DrawPrimitiveCommand |
 792             MASK_6326_SetFirePosition | MASK_6326_ShadingMode);
 793          smesa->dwPrimitiveSet |= hwprim | hw_prim_6326_mmio_fire[hwprim];
 794       } else {
 795          smesa->dwPrimitiveSet &= ~(MASK_DrawPrimitiveCommand |
 796             MASK_SetFirePosition | MASK_ShadingMode);
 797          smesa->dwPrimitiveSet |= hwprim | hw_prim_mmio_fire[hwprim];
 798       }
 799
 800       if (ctx->Light.ShadeModel == GL_FLAT) {
 801          smesa->AGPParseSet |= hw_prim_agp_shade[hwprim];
 802          smesa->dwPrimitiveSet |= hw_prim_mmio_shade[hwprim];
 803       } else {
 804          smesa->AGPParseSet |= MASK_PsShadingSmooth;
 805          if (smesa->is6326) {
 806             smesa->dwPrimitiveSet |= OP_6326_3D_SHADE_FLAT_GOURAUD;
 807          } else {
 808             smesa->dwPrimitiveSet |= SHADE_GOURAUD;
 809          }
 810       }
 811    }
 812 }
 813
 814 static void sisRenderPrimitive( GLcontext *ctx, GLenum prim )
 815 {
 816    sisContextPtr smesa = SIS_CONTEXT(ctx);
 817
 818    smesa->render_primitive = prim;
 819
 820    if (prim >= GL_TRIANGLES && (ctx->_TriangleCaps & DD_TRI_UNFILLED))
 821       return;
 822    sisRasterPrimitive( ctx, hw_prim[prim] );
 823 }
 824
 825 #define EMIT_ATTR( ATTR, STYLE)                                         \
 826 do {                                                                    \
 827    smesa->vertex_attrs[smesa->vertex_attr_count].attrib = (ATTR);       \
 828    smesa->vertex_attrs[smesa->vertex_attr_count].format = (STYLE);      \
 829    smesa->vertex_attr_count++;                                          \
 830 } while (0)
 831
 832 #define EMIT_PAD( N )                                                   \
 833 do {                                                                    \
 834    smesa->vertex_attrs[smesa->vertex_attr_count].attrib = 0;            \
 835    smesa->vertex_attrs[smesa->vertex_attr_count].format = EMIT_PAD;     \
 836    smesa->vertex_attrs[smesa->vertex_attr_count].offset = (N);          \
 837    smesa->vertex_attr_count++;                                          \
 838 } while (0)
 839
 840 static void sisRenderStart( GLcontext *ctx )
 841 {
 842    TNLcontext *tnl = TNL_CONTEXT(ctx);
 843    sisContextPtr smesa = SIS_CONTEXT(ctx);
 844    struct vertex_buffer *VB = &tnl->vb;
 845    DECLARE_RENDERINPUTS(index_bitset);
 846    GLuint AGPParseSet = smesa->AGPParseSet;
 847    GLboolean tex_fallback = GL_FALSE;
 848
 849    RENDERINPUTS_COPY( index_bitset, tnl->render_inputs_bitset );
 850
 851    if (ctx->DrawBuffer->_ColorDrawBufferIndexes[0] == BUFFER_FRONT_LEFT &&
 852       smesa->driDrawable->numClipRects != 0)
 853    {
 854       multipass_cliprect(ctx, 0);
 855       if (smesa->driDrawable->numClipRects > 1)
 856          tnl->Driver.Render.Multipass = multipass_cliprect;
 857       else
 858          tnl->Driver.Render.Multipass = NULL;
 859    } else {
 860       tnl->Driver.Render.Multipass = NULL;
 861    }
 862
 863    /* Important:
 864     */
 865    VB->AttribPtr[VERT_ATTRIB_POS] = VB->NdcPtr;
 866    smesa->vertex_attr_count = 0;
 867
 868    /* EMIT_ATTR's must be in order as they tell t_vertex.c how to build up a
 869     * hardware vertex.
 870     */
 871
 872    AGPParseSet &= ~(MASK_VertexDWSize | MASK_VertexDataFormat);
 873    AGPParseSet |= SiS_PS_HAS_XYZ | SiS_PS_HAS_DIFFUSE;
 874    if (RENDERINPUTS_TEST_RANGE( index_bitset, _TNL_FIRST_TEX, _TNL_LAST_TEX )) {
 875       EMIT_ATTR(_TNL_ATTRIB_POS, EMIT_4F_VIEWPORT);
 876       AGPParseSet |= SiS_PS_HAS_W;
 877       smesa->coloroffset = 4;
 878    } else {
 879       EMIT_ATTR(_TNL_ATTRIB_POS, EMIT_3F_VIEWPORT);
 880       smesa->coloroffset = 3;
 881    }
 882
 883    EMIT_ATTR(_TNL_ATTRIB_COLOR0, EMIT_4UB_4F_BGRA);
 884
 885    smesa->specoffset = 0;
 886    if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_COLOR1 ) ||
 887        RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_FOG )) {
 888       AGPParseSet |= SiS_PS_HAS_SPECULAR;
 889
 890       if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_COLOR1 )) {
 891          EMIT_ATTR(_TNL_ATTRIB_COLOR1, EMIT_3UB_3F_BGR);
 892          smesa->specoffset = smesa->coloroffset + 1;
 893       } else {
 894          EMIT_PAD(3);
 895       }
 896
 897       if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_FOG )) {
 898          EMIT_ATTR(_TNL_ATTRIB_FOG, EMIT_1UB_1F);
 899       } else {
 900          EMIT_PAD(1);
 901       }
 902    }
 903
 904    /* projective textures are not supported by the hardware */
 905    if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_TEX0 )) {
 906       if (VB->AttribPtr[_TNL_ATTRIB_TEX0]->size > 2)
 907          tex_fallback = GL_TRUE;
 908       EMIT_ATTR(_TNL_ATTRIB_TEX0, EMIT_2F);
 909       AGPParseSet |= SiS_PS_HAS_UV0;
 910    }
 911    /* Will only hit tex1 on SiS300 */
 912    if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_TEX1 )) {
 913       if (VB->AttribPtr[_TNL_ATTRIB_TEX1]->size > 2)
 914          tex_fallback = GL_TRUE;
 915       EMIT_ATTR(_TNL_ATTRIB_TEX1, EMIT_2F);
 916       AGPParseSet |= SiS_PS_HAS_UV1;
 917    }
 918    FALLBACK(smesa, SIS_FALLBACK_TEXTURE, tex_fallback);
 919
 920    if (!RENDERINPUTS_EQUAL( smesa->last_tcl_state_bitset, index_bitset )) {
 921       smesa->AGPParseSet = AGPParseSet;
 922
 923       smesa->vertex_size =  _tnl_install_attrs( ctx, smesa->vertex_attrs,
 924          smesa->vertex_attr_count, smesa->hw_viewport, 0 );
 925
 926       smesa->vertex_size >>= 2;
 927       smesa->AGPParseSet |= smesa->vertex_size << 28;
 928    }
 929 }
 930
 931 static void sisRenderFinish( GLcontext *ctx )
 932 {
 933 }
 934
 935 /**********************************************************************/
 936 /*                    AGP/PCI vertex submission                       */
 937 /**********************************************************************/
 938
 939 void
 940 sisFlushPrimsLocked(sisContextPtr smesa)
 941 {
 942    if (smesa->vb_cur == smesa->vb_last)
 943       return;
 944
 945    if (smesa->is6326)
 946       sis6326UpdateHWState(smesa->glCtx);
 947    else
 948       sisUpdateHWState(smesa->glCtx);
 949
 950    if (smesa->using_agp) {
 951       mWait3DCmdQueue(8);
 952       mEndPrimitive();
 953       MMIO(REG_3D_AGPCmBase, (smesa->vb_last - smesa->vb) +
 954          smesa->vb_agp_offset);
 955       MMIO(REG_3D_AGPTtDwNum, ((smesa->vb_cur - smesa->vb_last) / 4) |
 956          0x50000000);
 957       MMIO(REG_3D_ParsingSet, smesa->AGPParseSet);
 958       MMIO(REG_3D_AGPCmFire, (GLint)(-1));
 959       mEndPrimitive();
 960    } else {
 961       int mmio_index = 0, incr = 0;
 962       void (*sis_emit_func)(sisContextPtr smesa, char *verts) = NULL;
 963
 964       if (smesa->AGPParseSet & MASK_PsShadingSmooth)
 965          mmio_index |= VERT_SMOOTH;
 966       if (smesa->AGPParseSet & SiS_PS_HAS_SPECULAR)
 967          mmio_index |= VERT_SPEC;
 968       if (smesa->AGPParseSet & SiS_PS_HAS_W)
 969          mmio_index |= VERT_W;
 970       if (smesa->AGPParseSet & SiS_PS_HAS_UV0)
 971          mmio_index |= VERT_UV0;
 972       if (smesa->AGPParseSet & SiS_PS_HAS_UV1)
 973          mmio_index |= VERT_UV1;
 974       if (smesa->is6326)
 975          mmio_index |= VERT_6326;
 976
 977       switch (smesa->AGPParseSet & MASK_PsDataType) {
 978       case MASK_PsPointList:
 979          incr = smesa->vertex_size * 4;
 980          sis_emit_func = sis_point_func_mmio[mmio_index];
 981          break;
 982       case MASK_PsLineList:
 983          incr = smesa->vertex_size * 4 * 2;
 984          sis_emit_func = sis_line_func_mmio[mmio_index];
 985          break;
 986       case MASK_PsTriangleList:
 987          incr = smesa->vertex_size * 4 * 3;
 988          sis_emit_func = sis_tri_func_mmio[mmio_index];
 989          break;
 990       }
 991
 992       if (!smesa->is6326) {
 993          mWait3DCmdQueue(1);
 994          MMIO(REG_3D_PrimitiveSet, smesa->dwPrimitiveSet);
 995       }
 996       while (smesa->vb_last < smesa->vb_cur) {
 997          sis_emit_func(smesa, (char *)smesa->vb_last);
 998          smesa->vb_last += incr;
 999       }
1000       mWait3DCmdQueue(1);
1001       mEndPrimitive();
1002
1003       /* With PCI, we can just start writing to the start of the VB again. */
1004       smesa->vb_cur = smesa->vb;
1005    }
1006    smesa->vb_last = smesa->vb_cur;
1007 }
1008
1009 void sisFlushPrims(sisContextPtr smesa)
1010 {
1011    LOCK_HARDWARE();
1012    sisFlushPrimsLocked(smesa);
1013    UNLOCK_HARDWARE();
1014 }
1015
1016 /**********************************************************************/
1017 /*           Transition to/from hardware rasterization.               */
1018 /**********************************************************************/
1019
1020 static const char * const fallbackStrings[] = {
1021    "Texture mode",
1022    "Texture 0 mode",
1023    "Texture 1 mode",
1024    "Texture 0 env",     /* Note: unused */
1025    "Texture 1 env",     /* Note: unused */
1026    "glDrawBuffer(GL_FRONT_AND_BACK)",
1027    "glEnable(GL_STENCIL) without hw stencil buffer",
1028    "write mask",
1029    "no_rast",
1030 };
1031
1032 static const char *getFallbackString(GLuint bit)
1033 {
1034    int i = 0;
1035    while (bit > 1) {
1036       i++;
1037       bit >>= 1;
1038    }
1039    return fallbackStrings[i];
1040 }
1041
1042 void sisFallback( GLcontext *ctx, GLuint bit, GLboolean mode )
1043 {
1044    TNLcontext *tnl = TNL_CONTEXT(ctx);
1045    sisContextPtr smesa = SIS_CONTEXT(ctx);
1046    GLuint oldfallback = smesa->Fallback;
1047
1048    if (mode) {
1049       smesa->Fallback |= bit;
1050       if (oldfallback == 0) {
1051          SIS_FIREVERTICES(smesa);
1052          _swsetup_Wakeup( ctx );
1053          smesa->RenderIndex = ~0;
1054          if (SIS_DEBUG & DEBUG_FALLBACKS) {
1055             fprintf(stderr, "SiS begin rasterization fallback: 0x%x %s\n",
1056                     bit, getFallbackString(bit));
1057          }
1058       }
1059    }
1060    else {
1061       smesa->Fallback &= ~bit;
1062       if (oldfallback == bit) {
1063          _swrast_flush( ctx );
1064          tnl->Driver.Render.Start = sisRenderStart;
1065          tnl->Driver.Render.PrimitiveNotify = sisRenderPrimitive;
1066          tnl->Driver.Render.Finish = sisRenderFinish;
1067
1068          tnl->Driver.Render.BuildVertices = _tnl_build_vertices;
1069          tnl->Driver.Render.CopyPV = _tnl_copy_pv;
1070          tnl->Driver.Render.Interp = _tnl_interp;
1071
1072          _tnl_invalidate_vertex_state( ctx, ~0 );
1073          _tnl_invalidate_vertices( ctx, ~0 );
1074          _tnl_install_attrs( ctx,
1075                              smesa->vertex_attrs,
1076                              smesa->vertex_attr_count,
1077                              smesa->hw_viewport, 0 );
1078
1079          smesa->NewGLState |= _SIS_NEW_RENDER_STATE;
1080          if (SIS_DEBUG & DEBUG_FALLBACKS) {
1081             fprintf(stderr, "SiS end rasterization fallback: 0x%x %s\n",
1082                     bit, getFallbackString(bit));
1083          }
1084       }
1085    }
1086 }
1087
1088
1089 /**********************************************************************/
1090 /*                            Initialization.                         */
1091 /**********************************************************************/
1092
1093 void sisInitTriFuncs( GLcontext *ctx )
1094 {
1095    sisContextPtr smesa = SIS_CONTEXT(ctx);
1096    TNLcontext *tnl = TNL_CONTEXT(ctx);
1097    static int firsttime = 1;
1098
1099    if (firsttime) {
1100       init_rast_tab();
1101       firsttime = 0;
1102
1103       sis_vert_init_none();
1104       sis_vert_init_g();
1105       sis_vert_init_w();
1106       sis_vert_init_gw();
1107       sis_vert_init_s();
1108       sis_vert_init_gs();
1109       sis_vert_init_ws();
1110       sis_vert_init_gws();
1111       sis_vert_init_t0();
1112       sis_vert_init_gt0();
1113       sis_vert_init_wt0();
1114       sis_vert_init_gwt0();
1115       sis_vert_init_st0();
1116       sis_vert_init_gst0();
1117       sis_vert_init_wst0();
1118       sis_vert_init_gwst0();
1119       sis_vert_init_t1();
1120       sis_vert_init_gt1();
1121       sis_vert_init_wt1();
1122       sis_vert_init_gwt1();
1123       sis_vert_init_st1();
1124       sis_vert_init_gst1();
1125       sis_vert_init_wst1();
1126       sis_vert_init_gwst1();
1127       sis_vert_init_t0t1();
1128       sis_vert_init_gt0t1();
1129       sis_vert_init_wt0t1();
1130       sis_vert_init_gwt0t1();
1131       sis_vert_init_st0t1();
1132       sis_vert_init_gst0t1();
1133       sis_vert_init_wst0t1();
1134       sis_vert_init_gwst0t1();
1135    }
1136
1137    smesa->RenderIndex = ~0;
1138    smesa->NewGLState |= _SIS_NEW_RENDER_STATE;
1139
1140    tnl->Driver.RunPipeline = sisRunPipeline;
1141    tnl->Driver.Render.Start = sisRenderStart;
1142    tnl->Driver.Render.Finish = sisRenderFinish;
1143    tnl->Driver.Render.PrimitiveNotify = sisRenderPrimitive;
1144    tnl->Driver.Render.ResetLineStipple = _swrast_ResetLineStipple;
1145
1146    tnl->Driver.Render.BuildVertices = _tnl_build_vertices;
1147    tnl->Driver.Render.CopyPV = _tnl_copy_pv;
1148    tnl->Driver.Render.Interp = _tnl_interp;
1149
1150    _tnl_init_vertices( ctx, ctx->Const.MaxArrayLockSize + 12,
1151                        (6 + 2*ctx->Const.MaxTextureUnits) * sizeof(GLfloat) );
1152
1153    smesa->verts = (char *)tnl->clipspace.vertex_buf;
1154 }