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
  53
  54 #if 0
  55 /* Usage:
  56  *   - from r200_tcl_render
  57  *   - call r200EmitArrays to ensure uptodate arrays in dma
  58  *   - emit primitives (new type?) which reference the data
  59  *       -- need to use elts for lineloop, quads, quadstrip/flat
  60  *       -- other primitives are all well-formed (need tristrip-1,fake-poly)
  61  *
  62  */
  63 static void emit_ubyte_rgba3( GLcontext *ctx,
  64                        struct r200_dma_region *rvb,
  65                        char *data,
  66                        int stride,
  67                        int count )
  68 {
  69    int i;
  70    r200_color_t *out = (r200_color_t *)(rvb->start + rvb->address);
  71
  72    if (R200_DEBUG & DEBUG_VERTS)
  73       fprintf(stderr, "%s count %d stride %d out %p\n",
  74               __FUNCTION__, count, stride, (void *)out);
  75
  76    for (i = 0; i < count; i++) {
  77       out->red   = *data;
  78       out->green = *(data+1);
  79       out->blue  = *(data+2);
  80       out->alpha = 0xFF;
  81       out++;
  82       data += stride;
  83    }
  84 }
  85
  86 static void emit_ubyte_rgba4( GLcontext *ctx,
  87                               struct r200_dma_region *rvb,
  88                               char *data,
  89                               int stride,
  90                               int count )
  91 {
  92    int i;
  93    int *out = (int *)(rvb->address + rvb->start);
  94
  95    if (R200_DEBUG & DEBUG_VERTS)
  96       fprintf(stderr, "%s count %d stride %d\n",
  97               __FUNCTION__, count, stride);
  98
  99    if (stride == 4) {
 100       for (i = 0; i < count; i++)
 101          ((int *)out)[i] = LE32_TO_CPU(((int *)data)[i]);
 102    } else {
 103       for (i = 0; i < count; i++) {
 104          *(int *)out++ = LE32_TO_CPU(*(int *)data);
 105          data += stride;
 106       }
 107    }
 108 }
 109
 110
 111 static void emit_ubyte_rgba( GLcontext *ctx,
 112                              struct r200_dma_region *rvb,
 113                              char *data,
 114                              int size,
 115                              int stride,
 116                              int count )
 117 {
 118    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 119
 120    if (R200_DEBUG & DEBUG_VERTS)
 121       fprintf(stderr, "%s %d/%d\n", __FUNCTION__, count, size);
 122
 123    assert (!rvb->buf);
 124
 125    if (stride == 0) {
 126       r200AllocDmaRegion( rmesa, rvb, 4, 4 );
 127       count = 1;
 128       rvb->aos_start = GET_START(rvb);
 129       rvb->aos_stride = 0;
 130       rvb->aos_size = 1;
 131    }
 132    else {
 133       r200AllocDmaRegion( rmesa, rvb, 4 * count, 4 );   /* alignment? */
 134       rvb->aos_start = GET_START(rvb);
 135       rvb->aos_stride = 1;
 136       rvb->aos_size = 1;
 137    }
 138
 139    /* Emit the data
 140     */
 141    switch (size) {
 142    case 3:
 143       emit_ubyte_rgba3( ctx, rvb, data, stride, count );
 144       break;
 145    case 4:
 146       emit_ubyte_rgba4( ctx, rvb, data, stride, count );
 147       break;
 148    default:
 149       assert(0);
 150       exit(1);
 151       break;
 152    }
 153 }
 154 #endif
 155
 156
 157 #if defined(USE_X86_ASM)
 158 #define COPY_DWORDS( dst, src, nr )                                     \
 159 do {                                                                    \
 160         int __tmp;                                                      \
 161         __asm__ __volatile__( "rep ; movsl"                             \
 162                               : "=%c" (__tmp), "=D" (dst), "=S" (__tmp) \
 163                               : "0" (nr),                               \
 164                                 "D" ((long)dst),                        \
 165                                 "S" ((long)src) );                      \
 166 } while (0)
 167 #else
 168 #define COPY_DWORDS( dst, src, nr )             \
 169 do {                                            \
 170    int j;                                       \
 171    for ( j = 0 ; j < nr ; j++ )                 \
 172       dst[j] = ((int *)src)[j];                 \
 173    dst += nr;                                   \
 174 } while (0)
 175 #endif
 176
 177
 178
 179
 180
 181 static void emit_vec4( GLcontext *ctx,
 182                        struct r200_dma_region *rvb,
 183                        char *data,
 184                        int stride,
 185                        int count )
 186 {
 187    int i;
 188    int *out = (int *)(rvb->address + rvb->start);
 189
 190    if (R200_DEBUG & DEBUG_VERTS)
 191       fprintf(stderr, "%s count %d stride %d\n",
 192               __FUNCTION__, count, stride);
 193
 194    if (stride == 4)
 195       COPY_DWORDS( out, data, count );
 196    else
 197       for (i = 0; i < count; i++) {
 198          out[0] = *(int *)data;
 199          out++;
 200          data += stride;
 201       }
 202 }
 203
 204
 205 static void emit_vec8( GLcontext *ctx,
 206                        struct r200_dma_region *rvb,
 207                        char *data,
 208                        int stride,
 209                        int count )
 210 {
 211    int i;
 212    int *out = (int *)(rvb->address + rvb->start);
 213
 214    if (R200_DEBUG & DEBUG_VERTS)
 215       fprintf(stderr, "%s count %d stride %d\n",
 216               __FUNCTION__, count, stride);
 217
 218    if (stride == 8)
 219       COPY_DWORDS( out, data, count*2 );
 220    else
 221       for (i = 0; i < count; i++) {
 222          out[0] = *(int *)data;
 223          out[1] = *(int *)(data+4);
 224          out += 2;
 225          data += stride;
 226       }
 227 }
 228
 229 static void emit_vec12( GLcontext *ctx,
 230                        struct r200_dma_region *rvb,
 231                        char *data,
 232                        int stride,
 233                        int count )
 234 {
 235    int i;
 236    int *out = (int *)(rvb->address + rvb->start);
 237
 238    if (R200_DEBUG & DEBUG_VERTS)
 239       fprintf(stderr, "%s count %d stride %d out %p data %p\n",
 240               __FUNCTION__, count, stride, (void *)out, (void *)data);
 241
 242    if (stride == 12)
 243       COPY_DWORDS( out, data, count*3 );
 244    else
 245       for (i = 0; i < count; i++) {
 246          out[0] = *(int *)data;
 247          out[1] = *(int *)(data+4);
 248          out[2] = *(int *)(data+8);
 249          out += 3;
 250          data += stride;
 251       }
 252 }
 253
 254 static void emit_vec16( GLcontext *ctx,
 255                         struct r200_dma_region *rvb,
 256                         char *data,
 257                         int stride,
 258                         int count )
 259 {
 260    int i;
 261    int *out = (int *)(rvb->address + rvb->start);
 262
 263    if (R200_DEBUG & DEBUG_VERTS)
 264       fprintf(stderr, "%s count %d stride %d\n",
 265               __FUNCTION__, count, stride);
 266
 267    if (stride == 16)
 268       COPY_DWORDS( out, data, count*4 );
 269    else
 270       for (i = 0; i < count; i++) {
 271          out[0] = *(int *)data;
 272          out[1] = *(int *)(data+4);
 273          out[2] = *(int *)(data+8);
 274          out[3] = *(int *)(data+12);
 275          out += 4;
 276          data += stride;
 277       }
 278 }
 279
 280
 281 static void emit_vector( GLcontext *ctx,
 282                          struct r200_dma_region *rvb,
 283                          char *data,
 284                          int size,
 285                          int stride,
 286                          int count )
 287 {
 288    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 289
 290    if (R200_DEBUG & DEBUG_VERTS)
 291       fprintf(stderr, "%s count %d size %d stride %d\n",
 292               __FUNCTION__, count, size, stride);
 293
 294    assert (!rvb->buf);
 295
 296    if (stride == 0) {
 297       r200AllocDmaRegion( rmesa, rvb, size * 4, 4 );
 298       count = 1;
 299       rvb->aos_start = GET_START(rvb);
 300       rvb->aos_stride = 0;
 301       rvb->aos_size = size;
 302    }
 303    else {
 304       r200AllocDmaRegion( rmesa, rvb, size * count * 4, 4 );    /* alignment? */
 305       rvb->aos_start = GET_START(rvb);
 306       rvb->aos_stride = size;
 307       rvb->aos_size = size;
 308    }
 309
 310    /* Emit the data
 311     */
 312    switch (size) {
 313    case 1:
 314       emit_vec4( ctx, rvb, data, stride, count );
 315       break;
 316    case 2:
 317       emit_vec8( ctx, rvb, data, stride, count );
 318       break;
 319    case 3:
 320       emit_vec12( ctx, rvb, data, stride, count );
 321       break;
 322    case 4:
 323       emit_vec16( ctx, rvb, data, stride, count );
 324       break;
 325    default:
 326       assert(0);
 327       exit(1);
 328       break;
 329    }
 330
 331 }
 332
 333
 334
 335 /* Emit any changed arrays to new GART memory, re-emit a packet to
 336  * update the arrays.
 337  */
 338 void r200EmitArrays( GLcontext *ctx, GLuint inputs )
 339 {
 340    r200ContextPtr rmesa = R200_CONTEXT( ctx );
 341    struct vertex_buffer *VB = &TNL_CONTEXT( ctx )->vb;
 342    struct r200_dma_region **component = rmesa->tcl.aos_components;
 343    GLuint nr = 0;
 344    GLuint vfmt0 = 0, vfmt1 = 0;
 345    GLuint count = VB->Count;
 346
 347    if (1) {
 348       if (!rmesa->tcl.obj.buf)
 349          emit_vector( ctx,
 350                       &rmesa->tcl.obj,
 351                       (char *)VB->ObjPtr->data,
 352                       VB->ObjPtr->size,
 353                       VB->ObjPtr->stride,
 354                       count);
 355
 356       switch( VB->ObjPtr->size ) {
 357       case 4: vfmt0 |= R200_VTX_W0;
 358       case 3: vfmt0 |= R200_VTX_Z0;
 359       case 2:
 360       default:
 361          break;
 362       }
 363       component[nr++] = &rmesa->tcl.obj;
 364    }
 365
 366
 367    if (inputs & VERT_BIT_NORMAL) {
 368       if (!rmesa->tcl.norm.buf)
 369          emit_vector( ctx,
 370                       &(rmesa->tcl.norm),
 371                       (char *)VB->NormalPtr->data,
 372                       3,
 373                       VB->NormalPtr->stride,
 374                       count);
 375
 376       vfmt0 |= R200_VTX_N0;
 377       component[nr++] = &rmesa->tcl.norm;
 378    }
 379
 380    if (inputs & VERT_BIT_COLOR0) {
 381       int emitsize;
 382
 383       if (VB->ColorPtr[0]->size == 4 &&
 384           (VB->ColorPtr[0]->stride != 0 ||
 385            VB->ColorPtr[0]->data[0][3] != 1.0)) {
 386          vfmt0 |= R200_VTX_FP_RGBA << R200_VTX_COLOR_0_SHIFT;
 387          emitsize = 4;
 388       }
 389       else {
 390          vfmt0 |= R200_VTX_FP_RGB << R200_VTX_COLOR_0_SHIFT;
 391          emitsize = 3;
 392       }
 393
 394       if (!rmesa->tcl.rgba.buf)
 395          emit_vector( ctx,
 396                       &(rmesa->tcl.rgba),
 397                       (char *)VB->ColorPtr[0]->data,
 398                       emitsize,
 399                       VB->ColorPtr[0]->stride,
 400                       count);
 401
 402       component[nr++] = &rmesa->tcl.rgba;
 403    }
 404
 405
 406    if (inputs & VERT_BIT_COLOR1) {
 407       if (!rmesa->tcl.spec.buf) {
 408          emit_vector( ctx,
 409                       &rmesa->tcl.spec,
 410                       (char *)VB->SecondaryColorPtr[0]->data,
 411                       3,
 412                       VB->SecondaryColorPtr[0]->stride,
 413                       count);
 414       }
 415
 416       /* How does this work?
 417        */
 418       vfmt0 |= R200_VTX_FP_RGB << R200_VTX_COLOR_1_SHIFT;
 419       component[nr++] = &rmesa->tcl.spec;
 420    }
 421
 422 /*    vtx = (rmesa->hw.tcl.cmd[TCL_OUTPUT_VTXFMT] & */
 423 /*        ~(R200_TCL_VTX_Q0|R200_TCL_VTX_Q1)); */
 424
 425    if (inputs & VERT_BIT_TEX0) {
 426       if (!rmesa->tcl.tex[0].buf)
 427          emit_vector( ctx,
 428                       &(rmesa->tcl.tex[0]),
 429                       (char *)VB->TexCoordPtr[0]->data,
 430                       VB->TexCoordPtr[0]->size,
 431                       VB->TexCoordPtr[0]->stride,
 432                       count );
 433
 434       vfmt1 |= VB->TexCoordPtr[0]->size << R200_VTX_TEX0_COMP_CNT_SHIFT;
 435       component[nr++] = &rmesa->tcl.tex[0];
 436    }
 437
 438    if (inputs & VERT_BIT_TEX1) {
 439       if (!rmesa->tcl.tex[1].buf)
 440          emit_vector( ctx,
 441                       &(rmesa->tcl.tex[1]),
 442                       (char *)VB->TexCoordPtr[1]->data,
 443                       VB->TexCoordPtr[1]->size,
 444                       VB->TexCoordPtr[1]->stride,
 445                       count );
 446
 447       vfmt1 |= VB->TexCoordPtr[1]->size << R200_VTX_TEX1_COMP_CNT_SHIFT;
 448       component[nr++] = &rmesa->tcl.tex[1];
 449    }
 450
 451    if (vfmt0 != rmesa->hw.vtx.cmd[VTX_VTXFMT_0] ||
 452        vfmt1 != rmesa->hw.vtx.cmd[VTX_VTXFMT_1]) {
 453       R200_STATECHANGE( rmesa, vtx );
 454       rmesa->hw.vtx.cmd[VTX_VTXFMT_0] = vfmt0;
 455       rmesa->hw.vtx.cmd[VTX_VTXFMT_1] = vfmt1;
 456    }
 457
 458    rmesa->tcl.nr_aos_components = nr;
 459    rmesa->tcl.vertex_format = vfmt0;
 460 }
 461
 462
 463 void r200ReleaseArrays( GLcontext *ctx, GLuint newinputs )
 464 {
 465    r200ContextPtr rmesa = R200_CONTEXT( ctx );
 466
 467 /*    if (R200_DEBUG & DEBUG_VERTS)  */
 468 /*       _tnl_print_vert_flags( __FUNCTION__, newinputs ); */
 469
 470    if (newinputs & VERT_BIT_POS)
 471      r200ReleaseDmaRegion( rmesa, &rmesa->tcl.obj, __FUNCTION__ );
 472
 473    if (newinputs & VERT_BIT_NORMAL)
 474       r200ReleaseDmaRegion( rmesa, &rmesa->tcl.norm, __FUNCTION__ );
 475
 476    if (newinputs & VERT_BIT_COLOR0)
 477       r200ReleaseDmaRegion( rmesa, &rmesa->tcl.rgba, __FUNCTION__ );
 478
 479    if (newinputs & VERT_BIT_COLOR1)
 480       r200ReleaseDmaRegion( rmesa, &rmesa->tcl.spec, __FUNCTION__ );
 481
 482    if (newinputs & VERT_BIT_TEX0)
 483       r200ReleaseDmaRegion( rmesa, &rmesa->tcl.tex[0], __FUNCTION__ );
 484
 485    if (newinputs & VERT_BIT_TEX1)
 486       r200ReleaseDmaRegion( rmesa, &rmesa->tcl.tex[1], __FUNCTION__ );
 487 }