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

   1 /**************************************************************************
   2
   3 Copyright (C) 2004 Nicolai Haehnle.
   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 ATI, VA LINUX SYSTEMS AND/OR THEIR 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  *   Nicolai Haehnle <prefect_@gmx.net>
  31  */
  32
  33 #include "glheader.h"
  34 #include "state.h"
  35 #include "imports.h"
  36 #include "enums.h"
  37 #include "macros.h"
  38 #include "context.h"
  39 #include "dd.h"
  40 #include "simple_list.h"
  41
  42 #include "api_arrayelt.h"
  43 #include "swrast/swrast.h"
  44 #include "swrast_setup/swrast_setup.h"
  45 #include "array_cache/acache.h"
  46 #include "tnl/tnl.h"
  47
  48 #include "radeon_reg.h"
  49 #include "radeon_macros.h"
  50 #include "radeon_ioctl.h"
  51 #include "radeon_state.h"
  52 #include "r300_context.h"
  53 #include "r300_ioctl.h"
  54 #include "r300_state.h"
  55 #include "r300_reg.h"
  56 #include "r300_program.h"
  57 #include "r300_tex.h"
  58
  59 #include "r300_emit.h"
  60
  61 /* Turns out we might not need this after all... */
  62 void update_zbias(GLcontext * ctx, int prim)
  63 {
  64     r300ContextPtr rmesa = R300_CONTEXT(ctx);
  65     int enabled = 0;
  66     uint32_t values[4];
  67     //return ;
  68     switch(prim & PRIM_MODE_MASK) {
  69         case GL_POINTS:
  70                 if(ctx->Polygon.OffsetPoint == GL_TRUE)
  71                         enabled=1;
  72                 break;
  73         case GL_LINES:
  74         case GL_LINE_STRIP:
  75         case GL_LINE_LOOP:
  76                 if(ctx->Polygon.OffsetLine == GL_TRUE)
  77                         enabled=1;
  78                 break;
  79         case GL_TRIANGLES:
  80         case GL_TRIANGLE_STRIP:
  81         case GL_TRIANGLE_FAN:
  82         case GL_QUADS:
  83         case GL_QUAD_STRIP:
  84         case GL_POLYGON:
  85                 if(ctx->Polygon.OffsetFill == GL_TRUE)
  86                         enabled=1;
  87                 break;
  88         default:
  89                 fprintf(stderr, "%s:%s Do not know how to handle primitive %02x - help me !\n",
  90                         __FILE__, __FUNCTION__,
  91                         prim & PRIM_MODE_MASK);
  92
  93     }
  94
  95     if(enabled){
  96             values[0]=values[2]=r300PackFloat32(ctx->Polygon.OffsetFactor * 12.0);
  97             values[1]=values[3]=r300PackFloat32(ctx->Polygon.OffsetUnits * 4.0);
  98     }else{
  99             values[0]=values[2]=r300PackFloat32(0.0);
 100             values[1]=values[3]=r300PackFloat32(0.0);
 101     }
 102
 103     if(values[0] != rmesa->hw.zbs.cmd[R300_ZBS_T_FACTOR] ||
 104        values[1] != rmesa->hw.zbs.cmd[R300_ZBS_T_CONSTANT] ||
 105        values[2] != rmesa->hw.zbs.cmd[R300_ZBS_W_FACTOR] ||
 106        values[3] != rmesa->hw.zbs.cmd[R300_ZBS_W_CONSTANT]){
 107
 108               R300_STATECHANGE(rmesa, zbs);
 109               rmesa->hw.zbs.cmd[R300_ZBS_T_FACTOR] = values[0];
 110               rmesa->hw.zbs.cmd[R300_ZBS_T_CONSTANT] = values[1];
 111               rmesa->hw.zbs.cmd[R300_ZBS_W_FACTOR] = values[2];
 112               rmesa->hw.zbs.cmd[R300_ZBS_W_CONSTANT] = values[3];
 113
 114     }
 115 }
 116
 117 /**********************************************************************
 118 *                     Hardware rasterization
 119 *
 120 * When we fell back to software TCL, we still try to use the
 121 * rasterization hardware for rendering.
 122 **********************************************************************/
 123
 124 static int r300_get_primitive_type(r300ContextPtr rmesa, GLcontext *ctx, int prim)
 125 {
 126    TNLcontext *tnl = TNL_CONTEXT(ctx);
 127    struct vertex_buffer *VB = &tnl->vb;
 128    GLuint i;
 129    int type=-1;
 130
 131         switch (prim & PRIM_MODE_MASK) {
 132         case GL_POINTS:
 133                 type=R300_VAP_VF_CNTL__PRIM_POINTS;
 134                 break;
 135         case GL_LINES:
 136                 type=R300_VAP_VF_CNTL__PRIM_LINES;
 137                 break;
 138         case GL_LINE_STRIP:
 139                 type=R300_VAP_VF_CNTL__PRIM_LINE_STRIP;
 140                 break;
 141         case GL_LINE_LOOP:
 142                 type=R300_VAP_VF_CNTL__PRIM_LINE_LOOP;
 143                 break;
 144         case GL_TRIANGLES:
 145                 type=R300_VAP_VF_CNTL__PRIM_TRIANGLES;
 146                 break;
 147         case GL_TRIANGLE_STRIP:
 148                 type=R300_VAP_VF_CNTL__PRIM_TRIANGLE_STRIP;
 149                 break;
 150         case GL_TRIANGLE_FAN:
 151                 type=R300_VAP_VF_CNTL__PRIM_TRIANGLE_FAN;
 152                 break;
 153         case GL_QUADS:
 154                 type=R300_VAP_VF_CNTL__PRIM_QUADS;
 155                 break;
 156         case GL_QUAD_STRIP:
 157                 type=R300_VAP_VF_CNTL__PRIM_QUAD_STRIP;
 158                 break;
 159         case GL_POLYGON:
 160                 type=R300_VAP_VF_CNTL__PRIM_POLYGON;
 161                 break;
 162         default:
 163                 fprintf(stderr, "%s:%s Do not know how to handle primitive %02x - help me !\n",
 164                         __FILE__, __FUNCTION__,
 165                         prim & PRIM_MODE_MASK);
 166                 return -1;
 167                 break;
 168         }
 169    return type;
 170 }
 171
 172 static int r300_get_num_verts(r300ContextPtr rmesa,
 173         GLcontext *ctx,
 174         int num_verts,
 175         int prim)
 176 {
 177    TNLcontext *tnl = TNL_CONTEXT(ctx);
 178    struct vertex_buffer *VB = &tnl->vb;
 179    GLuint i;
 180    int type=-1, verts_off=0;
 181    char *name="UNKNOWN";
 182
 183         switch (prim & PRIM_MODE_MASK) {
 184         case GL_POINTS:
 185                 name="P";
 186                 verts_off = 0;
 187                 break;
 188         case GL_LINES:
 189                 name="L";
 190                 verts_off = num_verts % 2;
 191                 break;
 192         case GL_LINE_STRIP:
 193                 name="LS";
 194                 if(num_verts < 2)
 195                         verts_off = num_verts;
 196                 break;
 197         case GL_LINE_LOOP:
 198                 name="LL";
 199                 if(num_verts < 2)
 200                         verts_off = num_verts;
 201                 break;
 202         case GL_TRIANGLES:
 203                 name="T";
 204                 verts_off = num_verts % 3;
 205                 break;
 206         case GL_TRIANGLE_STRIP:
 207                 name="TS";
 208                 if(num_verts < 3)
 209                         verts_off = num_verts;
 210                 break;
 211         case GL_TRIANGLE_FAN:
 212                 name="TF";
 213                 if(num_verts < 3)
 214                         verts_off = num_verts;
 215                 break;
 216         case GL_QUADS:
 217                 name="Q";
 218                 verts_off = num_verts % 4;
 219                 break;
 220         case GL_QUAD_STRIP:
 221                 name="QS";
 222                 if(num_verts < 4)
 223                         verts_off = num_verts;
 224                 else
 225                         verts_off = num_verts % 2;
 226                 break;
 227         case GL_POLYGON:
 228                 name="P";
 229                 if(num_verts < 3)
 230                         verts_off = num_verts;
 231                 break;
 232         default:
 233                 fprintf(stderr, "%s:%s Do not know how to handle primitive %02x - help me !\n",
 234                         __FILE__, __FUNCTION__,
 235                         prim & PRIM_MODE_MASK);
 236                 return -1;
 237                 break;
 238         }
 239
 240         if(num_verts - verts_off == 0){
 241                 WARN_ONCE("user error: Need more than %d vertices to draw primitive %s !\n", num_verts, name);
 242                 return 0;
 243         }
 244
 245         if(verts_off > 0){
 246                 WARN_ONCE("user error: %d is not a valid number of vertices for primitive %s !\n", num_verts, name);
 247         }
 248
 249         return num_verts - verts_off;
 250 }
 251
 252 void dump_inputs(GLcontext *ctx, int render_inputs)
 253 {
 254         int k;
 255         fprintf(stderr, "inputs:");
 256         if(render_inputs & _TNL_BIT_POS)
 257                 fprintf(stderr, "_TNL_BIT_POS ");
 258         if(render_inputs & _TNL_BIT_NORMAL)
 259                 fprintf(stderr, "_TNL_BIT_NORMAL ");
 260
 261                 /* color components */
 262         if(render_inputs & _TNL_BIT_COLOR0)
 263                 fprintf(stderr, "_TNL_BIT_COLOR0 ");
 264         if(render_inputs & _TNL_BIT_COLOR1)
 265                 fprintf(stderr, "_TNL_BIT_COLOR1 ");
 266
 267         if(render_inputs & _TNL_BIT_FOG)
 268                 fprintf(stderr, "_TNL_BIT_FOG ");
 269
 270                 /* texture coordinates */
 271         for(k=0;k < ctx->Const.MaxTextureUnits;k++)
 272                 if(render_inputs & (_TNL_BIT_TEX0<<k))
 273                         fprintf(stderr, "_TNL_BIT_TEX%d ", k);
 274
 275         if(render_inputs & _TNL_BIT_INDEX)
 276                 fprintf(stderr, "_TNL_BIT_INDEX ");
 277         if(render_inputs & _TNL_BIT_POINTSIZE)
 278                 fprintf(stderr, "_TNL_BIT_POINTSIZE ");
 279
 280         fprintf(stderr, "\n");
 281 }
 282
 283 /* This function compiles GL context into state registers that
 284    describe data routing inside of R300 pipeline.
 285
 286    In particular, it programs input_route, output_vtx_fmt, texture
 287    unit configuration and gb_output_vtx_fmt
 288
 289    This function encompasses setup_AOS() from r300_lib.c
 290 */
 291
 292
 293
 294
 295 /* Immediate implementation - vertex data is sent via command stream */
 296
 297 static GLfloat default_vector[4]={0.0, 0.0, 0.0, 1.0};
 298
 299 #define output_vector(v, i) \
 300         { \
 301         int _i; \
 302         for(_i=0;_i<v->size;_i++){ \
 303                 efloat(VEC_ELT(v, GLfloat, i)[_i]); \
 304                 } \
 305         for(_i=v->size;_i<4;_i++){ \
 306                         efloat(default_vector[_i]); \
 307                         } \
 308         }
 309
 310 /* Immediate implementation - vertex data is sent via command stream */
 311
 312 static void r300_render_immediate_primitive(r300ContextPtr rmesa,
 313         GLcontext *ctx,
 314         int start,
 315         int end,
 316         int prim)
 317 {
 318    TNLcontext *tnl = TNL_CONTEXT(ctx);
 319    struct vertex_buffer *VB = &tnl->vb;
 320    GLuint i, render_inputs;
 321    int k, type, num_verts;
 322    LOCAL_VARS
 323
 324    type=r300_get_primitive_type(rmesa, ctx, prim);
 325    num_verts=r300_get_num_verts(rmesa, ctx, end-start, prim);
 326
 327                 #if 0
 328                 fprintf(stderr,"ObjPtr: size=%d stride=%d\n",
 329                         VB->ObjPtr->size, VB->ObjPtr->stride);
 330                 fprintf(stderr,"ColorPtr[0]: size=%d stride=%d\n",
 331                         VB->ColorPtr[0]->size, VB->ColorPtr[0]->stride);
 332                 fprintf(stderr,"TexCoordPtr[0]: size=%d stride=%d\n",
 333                         VB->TexCoordPtr[0]->size, VB->TexCoordPtr[0]->stride);
 334                 #endif
 335
 336    if(type<0 || num_verts <= 0)return;
 337
 338    if(!VB->ObjPtr){
 339         WARN_ONCE("FIXME: Don't know how to handle GL_ARB_vertex_buffer_object correctly\n");
 340         return;
 341    }
 342    /* A packet cannot have more than 16383 data words.. */
 343    if((num_verts*4*rmesa->state.aos_count)>16380){
 344         WARN_ONCE("Too many vertices to paint. Fix me !\n");
 345         return;
 346         }
 347
 348    //fprintf(stderr, "aos_count=%d start=%d end=%d\n", rmesa->state.aos_count, start, end);
 349
 350    if(rmesa->state.aos_count==0){
 351         WARN_ONCE("Aeiee ! aos_count==0, while it shouldn't. Skipping rendering\n");
 352         return;
 353         }
 354
 355    render_inputs = rmesa->state.render_inputs;
 356
 357    if(!render_inputs){
 358         WARN_ONCE("Aeiee ! render_inputs==0. Skipping rendering.\n");
 359         return;
 360         }
 361
 362         //dump_inputs(ctx, render_inputs); return ;
 363
 364    start_immediate_packet(num_verts, type, 4*rmesa->state.aos_count);
 365
 366         for(i=start;i<start+num_verts;i++){
 367                 #if 0
 368                 fprintf(stderr, "* (%f %f %f %f) (%f %f %f %f)\n",
 369                         VEC_ELT(VB->ObjPtr, GLfloat, i)[0],
 370                         VEC_ELT(VB->ObjPtr, GLfloat, i)[1],
 371                         VEC_ELT(VB->ObjPtr, GLfloat, i)[2],
 372                         VEC_ELT(VB->ObjPtr, GLfloat, i)[3],
 373
 374                         VEC_ELT(VB->ColorPtr[0], GLfloat, i)[0],
 375                         VEC_ELT(VB->ColorPtr[0], GLfloat, i)[1],
 376                         VEC_ELT(VB->ColorPtr[0], GLfloat, i)[2],
 377                         VEC_ELT(VB->ColorPtr[0], GLfloat, i)[3]
 378                         );
 379                 #endif
 380
 381
 382                 /* coordinates */
 383                 if(render_inputs & _TNL_BIT_POS)
 384                         output_vector(VB->ObjPtr, i);
 385                 if(render_inputs & _TNL_BIT_NORMAL)
 386                         output_vector(VB->NormalPtr, i);
 387
 388                 /* color components */
 389                 if(render_inputs & _TNL_BIT_COLOR0)
 390                         output_vector(VB->ColorPtr[0], i);
 391                 if(render_inputs & _TNL_BIT_COLOR1)
 392                         output_vector(VB->SecondaryColorPtr[0], i);
 393
 394 /*              if(render_inputs & _TNL_BIT_FOG) // Causes lock ups when immediate mode is on
 395                         output_vector(VB->FogCoordPtr, i);*/
 396
 397                 /* texture coordinates */
 398                 for(k=0;k < ctx->Const.MaxTextureUnits;k++)
 399                         if(render_inputs & (_TNL_BIT_TEX0<<k))
 400                                 output_vector(VB->TexCoordPtr[k], i);
 401
 402                 if(render_inputs & _TNL_BIT_INDEX)
 403                         output_vector(VB->IndexPtr[0], i);
 404                 if(render_inputs & _TNL_BIT_POINTSIZE)
 405                         output_vector(VB->PointSizePtr, i);
 406                 }
 407
 408 }
 409
 410
 411 static GLboolean r300_run_immediate_render(GLcontext *ctx,
 412                                  struct tnl_pipeline_stage *stage)
 413 {
 414    r300ContextPtr rmesa = R300_CONTEXT(ctx);
 415    TNLcontext *tnl = TNL_CONTEXT(ctx);
 416    struct vertex_buffer *VB = &tnl->vb;
 417    GLuint i;
 418    /* Only do 2d textures */
 419    struct gl_texture_object *to=ctx->Texture.Unit[0].Current2D;
 420    r300TexObjPtr t=to->DriverData;
 421    LOCAL_VARS
 422
 423
 424    /* Update texture state - needs to be done only when actually changed..
 425       All the time for now.. */
 426
 427
 428         if (RADEON_DEBUG == DEBUG_PRIMS)
 429                 fprintf(stderr, "%s\n", __FUNCTION__);
 430
 431    #if 1 /* we need this, somehow */
 432    /* Flush state - make sure command buffer is nice and large */
 433    r300Flush(ctx);
 434    /* Make sure we have enough space */
 435    #else
 436    /* Count is very imprecize, but should be good upper bound */
 437    r300EnsureCmdBufSpace(rmesa, rmesa->hw.max_state_size + 4+2+30
 438         +VB->PrimitiveCount*(1+8)+VB->Count*4*rmesa->state.texture.tc_count+4, __FUNCTION__);
 439    #endif
 440
 441    /* needed before starting 3d operation .. */
 442    reg_start(R300_RB3D_DSTCACHE_CTLSTAT,0);
 443         e32(0x0000000a);
 444
 445    reg_start(0x4f18,0);
 446         e32(0x00000003);
 447
 448
 449         #if 0 /* looks like the Z offset issue got fixed */
 450    rmesa->hw.vte.cmd[1] = R300_VPORT_X_SCALE_ENA
 451                                 | R300_VPORT_X_OFFSET_ENA
 452                                 | R300_VPORT_Y_SCALE_ENA
 453                                 | R300_VPORT_Y_OFFSET_ENA
 454                                 | R300_VTX_W0_FMT;
 455    R300_STATECHANGE(rmesa, vte);
 456         #endif
 457
 458
 459
 460    /* Magic register - note it is right after 20b0 */
 461
 462
 463    if(rmesa->state.texture.tc_count>0){
 464         reg_start(0x20b4,0);
 465                 e32(0x0000000c);
 466
 467         }
 468
 469    r300EmitState(rmesa);
 470
 471    #if 0
 472    reg_start(R300_RB3D_COLORMASK, 0);
 473         e32(0xf);
 474
 475    vsf_start_fragment(0x406, 4);
 476    efloat(0.0);
 477    efloat(0.0);
 478    efloat(0.0);
 479    efloat(1.0);
 480
 481    vsf_start_fragment(0x400, 4);
 482    efloat(0.0);
 483    efloat(0.0);
 484    efloat(0.0);
 485    efloat(1.0);
 486    #endif
 487
 488 /* Why do we need this for immediate mode?? */
 489 //   r300EmitLOAD_VBPNTR(rmesa, 0);
 490
 491    for(i=0; i < VB->PrimitiveCount; i++){
 492        GLuint prim = VB->Primitive[i].mode;
 493        GLuint start = VB->Primitive[i].start;
 494        GLuint length = VB->Primitive[i].count;
 495
 496         r300_render_immediate_primitive(rmesa, ctx, start, start + length, prim);
 497         }
 498
 499     /* This sequence is required after any 3d drawing packet
 500       I suspect it work arounds a bug (or deficiency) in hardware */
 501
 502    reg_start(R300_RB3D_DSTCACHE_CTLSTAT,0);
 503         e32(0x0000000a);
 504
 505    reg_start(0x4f18,0);
 506         e32(0x00000003);
 507
 508    return GL_FALSE;
 509 }
 510
 511 /* vertex buffer implementation */
 512
 513 static void r300_render_vb_primitive(r300ContextPtr rmesa,
 514         GLcontext *ctx,
 515         int start,
 516         int end,
 517         int prim)
 518 {
 519    int type, num_verts;
 520    LOCAL_VARS
 521
 522    type=r300_get_primitive_type(rmesa, ctx, prim);
 523    num_verts=r300_get_num_verts(rmesa, ctx, end-start, prim);
 524
 525    if(type<0 || num_verts <= 0)return;
 526
 527
 528    fire_AOS(PASS_PREFIX num_verts, type);
 529 }
 530
 531 static GLboolean r300_run_vb_render(GLcontext *ctx,
 532                                  struct tnl_pipeline_stage *stage)
 533 {
 534    r300ContextPtr rmesa = R300_CONTEXT(ctx);
 535    TNLcontext *tnl = TNL_CONTEXT(ctx);
 536    struct vertex_buffer *VB = &tnl->vb;
 537    int i, j;
 538    LOCAL_VARS
 539
 540         if (RADEON_DEBUG == DEBUG_PRIMS)
 541                 fprintf(stderr, "%s\n", __FUNCTION__);
 542
 543
 544         r300ReleaseArrays(ctx);
 545         r300EmitArrays(ctx, rmesa->state.render_inputs);
 546
 547 //      LOCK_HARDWARE(&(rmesa->radeon));
 548
 549         reg_start(R300_RB3D_DSTCACHE_CTLSTAT,0);
 550         e32(0x0000000a);
 551
 552         reg_start(0x4f18,0);
 553         e32(0x00000003);
 554
 555         r300EmitState(rmesa);
 556
 557         rmesa->state.Elts = VB->Elts;
 558
 559         for(i=0; i < VB->PrimitiveCount; i++){
 560                 GLuint prim = VB->Primitive[i].mode;
 561                 GLuint start = VB->Primitive[i].start;
 562                 GLuint length = VB->Primitive[i].count;
 563
 564                 r300EmitAOS(rmesa, rmesa->state.aos_count, start);
 565
 566                 r300_render_vb_primitive(rmesa, ctx, start, start + length, prim);
 567         }
 568
 569         reg_start(R300_RB3D_DSTCACHE_CTLSTAT,0);
 570         e32(0x0000000a);
 571
 572         reg_start(0x4f18,0);
 573         e32(0x00000003);
 574
 575 //      end_3d(PASS_PREFIX_VOID);
 576
 577    /* Flush state - we are done drawing.. */
 578 //      r300FlushCmdBufLocked(rmesa, __FUNCTION__);
 579 //      radeonWaitForIdleLocked(&(rmesa->radeon));
 580
 581 //      UNLOCK_HARDWARE(&(rmesa->radeon));
 582         return GL_FALSE;
 583 }
 584
 585 /**
 586  * Called by the pipeline manager to render a batch of primitives.
 587  * We can return true to pass on to the next stage (i.e. software
 588  * rasterization) or false to indicate that the pipeline has finished
 589  * after we render something.
 590  */
 591 static GLboolean r300_run_render(GLcontext *ctx,
 592                                  struct tnl_pipeline_stage *stage)
 593 {
 594    r300ContextPtr rmesa = R300_CONTEXT(ctx);
 595    TNLcontext *tnl = TNL_CONTEXT(ctx);
 596    struct vertex_buffer *VB = &tnl->vb;
 597    GLuint i;
 598
 599         if (RADEON_DEBUG == DEBUG_PRIMS)
 600                 fprintf(stderr, "%s\n", __FUNCTION__);
 601
 602
 603    #if 1
 604
 605         #if 1
 606         return r300_run_immediate_render(ctx, stage);
 607         #else
 608         return r300_run_vb_render(ctx, stage);
 609         #endif
 610    #else
 611         return GL_TRUE;
 612    #endif
 613
 614 #if 0
 615    mgaContextPtr mmesa = MGA_CONTEXT(ctx);
 616    TNLcontext *tnl = TNL_CONTEXT(ctx);
 617    struct vertex_buffer *VB = &tnl->vb;
 618    GLuint i;
 619
 620    /* Don't handle clipping or indexed vertices or vertex manipulations.
 621     */
 622    if (mmesa->RenderIndex != 0 ||
 623        !mga_validate_render( ctx, VB )) {
 624       return GL_TRUE;
 625    }
 626
 627    tnl->Driver.Render.Start( ctx );
 628    mmesa->SetupNewInputs = ~0;
 629
 630    for (i = 0 ; i < VB->PrimitiveCount ; i++)
 631    {
 632       GLuint prim = VB->Primitive[i].mode;
 633       GLuint start = VB->Primitive[i].start;
 634       GLuint length = VB->Primitive[i].count;
 635
 636       if (!length)
 637          continue;
 638
 639       mga_render_tab_verts[prim & PRIM_MODE_MASK]( ctx, start, start + length,
 640                                                    prim);
 641    }
 642
 643    tnl->Driver.Render.Finish( ctx );
 644
 645    return GL_FALSE;             /* finished the pipe */
 646 #endif
 647 }
 648
 649
 650 /**
 651  * Called by the pipeline manager once before rendering.
 652  * We check the GL state here to
 653  *  a) decide whether we can do the current state in hardware and
 654  *  b) update hardware registers
 655  */
 656 #define FALLBACK_IF(expr) \
 657 do {                                                                            \
 658         if (expr) {                                                             \
 659                 if (1 || RADEON_DEBUG & DEBUG_FALLBACKS)                                \
 660                         fprintf(stderr, "%s: fallback:%s\n",                    \
 661                                 __FUNCTION__, #expr);                           \
 662                 stage->active = GL_FALSE;                                       \
 663                 return;                                                         \
 664         }                                                                       \
 665 } while(0)
 666
 667 static void r300_check_render(GLcontext *ctx, struct tnl_pipeline_stage *stage)
 668 {
 669         r300ContextPtr r300 = R300_CONTEXT(ctx);
 670         int i;
 671
 672         if (RADEON_DEBUG & DEBUG_STATE)
 673                 fprintf(stderr, "%s\n", __FUNCTION__);
 674
 675         /* We only support rendering in hardware for now */
 676         if (ctx->RenderMode != GL_RENDER) {
 677                 stage->active = GL_FALSE;
 678                 return;
 679         }
 680
 681         // I failed to figure out how dither works in hardware,
 682         // let's just ignore it for now
 683         //FALLBACK_IF(ctx->Color.DitherFlag);
 684
 685         /* I'm almost certain I forgot something here */
 686         #if 0 /* This should work now.. */
 687         FALLBACK_IF(ctx->Color.AlphaEnabled); // GL_ALPHA_TEST
 688         FALLBACK_IF(ctx->Color.BlendEnabled); // GL_BLEND
 689         #endif
 690         //FALLBACK_IF(ctx->Fog.Enabled); // GL_FOG disable as swtcl doesnt seem to support this
 691         FALLBACK_IF(ctx->Line.SmoothFlag); // GL_LINE_SMOOTH
 692         FALLBACK_IF(ctx->Line.StippleFlag); // GL_LINE_STIPPLE
 693         FALLBACK_IF(ctx->Point.SmoothFlag); // GL_POINT_SMOOTH
 694         if (ctx->Extensions.NV_point_sprite || ctx->Extensions.ARB_point_sprite)
 695                 FALLBACK_IF(ctx->Point.PointSprite); // GL_POINT_SPRITE_NV
 696         //FALLBACK_IF(ctx->Polygon.OffsetPoint); // GL_POLYGON_OFFSET_POINT
 697         //FALLBACK_IF(ctx->Polygon.OffsetLine); // GL_POLYGON_OFFSET_LINE
 698         //FALLBACK_IF(ctx->Polygon.OffsetFill); // GL_POLYGON_OFFSET_FILL
 699         //if(ctx->Polygon.OffsetFill)WARN_ONCE("Polygon.OffsetFill not implemented, ignoring\n");
 700         FALLBACK_IF(ctx->Polygon.SmoothFlag); // GL_POLYGON_SMOOTH
 701         FALLBACK_IF(ctx->Polygon.StippleFlag); // GL_POLYGON_STIPPLE
 702         //FALLBACK_IF(ctx->Stencil.Enabled); // GL_STENCIL_TEST
 703         FALLBACK_IF(ctx->Multisample.Enabled); // GL_MULTISAMPLE_ARB
 704
 705         /* One step at a time - let one texture pass.. */
 706         for (i = 1; i < ctx->Const.MaxTextureUnits; i++)
 707                 FALLBACK_IF(ctx->Texture.Unit[i].Enabled);
 708
 709         /* let r300_run_render do its job */
 710         #if 0
 711         stage->active = GL_FALSE;
 712         #endif
 713 }
 714
 715
 716 static void dtr(struct tnl_pipeline_stage *stage)
 717 {
 718         (void)stage;
 719 }
 720
 721 const struct tnl_pipeline_stage _r300_render_stage = {
 722         "r300 hw rasterize",
 723         _NEW_ALL,               /* re-check (always re-check for now) */
 724         0,                      /* re-run (always runs) */
 725         GL_TRUE,                /* active */
 726         0, 0,                   /* inputs (set in check_render), outputs */
 727         0, 0,                   /* changed_inputs, private */
 728         dtr,                    /* destructor */
 729         r300_check_render,      /* check */
 730         r300_run_render         /* run */
 731 };