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 "vbo/vbo.h"
  46 #include "tnl/tnl.h"
  47 #include "tnl/t_vp_build.h"
  48
  49 #include "radeon_reg.h"
  50 #include "radeon_macros.h"
  51 #include "radeon_ioctl.h"
  52 #include "radeon_state.h"
  53 #include "r300_context.h"
  54 #include "r300_ioctl.h"
  55 #include "r300_state.h"
  56 #include "r300_reg.h"
  57 #include "r300_program.h"
  58 #include "r300_tex.h"
  59 #include "r300_maos.h"
  60 #include "r300_emit.h"
  61
  62 extern int future_hw_tcl_on;
  63
  64 /**********************************************************************
  65 *                     Hardware rasterization
  66 *
  67 * When we fell back to software TCL, we still try to use the
  68 * rasterization hardware for rendering.
  69 **********************************************************************/
  70
  71 static int r300_get_primitive_type(r300ContextPtr rmesa, GLcontext *ctx, int prim)
  72 {
  73         int type=-1;
  74
  75         switch (prim & PRIM_MODE_MASK) {
  76         case GL_POINTS:
  77                 type=R300_VAP_VF_CNTL__PRIM_POINTS;
  78                 break;
  79         case GL_LINES:
  80                 type=R300_VAP_VF_CNTL__PRIM_LINES;
  81                 break;
  82         case GL_LINE_STRIP:
  83                 type=R300_VAP_VF_CNTL__PRIM_LINE_STRIP;
  84                 break;
  85         case GL_LINE_LOOP:
  86                 type=R300_VAP_VF_CNTL__PRIM_LINE_LOOP;
  87                 break;
  88         case GL_TRIANGLES:
  89                 type=R300_VAP_VF_CNTL__PRIM_TRIANGLES;
  90                 break;
  91         case GL_TRIANGLE_STRIP:
  92                 type=R300_VAP_VF_CNTL__PRIM_TRIANGLE_STRIP;
  93                 break;
  94         case GL_TRIANGLE_FAN:
  95                 type=R300_VAP_VF_CNTL__PRIM_TRIANGLE_FAN;
  96                 break;
  97         case GL_QUADS:
  98                 type=R300_VAP_VF_CNTL__PRIM_QUADS;
  99                 break;
 100         case GL_QUAD_STRIP:
 101                 type=R300_VAP_VF_CNTL__PRIM_QUAD_STRIP;
 102                 break;
 103         case GL_POLYGON:
 104                 type=R300_VAP_VF_CNTL__PRIM_POLYGON;
 105                 break;
 106         default:
 107                 fprintf(stderr, "%s:%s Do not know how to handle primitive %02x - help me !\n",
 108                         __FILE__, __FUNCTION__,
 109                         prim & PRIM_MODE_MASK);
 110                 return -1;
 111                 break;
 112         }
 113    return type;
 114 }
 115
 116 int r300_get_num_verts(r300ContextPtr rmesa, int num_verts, int prim)
 117 {
 118         int verts_off=0;
 119         char *name="UNKNOWN";
 120
 121         switch (prim & PRIM_MODE_MASK) {
 122         case GL_POINTS:
 123                 name="P";
 124                 verts_off = 0;
 125                 break;
 126         case GL_LINES:
 127                 name="L";
 128                 verts_off = num_verts % 2;
 129                 break;
 130         case GL_LINE_STRIP:
 131                 name="LS";
 132                 if(num_verts < 2)
 133                         verts_off = num_verts;
 134                 break;
 135         case GL_LINE_LOOP:
 136                 name="LL";
 137                 if(num_verts < 2)
 138                         verts_off = num_verts;
 139                 break;
 140         case GL_TRIANGLES:
 141                 name="T";
 142                 verts_off = num_verts % 3;
 143                 break;
 144         case GL_TRIANGLE_STRIP:
 145                 name="TS";
 146                 if(num_verts < 3)
 147                         verts_off = num_verts;
 148                 break;
 149         case GL_TRIANGLE_FAN:
 150                 name="TF";
 151                 if(num_verts < 3)
 152                         verts_off = num_verts;
 153                 break;
 154         case GL_QUADS:
 155                 name="Q";
 156                 verts_off = num_verts % 4;
 157                 break;
 158         case GL_QUAD_STRIP:
 159                 name="QS";
 160                 if(num_verts < 4)
 161                         verts_off = num_verts;
 162                 else
 163                         verts_off = num_verts % 2;
 164                 break;
 165         case GL_POLYGON:
 166                 name="P";
 167                 if(num_verts < 3)
 168                         verts_off = num_verts;
 169                 break;
 170         default:
 171                 fprintf(stderr, "%s:%s Do not know how to handle primitive %02x - help me !\n",
 172                         __FILE__, __FUNCTION__,
 173                         prim & PRIM_MODE_MASK);
 174                 return -1;
 175                 break;
 176         }
 177
 178         if (RADEON_DEBUG & DEBUG_VERTS) {
 179                 if (num_verts - verts_off == 0) {
 180                         WARN_ONCE("user error: Need more than %d vertices to draw primitive %s !\n", num_verts, name);
 181                         return 0;
 182                 }
 183
 184                 if (verts_off > 0) {
 185                         WARN_ONCE("user error: %d is not a valid number of vertices for primitive %s !\n", num_verts, name);
 186                 }
 187         }
 188
 189         return num_verts - verts_off;
 190 }
 191
 192 /* Immediate implementation has been removed from CVS. */
 193
 194 /* vertex buffer implementation */
 195
 196 static void inline fire_EB(r300ContextPtr rmesa, unsigned long addr, int vertex_count, int type, int elt_size)
 197 {
 198         int cmd_reserved = 0;
 199         int cmd_written = 0;
 200         drm_radeon_cmd_header_t *cmd = NULL;
 201         unsigned long t_addr;
 202         unsigned long magic_1, magic_2;
 203         GLcontext *ctx;
 204         ctx = rmesa->radeon.glCtx;
 205
 206         assert(elt_size == 2 || elt_size == 4);
 207
 208         if(addr & (elt_size-1)){
 209                 WARN_ONCE("Badly aligned buffer\n");
 210                 return ;
 211         }
 212 #ifdef OPTIMIZE_ELTS
 213         magic_1 = (addr % 32) / 4;
 214         t_addr = addr & (~0x1d);
 215         magic_2 = (vertex_count + 1 + (t_addr & 0x2)) / 2 + magic_1;
 216
 217         check_space(6);
 218
 219         start_packet3(RADEON_CP_PACKET3_3D_DRAW_INDX_2, 0);
 220         if(elt_size == 4){
 221                 e32(R300_VAP_VF_CNTL__PRIM_WALK_INDICES | (vertex_count<<16) | type | R300_VAP_VF_CNTL__INDEX_SIZE_32bit);
 222         } else {
 223                 e32(R300_VAP_VF_CNTL__PRIM_WALK_INDICES | (vertex_count<<16) | type);
 224         }
 225
 226         start_packet3(RADEON_CP_PACKET3_INDX_BUFFER, 2);
 227         if(elt_size == 4){
 228                 e32(R300_EB_UNK1 | (0 << 16) | R300_EB_UNK2);
 229                 e32(addr /*& 0xffffffe3*/);
 230         } else {
 231                 e32(R300_EB_UNK1 | (magic_1 << 16) | R300_EB_UNK2);
 232                 e32(t_addr);
 233         }
 234
 235         if(elt_size == 4){
 236                 e32(vertex_count); /* Total number of dwords needed? */
 237         } else {
 238                 e32(magic_2); /* Total number of dwords needed? */
 239         }
 240         //cp_delay(rmesa, 1);
 241 #else
 242         (void)magic_2, (void)magic_1, (void)t_addr;
 243
 244         check_space(6);
 245
 246         start_packet3(RADEON_CP_PACKET3_3D_DRAW_INDX_2, 0);
 247         if(elt_size == 4){
 248                 e32(R300_VAP_VF_CNTL__PRIM_WALK_INDICES | (vertex_count<<16) | type | R300_VAP_VF_CNTL__INDEX_SIZE_32bit);
 249         } else {
 250                 e32(R300_VAP_VF_CNTL__PRIM_WALK_INDICES | (vertex_count<<16) | type);
 251         }
 252
 253         start_packet3(RADEON_CP_PACKET3_INDX_BUFFER, 2);
 254         e32(R300_EB_UNK1 | (0 << 16) | R300_EB_UNK2);
 255         e32(addr /*& 0xffffffe3*/);
 256
 257         if(elt_size == 4){
 258                 e32(vertex_count); /* Total number of dwords needed? */
 259         } else {
 260                 e32((vertex_count+1)/2); /* Total number of dwords needed? */
 261         }
 262         //cp_delay(rmesa, 1);
 263 #endif
 264 }
 265
 266 static void r300_render_vb_primitive(r300ContextPtr rmesa,
 267         GLcontext *ctx,
 268         int start,
 269         int end,
 270         int prim)
 271 {
 272    int type, num_verts;
 273
 274    type=r300_get_primitive_type(rmesa, ctx, prim);
 275    num_verts=r300_get_num_verts(rmesa, end-start, prim);
 276
 277    if(type<0 || num_verts <= 0)return;
 278
 279    if(rmesa->state.VB.Elts){
 280         r300EmitAOS(rmesa, rmesa->state.aos_count, /*0*/start);
 281         if(num_verts > 65535){ /* not implemented yet */
 282                 WARN_ONCE("Too many elts\n");
 283                 return;
 284         }
 285         r300EmitElts(ctx, rmesa->state.VB.Elts, num_verts, rmesa->state.VB.elt_size);
 286         fire_EB(rmesa, rmesa->state.elt_dma.aos_offset, num_verts, type, rmesa->state.VB.elt_size);
 287    }else{
 288            r300EmitAOS(rmesa, rmesa->state.aos_count, start);
 289            fire_AOS(rmesa, num_verts, type);
 290    }
 291 }
 292
 293 GLboolean r300_run_vb_render(GLcontext *ctx,
 294                                  struct tnl_pipeline_stage *stage)
 295 {
 296         r300ContextPtr rmesa = R300_CONTEXT(ctx);
 297         struct radeon_vertex_buffer *VB = &rmesa->state.VB;
 298         int i;
 299         int cmd_reserved = 0;
 300         int cmd_written = 0;
 301         drm_radeon_cmd_header_t *cmd = NULL;
 302
 303
 304         if (RADEON_DEBUG & DEBUG_PRIMS)
 305                 fprintf(stderr, "%s\n", __FUNCTION__);
 306
 307         if (stage) {
 308                 TNLcontext *tnl = TNL_CONTEXT(ctx);
 309                 radeon_vb_to_rvb(rmesa, VB, &tnl->vb);
 310         }
 311
 312         r300UpdateShaders(rmesa);
 313         if (r300EmitArrays(ctx))
 314                 return GL_TRUE;
 315
 316         r300UpdateShaderStates(rmesa);
 317
 318         reg_start(R300_RB3D_DSTCACHE_CTLSTAT,0);
 319         e32(R300_RB3D_DSTCACHE_UNKNOWN_0A);
 320
 321         reg_start(R300_RB3D_ZCACHE_CTLSTAT,0);
 322         e32(R300_RB3D_ZCACHE_UNKNOWN_03);
 323
 324         r300EmitState(rmesa);
 325
 326         for(i=0; i < VB->PrimitiveCount; i++){
 327                 GLuint prim = _tnl_translate_prim(&VB->Primitive[i]);
 328                 GLuint start = VB->Primitive[i].start;
 329                 GLuint length = VB->Primitive[i].count;
 330
 331                 r300_render_vb_primitive(rmesa, ctx, start, start + length, prim);
 332         }
 333
 334         reg_start(R300_RB3D_DSTCACHE_CTLSTAT,0);
 335         e32(R300_RB3D_DSTCACHE_UNKNOWN_0A /*R300_RB3D_DSTCACHE_UNKNOWN_02*/);
 336
 337         reg_start(R300_RB3D_ZCACHE_CTLSTAT,0);
 338         e32(R300_RB3D_ZCACHE_UNKNOWN_03 /*R300_RB3D_ZCACHE_UNKNOWN_01*/);
 339
 340 #ifdef USER_BUFFERS
 341         r300UseArrays(ctx);
 342 #endif
 343         r300ReleaseArrays(ctx);
 344         return GL_FALSE;
 345 }
 346
 347 #define FALLBACK_IF(expr)                                               \
 348         do {                                                            \
 349                 if (expr) {                                             \
 350                         if (1 || RADEON_DEBUG & DEBUG_FALLBACKS)        \
 351                                 WARN_ONCE("Software fallback:%s\n",     \
 352                                           #expr);                       \
 353                         return R300_FALLBACK_RAST;                      \
 354                 }                                                       \
 355         } while(0)
 356
 357 int r300Fallback(GLcontext *ctx)
 358 {
 359         r300ContextPtr r300 = R300_CONTEXT(ctx);
 360         struct r300_fragment_program *rp =
 361                 (struct r300_fragment_program *)
 362                 (char *)ctx->FragmentProgram._Current;
 363
 364         if (rp) {
 365                 if (!rp->translated)
 366                         r300_translate_fragment_shader(r300, rp);
 367
 368                 FALLBACK_IF(!rp->translated);
 369         }
 370
 371         /* We do not do SELECT or FEEDBACK (yet ?)
 372          * Is it worth doing them ?
 373          */
 374         FALLBACK_IF(ctx->RenderMode != GL_RENDER);
 375
 376         FALLBACK_IF(ctx->Stencil._TestTwoSide &&
 377                     (ctx->Stencil.Ref[0] != ctx->Stencil.Ref[1] ||
 378                      ctx->Stencil.ValueMask[0] != ctx->Stencil.ValueMask[1] ||
 379                      ctx->Stencil.WriteMask[0] != ctx->Stencil.WriteMask[1]));
 380
 381         if(!r300->disable_lowimpact_fallback){
 382                 /* GL_POLYGON_OFFSET_POINT */
 383                 FALLBACK_IF(ctx->Polygon.OffsetPoint);
 384                 /* GL_POLYGON_OFFSET_LINE */
 385                 FALLBACK_IF(ctx->Polygon.OffsetLine);
 386                 /* GL_POLYGON_STIPPLE */
 387                 FALLBACK_IF(ctx->Polygon.StippleFlag);
 388                 /* GL_MULTISAMPLE_ARB */
 389                 FALLBACK_IF(ctx->Multisample.Enabled);
 390                 /* blender ? */
 391                 FALLBACK_IF(ctx->Line.StippleFlag);
 392                 /* GL_LINE_SMOOTH */
 393                 FALLBACK_IF(ctx->Line.SmoothFlag);
 394                 /* GL_POINT_SMOOTH */
 395                 FALLBACK_IF(ctx->Point.SmoothFlag);
 396         }
 397
 398         /* Fallback for LOGICOP */
 399         FALLBACK_IF(ctx->Color.ColorLogicOpEnabled);
 400
 401         /* Rest could be done with vertex fragments */
 402         if (ctx->Extensions.NV_point_sprite ||
 403             ctx->Extensions.ARB_point_sprite)
 404                 /* GL_POINT_SPRITE_NV */
 405                 FALLBACK_IF(ctx->Point.PointSprite);
 406
 407         return R300_FALLBACK_NONE;
 408 }
 409
 410 /**
 411  * Called by the pipeline manager to render a batch of primitives.
 412  * We can return true to pass on to the next stage (i.e. software
 413  * rasterization) or false to indicate that the pipeline has finished
 414  * after we render something.
 415  */
 416 static GLboolean r300_run_render(GLcontext *ctx,
 417                                  struct tnl_pipeline_stage *stage)
 418 {
 419         if (RADEON_DEBUG & DEBUG_PRIMS)
 420                 fprintf(stderr, "%s\n", __FUNCTION__);
 421
 422         if (r300Fallback(ctx) >= R300_FALLBACK_RAST)
 423                 return GL_TRUE;
 424
 425         return r300_run_vb_render(ctx, stage);
 426 }
 427
 428 const struct tnl_pipeline_stage _r300_render_stage = {
 429         "r300 hw rasterize",
 430         NULL,
 431         NULL,
 432         NULL,
 433         NULL,
 434         r300_run_render         /* run */
 435 };
 436
 437 static GLboolean r300_run_tcl_render(GLcontext *ctx,
 438                                  struct tnl_pipeline_stage *stage)
 439 {
 440         r300ContextPtr rmesa = R300_CONTEXT(ctx);
 441         struct r300_vertex_program *vp;
 442
 443         hw_tcl_on=future_hw_tcl_on;
 444
 445         if (RADEON_DEBUG & DEBUG_PRIMS)
 446                 fprintf(stderr, "%s\n", __FUNCTION__);
 447         if(hw_tcl_on == GL_FALSE)
 448                 return GL_TRUE;
 449
 450         if (r300Fallback(ctx) >= R300_FALLBACK_TCL) {
 451                 hw_tcl_on = GL_FALSE;
 452                 return GL_TRUE;
 453         }
 454
 455         r300UpdateShaders(rmesa);
 456
 457         vp = (struct r300_vertex_program *)CURRENT_VERTEX_SHADER(ctx);
 458         if (vp->native == GL_FALSE) {
 459                 hw_tcl_on = GL_FALSE;
 460                 return GL_TRUE;
 461         }
 462
 463         //r300UpdateShaderStates(rmesa);
 464
 465         return r300_run_vb_render(ctx, stage);
 466 }
 467
 468 const struct tnl_pipeline_stage _r300_tcl_stage = {
 469         "r300 tcl",
 470         NULL,
 471         NULL,
 472         NULL,
 473         NULL,
 474         r300_run_tcl_render     /* run */
 475 };
 476