src/mesa/tnl/t_vb_vertex.c

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  6.5
   4  *
   5  * Copyright (C) 1999-2006  Brian Paul   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  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  11  * and/or sell copies of the Software, and to permit persons to whom the
  12  * Software is furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included
  15  * in all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  21  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  22  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23  *
  24  * Authors:
  25  *    Keith Whitwell <keith@tungstengraphics.com>
  26  */
  27
  28
  29 #include "glheader.h"
  30 #include "colormac.h"
  31 #include "context.h"
  32 #include "macros.h"
  33 #include "imports.h"
  34 #include "mtypes.h"
  35
  36 #include "math/m_xform.h"
  37
  38 #include "t_context.h"
  39 #include "t_pipeline.h"
  40
  41
  42
  43 struct vertex_stage_data {
  44    GLvector4f eye;
  45    GLvector4f clip;
  46    GLvector4f proj;
  47    GLubyte *clipmask;
  48    GLubyte ormask;
  49    GLubyte andmask;
  50 };
  51
  52 #define VERTEX_STAGE_DATA(stage) ((struct vertex_stage_data *)stage->privatePtr)
  53
  54
  55
  56
  57 /* This function implements cliptesting for user-defined clip planes.
  58  * The clipping of primitives to these planes is implemented in
  59  * t_render_clip.h.
  60  */
  61 #define USER_CLIPTEST(NAME, SZ)                                 \
  62 static void NAME( GLcontext *ctx,                               \
  63                   GLvector4f *clip,                             \
  64                   GLubyte *clipmask,                            \
  65                   GLubyte *clipormask,                          \
  66                   GLubyte *clipandmask )                        \
  67 {                                                               \
  68    GLuint p;                                                    \
  69                                                                 \
  70    for (p = 0; p < ctx->Const.MaxClipPlanes; p++)               \
  71       if (ctx->Transform.ClipPlanesEnabled & (1 << p)) {        \
  72          GLuint nr, i;                                          \
  73          const GLfloat a = ctx->Transform._ClipUserPlane[p][0]; \
  74          const GLfloat b = ctx->Transform._ClipUserPlane[p][1]; \
  75          const GLfloat c = ctx->Transform._ClipUserPlane[p][2]; \
  76          const GLfloat d = ctx->Transform._ClipUserPlane[p][3]; \
  77          GLfloat *coord = (GLfloat *)clip->data;                \
  78          GLuint stride = clip->stride;                          \
  79          GLuint count = clip->count;                            \
  80                                                                 \
  81          for (nr = 0, i = 0 ; i < count ; i++) {                \
  82             GLfloat dp = coord[0] * a + coord[1] * b;           \
  83             if (SZ > 2) dp += coord[2] * c;                     \
  84             if (SZ > 3) dp += coord[3] * d; else dp += d;       \
  85                                                                 \
  86             if (dp < 0) {                                       \
  87                nr++;                                            \
  88                clipmask[i] |= CLIP_USER_BIT;                    \
  89             }                                                   \
  90                                                                 \
  91             STRIDE_F(coord, stride);                            \
  92          }                                                      \
  93                                                                 \
  94          if (nr > 0) {                                          \
  95             *clipormask |= CLIP_USER_BIT;                       \
  96             if (nr == count) {                                  \
  97                *clipandmask |= CLIP_USER_BIT;                   \
  98                return;                                          \
  99             }                                                   \
 100          }                                                      \
 101       }                                                         \
 102 }
 103
 104
 105 USER_CLIPTEST(userclip2, 2)
 106 USER_CLIPTEST(userclip3, 3)
 107 USER_CLIPTEST(userclip4, 4)
 108
 109 static void (*(usercliptab[5]))( GLcontext *,
 110                                  GLvector4f *, GLubyte *,
 111                                  GLubyte *, GLubyte * ) =
 112 {
 113    NULL,
 114    NULL,
 115    userclip2,
 116    userclip3,
 117    userclip4
 118 };
 119
 120
 121
 122 static GLboolean run_vertex_stage( GLcontext *ctx,
 123                                    struct tnl_pipeline_stage *stage )
 124 {
 125    struct vertex_stage_data *store = (struct vertex_stage_data *)stage->privatePtr;
 126    TNLcontext *tnl = TNL_CONTEXT(ctx);
 127    struct vertex_buffer *VB = &tnl->vb;
 128
 129    if (ctx->ShaderObjects.CurrentProgram != NULL)
 130       return GL_TRUE;
 131
 132    if (ctx->VertexProgram._Enabled)
 133       return GL_TRUE;
 134
 135    if (ctx->_NeedEyeCoords) {
 136       /* Separate modelview transformation:
 137        * Use combined ModelProject to avoid some depth artifacts
 138        */
 139       if (ctx->ModelviewMatrixStack.Top->type == MATRIX_IDENTITY)
 140          VB->EyePtr = VB->ObjPtr;
 141       else
 142          VB->EyePtr = TransformRaw( &store->eye,
 143                                     ctx->ModelviewMatrixStack.Top,
 144                                     VB->ObjPtr);
 145    }
 146
 147    VB->ClipPtr = TransformRaw( &store->clip,
 148                                &ctx->_ModelProjectMatrix,
 149                                VB->ObjPtr );
 150
 151    /* Drivers expect this to be clean to element 4...
 152     */
 153    switch (VB->ClipPtr->size) {
 154    case 1:
 155       /* impossible */
 156    case 2:
 157       _mesa_vector4f_clean_elem( VB->ClipPtr, VB->Count, 2 );
 158       /* fall-through */
 159    case 3:
 160       _mesa_vector4f_clean_elem( VB->ClipPtr, VB->Count, 3 );
 161       /* fall-through */
 162    case 4:
 163       break;
 164    }
 165
 166
 167    /* Cliptest and perspective divide.  Clip functions must clear
 168     * the clipmask.
 169     */
 170    store->ormask = 0;
 171    store->andmask = CLIP_ALL_BITS;
 172
 173    if (tnl->NeedNdcCoords) {
 174       VB->NdcPtr =
 175          _mesa_clip_tab[VB->ClipPtr->size]( VB->ClipPtr,
 176                                             &store->proj,
 177                                             store->clipmask,
 178                                             &store->ormask,
 179                                             &store->andmask );
 180    }
 181    else {
 182       VB->NdcPtr = NULL;
 183       _mesa_clip_np_tab[VB->ClipPtr->size]( VB->ClipPtr,
 184                                             NULL,
 185                                             store->clipmask,
 186                                             &store->ormask,
 187                                             &store->andmask );
 188    }
 189
 190    if (store->andmask)
 191       return GL_FALSE;
 192
 193
 194    /* Test userclip planes.  This contributes to VB->ClipMask, so
 195     * is essentially required to be in this stage.
 196     */
 197    if (ctx->Transform.ClipPlanesEnabled) {
 198       usercliptab[VB->ClipPtr->size]( ctx,
 199                                       VB->ClipPtr,
 200                                       store->clipmask,
 201                                       &store->ormask,
 202                                       &store->andmask );
 203
 204       if (store->andmask)
 205          return GL_FALSE;
 206    }
 207
 208    VB->ClipAndMask = store->andmask;
 209    VB->ClipOrMask = store->ormask;
 210    VB->ClipMask = store->clipmask;
 211
 212    return GL_TRUE;
 213 }
 214
 215
 216 static GLboolean init_vertex_stage( GLcontext *ctx,
 217                                     struct tnl_pipeline_stage *stage )
 218 {
 219    struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
 220    struct vertex_stage_data *store;
 221    GLuint size = VB->Size;
 222
 223    stage->privatePtr = CALLOC(sizeof(*store));
 224    store = VERTEX_STAGE_DATA(stage);
 225    if (!store)
 226       return GL_FALSE;
 227
 228    _mesa_vector4f_alloc( &store->eye, 0, size, 32 );
 229    _mesa_vector4f_alloc( &store->clip, 0, size, 32 );
 230    _mesa_vector4f_alloc( &store->proj, 0, size, 32 );
 231
 232    store->clipmask = (GLubyte *) ALIGN_MALLOC(sizeof(GLubyte)*size, 32 );
 233
 234    if (!store->clipmask ||
 235        !store->eye.data ||
 236        !store->clip.data ||
 237        !store->proj.data)
 238       return GL_FALSE;
 239
 240    return GL_TRUE;
 241 }
 242
 243 static void dtr( struct tnl_pipeline_stage *stage )
 244 {
 245    struct vertex_stage_data *store = VERTEX_STAGE_DATA(stage);
 246
 247    if (store) {
 248       _mesa_vector4f_free( &store->eye );
 249       _mesa_vector4f_free( &store->clip );
 250       _mesa_vector4f_free( &store->proj );
 251       ALIGN_FREE( store->clipmask );
 252       FREE(store);
 253       stage->privatePtr = NULL;
 254       stage->run = init_vertex_stage;
 255    }
 256 }
 257
 258
 259 const struct tnl_pipeline_stage _tnl_vertex_transform_stage =
 260 {
 261    "modelview/project/cliptest/divide",
 262    NULL,                        /* private data */
 263    init_vertex_stage,
 264    dtr,                         /* destructor */
 265    NULL,
 266    run_vertex_stage             /* run -- initially set to init */
 267 };