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

   1 /**************************************************************************
   2
   3 Copyright (C) 2007 Dave Airlie
   4
   5 All Rights Reserved.
   6
   7 Permission is hereby granted, free of charge, to any person obtaining a
   8 copy of this software and associated documentation files (the "Software"),
   9 to deal in the Software without restriction, including without limitation
  10 on the rights to use, copy, modify, merge, publish, distribute, sub
  11 license, and/or sell copies of the Software, and to permit persons to whom
  12 the Software is furnished to do so, subject to the following conditions:
  13
  14 The above copyright notice and this permission notice (including the next
  15 paragraph) shall be included in all copies or substantial portions of the
  16 Software.
  17
  18 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  19 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20 FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  21 THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
  22 DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  23 OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  24 USE OR OTHER DEALINGS IN THE SOFTWARE.
  25
  26 **************************************************************************/
  27
  28 /*
  29  * Authors:
  30  *   Dave Airlie <airlied@linux.ie>
  31  *   Maciej Cencora <m.cencora@gmail.com>
  32  */
  33
  34 #include "tnl/tnl.h"
  35 #include "tnl/t_pipeline.h"
  36
  37 #include "r300_state.h"
  38 #include "r300_swtcl.h"
  39 #include "r300_emit.h"
  40 #include "r300_tex.h"
  41 #include "r300_render.h"
  42 #include "main/simple_list.h"
  43
  44 #define EMIT_ATTR( ATTR, STYLE )                                        \
  45 do {                                                                    \
  46         rmesa->radeon.swtcl.vertex_attrs[rmesa->radeon.swtcl.vertex_attr_count].attrib = (ATTR);        \
  47         rmesa->radeon.swtcl.vertex_attrs[rmesa->radeon.swtcl.vertex_attr_count].format = (STYLE);       \
  48         rmesa->radeon.swtcl.vertex_attr_count++;                                        \
  49 } while (0)
  50
  51 #define EMIT_PAD( N )                                                   \
  52 do {                                                                    \
  53    rmesa->radeon.swtcl.vertex_attrs[rmesa->radeon.swtcl.vertex_attr_count].attrib = 0;          \
  54    rmesa->radeon.swtcl.vertex_attrs[rmesa->radeon.swtcl.vertex_attr_count].format = EMIT_PAD;   \
  55    rmesa->radeon.swtcl.vertex_attrs[rmesa->radeon.swtcl.vertex_attr_count].offset = (N);                \
  56    rmesa->radeon.swtcl.vertex_attr_count++;                                     \
  57 } while (0)
  58
  59 #define ADD_ATTR(_attr, _format, _dst_loc, _swizzle, _write_mask, _normalize) \
  60 do { \
  61         attrs[num_attrs].element = (_attr); \
  62         attrs[num_attrs].data_type = (_format); \
  63         attrs[num_attrs].dst_loc = (_dst_loc); \
  64         attrs[num_attrs].swizzle = (_swizzle); \
  65         attrs[num_attrs].write_mask = (_write_mask); \
  66         attrs[num_attrs]._signed = 0; \
  67         attrs[num_attrs].normalize = (_normalize); \
  68         ++num_attrs; \
  69 } while (0)
  70
  71 void r300ChooseSwtclVertexFormat(struct gl_context *ctx, GLuint *_InputsRead,  GLuint *_OutputsWritten)
  72 {
  73         r300ContextPtr rmesa = R300_CONTEXT( ctx );
  74         TNLcontext *tnl = TNL_CONTEXT(ctx);
  75         struct vertex_buffer *VB = &tnl->vb;
  76         int first_free_tex = 0;
  77         GLuint InputsRead = 0;
  78         GLuint OutputsWritten = 0;
  79         int num_attrs = 0;
  80         GLuint fp_reads = rmesa->selected_fp->InputsRead;
  81         struct vertex_attribute *attrs = rmesa->vbuf.attribs;
  82
  83         radeon_print(RADEON_SWRENDER, RADEON_VERBOSE, "%s\n", __func__);
  84         rmesa->swtcl.coloroffset = rmesa->swtcl.specoffset = 0;
  85         rmesa->radeon.swtcl.vertex_attr_count = 0;
  86
  87         if (RADEON_DEBUG & RADEON_VERTS)
  88                 fprintf(stderr, "%s\n", __func__);
  89
  90         /* We always want non Ndc coords format */
  91         VB->AttribPtr[VERT_ATTRIB_POS] = VB->ClipPtr;
  92
  93         /* Always write position vector */
  94         InputsRead |= 1 << VERT_ATTRIB_POS;
  95         OutputsWritten |= 1 << VERT_RESULT_HPOS;
  96         EMIT_ATTR( _TNL_ATTRIB_POS, EMIT_4F );
  97         ADD_ATTR(VERT_ATTRIB_POS, R300_DATA_TYPE_FLOAT_4, SWTCL_OVM_POS, SWIZZLE_XYZW, MASK_XYZW, 0);
  98         rmesa->swtcl.coloroffset = 4;
  99
 100         if (fp_reads & FRAG_BIT_COL0) {
 101                 InputsRead |= 1 << VERT_ATTRIB_COLOR0;
 102                 OutputsWritten |= 1 << VERT_RESULT_COL0;
 103 #if MESA_LITTLE_ENDIAN
 104                 EMIT_ATTR( _TNL_ATTRIB_COLOR0, EMIT_4UB_4F_RGBA );
 105                 ADD_ATTR(VERT_ATTRIB_COLOR0, R300_DATA_TYPE_BYTE, SWTCL_OVM_COLOR0, SWIZZLE_XYZW, MASK_XYZW, 1);
 106 #else
 107                 EMIT_ATTR( _TNL_ATTRIB_COLOR0, EMIT_4UB_4F_ABGR );
 108                 ADD_ATTR(VERT_ATTRIB_COLOR0, R300_DATA_TYPE_BYTE, SWTCL_OVM_COLOR0, SWIZZLE_XYZW, MASK_XYZW, 1);
 109 #endif
 110         }
 111
 112         if (fp_reads & FRAG_BIT_COL1) {
 113                 GLuint swiz = MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_ONE);
 114                 InputsRead |= 1 << VERT_ATTRIB_COLOR1;
 115                 OutputsWritten |= 1 << VERT_RESULT_COL1;
 116 #if MESA_LITTLE_ENDIAN
 117                 EMIT_ATTR( _TNL_ATTRIB_COLOR1, EMIT_4UB_4F_RGBA );
 118                 ADD_ATTR(VERT_ATTRIB_COLOR1, R300_DATA_TYPE_BYTE, SWTCL_OVM_COLOR1, swiz, MASK_XYZW, 1);
 119 #else
 120                 EMIT_ATTR( _TNL_ATTRIB_COLOR1, EMIT_4UB_4F_ABGR );
 121                 ADD_ATTR(VERT_ATTRIB_COLOR1, R300_DATA_TYPE_BYTE, SWTCL_OVM_COLOR1, swiz, MASK_XYZW, 1);
 122 #endif
 123                 rmesa->swtcl.specoffset = rmesa->swtcl.coloroffset + 1;
 124         }
 125
 126         if (ctx->Light.Enabled && ctx->Light.Model.TwoSide) {
 127                 VB->AttribPtr[VERT_ATTRIB_GENERIC0] = VB->BackfaceColorPtr;
 128                 OutputsWritten |= 1 << VERT_RESULT_BFC0;
 129 #if MESA_LITTLE_ENDIAN
 130                 EMIT_ATTR( _TNL_ATTRIB_GENERIC0, EMIT_4UB_4F_RGBA );
 131                 ADD_ATTR(VERT_ATTRIB_GENERIC0, R300_DATA_TYPE_BYTE, SWTCL_OVM_COLOR2, SWIZZLE_XYZW, MASK_XYZW, 1);
 132 #else
 133                 EMIT_ATTR( _TNL_ATTRIB_GENERIC0, EMIT_4UB_4F_ABGR );
 134                 ADD_ATTR(VERT_ATTRIB_GENERIC0, R300_DATA_TYPE_BYTE, SWTCL_OVM_COLOR2, SWIZZLE_XYZW, MASK_XYZW, 1);
 135 #endif
 136                 if (fp_reads & FRAG_BIT_COL1) {
 137                         VB->AttribPtr[VERT_ATTRIB_GENERIC1] = VB->BackfaceSecondaryColorPtr;
 138                         GLuint swiz = MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_ONE);
 139                         OutputsWritten |= 1 << VERT_RESULT_BFC1;
 140 #if MESA_LITTLE_ENDIAN
 141                         EMIT_ATTR( _TNL_ATTRIB_GENERIC1, EMIT_4UB_4F_RGBA );
 142                         ADD_ATTR(VERT_ATTRIB_GENERIC1, R300_DATA_TYPE_BYTE, SWTCL_OVM_COLOR3, swiz, MASK_XYZW, 1);
 143 #else
 144                         EMIT_ATTR( _TNL_ATTRIB_GENERIC1, EMIT_4UB_4F_ABGR );
 145                         ADD_ATTR(VERT_ATTRIB_GENERIC1, R300_DATA_TYPE_BYTE, SWTCL_OVM_COLOR3, swiz, MASK_XYZW, 1);
 146 #endif
 147                 }
 148         }
 149
 150         if (RENDERINPUTS_TEST(tnl->render_inputs_bitset, _TNL_ATTRIB_POINTSIZE )) {
 151                 GLuint swiz = MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_ZERO, SWIZZLE_ZERO, SWIZZLE_ZERO);
 152                 InputsRead |= 1 << VERT_ATTRIB_POINT_SIZE;
 153                 OutputsWritten |= 1 << VERT_RESULT_PSIZ;
 154                 EMIT_ATTR( _TNL_ATTRIB_POINTSIZE, EMIT_1F );
 155                 ADD_ATTR(VERT_ATTRIB_POINT_SIZE, R300_DATA_TYPE_FLOAT_1, SWTCL_OVM_POINT_SIZE, swiz, MASK_X, 0);
 156         }
 157
 158         if (rmesa->selected_fp->wpos_attr != FRAG_ATTRIB_MAX) {
 159                 int tex_id = rmesa->selected_fp->wpos_attr - FRAG_ATTRIB_TEX0;
 160
 161                 VB->AttribPtr[VERT_ATTRIB_TEX0 + tex_id] = VB->AttribPtr[VERT_ATTRIB_POS];
 162                 VB->AttribPtr[_TNL_ATTRIB_TEX0 + tex_id] = VB->AttribPtr[VERT_ATTRIB_POS];
 163                 RENDERINPUTS_SET(tnl->render_inputs_bitset, _TNL_ATTRIB_TEX0 + tex_id);
 164         }
 165
 166         if (rmesa->selected_fp->fog_attr != FRAG_ATTRIB_MAX) {
 167                 int tex_id = rmesa->selected_fp->fog_attr - FRAG_ATTRIB_TEX0;
 168
 169                 VB->AttribPtr[VERT_ATTRIB_TEX0 + tex_id] = VB->AttribPtr[VERT_ATTRIB_FOG];
 170                 VB->AttribPtr[_TNL_ATTRIB_TEX0 + tex_id] = VB->AttribPtr[VERT_ATTRIB_FOG];
 171                 RENDERINPUTS_SET(tnl->render_inputs_bitset, _TNL_ATTRIB_TEX0 + tex_id);
 172         }
 173
 174         /**
 175          *  Sending only one texcoord component may lead to lock up,
 176          *  so for all textures always output 4 texcoord components to RS.
 177          */
 178         {
 179                 int i;
 180                 GLuint swiz, format, hw_format;
 181                 for (i = 0; i < ctx->Const.MaxTextureUnits; i++) {
 182                         if (fp_reads & FRAG_BIT_TEX(i)) {
 183                                 switch (VB->AttribPtr[_TNL_ATTRIB_TEX0 + i]->size) {
 184                                         case 1:
 185                                                 format = EMIT_1F;
 186                                                 hw_format = R300_DATA_TYPE_FLOAT_1;
 187                                                 swiz = MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_ZERO, SWIZZLE_ZERO, SWIZZLE_ONE);
 188                                                 break;
 189                                         case 2:
 190                                                 format = EMIT_2F;
 191                                                 hw_format = R300_DATA_TYPE_FLOAT_2;
 192                                                 swiz = MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_Y, SWIZZLE_ZERO, SWIZZLE_ONE);
 193                                                 break;
 194                                         case 3:
 195                                                 format = EMIT_3F;
 196                                                 hw_format = R300_DATA_TYPE_FLOAT_3;
 197                                                 swiz = MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_ONE);
 198                                                 break;
 199                                         case 4:
 200                                                 format = EMIT_4F;
 201                                                 hw_format = R300_DATA_TYPE_FLOAT_4;
 202                                                 swiz = SWIZZLE_XYZW;
 203                                                 break;
 204                                         default:
 205                                                 continue;
 206                                 }
 207                                 InputsRead |= 1 << (VERT_ATTRIB_TEX0 + i);
 208                                 OutputsWritten |= 1 << (VERT_RESULT_TEX0 + i);
 209                                 EMIT_ATTR(_TNL_ATTRIB_TEX(i), format);
 210                                 ADD_ATTR(VERT_ATTRIB_TEX0 + i, hw_format, SWTCL_OVM_TEX(first_free_tex), swiz, MASK_XYZW, 0);
 211                                 ++first_free_tex;
 212                         }
 213                 }
 214         }
 215
 216         if (first_free_tex >= ctx->Const.MaxTextureUnits) {
 217                 fprintf(stderr, "\tout of free texcoords to write fog coordinate\n");
 218                 exit(-1);
 219         }
 220
 221         R300_NEWPRIM(rmesa);
 222         rmesa->vbuf.num_attribs = num_attrs;
 223         *_InputsRead = InputsRead;
 224         *_OutputsWritten = OutputsWritten;
 225
 226         RENDERINPUTS_COPY(rmesa->render_inputs_bitset, tnl->render_inputs_bitset);
 227 }
 228
 229 static void r300PrepareVertices(struct gl_context *ctx)
 230 {
 231         r300ContextPtr rmesa = R300_CONTEXT(ctx);
 232         GLuint InputsRead, OutputsWritten;
 233         radeon_print(RADEON_SWRENDER, RADEON_TRACE, "%s\n", __func__);
 234
 235         r300ChooseSwtclVertexFormat(ctx, &InputsRead, &OutputsWritten);
 236         r300SetupVAP(ctx, InputsRead, OutputsWritten);
 237
 238         rmesa->radeon.swtcl.vertex_size =
 239                 _tnl_install_attrs( ctx,
 240                                     rmesa->radeon.swtcl.vertex_attrs,
 241                                     rmesa->radeon.swtcl.vertex_attr_count,
 242                                     NULL, 0 );
 243
 244         rmesa->radeon.swtcl.vertex_size /= 4;
 245 }
 246
 247 static void r300_predict_emit_size( r300ContextPtr rmesa )
 248 {
 249         if (!rmesa->radeon.swtcl.emit_prediction) {
 250                 const int vertex_size = 7;
 251                 const int prim_size = 3;
 252                 const int cache_flush_size = 4;
 253                 const int pre_emit_state = 4;
 254                 const int scissor_size = 3;
 255                 const int state_size = radeonCountStateEmitSize(&rmesa->radeon);
 256
 257                 if (rcommonEnsureCmdBufSpace(&rmesa->radeon,
 258                                         state_size + pre_emit_state + scissor_size
 259                                         + vertex_size + prim_size + cache_flush_size * 2,
 260                                         __FUNCTION__))
 261                         rmesa->radeon.swtcl.emit_prediction = radeonCountStateEmitSize(&rmesa->radeon);
 262                 else
 263                         rmesa->radeon.swtcl.emit_prediction = state_size;
 264
 265                 rmesa->radeon.swtcl.emit_prediction += rmesa->radeon.cmdbuf.cs->cdw
 266                         + vertex_size + scissor_size + prim_size + cache_flush_size * 2 + pre_emit_state;
 267                 radeon_print(RADEON_SWRENDER, RADEON_VERBOSE,
 268                                 "%s, size %d\n",
 269                                 __func__, rmesa->radeon.cmdbuf.cs->cdw
 270                                 + vertex_size + scissor_size + prim_size + cache_flush_size * 2 + pre_emit_state);
 271         }
 272 }
 273
 274
 275 static GLuint reduced_prim[] = {
 276         GL_POINTS,
 277         GL_LINES,
 278         GL_LINES,
 279         GL_LINES,
 280         GL_TRIANGLES,
 281         GL_TRIANGLES,
 282         GL_TRIANGLES,
 283         GL_TRIANGLES,
 284         GL_TRIANGLES,
 285         GL_TRIANGLES,
 286 };
 287
 288 static void r300RasterPrimitive( struct gl_context *ctx, GLuint prim );
 289
 290 /***********************************************************************
 291  *                    Emit primitives as inline vertices               *
 292  ***********************************************************************/
 293
 294
 295 #define HAVE_POINTS      1
 296 #define HAVE_LINES       1
 297 #define HAVE_LINE_STRIPS 1
 298 #define HAVE_TRIANGLES   1
 299 #define HAVE_TRI_STRIPS  1
 300 #define HAVE_TRI_STRIP_1 0
 301 #define HAVE_TRI_FANS    1
 302 #define HAVE_QUADS       0
 303 #define HAVE_QUAD_STRIPS 0
 304 #define HAVE_POLYGONS    1
 305 #define HAVE_ELTS        1
 306
 307 static void* r300_alloc_verts(r300ContextPtr rmesa, GLuint n, GLuint size)
 308 {
 309         void *rv;
 310         do {
 311                 r300_predict_emit_size( rmesa );
 312                 rv = rcommonAllocDmaLowVerts( &rmesa->radeon, n, size * 4 );
 313         } while (!rv);
 314         return rv;
 315 }
 316
 317 #undef LOCAL_VARS
 318 #undef ALLOC_VERTS
 319 #define CTX_ARG r300ContextPtr rmesa
 320 #define GET_VERTEX_DWORDS() rmesa->radeon.swtcl.vertex_size
 321 #define ALLOC_VERTS( n, size ) r300_alloc_verts(rmesa, n, size);
 322 #define LOCAL_VARS                                              \
 323    r300ContextPtr rmesa = R300_CONTEXT(ctx);            \
 324    const char *r300verts = (char *)rmesa->radeon.swtcl.verts;
 325 #define VERT(x) (r300Vertex *)(r300verts + ((x) * vertsize * sizeof(int)))
 326 #define VERTEX r300Vertex
 327 #undef TAG
 328 #define TAG(x) r300_##x
 329 #include "tnl_dd/t_dd_triemit.h"
 330
 331
 332
 333 /***********************************************************************
 334  *          Macros for t_dd_tritmp.h to draw basic primitives          *
 335  ***********************************************************************/
 336
 337 #define QUAD( a, b, c, d ) r300_quad( rmesa, a, b, c, d )
 338 #define TRI( a, b, c )     r300_triangle( rmesa, a, b, c )
 339 #define LINE( a, b )       r300_line( rmesa, a, b )
 340 #define POINT( a )         r300_point( rmesa, a )
 341
 342 /***********************************************************************
 343  *              Build render functions from dd templates               *
 344  ***********************************************************************/
 345
 346 #define R300_UNFILLED_BIT       0x01
 347 #define R300_MAX_TRIFUNC        0x02
 348
 349 static struct {
 350    tnl_points_func              points;
 351    tnl_line_func                line;
 352    tnl_triangle_func    triangle;
 353    tnl_quad_func                quad;
 354 } rast_tab[R300_MAX_TRIFUNC];
 355
 356 #define DO_FALLBACK  0
 357 #define DO_UNFILLED (IND & R300_UNFILLED_BIT)
 358 #define DO_TWOSIDE   0
 359 #define DO_FLAT      0
 360 #define DO_OFFSET    0
 361 #define DO_TRI       1
 362 #define DO_QUAD      1
 363 #define DO_LINE      1
 364 #define DO_POINTS    1
 365 #define DO_FULL_QUAD 1
 366
 367 #define HAVE_SPEC   1
 368 #define HAVE_BACK_COLORS  0
 369 #define HAVE_HW_FLATSHADE 1
 370 #define TAB rast_tab
 371
 372 #define DEPTH_SCALE 1.0
 373 #define UNFILLED_TRI unfilled_tri
 374 #define UNFILLED_QUAD unfilled_quad
 375 #define VERT_X(_v) _v->v.x
 376 #define VERT_Y(_v) _v->v.y
 377 #define VERT_Z(_v) _v->v.z
 378 #define AREA_IS_CCW( a ) (a < 0)
 379 #define GET_VERTEX(e) (rmesa->radeon.swtcl.verts + (e*rmesa->radeon.swtcl.vertex_size*sizeof(int)))
 380
 381 #define VERT_SET_RGBA( v, c ) \
 382 do { \
 383    r300_color_t *color = (r300_color_t *)&((v)->ui[coloroffset]); \
 384    UNCLAMPED_FLOAT_TO_UBYTE(color->red, (c)[0]); \
 385    UNCLAMPED_FLOAT_TO_UBYTE(color->green, (c)[1]); \
 386    UNCLAMPED_FLOAT_TO_UBYTE(color->blue, (c)[2]); \
 387    UNCLAMPED_FLOAT_TO_UBYTE(color->alpha, (c)[3]); \
 388 } while (0)
 389
 390 #define VERT_COPY_RGBA( v0, v1 ) v0->ui[coloroffset] = v1->ui[coloroffset]
 391
 392 #define VERT_SET_SPEC( v0, c ) \
 393 do { \
 394    if (specoffset) { \
 395    UNCLAMPED_FLOAT_TO_UBYTE(v0->v.specular.red, (c)[0]); \
 396    UNCLAMPED_FLOAT_TO_UBYTE(v0->v.specular.green, (c)[1]); \
 397    UNCLAMPED_FLOAT_TO_UBYTE(v0->v.specular.blue, (c)[2]); \
 398    } \
 399 } while (0)
 400
 401 #define VERT_COPY_SPEC( v0, v1 ) \
 402 do { \
 403    if (specoffset) { \
 404        v0->v.specular.red = v1->v.specular.red; \
 405        v0->v.specular.green = v1->v.specular.green; \
 406        v0->v.specular.blue = v1->v.specular.blue; \
 407    } \
 408 } while (0)
 409
 410 #define VERT_SAVE_RGBA( idx )    color[idx] = v[idx]->ui[coloroffset]
 411 #define VERT_RESTORE_RGBA( idx ) v[idx]->ui[coloroffset] = color[idx]
 412 #define VERT_SAVE_SPEC( idx )    if (specoffset) spec[idx] = v[idx]->ui[specoffset]
 413 #define VERT_RESTORE_SPEC( idx ) if (specoffset) v[idx]->ui[specoffset] = spec[idx]
 414
 415 #undef LOCAL_VARS
 416 #undef TAG
 417 #undef INIT
 418
 419 #define LOCAL_VARS(n)                                                   \
 420    r300ContextPtr rmesa = R300_CONTEXT(ctx);                    \
 421    GLuint color[n] = { 0, }, spec[n] = { 0, };                          \
 422    GLuint coloroffset = rmesa->swtcl.coloroffset;       \
 423    GLuint specoffset = rmesa->swtcl.specoffset;                 \
 424    (void) color; (void) spec; (void) coloroffset; (void) specoffset;
 425
 426 /***********************************************************************
 427  *                Helpers for rendering unfilled primitives            *
 428  ***********************************************************************/
 429
 430 #define RASTERIZE(x) r300RasterPrimitive( ctx, reduced_prim[x] )
 431 #define RENDER_PRIMITIVE rmesa->radeon.swtcl.render_primitive
 432 #undef TAG
 433 #define TAG(x) x
 434 #include "tnl_dd/t_dd_unfilled.h"
 435 #undef IND
 436
 437
 438 /***********************************************************************
 439  *                      Generate GL render functions                   *
 440  ***********************************************************************/
 441
 442
 443 #define IND (0)
 444 #define TAG(x) x
 445 #include "tnl_dd/t_dd_tritmp.h"
 446
 447 #define IND (R300_UNFILLED_BIT)
 448 #define TAG(x) x##_unfilled
 449 #include "tnl_dd/t_dd_tritmp.h"
 450
 451
 452 static void init_rast_tab( void )
 453 {
 454    init();
 455    init_unfilled();
 456 }
 457
 458 /**********************************************************************/
 459 /*               Render unclipped begin/end objects                   */
 460 /**********************************************************************/
 461
 462 #define RENDER_POINTS( start, count )           \
 463    for ( ; start < count ; start++)             \
 464       r300_point( rmesa, VERT(start) )
 465 #define RENDER_LINE( v0, v1 ) \
 466    r300_line( rmesa, VERT(v0), VERT(v1) )
 467 #define RENDER_TRI( v0, v1, v2 )  \
 468    r300_triangle( rmesa, VERT(v0), VERT(v1), VERT(v2) )
 469 #define RENDER_QUAD( v0, v1, v2, v3 ) \
 470    r300_quad( rmesa, VERT(v0), VERT(v1), VERT(v2), VERT(v3) )
 471 #define INIT(x) do {                                    \
 472    r300RenderPrimitive( ctx, x );                       \
 473 } while (0)
 474 #undef LOCAL_VARS
 475 #define LOCAL_VARS                                              \
 476    r300ContextPtr rmesa = R300_CONTEXT(ctx);            \
 477    const GLuint vertsize = rmesa->radeon.swtcl.vertex_size;             \
 478    const char *r300verts = (char *)rmesa->radeon.swtcl.verts;           \
 479    const GLuint * const elt = TNL_CONTEXT(ctx)->vb.Elts;        \
 480    const GLboolean stipple = ctx->Line.StippleFlag;             \
 481    (void) elt; (void) stipple;
 482 #define RESET_STIPPLE   //if ( stipple ) r200ResetLineStipple( ctx );
 483 #define RESET_OCCLUSION
 484 #define PRESERVE_VB_DEFS
 485 #define ELT(x) (x)
 486 #define TAG(x) r300_##x##_verts
 487 #include "tnl/t_vb_rendertmp.h"
 488 #undef ELT
 489 #undef TAG
 490 #define TAG(x) r300_##x##_elts
 491 #define ELT(x) elt[x]
 492 #include "tnl/t_vb_rendertmp.h"
 493
 494
 495
 496
 497 /**********************************************************************/
 498 /*                    Choose render functions                         */
 499 /**********************************************************************/
 500 static void r300ChooseRenderState( struct gl_context *ctx )
 501 {
 502         TNLcontext *tnl = TNL_CONTEXT(ctx);
 503         r300ContextPtr rmesa = R300_CONTEXT(ctx);
 504         GLuint index = 0;
 505         GLuint flags = ctx->_TriangleCaps;
 506         radeon_print(RADEON_SWRENDER, RADEON_VERBOSE, "%s\n", __func__);
 507
 508         if (flags & DD_TRI_UNFILLED)      index |= R300_UNFILLED_BIT;
 509
 510         if (index != rmesa->radeon.swtcl.RenderIndex) {
 511                 tnl->Driver.Render.Points = rast_tab[index].points;
 512                 tnl->Driver.Render.Line = rast_tab[index].line;
 513                 tnl->Driver.Render.ClippedLine = rast_tab[index].line;
 514                 tnl->Driver.Render.Triangle = rast_tab[index].triangle;
 515                 tnl->Driver.Render.Quad = rast_tab[index].quad;
 516
 517                 if (index == 0) {
 518                         tnl->Driver.Render.PrimTabVerts = r300_render_tab_verts;
 519                         tnl->Driver.Render.PrimTabElts = r300_render_tab_elts;
 520                         tnl->Driver.Render.ClippedPolygon = r300_fast_clipped_poly;
 521                 } else {
 522                         tnl->Driver.Render.PrimTabVerts = _tnl_render_tab_verts;
 523                         tnl->Driver.Render.PrimTabElts = _tnl_render_tab_elts;
 524                         tnl->Driver.Render.ClippedPolygon = _tnl_RenderClippedPolygon;
 525                 }
 526
 527                 rmesa->radeon.swtcl.RenderIndex = index;
 528         }
 529 }
 530
 531 void r300RenderStart(struct gl_context *ctx)
 532 {
 533         radeon_print(RADEON_SWRENDER, RADEON_VERBOSE, "%s\n", __func__);
 534         r300ContextPtr rmesa = R300_CONTEXT( ctx );
 535
 536         r300ChooseRenderState(ctx);
 537
 538         r300UpdateShaders(rmesa);
 539
 540         r300PrepareVertices(ctx);
 541
 542         r300ValidateBuffers(ctx);
 543
 544         r300UpdateShaderStates(rmesa);
 545
 546
 547         /* investigate if we can put back flush optimisation if needed */
 548         if (rmesa->radeon.dma.flush != NULL) {
 549                 rmesa->radeon.dma.flush(ctx);
 550         }
 551 }
 552
 553 void r300RenderFinish(struct gl_context *ctx)
 554 {
 555 }
 556
 557 static void r300RasterPrimitive( struct gl_context *ctx, GLuint hwprim )
 558 {
 559         r300ContextPtr rmesa = R300_CONTEXT(ctx);
 560         radeon_print(RADEON_SWRENDER, RADEON_TRACE, "%s\n", __func__);
 561
 562         if (rmesa->radeon.swtcl.hw_primitive != hwprim) {
 563                 R300_NEWPRIM( rmesa );
 564                 rmesa->radeon.swtcl.hw_primitive = hwprim;
 565         }
 566 }
 567
 568 void r300RenderPrimitive(struct gl_context *ctx, GLenum prim)
 569 {
 570
 571         r300ContextPtr rmesa = R300_CONTEXT(ctx);
 572         rmesa->radeon.swtcl.render_primitive = prim;
 573         radeon_print(RADEON_SWRENDER, RADEON_TRACE, "%s\n", __func__);
 574
 575         if ((prim == GL_TRIANGLES) && (ctx->_TriangleCaps & DD_TRI_UNFILLED))
 576                 return;
 577
 578         r300RasterPrimitive( ctx, reduced_prim[prim] );
 579 }
 580
 581 void r300ResetLineStipple(struct gl_context *ctx)
 582 {
 583         if (RADEON_DEBUG & RADEON_VERTS)
 584                 fprintf(stderr, "%s\n", __func__);
 585 }
 586
 587 void r300InitSwtcl(struct gl_context *ctx)
 588 {
 589         TNLcontext *tnl = TNL_CONTEXT(ctx);
 590         r300ContextPtr rmesa = R300_CONTEXT(ctx);
 591         static int firsttime = 1;
 592         radeon_print(RADEON_SWRENDER, RADEON_NORMAL, "%s\n", __func__);
 593
 594         if (firsttime) {
 595                 init_rast_tab();
 596                 firsttime = 0;
 597         }
 598         rmesa->radeon.swtcl.emit_prediction = 0;
 599
 600         tnl->Driver.Render.Start = r300RenderStart;
 601         tnl->Driver.Render.Finish = r300RenderFinish;
 602         tnl->Driver.Render.PrimitiveNotify = r300RenderPrimitive;
 603         tnl->Driver.Render.ResetLineStipple = r300ResetLineStipple;
 604         tnl->Driver.Render.BuildVertices = _tnl_build_vertices;
 605         tnl->Driver.Render.CopyPV = _tnl_copy_pv;
 606         tnl->Driver.Render.Interp = _tnl_interp;
 607
 608         /* FIXME: what are these numbers? */
 609         _tnl_init_vertices( ctx, ctx->Const.MaxArrayLockSize + 12,
 610                             48 * sizeof(GLfloat) );
 611
 612         rmesa->radeon.swtcl.verts = (GLubyte *)tnl->clipspace.vertex_buf;
 613         rmesa->radeon.swtcl.RenderIndex = ~0;
 614         rmesa->radeon.swtcl.render_primitive = GL_TRIANGLES;
 615         rmesa->radeon.swtcl.hw_primitive = 0;
 616
 617         _tnl_invalidate_vertex_state( ctx, ~0 );
 618         _tnl_invalidate_vertices( ctx, ~0 );
 619
 620         _tnl_need_projected_coords( ctx, GL_FALSE );
 621 }
 622
 623 void r300DestroySwtcl(struct gl_context *ctx)
 624 {
 625 }
 626
 627 static void r300EmitVertexAOS(r300ContextPtr rmesa, GLuint vertex_size, struct radeon_bo *bo, GLuint offset)
 628 {
 629         BATCH_LOCALS(&rmesa->radeon);
 630
 631         radeon_print(RADEON_SWRENDER, RADEON_TRACE,
 632                 "%s:  vertex_size %d, offset 0x%x \n",
 633                         __FUNCTION__, vertex_size, offset);
 634
 635         BEGIN_BATCH(7);
 636         OUT_BATCH_PACKET3(R300_PACKET3_3D_LOAD_VBPNTR, 2);
 637         OUT_BATCH(1);
 638         OUT_BATCH(vertex_size | (vertex_size << 8));
 639         OUT_BATCH_RELOC(offset, bo, offset, RADEON_GEM_DOMAIN_GTT, 0, 0);
 640         END_BATCH();
 641 }
 642
 643 static void r300EmitVbufPrim(r300ContextPtr rmesa, GLuint primitive, GLuint vertex_nr)
 644 {
 645         BATCH_LOCALS(&rmesa->radeon);
 646         int type, num_verts;
 647         if (RADEON_DEBUG & RADEON_VERTS)
 648                 fprintf(stderr, "%s\n", __func__);
 649
 650         type = r300PrimitiveType(rmesa, primitive);
 651         num_verts = r300NumVerts(rmesa, vertex_nr, primitive);
 652
 653         BEGIN_BATCH(3);
 654         OUT_BATCH_PACKET3(R300_PACKET3_3D_DRAW_VBUF_2, 0);
 655         OUT_BATCH(R300_VAP_VF_CNTL__PRIM_WALK_VERTEX_LIST | (num_verts << 16) | type);
 656         END_BATCH();
 657 }
 658
 659 void r300_swtcl_flush(struct gl_context *ctx, uint32_t current_offset)
 660 {
 661         radeon_print(RADEON_SWRENDER, RADEON_TRACE, "%s\n", __func__);
 662         r300ContextPtr rmesa = R300_CONTEXT(ctx);
 663
 664         r300EmitCacheFlush(rmesa);
 665
 666         radeonEmitState(&rmesa->radeon);
 667         r300_emit_scissor(ctx);
 668         r300EmitVertexAOS(rmesa,
 669                           rmesa->radeon.swtcl.vertex_size,
 670                           rmesa->radeon.swtcl.bo,
 671                           current_offset);
 672
 673         r300EmitVbufPrim(rmesa,
 674                    rmesa->radeon.swtcl.hw_primitive,
 675                    rmesa->radeon.swtcl.numverts);
 676         r300EmitCacheFlush(rmesa);
 677         if ( rmesa->radeon.swtcl.emit_prediction < rmesa->radeon.cmdbuf.cs->cdw )
 678                 WARN_ONCE("Rendering was %d commands larger than predicted size."
 679                         " We might overflow  command buffer.\n",
 680                         rmesa->radeon.cmdbuf.cs->cdw - rmesa->radeon.swtcl.emit_prediction );
 681         rmesa->radeon.swtcl.emit_prediction = 0;
 682         COMMIT_BATCH();
 683 }