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 /* Setup INPUT_ROUTE and INPUT_CNTL */
 489         r300EmitArrays(ctx, GL_TRUE);
 490
 491 /* Why do we need this for immediate mode?? Vertex processor needs it to know proper regs */
 492 //      r300EmitLOAD_VBPNTR(rmesa, 0);
 493
 494    for(i=0; i < VB->PrimitiveCount; i++){
 495        GLuint prim = VB->Primitive[i].mode;
 496        GLuint start = VB->Primitive[i].start;
 497        GLuint length = VB->Primitive[i].count;
 498
 499         r300_render_immediate_primitive(rmesa, ctx, start, start + length, prim);
 500         }
 501
 502     /* This sequence is required after any 3d drawing packet
 503       I suspect it work arounds a bug (or deficiency) in hardware */
 504
 505    reg_start(R300_RB3D_DSTCACHE_CTLSTAT,0);
 506         e32(0x0000000a);
 507
 508    reg_start(0x4f18,0);
 509         e32(0x00000003);
 510
 511    return GL_FALSE;
 512 }
 513
 514 /* vertex buffer implementation */
 515
 516 static void r300_render_vb_primitive(r300ContextPtr rmesa,
 517         GLcontext *ctx,
 518         int start,
 519         int end,
 520         int prim)
 521 {
 522    int type, num_verts;
 523    LOCAL_VARS
 524
 525    type=r300_get_primitive_type(rmesa, ctx, prim);
 526    num_verts=r300_get_num_verts(rmesa, ctx, end-start, prim);
 527
 528    if(type<0 || num_verts <= 0)return;
 529
 530
 531    fire_AOS(PASS_PREFIX num_verts, type);
 532 }
 533
 534 static GLboolean r300_run_vb_render(GLcontext *ctx,
 535                                  struct tnl_pipeline_stage *stage)
 536 {
 537    r300ContextPtr rmesa = R300_CONTEXT(ctx);
 538    TNLcontext *tnl = TNL_CONTEXT(ctx);
 539    struct vertex_buffer *VB = &tnl->vb;
 540    int i, j;
 541    LOCAL_VARS
 542
 543         if (RADEON_DEBUG == DEBUG_PRIMS)
 544                 fprintf(stderr, "%s\n", __FUNCTION__);
 545
 546
 547         r300ReleaseArrays(ctx);
 548         r300EmitArrays(ctx, GL_FALSE);
 549
 550 //      LOCK_HARDWARE(&(rmesa->radeon));
 551
 552         reg_start(R300_RB3D_DSTCACHE_CTLSTAT,0);
 553         e32(0x0000000a);
 554
 555         reg_start(0x4f18,0);
 556         e32(0x00000003);
 557
 558         r300EmitState(rmesa);
 559
 560         rmesa->state.Elts = VB->Elts;
 561
 562         for(i=0; i < VB->PrimitiveCount; i++){
 563                 GLuint prim = VB->Primitive[i].mode;
 564                 GLuint start = VB->Primitive[i].start;
 565                 GLuint length = VB->Primitive[i].count;
 566
 567                 r300EmitAOS(rmesa, rmesa->state.aos_count, start);
 568
 569                 r300_render_vb_primitive(rmesa, ctx, start, start + length, prim);
 570         }
 571
 572         reg_start(R300_RB3D_DSTCACHE_CTLSTAT,0);
 573         e32(0x0000000a);
 574
 575         reg_start(0x4f18,0);
 576         e32(0x00000003);
 577
 578 //      end_3d(PASS_PREFIX_VOID);
 579
 580    /* Flush state - we are done drawing.. */
 581 //      r300FlushCmdBufLocked(rmesa, __FUNCTION__);
 582 //      radeonWaitForIdleLocked(&(rmesa->radeon));
 583
 584 //      UNLOCK_HARDWARE(&(rmesa->radeon));
 585         return GL_FALSE;
 586 }
 587
 588 /**
 589  * Called by the pipeline manager to render a batch of primitives.
 590  * We can return true to pass on to the next stage (i.e. software
 591  * rasterization) or false to indicate that the pipeline has finished
 592  * after we render something.
 593  */
 594 static GLboolean r300_run_render(GLcontext *ctx,
 595                                  struct tnl_pipeline_stage *stage)
 596 {
 597    r300ContextPtr rmesa = R300_CONTEXT(ctx);
 598    TNLcontext *tnl = TNL_CONTEXT(ctx);
 599    struct vertex_buffer *VB = &tnl->vb;
 600    GLuint i;
 601
 602         if (RADEON_DEBUG == DEBUG_PRIMS)
 603                 fprintf(stderr, "%s\n", __FUNCTION__);
 604
 605
 606    #if 1
 607
 608         #if 0
 609         return r300_run_immediate_render(ctx, stage);
 610         #else
 611         return r300_run_vb_render(ctx, stage);
 612         #endif
 613    #else
 614         return GL_TRUE;
 615    #endif
 616
 617 #if 0
 618    mgaContextPtr mmesa = MGA_CONTEXT(ctx);
 619    TNLcontext *tnl = TNL_CONTEXT(ctx);
 620    struct vertex_buffer *VB = &tnl->vb;
 621    GLuint i;
 622
 623    /* Don't handle clipping or indexed vertices or vertex manipulations.
 624     */
 625    if (mmesa->RenderIndex != 0 ||
 626        !mga_validate_render( ctx, VB )) {
 627       return GL_TRUE;
 628    }
 629
 630    tnl->Driver.Render.Start( ctx );
 631    mmesa->SetupNewInputs = ~0;
 632
 633    for (i = 0 ; i < VB->PrimitiveCount ; i++)
 634    {
 635       GLuint prim = VB->Primitive[i].mode;
 636       GLuint start = VB->Primitive[i].start;
 637       GLuint length = VB->Primitive[i].count;
 638
 639       if (!length)
 640          continue;
 641
 642       mga_render_tab_verts[prim & PRIM_MODE_MASK]( ctx, start, start + length,
 643                                                    prim);
 644    }
 645
 646    tnl->Driver.Render.Finish( ctx );
 647
 648    return GL_FALSE;             /* finished the pipe */
 649 #endif
 650 }
 651
 652
 653 /**
 654  * Called by the pipeline manager once before rendering.
 655  * We check the GL state here to
 656  *  a) decide whether we can do the current state in hardware and
 657  *  b) update hardware registers
 658  */
 659 #define FALLBACK_IF(expr) \
 660 do {                                                                            \
 661         if (expr) {                                                             \
 662                 if (1 || RADEON_DEBUG & DEBUG_FALLBACKS)                                \
 663                         fprintf(stderr, "%s: fallback:%s\n",                    \
 664                                 __FUNCTION__, #expr);                           \
 665                 stage->active = GL_FALSE;                                       \
 666                 return;                                                         \
 667         }                                                                       \
 668 } while(0)
 669
 670 static void r300_check_render(GLcontext *ctx, struct tnl_pipeline_stage *stage)
 671 {
 672         r300ContextPtr r300 = R300_CONTEXT(ctx);
 673         int i;
 674
 675         if (RADEON_DEBUG & DEBUG_STATE)
 676                 fprintf(stderr, "%s\n", __FUNCTION__);
 677
 678         /* We only support rendering in hardware for now */
 679         if (ctx->RenderMode != GL_RENDER) {
 680                 stage->active = GL_FALSE;
 681                 return;
 682         }
 683
 684         // I failed to figure out how dither works in hardware,
 685         // let's just ignore it for now
 686         //FALLBACK_IF(ctx->Color.DitherFlag);
 687
 688         /* I'm almost certain I forgot something here */
 689         #if 0 /* This should work now.. */
 690         FALLBACK_IF(ctx->Color.AlphaEnabled); // GL_ALPHA_TEST
 691         FALLBACK_IF(ctx->Color.BlendEnabled); // GL_BLEND
 692         #endif
 693         //FALLBACK_IF(ctx->Fog.Enabled); // GL_FOG disable as swtcl doesnt seem to support this
 694         FALLBACK_IF(ctx->Line.SmoothFlag); // GL_LINE_SMOOTH
 695         FALLBACK_IF(ctx->Line.StippleFlag); // GL_LINE_STIPPLE
 696         FALLBACK_IF(ctx->Point.SmoothFlag); // GL_POINT_SMOOTH
 697         if (ctx->Extensions.NV_point_sprite || ctx->Extensions.ARB_point_sprite)
 698                 FALLBACK_IF(ctx->Point.PointSprite); // GL_POINT_SPRITE_NV
 699         //FALLBACK_IF(ctx->Polygon.OffsetPoint); // GL_POLYGON_OFFSET_POINT
 700         //FALLBACK_IF(ctx->Polygon.OffsetLine); // GL_POLYGON_OFFSET_LINE
 701         //FALLBACK_IF(ctx->Polygon.OffsetFill); // GL_POLYGON_OFFSET_FILL
 702         //if(ctx->Polygon.OffsetFill)WARN_ONCE("Polygon.OffsetFill not implemented, ignoring\n");
 703         FALLBACK_IF(ctx->Polygon.SmoothFlag); // GL_POLYGON_SMOOTH
 704         FALLBACK_IF(ctx->Polygon.StippleFlag); // GL_POLYGON_STIPPLE
 705         //FALLBACK_IF(ctx->Stencil.Enabled); // GL_STENCIL_TEST
 706         FALLBACK_IF(ctx->Multisample.Enabled); // GL_MULTISAMPLE_ARB
 707
 708         /* One step at a time - let one texture pass.. */
 709         for (i = 1; i < ctx->Const.MaxTextureUnits; i++)
 710                 FALLBACK_IF(ctx->Texture.Unit[i].Enabled);
 711
 712         /* let r300_run_render do its job */
 713         #if 0
 714         stage->active = GL_FALSE;
 715         #endif
 716 }
 717
 718
 719 static void dtr(struct tnl_pipeline_stage *stage)
 720 {
 721         (void)stage;
 722 }
 723
 724 const struct tnl_pipeline_stage _r300_render_stage = {
 725         "r300 hw rasterize",
 726         _NEW_ALL,               /* re-check (always re-check for now) */
 727         0,                      /* re-run (always runs) */
 728         GL_TRUE,                /* active */
 729         0, 0,                   /* inputs (set in check_render), outputs */
 730         0, 0,                   /* changed_inputs, private */
 731         dtr,                    /* destructor */
 732         r300_check_render,      /* check */
 733         r300_run_render         /* run */
 734 };