src/mesa/tnl_dd/t_dd_vb.c

   1
   2 /*
   3  * Mesa 3-D graphics library
   4  * Version:  3.5
   5  *
   6  * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
   7  *
   8  * Permission is hereby granted, free of charge, to any person obtaining a
   9  * copy of this software and associated documentation files (the "Software"),
  10  * to deal in the Software without restriction, including without limitation
  11  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  12  * and/or sell copies of the Software, and to permit persons to whom the
  13  * Software is furnished to do so, subject to the following conditions:
  14  *
  15  * The above copyright notice and this permission notice shall be included
  16  * in all copies or substantial portions of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  21  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  22  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  23  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  24  * OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  * Authors:
  27  *    Keith Whitwell <keith@tungstengraphics.com>
  28  */
  29 #include "math/m_translate.h"
  30
  31 #if (HAVE_HW_VIEWPORT)
  32 #define UNVIEWPORT_VARS
  33 #define UNVIEWPORT_X(x) x
  34 #define UNVIEWPORT_Y(x) x
  35 #define UNVIEWPORT_Z(x) x
  36 #endif
  37
  38 #ifndef LOCALVARS
  39 #define LOCALVARS
  40 #endif
  41
  42 #ifndef CHECK_HW_DIVIDE
  43 #define CHECK_HW_DIVIDE 1
  44 #endif
  45
  46 /* These don't need to be duplicated, but there's currently nowhere
  47  * really convenient to put them.  Need to build some actual .o files in
  48  * this directory?
  49  */
  50 static void copy_pv_rgba4_spec5( struct gl_context *ctx, GLuint edst, GLuint esrc )
  51 {
  52    LOCALVARS
  53    GLubyte *verts = GET_VERTEX_STORE();
  54    GLuint size = GET_VERTEX_SIZE();
  55    GLuint *dst = (GLuint *)(verts + (edst * size));
  56    GLuint *src = (GLuint *)(verts + (esrc * size));
  57    dst[4] = src[4];
  58    dst[5] = src[5];
  59 }
  60
  61 static void copy_pv_rgba4( struct gl_context *ctx, GLuint edst, GLuint esrc )
  62 {
  63    LOCALVARS
  64    GLubyte *verts = GET_VERTEX_STORE();
  65    GLuint size = GET_VERTEX_SIZE();
  66    GLuint *dst = (GLuint *)(verts + (edst * size));
  67    GLuint *src = (GLuint *)(verts + (esrc * size));
  68    dst[4] = src[4];
  69 }
  70
  71 static void copy_pv_rgba3( struct gl_context *ctx, GLuint edst, GLuint esrc )
  72 {
  73    LOCALVARS
  74    GLubyte *verts = GET_VERTEX_STORE();
  75    GLuint size = GET_VERTEX_SIZE();
  76    GLuint *dst = (GLuint *)(verts + (edst * size));
  77    GLuint *src = (GLuint *)(verts + (esrc * size));
  78    dst[3] = src[3];
  79 }
  80
  81
  82 void TAG(translate_vertex)(struct gl_context *ctx,
  83                            const VERTEX *src,
  84                            SWvertex *dst)
  85 {
  86    LOCALVARS
  87    GLuint format = GET_VERTEX_FORMAT();
  88    GLfloat *s = ctx->Viewport._WindowMap.m;
  89    UNVIEWPORT_VARS;
  90
  91    if (format == TINY_VERTEX_FORMAT) {
  92       if (HAVE_HW_VIEWPORT) {
  93          dst->attrib[VARYING_SLOT_POS][0] = s[0]  * src->v.x + s[12];
  94          dst->attrib[VARYING_SLOT_POS][1] = s[5]  * src->v.y + s[13];
  95          dst->attrib[VARYING_SLOT_POS][2] = s[10] * src->v.z + s[14];
  96          dst->attrib[VARYING_SLOT_POS][3] = 1.0;
  97       } else {
  98          dst->attrib[VARYING_SLOT_POS][0] = UNVIEWPORT_X( src->v.x );
  99          dst->attrib[VARYING_SLOT_POS][1] = UNVIEWPORT_Y( src->v.y );
 100          dst->attrib[VARYING_SLOT_POS][2] = UNVIEWPORT_Z( src->v.z );
 101          dst->attrib[VARYING_SLOT_POS][3] = 1.0;
 102       }
 103
 104       dst->color[0] = src->tv.color.red;
 105       dst->color[1] = src->tv.color.green;
 106       dst->color[2] = src->tv.color.blue;
 107       dst->color[3] = src->tv.color.alpha;
 108    }
 109    else {
 110       if (HAVE_HW_VIEWPORT) {
 111          if (HAVE_HW_DIVIDE && CHECK_HW_DIVIDE) {
 112             GLfloat oow = 1.0 / src->v.w;
 113             dst->attrib[VARYING_SLOT_POS][0] = s[0]  * src->v.x * oow + s[12];
 114             dst->attrib[VARYING_SLOT_POS][1] = s[5]  * src->v.y * oow + s[13];
 115             dst->attrib[VARYING_SLOT_POS][2] = s[10] * src->v.z * oow + s[14];
 116             dst->attrib[VARYING_SLOT_POS][3] = oow;
 117          } else {
 118             dst->attrib[VARYING_SLOT_POS][0] = s[0]  * src->v.x + s[12];
 119             dst->attrib[VARYING_SLOT_POS][1] = s[5]  * src->v.y + s[13];
 120             dst->attrib[VARYING_SLOT_POS][2] = s[10] * src->v.z + s[14];
 121             dst->attrib[VARYING_SLOT_POS][3] = src->v.w;
 122          }
 123       } else {
 124          dst->attrib[VARYING_SLOT_POS][0] = UNVIEWPORT_X( src->v.x );
 125          dst->attrib[VARYING_SLOT_POS][1] = UNVIEWPORT_Y( src->v.y );
 126          dst->attrib[VARYING_SLOT_POS][2] = UNVIEWPORT_Z( src->v.z );
 127          dst->attrib[VARYING_SLOT_POS][3] = src->v.w;
 128       }
 129
 130       dst->color[0] = src->v.color.red;
 131       dst->color[1] = src->v.color.green;
 132       dst->color[2] = src->v.color.blue;
 133       dst->color[3] = src->v.color.alpha;
 134
 135       dst->attrib[VARYING_SLOT_COL1][0] = UBYTE_TO_FLOAT(src->v.specular.red);
 136       dst->attrib[VARYING_SLOT_COL1][1] = UBYTE_TO_FLOAT(src->v.specular.green);
 137       dst->attrib[VARYING_SLOT_COL1][2] = UBYTE_TO_FLOAT(src->v.specular.blue);
 138
 139       dst->attrib[VARYING_SLOT_FOGC][0] = UBYTE_TO_FLOAT(src->v.specular.alpha);
 140
 141       if (HAVE_PTEX_VERTICES &&
 142           ((HAVE_TEX2_VERTICES && format == PROJ_TEX3_VERTEX_FORMAT) ||
 143            (format == PROJ_TEX1_VERTEX_FORMAT))) {
 144
 145          dst->attrib[VARYING_SLOT_TEX0][0] = src->pv.u0;
 146          dst->attrib[VARYING_SLOT_TEX0][1] = src->pv.v0;
 147          dst->attrib[VARYING_SLOT_TEX0][3] = src->pv.q0;
 148
 149          dst->attrib[VARYING_SLOT_TEX1][0] = src->pv.u1;
 150          dst->attrib[VARYING_SLOT_TEX1][1] = src->pv.v1;
 151          dst->attrib[VARYING_SLOT_TEX1][3] = src->pv.q1;
 152
 153          if (HAVE_TEX2_VERTICES) {
 154             dst->attrib[VARYING_SLOT_TEX2][0] = src->pv.u2;
 155             dst->attrib[VARYING_SLOT_TEX2][1] = src->pv.v2;
 156             dst->attrib[VARYING_SLOT_TEX2][3] = src->pv.q2;
 157          }
 158
 159          if (HAVE_TEX3_VERTICES) {
 160             dst->attrib[VARYING_SLOT_TEX3][0] = src->pv.u3;
 161             dst->attrib[VARYING_SLOT_TEX3][1] = src->pv.v3;
 162             dst->attrib[VARYING_SLOT_TEX3][3] = src->pv.q3;
 163          }
 164       }
 165       else {
 166          dst->attrib[VARYING_SLOT_TEX0][0] = src->v.u0;
 167          dst->attrib[VARYING_SLOT_TEX0][1] = src->v.v0;
 168          dst->attrib[VARYING_SLOT_TEX0][3] = 1.0;
 169
 170          dst->attrib[VARYING_SLOT_TEX1][0] = src->v.u1;
 171          dst->attrib[VARYING_SLOT_TEX1][1] = src->v.v1;
 172          dst->attrib[VARYING_SLOT_TEX1][3] = 1.0;
 173
 174          if (HAVE_TEX2_VERTICES) {
 175             dst->attrib[VARYING_SLOT_TEX2][0] = src->v.u2;
 176             dst->attrib[VARYING_SLOT_TEX2][1] = src->v.v2;
 177             dst->attrib[VARYING_SLOT_TEX2][3] = 1.0;
 178          }
 179
 180          if (HAVE_TEX3_VERTICES) {
 181             dst->attrib[VARYING_SLOT_TEX3][0] = src->v.u3;
 182             dst->attrib[VARYING_SLOT_TEX3][1] = src->v.v3;
 183             dst->attrib[VARYING_SLOT_TEX3][3] = 1.0;
 184          }
 185       }
 186    }
 187
 188    dst->pointSize = ctx->Point.Size;
 189 }
 190
 191
 192 /* prototype to silence warning */
 193 void TAG(print_vertex)( struct gl_context *ctx, const VERTEX *v );
 194
 195
 196 void TAG(print_vertex)( struct gl_context *ctx, const VERTEX *v )
 197 {
 198    LOCALVARS
 199    GLuint format = GET_VERTEX_FORMAT();
 200
 201    fprintf(stderr, "(%x) ", format);
 202
 203    switch (format) {
 204 #if HAVE_TINY_VERTICES
 205    case TINY_VERTEX_FORMAT:
 206       fprintf(stderr, "xyz %.4f,%.4f,%.4f rgba %x:%x:%x:%x\n",
 207               v->v.x, v->v.y, v->v.z,
 208               v->tv.color.red,
 209               v->tv.color.green,
 210               v->tv.color.blue,
 211               v->tv.color.alpha);
 212       break;
 213 #endif
 214 #if HAVE_NOTEX_VERTICES
 215    case NOTEX_VERTEX_FORMAT:
 216       fprintf(stderr, "xyzw %.4f,%.4f,%.4f,%.4f rgba %x:%x:%x:%x spec %x:%x:%x:%x\n",
 217               v->v.x, v->v.y, v->v.z, v->v.w,
 218               v->v.color.red,
 219               v->v.color.green,
 220               v->v.color.blue,
 221               v->v.color.alpha,
 222               v->v.specular.red,
 223               v->v.specular.green,
 224               v->v.specular.blue,
 225               v->v.specular.alpha);
 226       break;
 227 #endif
 228 #if HAVE_TEX0_VERTICES
 229    case TEX0_VERTEX_FORMAT:
 230       fprintf(stderr, "xyzw %.4f,%.4f,%.4f,%.4f rgba %x:%x:%x:%x st %.4f,%.4f\n",
 231               v->v.x, v->v.y, v->v.z, v->v.w,
 232               v->v.color.red,
 233               v->v.color.green,
 234               v->v.color.blue,
 235               v->v.color.alpha,
 236               v->v.u0,
 237               v->v.v0);
 238       break;
 239 #endif
 240 #if HAVE_TEX1_VERTICES
 241    case TEX1_VERTEX_FORMAT:
 242       fprintf(stderr, "xyzw %.4f,%.4f,%.4f,%.4f rgba %x:%x:%x:%x st %.4f,%.4f st %.4f,%.4f\n",
 243               v->v.x, v->v.y, v->v.z, v->v.w,
 244               v->v.color.red,
 245               v->v.color.green,
 246               v->v.color.blue,
 247               v->v.color.alpha,
 248               v->v.u0,
 249               v->v.v0,
 250               v->v.u1,
 251               v->v.u2);
 252       break;
 253 #endif
 254 #if HAVE_PTEX_VERTICES
 255    case PROJ_TEX1_VERTEX_FORMAT:
 256       fprintf(stderr, "xyzw %.4f,%.4f,%.4f,%.4f rgba %x:%x:%x:%x stq %.4f,%.4f,%.4f stq %.4f,%.4f,%.4f\n",
 257               v->v.x, v->v.y, v->v.z, v->v.w,
 258               v->v.color.red,
 259               v->v.color.green,
 260               v->v.color.blue,
 261               v->v.color.alpha,
 262               v->pv.u0,
 263               v->pv.v0,
 264               v->pv.q0,
 265               v->pv.u1,
 266               v->pv.v1,
 267               v->pv.q1);
 268       break;
 269 #endif
 270    default:
 271       fprintf(stderr, "???\n");
 272       break;
 273    }
 274
 275    fprintf(stderr, "\n");
 276 }
 277
 278
 279
 280 /* Interpolate the elements of the VB not included in typical hardware
 281  * vertices.
 282  *
 283  * NOTE: All these arrays are guarenteed by tnl to be writeable and
 284  * have good stride.
 285  */
 286 #ifndef INTERP_QUALIFIER
 287 #define INTERP_QUALIFIER static
 288 #endif
 289
 290 #define GET_COLOR(ptr, idx) ((ptr)->data[idx])
 291
 292
 293 INTERP_QUALIFIER void TAG(interp_extras)( struct gl_context *ctx,
 294                                           GLfloat t,
 295                                           GLuint dst, GLuint out, GLuint in,
 296                                           GLboolean force_boundary )
 297 {
 298    LOCALVARS
 299    struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
 300
 301    if (VB->BackfaceColorPtr) {
 302       assert(VB->BackfaceColorPtr->stride == 4 * sizeof(GLfloat));
 303
 304       INTERP_4F( t,
 305                     GET_COLOR(VB->BackfaceColorPtr, dst),
 306                     GET_COLOR(VB->BackfaceColorPtr, out),
 307                     GET_COLOR(VB->BackfaceColorPtr, in) );
 308
 309       if (VB->BackfaceSecondaryColorPtr) {
 310          INTERP_3F( t,
 311                        GET_COLOR(VB->BackfaceSecondaryColorPtr, dst),
 312                        GET_COLOR(VB->BackfaceSecondaryColorPtr, out),
 313                        GET_COLOR(VB->BackfaceSecondaryColorPtr, in) );
 314       }
 315    }
 316
 317    if (VB->EdgeFlag) {
 318       VB->EdgeFlag[dst] = VB->EdgeFlag[out] || force_boundary;
 319    }
 320
 321    INTERP_VERTEX(ctx, t, dst, out, in, force_boundary);
 322 }
 323
 324 INTERP_QUALIFIER void TAG(copy_pv_extras)( struct gl_context *ctx,
 325                                            GLuint dst, GLuint src )
 326 {
 327    LOCALVARS
 328       struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
 329
 330    if (VB->BackfaceColorPtr) {
 331       COPY_4FV( GET_COLOR(VB->BackfaceColorPtr, dst),
 332                 GET_COLOR(VB->BackfaceColorPtr, src) );
 333
 334       if (VB->BackfaceSecondaryColorPtr) {
 335          COPY_4FV( GET_COLOR(VB->BackfaceSecondaryColorPtr, dst),
 336                    GET_COLOR(VB->BackfaceSecondaryColorPtr, src) );
 337       }
 338    }
 339
 340    COPY_PV_VERTEX(ctx, dst, src);
 341 }
 342
 343
 344 #undef INTERP_QUALIFIER
 345 #undef GET_COLOR
 346
 347 #undef IND
 348 #undef TAG