src/mesa/drivers/dri/unichrome/via_tris.c

   1 /*
   2  * Copyright 1998-2003 VIA Technologies, Inc. All Rights Reserved.
   3  * Copyright 2001-2003 S3 Graphics, Inc. All Rights Reserved.
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * the rights to use, copy, modify, merge, publish, distribute, sub license,
   9  * and/or sell copies of the Software, and to permit persons to whom the
  10  * Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice (including the
  13  * next paragraph) shall be included in all copies or substantial portions
  14  * of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  19  * VIA, S3 GRAPHICS, AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  20  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  21  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  22  * DEALINGS IN THE SOFTWARE.
  23  */
  24
  25 #include <stdio.h>
  26 #include <math.h>
  27
  28 #include "glheader.h"
  29 #include "context.h"
  30 #include "mtypes.h"
  31 #include "macros.h"
  32 #include "colormac.h"
  33 #include "enums.h"
  34
  35 #include "swrast/swrast.h"
  36 #include "swrast_setup/swrast_setup.h"
  37 #include "tnl/t_context.h"
  38 #include "tnl/t_pipeline.h"
  39
  40 #include "via_context.h"
  41 #include "via_tris.h"
  42 #include "via_state.h"
  43 #include "via_vb.h"
  44 #include "via_ioctl.h"
  45
  46 /***********************************************************************
  47  *                    Emit primitives as inline vertices               *
  48  ***********************************************************************/
  49
  50 #if 0
  51 #define COPY_DWORDS(vb, vertsize, v)                                    \
  52     do {                                                                \
  53         int j;                                                          \
  54         int __tmp;                                                      \
  55         __asm__ __volatile__("rep ; movsl"                              \
  56                               : "=%c" (j), "=D" (vb), "=S" (__tmp)      \
  57                               : "0" (vertsize),                         \
  58                                 "D" ((long)vb),                         \
  59                                 "S" ((long)v));                         \
  60     } while (0)
  61 #else
  62 #define COPY_DWORDS(vb, vertsize, v)            \
  63     do {                                        \
  64         int j;                                  \
  65         for (j = 0; j < vertsize; j++)          \
  66             vb[j] = ((GLuint *)v)[j];           \
  67         vb += vertsize;                         \
  68     } while (0)
  69 #endif
  70
  71 static void __inline__ via_draw_triangle(viaContextPtr vmesa,
  72                                          viaVertexPtr v0,
  73                                          viaVertexPtr v1,
  74                                          viaVertexPtr v2)
  75 {
  76     GLuint vertsize = vmesa->vertexSize;
  77     GLuint *vb = viaAllocDma(vmesa, 3 * 4 * vertsize);
  78 /*     fprintf(stderr, "%s: %p %p %p\n", __FUNCTION__, v0, v1, v2); */
  79     COPY_DWORDS(vb, vertsize, v0);
  80     COPY_DWORDS(vb, vertsize, v1);
  81     COPY_DWORDS(vb, vertsize, v2);
  82 }
  83
  84
  85 static void __inline__ via_draw_quad(viaContextPtr vmesa,
  86                                      viaVertexPtr v0,
  87                                      viaVertexPtr v1,
  88                                      viaVertexPtr v2,
  89                                      viaVertexPtr v3)
  90 {
  91     GLuint vertsize = vmesa->vertexSize;
  92     GLuint *vb = viaAllocDma(vmesa, 6 * 4 * vertsize);
  93
  94 /*     fprintf(stderr, "%s: %p %p %p %p\n", __FUNCTION__, v0, v1, v2, v3); */
  95     COPY_DWORDS(vb, vertsize, v0);
  96     COPY_DWORDS(vb, vertsize, v1);
  97     COPY_DWORDS(vb, vertsize, v3);
  98     COPY_DWORDS(vb, vertsize, v1);
  99     COPY_DWORDS(vb, vertsize, v2);
 100     COPY_DWORDS(vb, vertsize, v3);
 101 }
 102
 103 static __inline__ void via_draw_line(viaContextPtr vmesa,
 104                                      viaVertexPtr v0,
 105                                      viaVertexPtr v1)
 106 {
 107     GLuint vertsize = vmesa->vertexSize;
 108     GLuint *vb = viaAllocDma(vmesa, 2 * 4 * vertsize);
 109     COPY_DWORDS(vb, vertsize, v0);
 110     COPY_DWORDS(vb, vertsize, v1);
 111 }
 112
 113
 114 static __inline__ void via_draw_point(viaContextPtr vmesa,
 115                                       viaVertexPtr v0)
 116 {
 117     GLuint vertsize = vmesa->vertexSize;
 118     GLuint *vb = viaAllocDma(vmesa, 4 * vertsize);
 119     COPY_DWORDS(vb, vertsize, v0);
 120 }
 121
 122
 123
 124
 125 /***********************************************************************
 126  *          Macros for via_dd_tritmp.h to draw basic primitives        *
 127  ***********************************************************************/
 128
 129 #define TRI(a, b, c)                                \
 130     do {                                            \
 131         if (VIA_DEBUG) fprintf(stderr, "hw TRI\n"); \
 132         if (DO_FALLBACK)                            \
 133             vmesa->drawTri(vmesa, a, b, c);         \
 134         else                                        \
 135             via_draw_triangle(vmesa, a, b, c);      \
 136     } while (0)
 137
 138 #define QUAD(a, b, c, d)                            \
 139     do {                                            \
 140         if (VIA_DEBUG) fprintf(stderr, "hw QUAD\n");\
 141         if (DO_FALLBACK) {                          \
 142             vmesa->drawTri(vmesa, a, b, d);         \
 143             vmesa->drawTri(vmesa, b, c, d);         \
 144         }                                           \
 145         else                                        \
 146             via_draw_quad(vmesa, a, b, c, d);       \
 147     } while (0)
 148
 149 #define LINE(v0, v1)                                \
 150     do {                                            \
 151         if(VIA_DEBUG) fprintf(stderr, "hw LINE\n");\
 152         if (DO_FALLBACK)                            \
 153             vmesa->drawLine(vmesa, v0, v1);         \
 154         else                                        \
 155             via_draw_line(vmesa, v0, v1);           \
 156     } while (0)
 157
 158 #define POINT(v0)                                    \
 159     do {                                             \
 160         if (VIA_DEBUG) fprintf(stderr, "hw POINT\n");\
 161         if (DO_FALLBACK)                             \
 162             vmesa->drawPoint(vmesa, v0);             \
 163         else                                         \
 164             via_draw_point(vmesa, v0);               \
 165     } while (0)
 166
 167
 168 /***********************************************************************
 169  *              Build render functions from dd templates               *
 170  ***********************************************************************/
 171
 172 #define VIA_OFFSET_BIT         0x01
 173 #define VIA_TWOSIDE_BIT        0x02
 174 #define VIA_UNFILLED_BIT       0x04
 175 #define VIA_FALLBACK_BIT       0x08
 176 #define VIA_MAX_TRIFUNC        0x10
 177
 178
 179 static struct {
 180     tnl_points_func          points;
 181     tnl_line_func            line;
 182     tnl_triangle_func        triangle;
 183     tnl_quad_func            quad;
 184 } rast_tab[VIA_MAX_TRIFUNC];
 185
 186
 187 #define DO_FALLBACK (IND & VIA_FALLBACK_BIT)
 188 #define DO_OFFSET   (IND & VIA_OFFSET_BIT)
 189 #define DO_UNFILLED (IND & VIA_UNFILLED_BIT)
 190 #define DO_TWOSIDE  (IND & VIA_TWOSIDE_BIT)
 191 #define DO_FLAT      0
 192 #define DO_TRI       1
 193 #define DO_QUAD      1
 194 #define DO_LINE      1
 195 #define DO_POINTS    1
 196 #define DO_FULL_QUAD 1
 197
 198 #define HAVE_RGBA         1
 199 #define HAVE_SPEC         1
 200 #define HAVE_BACK_COLORS  0
 201 #define HAVE_HW_FLATSHADE 1
 202 #define VERTEX            viaVertex
 203 #define TAB               rast_tab
 204
 205 /* Only used to pull back colors into vertices (ie, we know color is
 206  * floating point).
 207  */
 208 #define VIA_COLOR(dst, src)                     \
 209     do {                                        \
 210         dst[0] = src[2];                        \
 211         dst[1] = src[1];                        \
 212         dst[2] = src[0];                        \
 213         dst[3] = src[3];                        \
 214     } while (0)
 215
 216 #define VIA_SPEC(dst, src)                      \
 217     do {                                        \
 218         dst[0] = src[2];                        \
 219         dst[1] = src[1];                        \
 220         dst[2] = src[0];                        \
 221     } while (0)
 222
 223
 224 #define DEPTH_SCALE (1.0 / 0xffff)
 225 #define UNFILLED_TRI unfilled_tri
 226 #define UNFILLED_QUAD unfilled_quad
 227 #define VERT_X(_v) _v->v.x
 228 #define VERT_Y(_v) _v->v.y
 229 #define VERT_Z(_v) _v->v.z
 230 #define AREA_IS_CCW(a) (a > 0)
 231 #define GET_VERTEX(e) (vmesa->verts + (e * vmesa->vertexSize * sizeof(int)))
 232
 233 #define VERT_SET_RGBA( v, c )                                   \
 234 do {                                                            \
 235    via_color_t *color = (via_color_t *)&((v)->ui[coloroffset]); \
 236    UNCLAMPED_FLOAT_TO_UBYTE(color->red, (c)[0]);                \
 237    UNCLAMPED_FLOAT_TO_UBYTE(color->green, (c)[1]);              \
 238    UNCLAMPED_FLOAT_TO_UBYTE(color->blue, (c)[2]);               \
 239    UNCLAMPED_FLOAT_TO_UBYTE(color->alpha, (c)[3]);              \
 240 } while (0)
 241
 242 #define VERT_COPY_RGBA( v0, v1 ) v0->ui[coloroffset] = v1->ui[coloroffset]
 243
 244 #define VERT_SET_SPEC( v0, c )                                  \
 245 do {                                                            \
 246    if (havespec) {                                              \
 247       UNCLAMPED_FLOAT_TO_UBYTE(v0->v.specular.red, (c)[0]);     \
 248       UNCLAMPED_FLOAT_TO_UBYTE(v0->v.specular.green, (c)[1]);   \
 249       UNCLAMPED_FLOAT_TO_UBYTE(v0->v.specular.blue, (c)[2]);    \
 250    }                                                            \
 251 } while (0)
 252 #define VERT_COPY_SPEC( v0, v1 )                        \
 253 do {                                                    \
 254    if (havespec) {                                      \
 255       v0->v.specular.red   = v1->v.specular.red;        \
 256       v0->v.specular.green = v1->v.specular.green;      \
 257       v0->v.specular.blue  = v1->v.specular.blue;       \
 258    }                                                    \
 259 } while (0)
 260
 261
 262 #define VERT_SAVE_RGBA( idx )    color[idx] = v[idx]->ui[coloroffset]
 263 #define VERT_RESTORE_RGBA( idx ) v[idx]->ui[coloroffset] = color[idx]
 264 #define VERT_SAVE_SPEC( idx )    if (havespec) spec[idx] = v[idx]->ui[5]
 265 #define VERT_RESTORE_SPEC( idx ) if (havespec) v[idx]->ui[5] = spec[idx]
 266
 267
 268 #define LOCAL_VARS(n)                                                   \
 269     viaContextPtr vmesa = VIA_CONTEXT(ctx);                             \
 270     GLuint color[n], spec[n];                                           \
 271     GLuint coloroffset = (vmesa->vertexSize == 4 ? 3 : 4);              \
 272     GLboolean havespec = (vmesa->vertexSize > 4);                       \
 273     (void)color; (void)spec; (void)coloroffset; (void)havespec;
 274
 275
 276 /***********************************************************************
 277  *                Helpers for rendering unfilled primitives            *
 278  ***********************************************************************/
 279
 280 static const GLenum hwPrim[GL_POLYGON + 1] = {
 281     GL_POINTS,
 282     GL_LINES,
 283     GL_LINES,
 284     GL_LINES,
 285     GL_TRIANGLES,
 286     GL_TRIANGLES,
 287     GL_TRIANGLES,
 288     GL_TRIANGLES,
 289     GL_TRIANGLES,
 290     GL_TRIANGLES
 291 };
 292
 293
 294 #define RASTERIZE(x) viaRasterPrimitive( ctx, x, hwPrim[x] )
 295 #define RENDER_PRIMITIVE vmesa->renderPrimitive
 296 #define TAG(x) x
 297 #define IND VIA_FALLBACK_BIT
 298 #include "tnl_dd/t_dd_unfilled.h"
 299 #undef IND
 300 #undef RASTERIZE
 301
 302 /***********************************************************************
 303  *                      Generate GL render functions                   *
 304  ***********************************************************************/
 305 #define RASTERIZE(x)
 306
 307 #define IND (0)
 308 #define TAG(x) x
 309 #include "tnl_dd/t_dd_tritmp.h"
 310
 311 #define IND (VIA_OFFSET_BIT)
 312 #define TAG(x) x##_offset
 313 #include "tnl_dd/t_dd_tritmp.h"
 314
 315 #define IND (VIA_TWOSIDE_BIT)
 316 #define TAG(x) x##_twoside
 317 #include "tnl_dd/t_dd_tritmp.h"
 318
 319 #define IND (VIA_TWOSIDE_BIT|VIA_OFFSET_BIT)
 320 #define TAG(x) x##_twoside_offset
 321 #include "tnl_dd/t_dd_tritmp.h"
 322
 323 #define IND (VIA_UNFILLED_BIT)
 324 #define TAG(x) x##_unfilled
 325 #include "tnl_dd/t_dd_tritmp.h"
 326
 327 #define IND (VIA_OFFSET_BIT|VIA_UNFILLED_BIT)
 328 #define TAG(x) x##_offset_unfilled
 329 #include "tnl_dd/t_dd_tritmp.h"
 330
 331 #define IND (VIA_TWOSIDE_BIT|VIA_UNFILLED_BIT)
 332 #define TAG(x) x##_twoside_unfilled
 333 #include "tnl_dd/t_dd_tritmp.h"
 334
 335 #define IND (VIA_TWOSIDE_BIT|VIA_OFFSET_BIT|VIA_UNFILLED_BIT)
 336 #define TAG(x) x##_twoside_offset_unfilled
 337 #include "tnl_dd/t_dd_tritmp.h"
 338
 339 #define IND (VIA_FALLBACK_BIT)
 340 #define TAG(x) x##_fallback
 341 #include "tnl_dd/t_dd_tritmp.h"
 342
 343 #define IND (VIA_OFFSET_BIT|VIA_FALLBACK_BIT)
 344 #define TAG(x) x##_offset_fallback
 345 #include "tnl_dd/t_dd_tritmp.h"
 346
 347 #define IND (VIA_TWOSIDE_BIT|VIA_FALLBACK_BIT)
 348 #define TAG(x) x##_twoside_fallback
 349 #include "tnl_dd/t_dd_tritmp.h"
 350
 351 #define IND (VIA_TWOSIDE_BIT|VIA_OFFSET_BIT|VIA_FALLBACK_BIT)
 352 #define TAG(x) x##_twoside_offset_fallback
 353 #include "tnl_dd/t_dd_tritmp.h"
 354
 355 #define IND (VIA_UNFILLED_BIT|VIA_FALLBACK_BIT)
 356 #define TAG(x) x##_unfilled_fallback
 357 #include "tnl_dd/t_dd_tritmp.h"
 358
 359 #define IND (VIA_OFFSET_BIT|VIA_UNFILLED_BIT|VIA_FALLBACK_BIT)
 360 #define TAG(x) x##_offset_unfilled_fallback
 361 #include "tnl_dd/t_dd_tritmp.h"
 362
 363 #define IND (VIA_TWOSIDE_BIT|VIA_UNFILLED_BIT|VIA_FALLBACK_BIT)
 364 #define TAG(x) x##_twoside_unfilled_fallback
 365 #include "tnl_dd/t_dd_tritmp.h"
 366
 367 #define IND (VIA_TWOSIDE_BIT|VIA_OFFSET_BIT|VIA_UNFILLED_BIT| \
 368              VIA_FALLBACK_BIT)
 369 #define TAG(x) x##_twoside_offset_unfilled_fallback
 370 #include "tnl_dd/t_dd_tritmp.h"
 371
 372
 373 static void init_rast_tab(void)
 374 {
 375     init();
 376     init_offset();
 377     init_twoside();
 378     init_twoside_offset();
 379     init_unfilled();
 380     init_offset_unfilled();
 381     init_twoside_unfilled();
 382     init_twoside_offset_unfilled();
 383     init_fallback();
 384     init_offset_fallback();
 385     init_twoside_fallback();
 386     init_twoside_offset_fallback();
 387     init_unfilled_fallback();
 388     init_offset_unfilled_fallback();
 389     init_twoside_unfilled_fallback();
 390     init_twoside_offset_unfilled_fallback();
 391 }
 392
 393
 394 /***********************************************************************
 395  *                    Rasterization fallback helpers                   *
 396  ***********************************************************************/
 397
 398
 399 /* This code is hit only when a mix of accelerated and unaccelerated
 400  * primitives are being drawn, and only for the unaccelerated
 401  * primitives.
 402  */
 403 static void
 404 via_fallback_tri(viaContextPtr vmesa,
 405                  viaVertex *v0,
 406                  viaVertex *v1,
 407                  viaVertex *v2)
 408 {
 409     GLcontext *ctx = vmesa->glCtx;
 410     SWvertex v[3];
 411     via_translate_vertex(ctx, v0, &v[0]);
 412     via_translate_vertex(ctx, v1, &v[1]);
 413     via_translate_vertex(ctx, v2, &v[2]);
 414     viaSpanRenderStart( ctx );
 415     _swrast_Triangle(ctx, &v[0], &v[1], &v[2]);
 416     viaSpanRenderFinish( ctx );
 417 }
 418
 419
 420 static void
 421 via_fallback_line(viaContextPtr vmesa,
 422                   viaVertex *v0,
 423                   viaVertex *v1)
 424 {
 425     GLcontext *ctx = vmesa->glCtx;
 426     SWvertex v[2];
 427     via_translate_vertex(ctx, v0, &v[0]);
 428     via_translate_vertex(ctx, v1, &v[1]);
 429     viaSpanRenderStart( ctx );
 430     _swrast_Line(ctx, &v[0], &v[1]);
 431     viaSpanRenderFinish( ctx );
 432 }
 433
 434
 435 static void
 436 via_fallback_point(viaContextPtr vmesa,
 437                    viaVertex *v0)
 438 {
 439     GLcontext *ctx = vmesa->glCtx;
 440     SWvertex v[1];
 441     via_translate_vertex(ctx, v0, &v[0]);
 442     viaSpanRenderStart( ctx );
 443     _swrast_Point(ctx, &v[0]);
 444     viaSpanRenderFinish( ctx );
 445 }
 446
 447 /**********************************************************************/
 448 /*               Render unclipped begin/end objects                   */
 449 /**********************************************************************/
 450 #define IND 0
 451 #define V(x) (viaVertex *)(vertptr + ((x) * vertsize * sizeof(int)))
 452 #define RENDER_POINTS(start, count)   \
 453     for (; start < count; start++) POINT(V(ELT(start)));
 454 #define RENDER_LINE(v0, v1)         LINE(V(v0), V(v1))
 455 #define RENDER_TRI( v0, v1, v2)     TRI( V(v0), V(v1), V(v2))
 456 #define RENDER_QUAD(v0, v1, v2, v3) QUAD(V(v0), V(v1), V(v2), V(v3))
 457 #define INIT(x) viaRasterPrimitive(ctx, x, hwPrim[x])
 458 #undef LOCAL_VARS
 459 #define LOCAL_VARS                                              \
 460     viaContextPtr vmesa = VIA_CONTEXT(ctx);                     \
 461     GLubyte *vertptr = (GLubyte *)vmesa->verts;                 \
 462     const GLuint vertsize = vmesa->vertexSize;          \
 463     const GLuint * const elt = TNL_CONTEXT(ctx)->vb.Elts;       \
 464     (void)elt;
 465 #define RESET_STIPPLE
 466 #define RESET_OCCLUSION
 467 #define PRESERVE_VB_DEFS
 468 #define ELT(x) x
 469 #define TAG(x) via_fast##x##_verts
 470 #include "tnl/t_vb_rendertmp.h"
 471 #undef ELT
 472 #undef TAG
 473 #define TAG(x) via_fast##x##_elts
 474 #define ELT(x) elt[x]
 475 #include "tnl/t_vb_rendertmp.h"
 476 #undef ELT
 477 #undef TAG
 478 #undef NEED_EDGEFLAG_SETUP
 479 #undef EDGEFLAG_GET
 480 #undef EDGEFLAG_SET
 481 #undef RESET_OCCLUSION
 482
 483
 484 /**********************************************************************/
 485 /*                   Render clipped primitives                        */
 486 /**********************************************************************/
 487
 488
 489
 490 static void viaRenderClippedPoly(GLcontext *ctx, const GLuint *elts,
 491                                  GLuint n)
 492 {
 493     TNLcontext *tnl = TNL_CONTEXT(ctx);
 494     struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
 495     GLuint prim = VIA_CONTEXT(ctx)->renderPrimitive;
 496
 497     /* Render the new vertices as an unclipped polygon.
 498      */
 499     {
 500         GLuint *tmp = VB->Elts;
 501         VB->Elts = (GLuint *)elts;
 502         tnl->Driver.Render.PrimTabElts[GL_POLYGON](ctx, 0, n,
 503                                                    PRIM_BEGIN|PRIM_END);
 504         VB->Elts = tmp;
 505     }
 506
 507     /* Restore the render primitive
 508      */
 509     if (prim != GL_POLYGON)
 510        tnl->Driver.Render.PrimitiveNotify( ctx, prim );
 511 }
 512
 513 static void viaRenderClippedLine(GLcontext *ctx, GLuint ii, GLuint jj)
 514 {
 515     TNLcontext *tnl = TNL_CONTEXT(ctx);
 516     tnl->Driver.Render.Line(ctx, ii, jj);
 517 }
 518
 519 static void viaFastRenderClippedPoly(GLcontext *ctx, const GLuint *elts,
 520                                      GLuint n)
 521 {
 522     viaContextPtr vmesa = VIA_CONTEXT(ctx);
 523     GLuint vertsize = vmesa->vertexSize;
 524     GLuint *vb = viaAllocDma(vmesa, (n - 2) * 3 * 4 * vertsize);
 525     GLubyte *vertptr = (GLubyte *)vmesa->verts;
 526     const GLuint *start = (const GLuint *)V(elts[0]);
 527     int i;
 528
 529     for (i = 2; i < n; i++) {
 530         COPY_DWORDS(vb, vertsize, V(elts[i - 1]));
 531         COPY_DWORDS(vb, vertsize, V(elts[i]));
 532         COPY_DWORDS(vb, vertsize, start);
 533     }
 534 }
 535
 536 /**********************************************************************/
 537 /*                    Choose render functions                         */
 538 /**********************************************************************/
 539
 540
 541
 542 #define _VIA_NEW_RENDERSTATE (_DD_NEW_LINE_STIPPLE |            \
 543                               _DD_NEW_TRI_UNFILLED |            \
 544                               _DD_NEW_TRI_LIGHT_TWOSIDE |       \
 545                               _DD_NEW_TRI_OFFSET |              \
 546                               _DD_NEW_TRI_STIPPLE |             \
 547                               _NEW_POLYGONSTIPPLE)
 548
 549 /* Via does support line stipple in hardware, and it is partially
 550  * working in the older versions of this driver:
 551  */
 552 #define LINE_FALLBACK (DD_LINE_STIPPLE)
 553 #define POINT_FALLBACK (0)
 554 #define TRI_FALLBACK (0)
 555 #define ANY_FALLBACK_FLAGS (POINT_FALLBACK|LINE_FALLBACK|TRI_FALLBACK)
 556 #define ANY_RASTER_FLAGS (DD_TRI_LIGHT_TWOSIDE|DD_TRI_OFFSET|DD_TRI_UNFILLED)
 557
 558 static void viaChooseRenderState(GLcontext *ctx)
 559 {
 560     TNLcontext *tnl = TNL_CONTEXT(ctx);
 561     viaContextPtr vmesa = VIA_CONTEXT(ctx);
 562     GLuint flags = ctx->_TriangleCaps;
 563     GLuint index = 0;
 564     if (VIA_DEBUG) fprintf(stderr, "%s - in\n", __FUNCTION__);
 565
 566     if (VIA_DEBUG) fprintf(stderr, "_TriangleCaps = %x\n", flags);
 567     if (flags & (ANY_FALLBACK_FLAGS|ANY_RASTER_FLAGS)) {
 568         if (flags & ANY_RASTER_FLAGS) {
 569             if (flags & DD_TRI_LIGHT_TWOSIDE)    index |= VIA_TWOSIDE_BIT;
 570             if (flags & DD_TRI_OFFSET)           index |= VIA_OFFSET_BIT;
 571             if (flags & DD_TRI_UNFILLED)         index |= VIA_UNFILLED_BIT;
 572         }
 573
 574         vmesa->drawPoint = via_draw_point;
 575         vmesa->drawLine = via_draw_line;
 576         vmesa->drawTri = via_draw_triangle;
 577
 578         /* Hook in fallbacks for specific primitives.
 579          */
 580         if (flags & ANY_FALLBACK_FLAGS) {
 581             if (flags & POINT_FALLBACK)
 582                 vmesa->drawPoint = via_fallback_point;
 583
 584             if (flags & LINE_FALLBACK)
 585                 vmesa->drawLine = via_fallback_line;
 586
 587             if (flags & TRI_FALLBACK)
 588                 vmesa->drawTri = via_fallback_tri;
 589
 590             index |= VIA_FALLBACK_BIT;
 591         }
 592     }
 593     if (VIA_DEBUG) {
 594         fprintf(stderr, "index = %x\n", index);
 595         fprintf(stderr, "renderIndex = %x\n", vmesa->renderIndex);
 596     }
 597     if (vmesa->renderIndex != index) {
 598         vmesa->renderIndex = index;
 599
 600         tnl->Driver.Render.Points = rast_tab[index].points;
 601         tnl->Driver.Render.Line = rast_tab[index].line;
 602         tnl->Driver.Render.Triangle = rast_tab[index].triangle;
 603
 604         tnl->Driver.Render.Quad = rast_tab[index].quad;
 605
 606         if (index == 0) {
 607             tnl->Driver.Render.PrimTabVerts = via_fastrender_tab_verts;
 608             tnl->Driver.Render.PrimTabElts = via_fastrender_tab_elts;
 609             tnl->Driver.Render.ClippedLine = line; /* from tritmp.h */
 610             tnl->Driver.Render.ClippedPolygon = viaFastRenderClippedPoly;
 611         }
 612         else {
 613             tnl->Driver.Render.PrimTabVerts = _tnl_render_tab_verts;
 614             tnl->Driver.Render.PrimTabElts = _tnl_render_tab_elts;
 615             tnl->Driver.Render.ClippedLine = viaRenderClippedLine;
 616             tnl->Driver.Render.ClippedPolygon = viaRenderClippedPoly;
 617         }
 618     }
 619     if (VIA_DEBUG) fprintf(stderr, "%s - out\n", __FUNCTION__);
 620 }
 621
 622
 623
 624
 625
 626 /**********************************************************************/
 627 /*                 High level hooks for t_vb_render.c                 */
 628 /**********************************************************************/
 629
 630 static void viaRunPipeline(GLcontext *ctx)
 631 {
 632     viaContextPtr vmesa = VIA_CONTEXT(ctx);
 633
 634     if (vmesa->newState) {
 635        viaValidateState( ctx );
 636
 637        if (!vmesa->Fallback) {
 638           viaChooseVertexState(ctx);
 639           viaChooseRenderState(ctx);
 640        }
 641     }
 642
 643     _tnl_run_pipeline(ctx);
 644 }
 645
 646 static void viaRenderStart(GLcontext *ctx)
 647 {
 648     /* Check for projective texturing.  Make sure all texcoord
 649      * pointers point to something.  (fix in mesa?)
 650      */
 651     viaCheckTexSizes(ctx);
 652 }
 653
 654 static void viaRenderFinish(GLcontext *ctx)
 655 {
 656     if (VIA_CONTEXT(ctx)->renderIndex & VIA_FALLBACK_BIT)
 657         _swrast_flush(ctx);
 658     else
 659         VIA_FINISH_PRIM(VIA_CONTEXT(ctx));
 660 }
 661
 662
 663
 664 /* System to flush dma and emit state changes based on the rasterized
 665  * primitive.
 666  */
 667 void viaRasterPrimitive(GLcontext *ctx,
 668                         GLenum glprim,
 669                         GLenum hwprim)
 670 {
 671     viaContextPtr vmesa = VIA_CONTEXT(ctx);
 672     GLuint regCmdB;
 673     RING_VARS;
 674
 675     if (VIA_DEBUG)
 676        fprintf(stderr, "%s: %s/%s\n", __FUNCTION__, _mesa_lookup_enum_by_nr(glprim),
 677                _mesa_lookup_enum_by_nr(hwprim));
 678
 679     VIA_FINISH_PRIM(vmesa);
 680
 681     vmesa->renderPrimitive = glprim;
 682
 683     regCmdB = vmesa->regCmdB;
 684
 685     switch (hwprim) {
 686     case GL_POINTS:
 687         vmesa->regCmdA_End = vmesa->regCmdA | HC_HPMType_Point | HC_HVCycle_Full;
 688         if (ctx->Light.ShadeModel == GL_FLAT)
 689             vmesa->regCmdA_End |= HC_HShading_FlatA;
 690         break;
 691     case GL_LINES:
 692         vmesa->regCmdA_End = vmesa->regCmdA | HC_HPMType_Line | HC_HVCycle_Full;
 693         if (ctx->Light.ShadeModel == GL_FLAT)
 694             vmesa->regCmdA_End |= HC_HShading_FlatB;
 695         break;
 696     case GL_LINE_LOOP:
 697     case GL_LINE_STRIP:
 698         vmesa->regCmdA_End = vmesa->regCmdA | HC_HPMType_Line | HC_HVCycle_AFP |
 699                              HC_HVCycle_AB | HC_HVCycle_NewB;
 700         regCmdB |= HC_HVCycle_AB | HC_HVCycle_NewB | HC_HLPrst_MASK;
 701         if (ctx->Light.ShadeModel == GL_FLAT)
 702             vmesa->regCmdA_End |= HC_HShading_FlatB;
 703         break;
 704     case GL_TRIANGLES:
 705         vmesa->regCmdA_End = vmesa->regCmdA | HC_HPMType_Tri | HC_HVCycle_Full;
 706         if (ctx->Light.ShadeModel == GL_FLAT)
 707             vmesa->regCmdA_End |= HC_HShading_FlatC;
 708         break;
 709     case GL_TRIANGLE_STRIP:
 710         vmesa->regCmdA_End = vmesa->regCmdA | HC_HPMType_Tri | HC_HVCycle_AFP |
 711                              HC_HVCycle_AC | HC_HVCycle_BB | HC_HVCycle_NewC;
 712         regCmdB |= HC_HVCycle_AA | HC_HVCycle_BC | HC_HVCycle_NewC;
 713         if (ctx->Light.ShadeModel == GL_FLAT)
 714             vmesa->regCmdA_End |= HC_HShading_FlatB;
 715         break;
 716     case GL_TRIANGLE_FAN:
 717         vmesa->regCmdA_End = vmesa->regCmdA | HC_HPMType_Tri | HC_HVCycle_AFP |
 718                              HC_HVCycle_AA | HC_HVCycle_BC | HC_HVCycle_NewC;
 719         regCmdB |= HC_HVCycle_AA | HC_HVCycle_BC | HC_HVCycle_NewC;
 720         if (ctx->Light.ShadeModel == GL_FLAT)
 721             vmesa->regCmdA_End |= HC_HShading_FlatC;
 722         break;
 723     case GL_QUADS:
 724         abort();
 725         return;
 726     case GL_QUAD_STRIP:
 727         abort();
 728         return;
 729     case GL_POLYGON:
 730         vmesa->regCmdA_End = vmesa->regCmdA | HC_HPMType_Tri | HC_HVCycle_AFP |
 731                              HC_HVCycle_AA | HC_HVCycle_BC | HC_HVCycle_NewC;
 732         regCmdB |= HC_HVCycle_AA | HC_HVCycle_BC | HC_HVCycle_NewC;
 733         if (ctx->Light.ShadeModel == GL_FLAT)
 734             vmesa->regCmdA_End |= HC_HShading_FlatC;
 735         break;
 736     default:
 737         abort();
 738         return;
 739     }
 740
 741     assert((vmesa->dmaLow & 0x4) == 0);
 742
 743     BEGIN_RING(8);
 744     OUT_RING( HC_HEADER2 );
 745     OUT_RING( (HC_ParaType_NotTex << 16) );
 746     OUT_RING( 0xCCCCCCCC );
 747     OUT_RING( 0xDDDDDDDD );
 748
 749     OUT_RING( HC_HEADER2 );
 750     OUT_RING( (HC_ParaType_CmdVdata << 16) );
 751     OUT_RING( regCmdB );
 752     OUT_RING( vmesa->regCmdA_End );
 753     ADVANCE_RING();
 754
 755     vmesa->dmaLastPrim = vmesa->dmaLow;
 756     vmesa->hwPrimitive = hwprim;
 757 }
 758
 759 /* Callback for mesa:
 760  */
 761 static void viaRenderPrimitive( GLcontext *ctx, GLuint prim )
 762 {
 763    viaRasterPrimitive( ctx, prim, hwPrim[prim] );
 764 }
 765
 766
 767 void viaFinishPrimitive(viaContextPtr vmesa)
 768 {
 769     if (!vmesa->dmaLastPrim) {
 770        return;
 771     }
 772     else if (vmesa->dmaLow != vmesa->dmaLastPrim) {
 773         GLuint cmdA = vmesa->regCmdA_End | HC_HPLEND_MASK | HC_HPMValidN_MASK | HC_HE3Fire_MASK;
 774         RING_VARS;
 775
 776         /* KW: modified 0x1 to 0x4 below:
 777          */
 778         if ((vmesa->dmaLow & 0x1) || !vmesa->useAgp) {
 779            BEGIN_RING_NOCHECK( 1 );
 780            OUT_RING( cmdA );
 781            ADVANCE_RING();
 782         }
 783         else {
 784            BEGIN_RING_NOCHECK( 2 );
 785            OUT_RING( cmdA );
 786            OUT_RING( cmdA );
 787            ADVANCE_RING();
 788         }
 789         vmesa->dmaLastPrim = 0;
 790
 791         if (1 || vmesa->dmaLow > VIA_DMA_HIGHWATER)
 792            viaFlushPrims( vmesa );
 793     }
 794     else {
 795        assert(vmesa->dmaLow >= (32 + DMA_OFFSET));
 796        vmesa->dmaLow -= 32;
 797        vmesa->dmaLastPrim = 0;
 798     }
 799 }
 800
 801
 802 /**********************************************************************/
 803 /*           Transition to/from hardware rasterization.               */
 804 /**********************************************************************/
 805
 806
 807 void viaFallback(viaContextPtr vmesa, GLuint bit, GLboolean mode)
 808 {
 809     GLcontext *ctx = vmesa->glCtx;
 810     TNLcontext *tnl = TNL_CONTEXT(ctx);
 811     GLuint oldfallback = vmesa->Fallback;
 812     if (VIA_DEBUG) fprintf(stderr, "%s old %x bit %x mode %d\n", __FUNCTION__,
 813                    vmesa->Fallback, bit, mode);
 814
 815     if (mode) {
 816         vmesa->Fallback |= bit;
 817         if (oldfallback == 0) {
 818             if (VIA_DEBUG) fprintf(stderr, "ENTER FALLBACK\n");
 819             VIA_FLUSH_DMA(vmesa);
 820             _swsetup_Wakeup(ctx);
 821             vmesa->renderIndex = ~0;
 822         }
 823     }
 824     else {
 825         vmesa->Fallback &= ~bit;
 826         if (oldfallback == bit) {
 827             if (VIA_DEBUG) fprintf(stderr, "LEAVE FALLBACK\n");
 828             tnl->Driver.Render.Start = viaRenderStart;
 829             tnl->Driver.Render.PrimitiveNotify = viaRenderPrimitive;
 830             tnl->Driver.Render.Finish = viaRenderFinish;
 831             tnl->Driver.Render.BuildVertices = viaBuildVertices;
 832             vmesa->newState |= (_VIA_NEW_RENDERSTATE|_VIA_NEW_VERTEX);
 833         }
 834     }
 835
 836 }
 837
 838
 839 /**********************************************************************/
 840 /*                            Initialization.                         */
 841 /**********************************************************************/
 842
 843
 844 void viaInitTriFuncs(GLcontext *ctx)
 845 {
 846     TNLcontext *tnl = TNL_CONTEXT(ctx);
 847     static int firsttime = 1;
 848
 849     if (firsttime) {
 850         init_rast_tab();
 851         firsttime = 0;
 852     }
 853
 854     tnl->Driver.RunPipeline = viaRunPipeline;
 855     tnl->Driver.Render.Start = viaRenderStart;
 856     tnl->Driver.Render.Finish = viaRenderFinish;
 857     tnl->Driver.Render.PrimitiveNotify = viaRenderPrimitive;
 858     tnl->Driver.Render.ResetLineStipple = _swrast_ResetLineStipple;
 859     tnl->Driver.Render.BuildVertices = viaBuildVertices;
 860 }