src/mesa/drivers/dri/r300/r300_swtcl.c

   1 /**************************************************************************
   2
   3 Copyright (C) 2007 Dave Airlie
   4
   5 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 on the rights to use, copy, modify, merge, publish, distribute, sub
  11 license, and/or sell copies of the Software, and to permit persons to whom
  12 the Software is furnished to do so, subject to the following conditions:
  13
  14 The above copyright notice and this permission notice (including the next
  15 paragraph) shall be included in all copies or substantial portions of the
  16 Software.
  17
  18 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  19 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20 FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  21 THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
  22 DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  23 OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  24 USE OR OTHER DEALINGS IN THE SOFTWARE.
  25
  26 **************************************************************************/
  27
  28 /*
  29  * Authors:
  30  *   Dave Airlie <airlied@linux.ie>
  31  */
  32
  33 /* derived from r200 swtcl path */
  34
  35
  36
  37 #include "main/glheader.h"
  38 #include "main/mtypes.h"
  39 #include "main/colormac.h"
  40 #include "main/enums.h"
  41 #include "main/image.h"
  42 #include "main/imports.h"
  43 #include "main/light.h"
  44 #include "main/macros.h"
  45
  46 #include "swrast/s_context.h"
  47 #include "swrast/s_fog.h"
  48 #include "swrast_setup/swrast_setup.h"
  49 #include "math/m_translate.h"
  50 #include "tnl/tnl.h"
  51 #include "tnl/t_context.h"
  52 #include "tnl/t_pipeline.h"
  53
  54 #include "r300_context.h"
  55 #include "r300_swtcl.h"
  56 #include "r300_state.h"
  57 #include "r300_ioctl.h"
  58 #include "r300_emit.h"
  59 #include "r300_mem.h"
  60
  61 static void flush_last_swtcl_prim( r300ContextPtr rmesa  );
  62
  63
  64 void r300EmitVertexAOS(r300ContextPtr rmesa, GLuint vertex_size, GLuint offset);
  65 void r300EmitVbufPrim(r300ContextPtr rmesa, GLuint primitive, GLuint vertex_nr);
  66 #define EMIT_ATTR( ATTR, STYLE )                                        \
  67 do {                                                                    \
  68    rmesa->swtcl.vertex_attrs[rmesa->swtcl.vertex_attr_count].attrib = (ATTR);   \
  69    rmesa->swtcl.vertex_attrs[rmesa->swtcl.vertex_attr_count].format = (STYLE);  \
  70    rmesa->swtcl.vertex_attr_count++;                                    \
  71 } while (0)
  72
  73 #define EMIT_PAD( N )                                                   \
  74 do {                                                                    \
  75    rmesa->swtcl.vertex_attrs[rmesa->swtcl.vertex_attr_count].attrib = 0;                \
  76    rmesa->swtcl.vertex_attrs[rmesa->swtcl.vertex_attr_count].format = EMIT_PAD; \
  77    rmesa->swtcl.vertex_attrs[rmesa->swtcl.vertex_attr_count].offset = (N);              \
  78    rmesa->swtcl.vertex_attr_count++;                                    \
  79 } while (0)
  80
  81 static void r300SetVertexFormat( GLcontext *ctx )
  82 {
  83         r300ContextPtr rmesa = R300_CONTEXT( ctx );
  84         TNLcontext *tnl = TNL_CONTEXT(ctx);
  85         struct vertex_buffer *VB = &tnl->vb;
  86         DECLARE_RENDERINPUTS(index_bitset);
  87         GLuint InputsRead = 0, OutputsWritten = 0;
  88         int vap_fmt_0 = 0;
  89         int vap_vte_cntl = 0;
  90         int offset = 0;
  91         int vte = 0;
  92         GLint inputs[VERT_ATTRIB_MAX];
  93         GLint tab[VERT_ATTRIB_MAX];
  94         int swizzle[VERT_ATTRIB_MAX][4];
  95         GLuint i, nr;
  96         GLuint sz, vap_fmt_1 = 0;
  97
  98         DECLARE_RENDERINPUTS(render_inputs_bitset);
  99         RENDERINPUTS_COPY(render_inputs_bitset, tnl->render_inputs_bitset);
 100         RENDERINPUTS_COPY( index_bitset, tnl->render_inputs_bitset );
 101         RENDERINPUTS_COPY(rmesa->state.render_inputs_bitset, render_inputs_bitset);
 102
 103         vte = rmesa->hw.vte.cmd[1];
 104         vte &= ~(R300_VTX_XY_FMT | R300_VTX_Z_FMT | R300_VTX_W0_FMT);
 105         /* Important:
 106          */
 107         if ( VB->NdcPtr != NULL ) {
 108                 VB->AttribPtr[VERT_ATTRIB_POS] = VB->NdcPtr;
 109                 vte |= R300_VTX_XY_FMT | R300_VTX_Z_FMT;
 110         }
 111         else {
 112                 VB->AttribPtr[VERT_ATTRIB_POS] = VB->ClipPtr;
 113                 vte |= R300_VTX_W0_FMT;
 114         }
 115
 116         assert( VB->AttribPtr[VERT_ATTRIB_POS] != NULL );
 117         rmesa->swtcl.vertex_attr_count = 0;
 118
 119         /* EMIT_ATTR's must be in order as they tell t_vertex.c how to
 120          * build up a hardware vertex.
 121          */
 122         if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_POS)) {
 123                 sz = VB->AttribPtr[VERT_ATTRIB_POS]->size;
 124                 InputsRead |= 1 << VERT_ATTRIB_POS;
 125                 OutputsWritten |= 1 << VERT_RESULT_HPOS;
 126                 EMIT_ATTR( _TNL_ATTRIB_POS, EMIT_1F + sz - 1 );
 127                 offset = sz;
 128         } else {
 129                 offset = 4;
 130                 EMIT_PAD(4 * sizeof(float));
 131         }
 132
 133         if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_POINTSIZE )) {
 134                 EMIT_ATTR( _TNL_ATTRIB_POINTSIZE, EMIT_1F );
 135                 vap_fmt_0 |=  R300_VAP_OUTPUT_VTX_FMT_0__PT_SIZE_PRESENT;
 136                 offset += 1;
 137         }
 138
 139         if (RENDERINPUTS_TEST(index_bitset, _TNL_ATTRIB_COLOR0)) {
 140                 sz = VB->AttribPtr[VERT_ATTRIB_COLOR0]->size;
 141                 rmesa->swtcl.coloroffset = offset;
 142                 InputsRead |= 1 << VERT_ATTRIB_COLOR0;
 143                 OutputsWritten |= 1 << VERT_RESULT_COL0;
 144                 EMIT_ATTR( _TNL_ATTRIB_COLOR0, EMIT_1F + sz - 1 );
 145                 offset += sz;
 146         }
 147
 148         rmesa->swtcl.specoffset = 0;
 149         if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_COLOR1 )) {
 150                 sz = VB->AttribPtr[VERT_ATTRIB_COLOR1]->size;
 151                 rmesa->swtcl.specoffset = offset;
 152                 EMIT_ATTR( _TNL_ATTRIB_COLOR1, EMIT_1F + sz - 1 );
 153                 InputsRead |= 1 << VERT_ATTRIB_COLOR1;
 154                 OutputsWritten |= 1 << VERT_RESULT_COL1;
 155         }
 156
 157         if (RENDERINPUTS_TEST_RANGE( index_bitset, _TNL_FIRST_TEX, _TNL_LAST_TEX )) {
 158                 int i;
 159
 160                 for (i = 0; i < ctx->Const.MaxTextureUnits; i++) {
 161                         if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_TEX(i) )) {
 162                                 sz = VB->TexCoordPtr[i]->size;
 163                                 InputsRead |= 1 << (VERT_ATTRIB_TEX0 + i);
 164                                 OutputsWritten |= 1 << (VERT_RESULT_TEX0 + i);
 165                                 EMIT_ATTR( _TNL_ATTRIB_TEX0+i, EMIT_1F + sz - 1 );
 166                                 vap_fmt_1 |= sz << (3 * i);
 167                         }
 168                 }
 169         }
 170
 171         for (i = 0, nr = 0; i < VERT_ATTRIB_MAX; i++) {
 172                 if (InputsRead & (1 << i)) {
 173                         inputs[i] = nr++;
 174                 } else {
 175                         inputs[i] = -1;
 176                 }
 177         }
 178
 179         /* Fixed, apply to vir0 only */
 180         if (InputsRead & (1 << VERT_ATTRIB_POS))
 181                 inputs[VERT_ATTRIB_POS] = 0;
 182         if (InputsRead & (1 << VERT_ATTRIB_COLOR0))
 183                 inputs[VERT_ATTRIB_COLOR0] = 2;
 184         if (InputsRead & (1 << VERT_ATTRIB_COLOR1))
 185                 inputs[VERT_ATTRIB_COLOR1] = 3;
 186         for (i = VERT_ATTRIB_TEX0; i <= VERT_ATTRIB_TEX7; i++)
 187                 if (InputsRead & (1 << i))
 188                         inputs[i] = 6 + (i - VERT_ATTRIB_TEX0);
 189
 190         for (i = 0, nr = 0; i < VERT_ATTRIB_MAX; i++) {
 191                 if (InputsRead & (1 << i)) {
 192                         tab[nr++] = i;
 193                 }
 194         }
 195
 196         for (i = 0; i < nr; i++) {
 197                 int ci;
 198
 199                 swizzle[i][0] = SWIZZLE_ZERO;
 200                 swizzle[i][1] = SWIZZLE_ZERO;
 201                 swizzle[i][2] = SWIZZLE_ZERO;
 202                 swizzle[i][3] = SWIZZLE_ONE;
 203
 204                 for (ci = 0; ci < VB->AttribPtr[tab[i]]->size; ci++) {
 205                         swizzle[i][ci] = ci;
 206                 }
 207         }
 208
 209         R300_NEWPRIM(rmesa);
 210         R300_STATECHANGE(rmesa, vir[0]);
 211         ((drm_r300_cmd_header_t *) rmesa->hw.vir[0].cmd)->packet0.count =
 212                 r300VAPInputRoute0(&rmesa->hw.vir[0].cmd[R300_VIR_CNTL_0],
 213                                    VB->AttribPtr, inputs, tab, nr);
 214         R300_STATECHANGE(rmesa, vir[1]);
 215         ((drm_r300_cmd_header_t *) rmesa->hw.vir[1].cmd)->packet0.count =
 216                 r300VAPInputRoute1(&rmesa->hw.vir[1].cmd[R300_VIR_CNTL_0], swizzle,
 217                                    nr);
 218
 219         R300_STATECHANGE(rmesa, vic);
 220         rmesa->hw.vic.cmd[R300_VIC_CNTL_0] = r300VAPInputCntl0(ctx, InputsRead);
 221         rmesa->hw.vic.cmd[R300_VIC_CNTL_1] = r300VAPInputCntl1(ctx, InputsRead);
 222
 223         R300_STATECHANGE(rmesa, vof);
 224         rmesa->hw.vof.cmd[R300_VOF_CNTL_0] = r300VAPOutputCntl0(ctx, OutputsWritten);
 225         rmesa->hw.vof.cmd[R300_VOF_CNTL_1] = vap_fmt_1;
 226
 227         rmesa->swtcl.vertex_size =
 228                 _tnl_install_attrs( ctx,
 229                                     rmesa->swtcl.vertex_attrs,
 230                                     rmesa->swtcl.vertex_attr_count,
 231                                     NULL, 0 );
 232
 233         rmesa->swtcl.vertex_size /= 4;
 234
 235         RENDERINPUTS_COPY( rmesa->tnl_index_bitset, index_bitset );
 236
 237
 238         R300_STATECHANGE(rmesa, vte);
 239         rmesa->hw.vte.cmd[1] = vte;
 240         rmesa->hw.vte.cmd[2] = rmesa->swtcl.vertex_size;
 241 }
 242
 243
 244 /* Flush vertices in the current dma region.
 245  */
 246 static void flush_last_swtcl_prim( r300ContextPtr rmesa  )
 247 {
 248         if (RADEON_DEBUG & DEBUG_IOCTL)
 249                 fprintf(stderr, "%s\n", __FUNCTION__);
 250
 251         rmesa->dma.flush = NULL;
 252
 253         if (rmesa->dma.current.buf) {
 254                 struct r300_dma_region *current = &rmesa->dma.current;
 255                 GLuint current_offset = GET_START(current);
 256
 257                 assert (current->start +
 258                         rmesa->swtcl.numverts * rmesa->swtcl.vertex_size * 4 ==
 259                         current->ptr);
 260
 261                 if (rmesa->dma.current.start != rmesa->dma.current.ptr) {
 262
 263                         r300EnsureCmdBufSpace( rmesa, rmesa->hw.max_state_size + (12*sizeof(int)), __FUNCTION__);
 264
 265                         r300EmitState(rmesa);
 266
 267                         r300EmitVertexAOS( rmesa,
 268                                            rmesa->swtcl.vertex_size,
 269                                            current_offset);
 270
 271                         r300EmitVbufPrim( rmesa,
 272                                           rmesa->swtcl.hw_primitive,
 273                                           rmesa->swtcl.numverts);
 274
 275                         r300EmitCacheFlush(rmesa);
 276                 }
 277
 278                 rmesa->swtcl.numverts = 0;
 279                 current->start = current->ptr;
 280         }
 281 }
 282
 283 /* Alloc space in the current dma region.
 284  */
 285 static void *
 286 r300AllocDmaLowVerts( r300ContextPtr rmesa, int nverts, int vsize )
 287 {
 288         GLuint bytes = vsize * nverts;
 289
 290         if ( rmesa->dma.current.ptr + bytes > rmesa->dma.current.end )
 291                 r300RefillCurrentDmaRegion( rmesa, bytes);
 292
 293         if (!rmesa->dma.flush) {
 294                 rmesa->radeon.glCtx->Driver.NeedFlush |= FLUSH_STORED_VERTICES;
 295                 rmesa->dma.flush = flush_last_swtcl_prim;
 296         }
 297
 298         ASSERT( vsize == rmesa->swtcl.vertex_size * 4 );
 299         ASSERT( rmesa->dma.flush == flush_last_swtcl_prim );
 300         ASSERT( rmesa->dma.current.start +
 301                 rmesa->swtcl.numverts * rmesa->swtcl.vertex_size * 4 ==
 302                 rmesa->dma.current.ptr );
 303
 304         {
 305                 GLubyte *head = (GLubyte *) (rmesa->dma.current.address + rmesa->dma.current.ptr);
 306                 rmesa->dma.current.ptr += bytes;
 307                 rmesa->swtcl.numverts += nverts;
 308                 return head;
 309         }
 310 }
 311
 312 static GLuint reduced_prim[] = {
 313   GL_POINTS,
 314   GL_LINES,
 315   GL_LINES,
 316   GL_LINES,
 317   GL_TRIANGLES,
 318   GL_TRIANGLES,
 319   GL_TRIANGLES,
 320   GL_TRIANGLES,
 321   GL_TRIANGLES,
 322   GL_TRIANGLES,
 323 };
 324
 325 static void r300RasterPrimitive( GLcontext *ctx, GLuint prim );
 326 static void r300RenderPrimitive( GLcontext *ctx, GLenum prim );
 327 //static void r300ResetLineStipple( GLcontext *ctx );
 328
 329 /***********************************************************************
 330  *                    Emit primitives as inline vertices               *
 331  ***********************************************************************/
 332
 333
 334 #define HAVE_POINTS      1
 335 #define HAVE_LINES       1
 336 #define HAVE_LINE_STRIPS 1
 337 #define HAVE_TRIANGLES   1
 338 #define HAVE_TRI_STRIPS  1
 339 #define HAVE_TRI_STRIP_1 0
 340 #define HAVE_TRI_FANS    1
 341 #define HAVE_QUADS       0
 342 #define HAVE_QUAD_STRIPS 0
 343 #define HAVE_POLYGONS    1
 344 #define HAVE_ELTS        1
 345
 346 #undef LOCAL_VARS
 347 #undef ALLOC_VERTS
 348 #define CTX_ARG r300ContextPtr rmesa
 349 #define GET_VERTEX_DWORDS() rmesa->swtcl.vertex_size
 350 #define ALLOC_VERTS( n, size ) r300AllocDmaLowVerts( rmesa, n, size * 4 )
 351 #define LOCAL_VARS                                              \
 352    r300ContextPtr rmesa = R300_CONTEXT(ctx);            \
 353    const char *r300verts = (char *)rmesa->swtcl.verts;
 354 #define VERT(x) (r300Vertex *)(r300verts + ((x) * vertsize * sizeof(int)))
 355 #define VERTEX r300Vertex
 356 #define DO_DEBUG_VERTS (1 && (RADEON_DEBUG & DEBUG_VERTS))
 357 #define PRINT_VERTEX(x)
 358 #undef TAG
 359 #define TAG(x) r300_##x
 360 #include "tnl_dd/t_dd_triemit.h"
 361
 362
 363
 364 /***********************************************************************
 365  *          Macros for t_dd_tritmp.h to draw basic primitives          *
 366  ***********************************************************************/
 367
 368 #define QUAD( a, b, c, d ) r300_quad( rmesa, a, b, c, d )
 369 #define TRI( a, b, c )     r300_triangle( rmesa, a, b, c )
 370 #define LINE( a, b )       r300_line( rmesa, a, b )
 371 #define POINT( a )         r300_point( rmesa, a )
 372
 373 /***********************************************************************
 374  *              Build render functions from dd templates               *
 375  ***********************************************************************/
 376
 377 #define R300_TWOSIDE_BIT        0x01
 378 #define R300_UNFILLED_BIT       0x02
 379 #define R300_MAX_TRIFUNC        0x04
 380
 381 static struct {
 382    tnl_points_func              points;
 383    tnl_line_func                line;
 384    tnl_triangle_func    triangle;
 385    tnl_quad_func                quad;
 386 } rast_tab[R300_MAX_TRIFUNC];
 387
 388 #define DO_FALLBACK  0
 389 #define DO_UNFILLED (IND & R300_UNFILLED_BIT)
 390 #define DO_TWOSIDE  (IND & R300_TWOSIDE_BIT)
 391 #define DO_FLAT      0
 392 #define DO_OFFSET     0
 393 #define DO_TRI       1
 394 #define DO_QUAD      1
 395 #define DO_LINE      1
 396 #define DO_POINTS    1
 397 #define DO_FULL_QUAD 1
 398
 399 #define HAVE_RGBA   1
 400 #define HAVE_SPEC   1
 401 #define HAVE_BACK_COLORS  0
 402 #define HAVE_HW_FLATSHADE 1
 403 #define TAB rast_tab
 404
 405 #define DEPTH_SCALE 1.0
 406 #define UNFILLED_TRI unfilled_tri
 407 #define UNFILLED_QUAD unfilled_quad
 408 #define VERT_X(_v) _v->v.x
 409 #define VERT_Y(_v) _v->v.y
 410 #define VERT_Z(_v) _v->v.z
 411 #define AREA_IS_CCW( a ) (a < 0)
 412 #define GET_VERTEX(e) (rmesa->swtcl.verts + (e*rmesa->swtcl.vertex_size*sizeof(int)))
 413
 414 /* Only used to pull back colors into vertices (ie, we know color is
 415  * floating point).
 416  */
 417 #define R300_COLOR( dst, src )                          \
 418 do {                                                    \
 419    UNCLAMPED_FLOAT_TO_UBYTE((dst)[0], (src)[2]);        \
 420    UNCLAMPED_FLOAT_TO_UBYTE((dst)[1], (src)[1]);        \
 421    UNCLAMPED_FLOAT_TO_UBYTE((dst)[2], (src)[0]);        \
 422    UNCLAMPED_FLOAT_TO_UBYTE((dst)[3], (src)[3]);        \
 423 } while (0)
 424
 425 #define VERT_SET_RGBA( v, c )    if (coloroffset) R300_COLOR( v->ub4[coloroffset], c )
 426 #define VERT_COPY_RGBA( v0, v1 ) if (coloroffset) v0->ui[coloroffset] = v1->ui[coloroffset]
 427 #define VERT_SAVE_RGBA( idx )    if (coloroffset) color[idx] = v[idx]->ui[coloroffset]
 428 #define VERT_RESTORE_RGBA( idx ) if (coloroffset) v[idx]->ui[coloroffset] = color[idx]
 429
 430 #define R300_SPEC( dst, src )                           \
 431 do {                                                    \
 432    UNCLAMPED_FLOAT_TO_UBYTE((dst)[0], (src)[2]);        \
 433    UNCLAMPED_FLOAT_TO_UBYTE((dst)[1], (src)[1]);        \
 434    UNCLAMPED_FLOAT_TO_UBYTE((dst)[2], (src)[0]);        \
 435 } while (0)
 436
 437 #define VERT_SET_SPEC( v, c )    if (specoffset) R300_SPEC( v->ub4[specoffset], c )
 438 #define VERT_COPY_SPEC( v0, v1 ) if (specoffset) COPY_3V(v0->ub4[specoffset], v1->ub4[specoffset])
 439 #define VERT_SAVE_SPEC( idx )    if (specoffset) spec[idx] = v[idx]->ui[specoffset]
 440 #define VERT_RESTORE_SPEC( idx ) if (specoffset) v[idx]->ui[specoffset] = spec[idx]
 441
 442 #undef LOCAL_VARS
 443 #undef TAG
 444 #undef INIT
 445
 446 #define LOCAL_VARS(n)                                                   \
 447    r300ContextPtr rmesa = R300_CONTEXT(ctx);                    \
 448    GLuint color[n], spec[n];                                            \
 449    GLuint coloroffset = rmesa->swtcl.coloroffset;       \
 450    GLuint specoffset = rmesa->swtcl.specoffset;                 \
 451    (void) color; (void) spec; (void) coloroffset; (void) specoffset;
 452
 453 /***********************************************************************
 454  *                Helpers for rendering unfilled primitives            *
 455  ***********************************************************************/
 456
 457 #define RASTERIZE(x) r300RasterPrimitive( ctx, reduced_prim[x] )
 458 #define RENDER_PRIMITIVE rmesa->swtcl.render_primitive
 459 #undef TAG
 460 #define TAG(x) x
 461 #include "tnl_dd/t_dd_unfilled.h"
 462 #undef IND
 463
 464
 465 /***********************************************************************
 466  *                      Generate GL render functions                   *
 467  ***********************************************************************/
 468
 469
 470 #define IND (0)
 471 #define TAG(x) x
 472 #include "tnl_dd/t_dd_tritmp.h"
 473
 474 #define IND (R300_TWOSIDE_BIT)
 475 #define TAG(x) x##_twoside
 476 #include "tnl_dd/t_dd_tritmp.h"
 477
 478 #define IND (R300_UNFILLED_BIT)
 479 #define TAG(x) x##_unfilled
 480 #include "tnl_dd/t_dd_tritmp.h"
 481
 482 #define IND (R300_TWOSIDE_BIT|R300_UNFILLED_BIT)
 483 #define TAG(x) x##_twoside_unfilled
 484 #include "tnl_dd/t_dd_tritmp.h"
 485
 486
 487
 488 static void init_rast_tab( void )
 489 {
 490    init();
 491    init_twoside();
 492    init_unfilled();
 493    init_twoside_unfilled();
 494 }
 495
 496 /**********************************************************************/
 497 /*               Render unclipped begin/end objects                   */
 498 /**********************************************************************/
 499
 500 #define RENDER_POINTS( start, count )           \
 501    for ( ; start < count ; start++)             \
 502       r300_point( rmesa, VERT(start) )
 503 #define RENDER_LINE( v0, v1 ) \
 504    r300_line( rmesa, VERT(v0), VERT(v1) )
 505 #define RENDER_TRI( v0, v1, v2 )  \
 506    r300_triangle( rmesa, VERT(v0), VERT(v1), VERT(v2) )
 507 #define RENDER_QUAD( v0, v1, v2, v3 ) \
 508    r300_quad( rmesa, VERT(v0), VERT(v1), VERT(v2), VERT(v3) )
 509 #define INIT(x) do {                                    \
 510    r300RenderPrimitive( ctx, x );                       \
 511 } while (0)
 512 #undef LOCAL_VARS
 513 #define LOCAL_VARS                                              \
 514    r300ContextPtr rmesa = R300_CONTEXT(ctx);            \
 515    const GLuint vertsize = rmesa->swtcl.vertex_size;            \
 516    const char *r300verts = (char *)rmesa->swtcl.verts;          \
 517    const GLuint * const elt = TNL_CONTEXT(ctx)->vb.Elts;        \
 518    const GLboolean stipple = ctx->Line.StippleFlag;             \
 519    (void) elt; (void) stipple;
 520 #define RESET_STIPPLE   //if ( stipple ) r200ResetLineStipple( ctx );
 521 #define RESET_OCCLUSION
 522 #define PRESERVE_VB_DEFS
 523 #define ELT(x) (x)
 524 #define TAG(x) r300_##x##_verts
 525 #include "tnl/t_vb_rendertmp.h"
 526 #undef ELT
 527 #undef TAG
 528 #define TAG(x) r300_##x##_elts
 529 #define ELT(x) elt[x]
 530 #include "tnl/t_vb_rendertmp.h"
 531
 532
 533
 534
 535 /**********************************************************************/
 536 /*                    Choose render functions                         */
 537 /**********************************************************************/
 538 static void r300ChooseRenderState( GLcontext *ctx )
 539 {
 540         TNLcontext *tnl = TNL_CONTEXT(ctx);
 541         r300ContextPtr rmesa = R300_CONTEXT(ctx);
 542         GLuint index = 0;
 543         GLuint flags = ctx->_TriangleCaps;
 544
 545         if (flags & DD_TRI_LIGHT_TWOSIDE) index |= R300_TWOSIDE_BIT;
 546         if (flags & DD_TRI_UNFILLED)      index |= R300_UNFILLED_BIT;
 547
 548         if (index != rmesa->swtcl.RenderIndex) {
 549                 tnl->Driver.Render.Points = rast_tab[index].points;
 550                 tnl->Driver.Render.Line = rast_tab[index].line;
 551                 tnl->Driver.Render.ClippedLine = rast_tab[index].line;
 552                 tnl->Driver.Render.Triangle = rast_tab[index].triangle;
 553                 tnl->Driver.Render.Quad = rast_tab[index].quad;
 554
 555                 if (index == 0) {
 556                         tnl->Driver.Render.PrimTabVerts = r300_render_tab_verts;
 557                         tnl->Driver.Render.PrimTabElts = r300_render_tab_elts;
 558                         tnl->Driver.Render.ClippedPolygon = r300_fast_clipped_poly;
 559                 } else {
 560                         tnl->Driver.Render.PrimTabVerts = _tnl_render_tab_verts;
 561                         tnl->Driver.Render.PrimTabElts = _tnl_render_tab_elts;
 562                         tnl->Driver.Render.ClippedPolygon = _tnl_RenderClippedPolygon;
 563                 }
 564
 565                 rmesa->swtcl.RenderIndex = index;
 566         }
 567 }
 568
 569
 570 static void r300RenderStart(GLcontext *ctx)
 571 {
 572         r300ContextPtr rmesa = R300_CONTEXT( ctx );
 573         //      fprintf(stderr, "%s\n", __FUNCTION__);
 574
 575         r300ChooseRenderState(ctx);
 576         r300SetVertexFormat(ctx);
 577
 578         r300UpdateShaders(rmesa);
 579         r300UpdateShaderStates(rmesa);
 580
 581         r300EmitCacheFlush(rmesa);
 582
 583         if (rmesa->dma.flush != 0 &&
 584             rmesa->dma.flush != flush_last_swtcl_prim)
 585                 rmesa->dma.flush( rmesa );
 586
 587 }
 588
 589 static void r300RenderFinish(GLcontext *ctx)
 590 {
 591 }
 592
 593 static void r300RasterPrimitive( GLcontext *ctx, GLuint hwprim )
 594 {
 595         r300ContextPtr rmesa = R300_CONTEXT(ctx);
 596
 597         if (rmesa->swtcl.hw_primitive != hwprim) {
 598                 R300_NEWPRIM( rmesa );
 599                 rmesa->swtcl.hw_primitive = hwprim;
 600         }
 601 }
 602
 603 static void r300RenderPrimitive(GLcontext *ctx, GLenum prim)
 604 {
 605
 606         r300ContextPtr rmesa = R300_CONTEXT(ctx);
 607         rmesa->swtcl.render_primitive = prim;
 608
 609         if ((prim == GL_TRIANGLES) && (ctx->_TriangleCaps & DD_TRI_UNFILLED))
 610           return;
 611
 612         r300RasterPrimitive( ctx, reduced_prim[prim] );
 613         //      fprintf(stderr, "%s\n", __FUNCTION__);
 614
 615 }
 616
 617 static void r300ResetLineStipple(GLcontext *ctx)
 618 {
 619
 620
 621 }
 622
 623 void r300InitSwtcl(GLcontext *ctx)
 624 {
 625         TNLcontext *tnl = TNL_CONTEXT(ctx);
 626         r300ContextPtr rmesa = R300_CONTEXT(ctx);
 627         static int firsttime = 1;
 628
 629         if (firsttime) {
 630                 init_rast_tab();
 631                 firsttime = 0;
 632         }
 633
 634         tnl->Driver.Render.Start = r300RenderStart;
 635         tnl->Driver.Render.Finish = r300RenderFinish;
 636         tnl->Driver.Render.PrimitiveNotify = r300RenderPrimitive;
 637         tnl->Driver.Render.ResetLineStipple = r300ResetLineStipple;
 638         tnl->Driver.Render.BuildVertices = _tnl_build_vertices;
 639         tnl->Driver.Render.CopyPV = _tnl_copy_pv;
 640         tnl->Driver.Render.Interp = _tnl_interp;
 641
 642         /* FIXME: what are these numbers? */
 643         _tnl_init_vertices( ctx, ctx->Const.MaxArrayLockSize + 12,
 644                             48 * sizeof(GLfloat) );
 645
 646         rmesa->swtcl.verts = (GLubyte *)tnl->clipspace.vertex_buf;
 647         rmesa->swtcl.RenderIndex = ~0;
 648         rmesa->swtcl.render_primitive = GL_TRIANGLES;
 649         rmesa->swtcl.hw_primitive = 0;
 650
 651         _tnl_invalidate_vertex_state( ctx, ~0 );
 652         _tnl_invalidate_vertices( ctx, ~0 );
 653         RENDERINPUTS_ZERO( rmesa->tnl_index_bitset );
 654
 655         _tnl_need_projected_coords( ctx, GL_FALSE );
 656         r300ChooseRenderState(ctx);
 657
 658         _mesa_validate_all_lighting_tables( ctx );
 659
 660         tnl->Driver.NotifyMaterialChange =
 661           _mesa_validate_all_lighting_tables;
 662 }
 663
 664 void r300DestroySwtcl(GLcontext *ctx)
 665 {
 666 }
 667
 668 void r300EmitVertexAOS(r300ContextPtr rmesa, GLuint vertex_size, GLuint offset)
 669 {
 670         int cmd_reserved = 0;
 671         int cmd_written = 0;
 672
 673         drm_radeon_cmd_header_t *cmd = NULL;
 674         if (RADEON_DEBUG & DEBUG_VERTS)
 675           fprintf(stderr, "%s:  vertex_size %d, offset 0x%x \n",
 676                   __FUNCTION__, vertex_size, offset);
 677
 678         start_packet3(CP_PACKET3(R300_PACKET3_3D_LOAD_VBPNTR, 2), 2);
 679         e32(1);
 680         e32(vertex_size | (vertex_size << 8));
 681         e32(offset);
 682 }
 683
 684 void r300EmitVbufPrim(r300ContextPtr rmesa, GLuint primitive, GLuint vertex_nr)
 685 {
 686
 687         int cmd_reserved = 0;
 688         int cmd_written = 0;
 689         int type, num_verts;
 690         drm_radeon_cmd_header_t *cmd = NULL;
 691
 692         type = r300PrimitiveType(rmesa, primitive);
 693         num_verts = r300NumVerts(rmesa, vertex_nr, primitive);
 694
 695         start_packet3(CP_PACKET3(R300_PACKET3_3D_DRAW_VBUF_2, 0), 0);
 696         e32(R300_VAP_VF_CNTL__PRIM_WALK_VERTEX_LIST | (num_verts << 16) | type);
 697 }