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, GLubyte *vimap_rev )
 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, emitsize;
 388
 389    for ( i = 0; i < 15; i++ ) {
 390       GLubyte attrib = vimap_rev[i];
 391       if (attrib != 255) {
 392          switch (i) {
 393          case 0:
 394             emitsize = (VB->AttribPtr[attrib]->size);
 395             switch (emitsize) {
 396             case 4:
 397                vfmt0 |= R200_VTX_W0;
 398                /* fallthrough */
 399             case 3:
 400                vfmt0 |= R200_VTX_Z0;
 401                break;
 402             case 2:
 403                break;
 404             default: assert(0);
 405             }
 406             break;
 407          case 1:
 408             assert(attrib == VERT_ATTRIB_WEIGHT);
 409             emitsize = (VB->AttribPtr[attrib]->size);
 410             vfmt0 |= emitsize << R200_VTX_WEIGHT_COUNT_SHIFT;
 411             break;
 412          case 2:
 413             assert(attrib == VERT_ATTRIB_NORMAL);
 414             emitsize = 3;
 415             vfmt0 |= R200_VTX_N0;
 416             break;
 417          case 3:
 418             /* special handling to fix up fog. Will get us into trouble with vbos...*/
 419             assert(attrib == VERT_ATTRIB_FOG);
 420             if (!rmesa->tcl.vertex_data[i].buf) {
 421                if (ctx->VertexProgram._Enabled)
 422                   emit_vector( ctx,
 423                          &(rmesa->tcl.vertex_data[attrib]),
 424                          (char *)VB->AttribPtr[attrib]->data,
 425                          1,
 426                          VB->AttribPtr[attrib]->stride,
 427                          count);
 428                else
 429                   emit_vecfog( ctx,
 430                          &(rmesa->tcl.vertex_data[attrib]),
 431                          (char *)VB->AttribPtr[attrib]->data,
 432                          VB->AttribPtr[attrib]->stride,
 433                          count);
 434             }
 435             vfmt0 |= R200_VTX_DISCRETE_FOG;
 436             goto after_emit;
 437             break;
 438          case 4:
 439          case 5:
 440          case 6:
 441          case 7:
 442             if (VB->AttribPtr[attrib]->size == 4 &&
 443                (VB->AttribPtr[attrib]->stride != 0 ||
 444                 VB->AttribPtr[attrib]->data[0][3] != 1.0)) emitsize = 4;
 445             else emitsize = 3;
 446             if (emitsize == 4)
 447                vfmt0 |= R200_VTX_FP_RGBA << (R200_VTX_COLOR_0_SHIFT + (i - 4) * 2);
 448             else {
 449                vfmt0 |= R200_VTX_FP_RGB << (R200_VTX_COLOR_0_SHIFT + (i - 4) * 2);
 450             }
 451             break;
 452          case 8:
 453          case 9:
 454          case 10:
 455          case 11:
 456          case 12:
 457          case 13:
 458             emitsize = VB->AttribPtr[attrib]->size;
 459             vfmt1 |= emitsize << (R200_VTX_TEX0_COMP_CNT_SHIFT + (i - 8) * 3);
 460             break;
 461          case 14:
 462             emitsize = VB->AttribPtr[attrib]->size >= 2 ? VB->AttribPtr[attrib]->size : 2;
 463             switch (emitsize) {
 464             case 2:
 465                vfmt0 |= R200_VTX_XY1;
 466                /* fallthrough */
 467             case 3:
 468                vfmt0 |= R200_VTX_Z1;
 469                /* fallthrough */
 470             case 4:
 471                vfmt0 |= R200_VTX_W1;
 472             break;
 473             }
 474          default:
 475             assert(0);
 476          }
 477          if (!rmesa->tcl.vertex_data[i].buf) {
 478             emit_vector( ctx,
 479                          &(rmesa->tcl.vertex_data[i]),
 480                          (char *)VB->AttribPtr[attrib]->data,
 481                          emitsize,
 482                          VB->AttribPtr[attrib]->stride,
 483                          count );
 484          }
 485 after_emit:
 486          assert(nr < 12);
 487          component[nr++] = &rmesa->tcl.vertex_data[i];
 488       }
 489    }
 490
 491    if (vfmt0 != rmesa->hw.vtx.cmd[VTX_VTXFMT_0] ||
 492        vfmt1 != rmesa->hw.vtx.cmd[VTX_VTXFMT_1]) {
 493       R200_STATECHANGE( rmesa, vtx );
 494       rmesa->hw.vtx.cmd[VTX_VTXFMT_0] = vfmt0;
 495       rmesa->hw.vtx.cmd[VTX_VTXFMT_1] = vfmt1;
 496    }
 497
 498    rmesa->tcl.nr_aos_components = nr;
 499 }
 500
 501
 502 void r200ReleaseArrays( GLcontext *ctx, GLuint newinputs )
 503 {
 504    r200ContextPtr rmesa = R200_CONTEXT( ctx );
 505
 506    /* only do it for changed inputs ? */
 507    int i;
 508    for (i = 0; i < 15; i++) {
 509       if (newinputs & (1 << i))
 510          r200ReleaseDmaRegion( rmesa,
 511             &rmesa->tcl.vertex_data[i], __FUNCTION__ );
 512    }
 513 }