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 #include "r300_maos.h"
  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         fprintf(stderr, "%08x ", render_inputs);
 257
 258         if(render_inputs & _TNL_BIT_POS)
 259                 fprintf(stderr, "_TNL_BIT_POS ");
 260         if(render_inputs & _TNL_BIT_NORMAL)
 261                 fprintf(stderr, "_TNL_BIT_NORMAL ");
 262
 263                 /* color components */
 264         if(render_inputs & _TNL_BIT_COLOR0)
 265                 fprintf(stderr, "_TNL_BIT_COLOR0 ");
 266         if(render_inputs & _TNL_BIT_COLOR1)
 267                 fprintf(stderr, "_TNL_BIT_COLOR1 ");
 268
 269         if(render_inputs & _TNL_BIT_FOG)
 270                 fprintf(stderr, "_TNL_BIT_FOG ");
 271
 272                 /* texture coordinates */
 273         for(k=0;k < ctx->Const.MaxTextureUnits;k++)
 274                 if(render_inputs & (_TNL_BIT_TEX0<<k))
 275                         fprintf(stderr, "_TNL_BIT_TEX%d ", k);
 276
 277         if(render_inputs & _TNL_BIT_INDEX)
 278                 fprintf(stderr, "_TNL_BIT_INDEX ");
 279         if(render_inputs & _TNL_BIT_POINTSIZE)
 280                 fprintf(stderr, "_TNL_BIT_POINTSIZE ");
 281
 282         fprintf(stderr, "\n");
 283 }
 284
 285 /* This function compiles GL context into state registers that
 286    describe data routing inside of R300 pipeline.
 287
 288    In particular, it programs input_route, output_vtx_fmt, texture
 289    unit configuration and gb_output_vtx_fmt
 290
 291    This function encompasses setup_AOS() from r300_lib.c
 292 */
 293
 294
 295
 296
 297 /* Immediate implementation - vertex data is sent via command stream */
 298
 299 static GLfloat default_vector[4]={0.0, 0.0, 0.0, 1.0};
 300
 301 #define output_vector(v, i) \
 302         { \
 303         int _i; \
 304         for(_i=0;_i<v->size;_i++){ \
 305                 efloat(VEC_ELT(v, GLfloat, i)[_i]); \
 306                 } \
 307         for(_i=v->size;_i<4;_i++){ \
 308                         efloat(default_vector[_i]); \
 309                         } \
 310         }
 311
 312 /* Immediate implementation - vertex data is sent via command stream */
 313
 314 static void r300_render_immediate_primitive(r300ContextPtr rmesa,
 315         GLcontext *ctx,
 316         int start,
 317         int end,
 318         int prim)
 319 {
 320    TNLcontext *tnl = TNL_CONTEXT(ctx);
 321    struct vertex_buffer *VB = &tnl->vb;
 322    GLuint i, render_inputs;
 323    int k, type, num_verts;
 324    LOCAL_VARS
 325
 326    type=r300_get_primitive_type(rmesa, ctx, prim);
 327    num_verts=r300_get_num_verts(rmesa, ctx, end-start, prim);
 328
 329                 #if 0
 330                 fprintf(stderr,"ObjPtr: size=%d stride=%d\n",
 331                         VB->ObjPtr->size, VB->ObjPtr->stride);
 332                 fprintf(stderr,"ColorPtr[0]: size=%d stride=%d\n",
 333                         VB->ColorPtr[0]->size, VB->ColorPtr[0]->stride);
 334                 fprintf(stderr,"TexCoordPtr[0]: size=%d stride=%d\n",
 335                         VB->TexCoordPtr[0]->size, VB->TexCoordPtr[0]->stride);
 336                 #endif
 337
 338    if(type<0 || num_verts <= 0)return;
 339
 340    if(!VB->ObjPtr){
 341         WARN_ONCE("FIXME: Don't know how to handle GL_ARB_vertex_buffer_object correctly\n");
 342         return;
 343    }
 344    /* A packet cannot have more than 16383 data words.. */
 345    if((num_verts*4*rmesa->state.aos_count)>16380){
 346         WARN_ONCE("Too many vertices to paint. Fix me !\n");
 347         return;
 348         }
 349
 350    //fprintf(stderr, "aos_count=%d start=%d end=%d\n", rmesa->state.aos_count, start, end);
 351
 352    if(rmesa->state.aos_count==0){
 353         WARN_ONCE("Aeiee ! aos_count==0, while it shouldn't. Skipping rendering\n");
 354         return;
 355         }
 356
 357    render_inputs = rmesa->state.render_inputs;
 358
 359    if(!render_inputs){
 360         WARN_ONCE("Aeiee ! render_inputs==0. Skipping rendering.\n");
 361         return;
 362         }
 363
 364         //dump_inputs(ctx, render_inputs); return ;
 365
 366    start_immediate_packet(num_verts, type, 4*rmesa->state.aos_count);
 367
 368         for(i=start;i<start+num_verts;i++){
 369                 #if 0
 370                 fprintf(stderr, "* (%f %f %f %f) (%f %f %f %f)\n",
 371                         VEC_ELT(VB->ObjPtr, GLfloat, i)[0],
 372                         VEC_ELT(VB->ObjPtr, GLfloat, i)[1],
 373                         VEC_ELT(VB->ObjPtr, GLfloat, i)[2],
 374                         VEC_ELT(VB->ObjPtr, GLfloat, i)[3],
 375
 376                         VEC_ELT(VB->ColorPtr[0], GLfloat, i)[0],
 377                         VEC_ELT(VB->ColorPtr[0], GLfloat, i)[1],
 378                         VEC_ELT(VB->ColorPtr[0], GLfloat, i)[2],
 379                         VEC_ELT(VB->ColorPtr[0], GLfloat, i)[3]
 380                         );
 381                 #endif
 382
 383
 384                 /* coordinates */
 385                 if(render_inputs & _TNL_BIT_POS)
 386                         output_vector(VB->ObjPtr, i);
 387                 if(render_inputs & _TNL_BIT_NORMAL)
 388                         output_vector(VB->NormalPtr, i);
 389
 390                 /* color components */
 391                 if(render_inputs & _TNL_BIT_COLOR0)
 392                         output_vector(VB->ColorPtr[0], i);
 393                 if(render_inputs & _TNL_BIT_COLOR1)
 394                         output_vector(VB->SecondaryColorPtr[0], i);
 395
 396 /*              if(render_inputs & _TNL_BIT_FOG) // Causes lock ups when immediate mode is on
 397                         output_vector(VB->FogCoordPtr, i);*/
 398
 399                 /* texture coordinates */
 400                 for(k=0;k < ctx->Const.MaxTextureUnits;k++)
 401                         if(render_inputs & (_TNL_BIT_TEX0<<k))
 402                                 output_vector(VB->TexCoordPtr[k], i);
 403
 404                 if(render_inputs & _TNL_BIT_INDEX)
 405                         output_vector(VB->IndexPtr[0], i);
 406                 if(render_inputs & _TNL_BIT_POINTSIZE)
 407                         output_vector(VB->PointSizePtr, i);
 408                 }
 409
 410 }
 411
 412
 413 static GLboolean r300_run_immediate_render(GLcontext *ctx,
 414                                  struct tnl_pipeline_stage *stage)
 415 {
 416    r300ContextPtr rmesa = R300_CONTEXT(ctx);
 417    TNLcontext *tnl = TNL_CONTEXT(ctx);
 418    struct vertex_buffer *VB = &tnl->vb;
 419    GLuint i;
 420    /* Only do 2d textures */
 421    struct gl_texture_object *to=ctx->Texture.Unit[0].Current2D;
 422    r300TexObjPtr t=to->DriverData;
 423    LOCAL_VARS
 424
 425
 426    /* Update texture state - needs to be done only when actually changed..
 427       All the time for now.. */
 428
 429
 430         if (RADEON_DEBUG == DEBUG_PRIMS)
 431                 fprintf(stderr, "%s\n", __FUNCTION__);
 432
 433    #if 1 /* we need this, somehow */
 434    /* Flush state - make sure command buffer is nice and large */
 435    r300Flush(ctx);
 436    /* Make sure we have enough space */
 437    #else
 438    /* Count is very imprecize, but should be good upper bound */
 439    r300EnsureCmdBufSpace(rmesa, rmesa->hw.max_state_size + 4+2+30
 440         +VB->PrimitiveCount*(1+8)+VB->Count*4*rmesa->state.texture.tc_count+4, __FUNCTION__);
 441    #endif
 442
 443    /* needed before starting 3d operation .. */
 444    reg_start(R300_RB3D_DSTCACHE_CTLSTAT,0);
 445         e32(0x0000000a);
 446
 447    reg_start(0x4f18,0);
 448         e32(0x00000003);
 449
 450
 451         #if 0 /* looks like the Z offset issue got fixed */
 452    rmesa->hw.vte.cmd[1] = R300_VPORT_X_SCALE_ENA
 453                                 | R300_VPORT_X_OFFSET_ENA
 454                                 | R300_VPORT_Y_SCALE_ENA
 455                                 | R300_VPORT_Y_OFFSET_ENA
 456                                 | R300_VTX_W0_FMT;
 457    R300_STATECHANGE(rmesa, vte);
 458         #endif
 459
 460
 461
 462    /* Magic register - note it is right after 20b0 */
 463
 464
 465    if(rmesa->state.texture.tc_count>0){
 466         reg_start(0x20b4,0);
 467                 e32(0x0000000c);
 468
 469         }
 470
 471    r300EmitState(rmesa);
 472
 473    #if 0
 474    reg_start(R300_RB3D_COLORMASK, 0);
 475         e32(0xf);
 476
 477    vsf_start_fragment(0x406, 4);
 478    efloat(0.0);
 479    efloat(0.0);
 480    efloat(0.0);
 481    efloat(1.0);
 482
 483    vsf_start_fragment(0x400, 4);
 484    efloat(0.0);
 485    efloat(0.0);
 486    efloat(0.0);
 487    efloat(1.0);
 488    #endif
 489
 490 /* Setup INPUT_ROUTE and INPUT_CNTL */
 491         r300EmitArrays(ctx, GL_TRUE);
 492
 493 /* Why do we need this for immediate mode?? Vertex processor needs it to know proper regs */
 494 //      r300EmitLOAD_VBPNTR(rmesa, 0);
 495
 496    for(i=0; i < VB->PrimitiveCount; i++){
 497        GLuint prim = VB->Primitive[i].mode;
 498        GLuint start = VB->Primitive[i].start;
 499        GLuint length = VB->Primitive[i].count;
 500
 501         r300_render_immediate_primitive(rmesa, ctx, start, start + length, prim);
 502         }
 503
 504     /* This sequence is required after any 3d drawing packet
 505       I suspect it work arounds a bug (or deficiency) in hardware */
 506
 507    reg_start(R300_RB3D_DSTCACHE_CTLSTAT,0);
 508         e32(0x0000000a);
 509
 510    reg_start(0x4f18,0);
 511         e32(0x00000003);
 512
 513    return GL_FALSE;
 514 }
 515
 516 /* vertex buffer implementation */
 517 void emit_elts(GLcontext * ctx, GLuint *elts, int oec, int ec);
 518
 519 #    define R300_EB_UNK1_SHIFT 24
 520 #    define R300_EB_UNK1 (0x80<<24)
 521 #    define R300_EB_UNK2 0x0810
 522
 523 unsigned long get_num_elts(unsigned long count)
 524 {
 525         unsigned long magic_1;
 526
 527         /* round up elt count so that magic_1 is 0 (divisable by 4)*/
 528         return (count+3) & (~3);
 529         //return count - (count % 4);
 530 }
 531
 532 static void inline fire_EB(PREFIX unsigned long addr, int vertex_count, int type)
 533 {
 534         LOCAL_VARS
 535         unsigned long magic_1;
 536         unsigned char magic1_tbl[4]={ 0, 6, 4, 2 };
 537
 538         magic_1 = magic1_tbl[vertex_count % 4];
 539
 540         if(magic_1 != 0){
 541                 WARN_ONCE("Dont know how to handle this yet!\n");
 542                 return ;
 543         }
 544
 545         check_space(6);
 546
 547         start_packet3(RADEON_CP_PACKET3_3D_DRAW_INDX_2, 0);
 548         e32(R300_VAP_VF_CNTL__PRIM_WALK_INDICES | (vertex_count<<16) | type);
 549
 550         start_packet3(RADEON_CP_PACKET3_INDX_BUFFER, 2);
 551         e32(R300_EB_UNK1 | (magic_1 << 16) | R300_EB_UNK2);
 552         e32(addr);
 553         e32(((vertex_count+1) / 2) + magic_1);
 554 }
 555
 556 static void r300_render_vb_primitive(r300ContextPtr rmesa,
 557         GLcontext *ctx,
 558         int start,
 559         int end,
 560         int prim)
 561 {
 562    int type, num_verts;
 563    radeonScreenPtr rsp=rmesa->radeon.radeonScreen;
 564    LOCAL_VARS
 565    TNLcontext *tnl = TNL_CONTEXT(ctx);
 566    struct vertex_buffer *VB = &tnl->vb;
 567
 568    type=r300_get_primitive_type(rmesa, ctx, prim);
 569    num_verts=r300_get_num_verts(rmesa, ctx, end-start, prim);
 570
 571    if(type<0 || num_verts <= 0)return;
 572
 573    if(rmesa->state.Elts){
 574         unsigned long elt_count;
 575
 576         WARN_ONCE("Rendering with elts\n");
 577
 578         elt_count=get_num_elts(num_verts);
 579         //emit_elts(ctx, rmesa->state.Elts, VB->Count, get_num_elts(VB->Count));
 580         emit_elts(ctx, rmesa->state.Elts+start, num_verts, elt_count);
 581         fire_EB(PASS_PREFIX rsp->gartTextures.handle/*rmesa->state.elt_ao.aos_offset*/, elt_count, type);
 582    }else
 583            fire_AOS(PASS_PREFIX num_verts, type);
 584 }
 585
 586 static GLboolean r300_run_vb_render(GLcontext *ctx,
 587                                  struct tnl_pipeline_stage *stage)
 588 {
 589    r300ContextPtr rmesa = R300_CONTEXT(ctx);
 590    TNLcontext *tnl = TNL_CONTEXT(ctx);
 591    struct vertex_buffer *VB = &tnl->vb;
 592    int i, j;
 593    LOCAL_VARS
 594
 595         if (RADEON_DEBUG == DEBUG_PRIMS)
 596                 fprintf(stderr, "%s\n", __FUNCTION__);
 597
 598
 599         r300ReleaseArrays(ctx);
 600         r300EmitArrays(ctx, GL_FALSE);
 601         //dump_inputs(ctx, rmesa->state.render_inputs);
 602 #if 0 /* Cant do this here yet due to magic_1 */
 603         if(rmesa->state.Elts)
 604                 emit_elts(ctx, rmesa->state.Elts, /*600*/VB->Count, get_num_elts(/*600*/VB->Count));
 605 #endif
 606
 607 //      LOCK_HARDWARE(&(rmesa->radeon));
 608
 609         reg_start(R300_RB3D_DSTCACHE_CTLSTAT,0);
 610         e32(0x0000000a);
 611
 612         reg_start(0x4f18,0);
 613         e32(0x00000003);
 614
 615         r300EmitState(rmesa);
 616
 617         rmesa->state.Elts = VB->Elts;
 618
 619         for(i=0; i < VB->PrimitiveCount; i++){
 620                 GLuint prim = VB->Primitive[i].mode;
 621                 GLuint start = VB->Primitive[i].start;
 622                 GLuint length = VB->Primitive[i].count;
 623
 624                 r300EmitAOS(rmesa, rmesa->state.aos_count, start);
 625
 626                 r300_render_vb_primitive(rmesa, ctx, start, start + length, prim);
 627         }
 628
 629         reg_start(R300_RB3D_DSTCACHE_CTLSTAT,0);
 630         e32(0x0000000a);
 631
 632         reg_start(0x4f18,0);
 633         e32(0x00000003);
 634
 635 //      end_3d(PASS_PREFIX_VOID);
 636
 637    /* Flush state - we are done drawing.. */
 638 //      r300FlushCmdBufLocked(rmesa, __FUNCTION__);
 639 //      radeonWaitForIdleLocked(&(rmesa->radeon));
 640
 641 //      UNLOCK_HARDWARE(&(rmesa->radeon));
 642         return GL_FALSE;
 643 }
 644
 645 /**
 646  * Called by the pipeline manager to render a batch of primitives.
 647  * We can return true to pass on to the next stage (i.e. software
 648  * rasterization) or false to indicate that the pipeline has finished
 649  * after we render something.
 650  */
 651 static GLboolean r300_run_render(GLcontext *ctx,
 652                                  struct tnl_pipeline_stage *stage)
 653 {
 654    r300ContextPtr rmesa = R300_CONTEXT(ctx);
 655    TNLcontext *tnl = TNL_CONTEXT(ctx);
 656    struct vertex_buffer *VB = &tnl->vb;
 657    GLuint i;
 658
 659         if (RADEON_DEBUG == DEBUG_PRIMS)
 660                 fprintf(stderr, "%s\n", __FUNCTION__);
 661
 662
 663    #if 1
 664
 665         #if 1
 666         return r300_run_immediate_render(ctx, stage);
 667         #else
 668         return r300_run_vb_render(ctx, stage);
 669         #endif
 670    #else
 671         return GL_TRUE;
 672    #endif
 673
 674 #if 0
 675    mgaContextPtr mmesa = MGA_CONTEXT(ctx);
 676    TNLcontext *tnl = TNL_CONTEXT(ctx);
 677    struct vertex_buffer *VB = &tnl->vb;
 678    GLuint i;
 679
 680    /* Don't handle clipping or indexed vertices or vertex manipulations.
 681     */
 682    if (mmesa->RenderIndex != 0 ||
 683        !mga_validate_render( ctx, VB )) {
 684       return GL_TRUE;
 685    }
 686
 687    tnl->Driver.Render.Start( ctx );
 688    mmesa->SetupNewInputs = ~0;
 689
 690    for (i = 0 ; i < VB->PrimitiveCount ; i++)
 691    {
 692       GLuint prim = VB->Primitive[i].mode;
 693       GLuint start = VB->Primitive[i].start;
 694       GLuint length = VB->Primitive[i].count;
 695
 696       if (!length)
 697          continue;
 698
 699       mga_render_tab_verts[prim & PRIM_MODE_MASK]( ctx, start, start + length,
 700                                                    prim);
 701    }
 702
 703    tnl->Driver.Render.Finish( ctx );
 704
 705    return GL_FALSE;             /* finished the pipe */
 706 #endif
 707 }
 708
 709
 710 /**
 711  * Called by the pipeline manager once before rendering.
 712  * We check the GL state here to
 713  *  a) decide whether we can do the current state in hardware and
 714  *  b) update hardware registers
 715  */
 716 #define FALLBACK_IF(expr) \
 717 do {                                                                            \
 718         if (expr) {                                                             \
 719                 if (1 || RADEON_DEBUG & DEBUG_FALLBACKS)                                \
 720                         fprintf(stderr, "%s: fallback:%s\n",                    \
 721                                 __FUNCTION__, #expr);                           \
 722                 stage->active = GL_FALSE;                                       \
 723                 return;                                                         \
 724         }                                                                       \
 725 } while(0)
 726
 727 static void r300_check_render(GLcontext *ctx, struct tnl_pipeline_stage *stage)
 728 {
 729         r300ContextPtr r300 = R300_CONTEXT(ctx);
 730         int i;
 731
 732         if (RADEON_DEBUG & DEBUG_STATE)
 733                 fprintf(stderr, "%s\n", __FUNCTION__);
 734
 735         /* We only support rendering in hardware for now */
 736         if (ctx->RenderMode != GL_RENDER) {
 737                 stage->active = GL_FALSE;
 738                 return;
 739         }
 740
 741         // I failed to figure out how dither works in hardware,
 742         // let's just ignore it for now
 743         //FALLBACK_IF(ctx->Color.DitherFlag);
 744
 745         /* I'm almost certain I forgot something here */
 746         #if 0 /* This should work now.. */
 747         FALLBACK_IF(ctx->Color.AlphaEnabled); // GL_ALPHA_TEST
 748         FALLBACK_IF(ctx->Color.BlendEnabled); // GL_BLEND
 749         #endif
 750         //FALLBACK_IF(ctx->Fog.Enabled); // GL_FOG disable as swtcl doesnt seem to support this
 751         FALLBACK_IF(ctx->Line.SmoothFlag); // GL_LINE_SMOOTH
 752         FALLBACK_IF(ctx->Line.StippleFlag); // GL_LINE_STIPPLE
 753         FALLBACK_IF(ctx->Point.SmoothFlag); // GL_POINT_SMOOTH
 754         if (ctx->Extensions.NV_point_sprite || ctx->Extensions.ARB_point_sprite)
 755                 FALLBACK_IF(ctx->Point.PointSprite); // GL_POINT_SPRITE_NV
 756         //FALLBACK_IF(ctx->Polygon.OffsetPoint); // GL_POLYGON_OFFSET_POINT
 757         //FALLBACK_IF(ctx->Polygon.OffsetLine); // GL_POLYGON_OFFSET_LINE
 758         //FALLBACK_IF(ctx->Polygon.OffsetFill); // GL_POLYGON_OFFSET_FILL
 759         //if(ctx->Polygon.OffsetFill)WARN_ONCE("Polygon.OffsetFill not implemented, ignoring\n");
 760         FALLBACK_IF(ctx->Polygon.SmoothFlag); // GL_POLYGON_SMOOTH
 761         FALLBACK_IF(ctx->Polygon.StippleFlag); // GL_POLYGON_STIPPLE
 762         //FALLBACK_IF(ctx->Stencil.Enabled); // GL_STENCIL_TEST
 763         FALLBACK_IF(ctx->Multisample.Enabled); // GL_MULTISAMPLE_ARB
 764
 765         /* One step at a time - let one texture pass.. */
 766         for (i = 1; i < ctx->Const.MaxTextureUnits; i++)
 767                 FALLBACK_IF(ctx->Texture.Unit[i].Enabled);
 768
 769         /* let r300_run_render do its job */
 770         #if 0
 771         stage->active = GL_FALSE;
 772         #endif
 773 }
 774
 775
 776 static void dtr(struct tnl_pipeline_stage *stage)
 777 {
 778         (void)stage;
 779 }
 780
 781 const struct tnl_pipeline_stage _r300_render_stage = {
 782         "r300 hw rasterize",
 783         _NEW_ALL,               /* re-check (always re-check for now) */
 784         0,                      /* re-run (always runs) */
 785         GL_TRUE,                /* active */
 786         0, 0,                   /* inputs (set in check_render), outputs */
 787         0, 0,                   /* changed_inputs, private */
 788         dtr,                    /* destructor */
 789         r300_check_render,      /* check */
 790         r300_run_render         /* run */
 791 };