src/mesa/drivers/dri/r200/r200_maos_arrays.c

   1 /* $XFree86: xc/lib/GL/mesa/src/drv/r200/r200_maos_arrays.c,v 1.3 2003/02/23 23:59:01 dawes Exp $ */
   2 /*
   3 Copyright (C) The Weather Channel, Inc.  2002.  All Rights Reserved.
   4
   5 The Weather Channel (TM) funded Tungsten Graphics to develop the
   6 initial release of the Radeon 8500 driver under the XFree86 license.
   7 This notice must be preserved.
   8
   9 Permission is hereby granted, free of charge, to any person obtaining
  10 a copy of this software and associated documentation files (the
  11 "Software"), to deal in the Software without restriction, including
  12 without limitation the rights to use, copy, modify, merge, publish,
  13 distribute, sublicense, and/or sell copies of the Software, and to
  14 permit persons to whom the Software is furnished to do so, subject to
  15 the following conditions:
  16
  17 The above copyright notice and this permission notice (including the
  18 next paragraph) shall be included in all copies or substantial
  19 portions of the Software.
  20
  21 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  22 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  23 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  24 IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
  25 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  26 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  27 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  28
  29 **************************************************************************/
  30
  31 /*
  32  * Authors:
  33  *   Keith Whitwell <keith@tungstengraphics.com>
  34  */
  35
  36 #include "glheader.h"
  37 #include "mtypes.h"
  38 #include "colormac.h"
  39 #include "imports.h"
  40 #include "macros.h"
  41
  42 #include "swrast_setup/swrast_setup.h"
  43 #include "math/m_translate.h"
  44 #include "tnl/tnl.h"
  45 #include "tnl/t_context.h"
  46
  47 #include "r200_context.h"
  48 #include "r200_ioctl.h"
  49 #include "r200_state.h"
  50 #include "r200_swtcl.h"
  51 #include "r200_maos.h"
  52 #include "r200_tcl.h"
  53
  54
  55 #if 0
  56 /* Usage:
  57  *   - from r200_tcl_render
  58  *   - call r200EmitArrays to ensure uptodate arrays in dma
  59  *   - emit primitives (new type?) which reference the data
  60  *       -- need to use elts for lineloop, quads, quadstrip/flat
  61  *       -- other primitives are all well-formed (need tristrip-1,fake-poly)
  62  *
  63  */
  64 static void emit_ubyte_rgba3( GLcontext *ctx,
  65                        struct r200_dma_region *rvb,
  66                        char *data,
  67                        int stride,
  68                        int count )
  69 {
  70    int i;
  71    r200_color_t *out = (r200_color_t *)(rvb->start + rvb->address);
  72
  73    if (R200_DEBUG & DEBUG_VERTS)
  74       fprintf(stderr, "%s count %d stride %d out %p\n",
  75               __FUNCTION__, count, stride, (void *)out);
  76
  77    for (i = 0; i < count; i++) {
  78       out->red   = *data;
  79       out->green = *(data+1);
  80       out->blue  = *(data+2);
  81       out->alpha = 0xFF;
  82       out++;
  83       data += stride;
  84    }
  85 }
  86
  87 static void emit_ubyte_rgba4( GLcontext *ctx,
  88                               struct r200_dma_region *rvb,
  89                               char *data,
  90                               int stride,
  91                               int count )
  92 {
  93    int i;
  94    int *out = (int *)(rvb->address + rvb->start);
  95
  96    if (R200_DEBUG & DEBUG_VERTS)
  97       fprintf(stderr, "%s count %d stride %d\n",
  98               __FUNCTION__, count, stride);
  99
 100    if (stride == 4) {
 101       for (i = 0; i < count; i++)
 102          ((int *)out)[i] = LE32_TO_CPU(((int *)data)[i]);
 103    } else {
 104       for (i = 0; i < count; i++) {
 105          *(int *)out++ = LE32_TO_CPU(*(int *)data);
 106          data += stride;
 107       }
 108    }
 109 }
 110
 111
 112 static void emit_ubyte_rgba( GLcontext *ctx,
 113                              struct r200_dma_region *rvb,
 114                              char *data,
 115                              int size,
 116                              int stride,
 117                              int count )
 118 {
 119    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 120
 121    if (R200_DEBUG & DEBUG_VERTS)
 122       fprintf(stderr, "%s %d/%d\n", __FUNCTION__, count, size);
 123
 124    assert (!rvb->buf);
 125
 126    if (stride == 0) {
 127       r200AllocDmaRegion( rmesa, rvb, 4, 4 );
 128       count = 1;
 129       rvb->aos_start = GET_START(rvb);
 130       rvb->aos_stride = 0;
 131       rvb->aos_size = 1;
 132    }
 133    else {
 134       r200AllocDmaRegion( rmesa, rvb, 4 * count, 4 );   /* alignment? */
 135       rvb->aos_start = GET_START(rvb);
 136       rvb->aos_stride = 1;
 137       rvb->aos_size = 1;
 138    }
 139
 140    /* Emit the data
 141     */
 142    switch (size) {
 143    case 3:
 144       emit_ubyte_rgba3( ctx, rvb, data, stride, count );
 145       break;
 146    case 4:
 147       emit_ubyte_rgba4( ctx, rvb, data, stride, count );
 148       break;
 149    default:
 150       assert(0);
 151       exit(1);
 152       break;
 153    }
 154 }
 155 #endif
 156
 157
 158 #if defined(USE_X86_ASM)
 159 #define COPY_DWORDS( dst, src, nr )                                     \
 160 do {                                                                    \
 161         int __tmp;                                                      \
 162         __asm__ __volatile__( "rep ; movsl"                             \
 163                               : "=%c" (__tmp), "=D" (dst), "=S" (__tmp) \
 164                               : "0" (nr),                               \
 165                                 "D" ((long)dst),                        \
 166                                 "S" ((long)src) );                      \
 167 } while (0)
 168 #else
 169 #define COPY_DWORDS( dst, src, nr )             \
 170 do {                                            \
 171    int j;                                       \
 172    for ( j = 0 ; j < nr ; j++ )                 \
 173       dst[j] = ((int *)src)[j];                 \
 174    dst += nr;                                   \
 175 } while (0)
 176 #endif
 177
 178
 179 static void emit_vecfog( GLcontext *ctx,
 180                          struct r200_dma_region *rvb,
 181                          char *data,
 182                          int stride,
 183                          int count )
 184 {
 185    int i;
 186    GLfloat *out;
 187
 188    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 189
 190    if (R200_DEBUG & DEBUG_VERTS)
 191       fprintf(stderr, "%s count %d stride %d\n",
 192               __FUNCTION__, count, stride);
 193
 194    assert (!rvb->buf);
 195
 196    if (stride == 0) {
 197       r200AllocDmaRegion( rmesa, rvb, 4, 4 );
 198       count = 1;
 199       rvb->aos_start = GET_START(rvb);
 200       rvb->aos_stride = 0;
 201       rvb->aos_size = 1;
 202    }
 203    else {
 204       r200AllocDmaRegion( rmesa, rvb, count * 4, 4 );   /* alignment? */
 205       rvb->aos_start = GET_START(rvb);
 206       rvb->aos_stride = 1;
 207       rvb->aos_size = 1;
 208    }
 209
 210    /* Emit the data
 211     */
 212    out = (GLfloat *)(rvb->address + rvb->start);
 213    for (i = 0; i < count; i++) {
 214       out[0] = r200ComputeFogBlendFactor( ctx, *(GLfloat *)data );
 215       out++;
 216       data += stride;
 217    }
 218
 219 }
 220
 221
 222 static void emit_vec4( GLcontext *ctx,
 223                        struct r200_dma_region *rvb,
 224                        char *data,
 225                        int stride,
 226                        int count )
 227 {
 228    int i;
 229    int *out = (int *)(rvb->address + rvb->start);
 230
 231    if (R200_DEBUG & DEBUG_VERTS)
 232       fprintf(stderr, "%s count %d stride %d\n",
 233               __FUNCTION__, count, stride);
 234
 235    if (stride == 4)
 236       COPY_DWORDS( out, data, count );
 237    else
 238       for (i = 0; i < count; i++) {
 239          out[0] = *(int *)data;
 240          out++;
 241          data += stride;
 242       }
 243 }
 244
 245
 246 static void emit_vec8( GLcontext *ctx,
 247                        struct r200_dma_region *rvb,
 248                        char *data,
 249                        int stride,
 250                        int count )
 251 {
 252    int i;
 253    int *out = (int *)(rvb->address + rvb->start);
 254
 255    if (R200_DEBUG & DEBUG_VERTS)
 256       fprintf(stderr, "%s count %d stride %d\n",
 257               __FUNCTION__, count, stride);
 258
 259    if (stride == 8)
 260       COPY_DWORDS( out, data, count*2 );
 261    else
 262       for (i = 0; i < count; i++) {
 263          out[0] = *(int *)data;
 264          out[1] = *(int *)(data+4);
 265          out += 2;
 266          data += stride;
 267       }
 268 }
 269
 270 static void emit_vec12( GLcontext *ctx,
 271                        struct r200_dma_region *rvb,
 272                        char *data,
 273                        int stride,
 274                        int count )
 275 {
 276    int i;
 277    int *out = (int *)(rvb->address + rvb->start);
 278
 279    if (R200_DEBUG & DEBUG_VERTS)
 280       fprintf(stderr, "%s count %d stride %d out %p data %p\n",
 281               __FUNCTION__, count, stride, (void *)out, (void *)data);
 282
 283    if (stride == 12)
 284       COPY_DWORDS( out, data, count*3 );
 285    else
 286       for (i = 0; i < count; i++) {
 287          out[0] = *(int *)data;
 288          out[1] = *(int *)(data+4);
 289          out[2] = *(int *)(data+8);
 290          out += 3;
 291          data += stride;
 292       }
 293 }
 294
 295 static void emit_vec16( GLcontext *ctx,
 296                         struct r200_dma_region *rvb,
 297                         char *data,
 298                         int stride,
 299                         int count )
 300 {
 301    int i;
 302    int *out = (int *)(rvb->address + rvb->start);
 303
 304    if (R200_DEBUG & DEBUG_VERTS)
 305       fprintf(stderr, "%s count %d stride %d\n",
 306               __FUNCTION__, count, stride);
 307
 308    if (stride == 16)
 309       COPY_DWORDS( out, data, count*4 );
 310    else
 311       for (i = 0; i < count; i++) {
 312          out[0] = *(int *)data;
 313          out[1] = *(int *)(data+4);
 314          out[2] = *(int *)(data+8);
 315          out[3] = *(int *)(data+12);
 316          out += 4;
 317          data += stride;
 318       }
 319 }
 320
 321
 322 static void emit_vector( GLcontext *ctx,
 323                          struct r200_dma_region *rvb,
 324                          char *data,
 325                          int size,
 326                          int stride,
 327                          int count )
 328 {
 329    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 330
 331    if (R200_DEBUG & DEBUG_VERTS)
 332       fprintf(stderr, "%s count %d size %d stride %d\n",
 333               __FUNCTION__, count, size, stride);
 334
 335    assert (!rvb->buf);
 336
 337    if (stride == 0) {
 338       r200AllocDmaRegion( rmesa, rvb, size * 4, 4 );
 339       count = 1;
 340       rvb->aos_start = GET_START(rvb);
 341       rvb->aos_stride = 0;
 342       rvb->aos_size = size;
 343    }
 344    else {
 345       r200AllocDmaRegion( rmesa, rvb, size * count * 4, 4 );    /* alignment? */
 346       rvb->aos_start = GET_START(rvb);
 347       rvb->aos_stride = size;
 348       rvb->aos_size = size;
 349    }
 350
 351    /* Emit the data
 352     */
 353    switch (size) {
 354    case 1:
 355       emit_vec4( ctx, rvb, data, stride, count );
 356       break;
 357    case 2:
 358       emit_vec8( ctx, rvb, data, stride, count );
 359       break;
 360    case 3:
 361       emit_vec12( ctx, rvb, data, stride, count );
 362       break;
 363    case 4:
 364       emit_vec16( ctx, rvb, data, stride, count );
 365       break;
 366    default:
 367       assert(0);
 368       exit(1);
 369       break;
 370    }
 371
 372 }
 373
 374
 375
 376 /* Emit any changed arrays to new GART memory, re-emit a packet to
 377  * update the arrays.
 378  */
 379 void r200EmitArrays( GLcontext *ctx, GLuint inputs )
 380 {
 381    r200ContextPtr rmesa = R200_CONTEXT( ctx );
 382    struct vertex_buffer *VB = &TNL_CONTEXT( ctx )->vb;
 383    struct r200_dma_region **component = rmesa->tcl.aos_components;
 384    GLuint nr = 0;
 385    GLuint vfmt0 = 0, vfmt1 = 0;
 386    GLuint count = VB->Count;
 387    GLuint i;
 388
 389    if (inputs & VERT_BIT_POS) {
 390       if (!rmesa->tcl.obj.buf)
 391          emit_vector( ctx,
 392                       &rmesa->tcl.obj,
 393                       (char *)VB->ObjPtr->data,
 394                       VB->ObjPtr->size,
 395                       VB->ObjPtr->stride,
 396                       count);
 397
 398       switch( VB->ObjPtr->size ) {
 399       case 4: vfmt0 |= R200_VTX_W0;
 400       case 3: vfmt0 |= R200_VTX_Z0;
 401       case 2:
 402       default:
 403          break;
 404       }
 405       component[nr++] = &rmesa->tcl.obj;
 406    }
 407
 408    if (inputs & VERT_BIT_NORMAL) {
 409       if (!rmesa->tcl.norm.buf)
 410          emit_vector( ctx,
 411                       &(rmesa->tcl.norm),
 412                       (char *)VB->NormalPtr->data,
 413                       3,
 414                       VB->NormalPtr->stride,
 415                       count);
 416
 417       vfmt0 |= R200_VTX_N0;
 418       component[nr++] = &rmesa->tcl.norm;
 419    }
 420
 421    if (inputs & VERT_BIT_FOG) {
 422       if (!rmesa->tcl.fog.buf) {
 423          if (ctx->VertexProgram._Enabled)
 424             emit_vector( ctx,
 425                          &(rmesa->tcl.fog),
 426                          (char *)VB->FogCoordPtr->data,
 427                          1,
 428                          VB->FogCoordPtr->stride,
 429                          count);
 430          else
 431             emit_vecfog( ctx,
 432                          &(rmesa->tcl.fog),
 433                          (char *)VB->FogCoordPtr->data,
 434                          VB->FogCoordPtr->stride,
 435                          count);
 436       }
 437
 438       vfmt0 |= R200_VTX_DISCRETE_FOG;
 439       component[nr++] = &rmesa->tcl.fog;
 440    }
 441
 442    if (inputs & VERT_BIT_COLOR0) {
 443       int emitsize;
 444
 445       if (VB->ColorPtr[0]->size == 4 &&
 446           (VB->ColorPtr[0]->stride != 0 ||
 447            VB->ColorPtr[0]->data[0][3] != 1.0)) {
 448          vfmt0 |= R200_VTX_FP_RGBA << R200_VTX_COLOR_0_SHIFT;
 449          emitsize = 4;
 450       }
 451       else {
 452          vfmt0 |= R200_VTX_FP_RGB << R200_VTX_COLOR_0_SHIFT;
 453          emitsize = 3;
 454       }
 455
 456       if (!rmesa->tcl.rgba.buf)
 457          emit_vector( ctx,
 458                       &(rmesa->tcl.rgba),
 459                       (char *)VB->ColorPtr[0]->data,
 460                       emitsize,
 461                       VB->ColorPtr[0]->stride,
 462                       count);
 463
 464       component[nr++] = &rmesa->tcl.rgba;
 465    }
 466
 467
 468    if (inputs & VERT_BIT_COLOR1) {
 469       if (!rmesa->tcl.spec.buf) {
 470          emit_vector( ctx,
 471                       &rmesa->tcl.spec,
 472                       (char *)VB->SecondaryColorPtr[0]->data,
 473                       3,
 474                       VB->SecondaryColorPtr[0]->stride,
 475                       count);
 476       }
 477
 478       /* How does this work?
 479        */
 480       vfmt0 |= R200_VTX_FP_RGB << R200_VTX_COLOR_1_SHIFT;
 481       component[nr++] = &rmesa->tcl.spec;
 482    }
 483
 484    for ( i = 0 ; i < ctx->Const.MaxTextureUnits ; i++ ) {
 485       if (inputs & (VERT_BIT_TEX0 << i)) {
 486          if (!rmesa->tcl.tex[i].buf)
 487              emit_vector( ctx,
 488                           &(rmesa->tcl.tex[i]),
 489                           (char *)VB->TexCoordPtr[i]->data,
 490                           VB->TexCoordPtr[i]->size,
 491                           VB->TexCoordPtr[i]->stride,
 492                           count );
 493
 494          vfmt1 |= VB->TexCoordPtr[i]->size << (i * 3);
 495          component[nr++] = &rmesa->tcl.tex[i];
 496       }
 497    }
 498
 499    if (ctx->VertexProgram._Enabled) {
 500       int *vp_inputs = rmesa->curr_vp_hw->inputs;
 501       for ( i = VERT_ATTRIB_GENERIC0; i < VERT_ATTRIB_MAX; i++ ) {
 502          if (inputs & (1 << i)) {
 503             int geninput = i - VERT_ATTRIB_GENERIC0;
 504             if (!rmesa->tcl.generic[geninput].buf) {
 505                emit_vector( ctx,
 506                           &(rmesa->tcl.generic[geninput]),
 507                           (char *)VB->AttribPtr[i]->data,
 508                           4,
 509                           VB->AttribPtr[i]->stride,
 510                           count );
 511             }
 512             component[nr++] = &rmesa->tcl.generic[geninput];
 513             switch (vp_inputs[i]) {
 514             case 0:
 515                vfmt0 |=  R200_VTX_W0 | R200_VTX_Z0;
 516                break;
 517             case 2:
 518             case 3:
 519             case 4:
 520             case 5:
 521                vfmt0 |= R200_VTX_FP_RGBA << (R200_VTX_COLOR_0_SHIFT + (vp_inputs[i] - 2) * 2);
 522                break;
 523             case 6:
 524             case 7:
 525             case 8:
 526             case 9:
 527             case 10:
 528             case 11:
 529                vfmt1 |= 4 << (R200_VTX_TEX0_COMP_CNT_SHIFT + (vp_inputs[i] - 6) * 3);
 530                break;
 531             case 13:
 532                vfmt0 |= R200_VTX_XY1 | R200_VTX_Z1 | R200_VTX_W1;
 533                break;
 534             case 1:
 535             case 12:
 536             default:
 537                assert(0);
 538             }
 539          }
 540       }
 541    }
 542
 543    if (vfmt0 != rmesa->hw.vtx.cmd[VTX_VTXFMT_0] ||
 544        vfmt1 != rmesa->hw.vtx.cmd[VTX_VTXFMT_1]) {
 545       R200_STATECHANGE( rmesa, vtx );
 546       rmesa->hw.vtx.cmd[VTX_VTXFMT_0] = vfmt0;
 547       rmesa->hw.vtx.cmd[VTX_VTXFMT_1] = vfmt1;
 548    }
 549
 550    rmesa->tcl.nr_aos_components = nr;
 551    rmesa->tcl.vertex_format = vfmt0;
 552 }
 553
 554
 555 void r200ReleaseArrays( GLcontext *ctx, GLuint newinputs )
 556 {
 557    GLuint unit;
 558    r200ContextPtr rmesa = R200_CONTEXT( ctx );
 559
 560 /*    if (R200_DEBUG & DEBUG_VERTS)  */
 561 /*       _tnl_print_vert_flags( __FUNCTION__, newinputs ); */
 562
 563    if (newinputs & VERT_BIT_POS)
 564      r200ReleaseDmaRegion( rmesa, &rmesa->tcl.obj, __FUNCTION__ );
 565
 566    if (newinputs & VERT_BIT_NORMAL)
 567       r200ReleaseDmaRegion( rmesa, &rmesa->tcl.norm, __FUNCTION__ );
 568
 569    if (newinputs & VERT_BIT_FOG)
 570       r200ReleaseDmaRegion( rmesa, &rmesa->tcl.fog, __FUNCTION__ );
 571
 572    if (newinputs & VERT_BIT_COLOR0)
 573       r200ReleaseDmaRegion( rmesa, &rmesa->tcl.rgba, __FUNCTION__ );
 574
 575    if (newinputs & VERT_BIT_COLOR1)
 576       r200ReleaseDmaRegion( rmesa, &rmesa->tcl.spec, __FUNCTION__ );
 577
 578    for (unit = 0 ; unit < ctx->Const.MaxTextureUnits; unit++) {
 579       if (newinputs & VERT_BIT_TEX(unit))
 580          r200ReleaseDmaRegion( rmesa, &rmesa->tcl.tex[unit], __FUNCTION__ );
 581    }
 582
 583    if (ctx->VertexProgram._Enabled) {
 584       int i;
 585       for (i = VERT_ATTRIB_GENERIC0; i < VERT_ATTRIB_MAX; i++) {
 586          if (newinputs & (1 << i))
 587             r200ReleaseDmaRegion( rmesa,
 588                &rmesa->tcl.generic[i - VERT_ATTRIB_GENERIC0], __FUNCTION__ );
 589       }
 590    }
 591
 592 }