src/mesa/tnl/t_vb_vertex.c

   1 /*
   2  * Mesa 3-D graphics library
   3  *
   4  * Copyright (C) 1999-2006  Brian Paul   All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the "Software"),
   8  * to deal in the Software without restriction, including without limitation
   9  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  10  * and/or sell copies of the Software, and to permit persons to whom the
  11  * Software is furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included
  14  * in all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  17  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  20  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  21  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  22  * OTHER DEALINGS IN THE SOFTWARE.
  23  *
  24  * Authors:
  25  *    Keith Whitwell <keithw@vmware.com>
  26  */
  27
  28
  29 #include "main/glheader.h"
  30 #include "main/macros.h"
  31 #include "main/imports.h"
  32 #include "main/mtypes.h"
  33
  34 #include "math/m_xform.h"
  35
  36 #include "util/bitscan.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( struct gl_context *ctx,                               \
  63                   GLvector4f *clip,                             \
  64                   GLubyte *clipmask,                            \
  65                   GLubyte *clipormask,                          \
  66                   GLubyte *clipandmask )                        \
  67 {                                                               \
  68    GLbitfield mask = ctx->Transform.ClipPlanesEnabled;          \
  69    while (mask) {                                               \
  70       const int p = u_bit_scan(&mask);                          \
  71       GLuint nr, i;                                             \
  72       const GLfloat a = ctx->Transform._ClipUserPlane[p][0];    \
  73       const GLfloat b = ctx->Transform._ClipUserPlane[p][1];    \
  74       const GLfloat c = ctx->Transform._ClipUserPlane[p][2];    \
  75       const GLfloat d = ctx->Transform._ClipUserPlane[p][3];    \
  76       GLfloat *coord = (GLfloat *)clip->data;                   \
  77       GLuint stride = clip->stride;                             \
  78       GLuint count = clip->count;                               \
  79                                                                 \
  80       for (nr = 0, i = 0 ; i < count ; i++) {                   \
  81          GLfloat dp = coord[0] * a + coord[1] * b;              \
  82          if (SZ > 2) dp += coord[2] * c;                        \
  83          if (SZ > 3) dp += coord[3] * d; else dp += d;          \
  84                                                                 \
  85          if (dp < 0) {                                          \
  86             nr++;                                               \
  87             clipmask[i] |= CLIP_USER_BIT;                       \
  88          }                                                      \
  89                                                                 \
  90          STRIDE_F(coord, stride);                               \
  91       }                                                         \
  92                                                                 \
  93       if (nr > 0) {                                             \
  94          *clipormask |= CLIP_USER_BIT;                          \
  95          if (nr == count) {                                     \
  96             *clipandmask |= CLIP_USER_BIT;                      \
  97             return;                                             \
  98          }                                                      \
  99       }                                                         \
 100    }                                                            \
 101 }
 102
 103
 104 USER_CLIPTEST(userclip2, 2)
 105 USER_CLIPTEST(userclip3, 3)
 106 USER_CLIPTEST(userclip4, 4)
 107
 108 static void (*(usercliptab[5]))( struct gl_context *,
 109                                  GLvector4f *, GLubyte *,
 110                                  GLubyte *, GLubyte * ) =
 111 {
 112    NULL,
 113    NULL,
 114    userclip2,
 115    userclip3,
 116    userclip4
 117 };
 118
 119
 120 void
 121 tnl_clip_prepare(struct gl_context *ctx)
 122 {
 123    /* Neither the x86 nor sparc asm cliptest functions have been updated
 124     * for ARB_depth_clamp, so force the C paths.
 125     */
 126    if (ctx->Transform.DepthClampNear && ctx->Transform.DepthClampFar) {
 127       static GLboolean c_funcs_installed = GL_FALSE;
 128       if (!c_funcs_installed) {
 129          init_c_cliptest();
 130          c_funcs_installed = GL_TRUE;
 131       }
 132    }
 133 }
 134
 135
 136
 137 static GLboolean run_vertex_stage( struct gl_context *ctx,
 138                                    struct tnl_pipeline_stage *stage )
 139 {
 140    struct vertex_stage_data *store = (struct vertex_stage_data *)stage->privatePtr;
 141    TNLcontext *tnl = TNL_CONTEXT(ctx);
 142    struct vertex_buffer *VB = &tnl->vb;
 143
 144    if (ctx->VertexProgram._Current)
 145       return GL_TRUE;
 146
 147    tnl_clip_prepare(ctx);
 148
 149    if (ctx->_NeedEyeCoords) {
 150       /* Separate modelview transformation:
 151        * Use combined ModelProject to avoid some depth artifacts
 152        */
 153       if (ctx->ModelviewMatrixStack.Top->type == MATRIX_IDENTITY)
 154          VB->EyePtr = VB->AttribPtr[_TNL_ATTRIB_POS];
 155       else
 156          VB->EyePtr = TransformRaw( &store->eye,
 157                                     ctx->ModelviewMatrixStack.Top,
 158                                     VB->AttribPtr[_TNL_ATTRIB_POS]);
 159    }
 160
 161    VB->ClipPtr = TransformRaw( &store->clip,
 162                                &ctx->_ModelProjectMatrix,
 163                                VB->AttribPtr[_TNL_ATTRIB_POS] );
 164
 165    /* Drivers expect this to be clean to element 4...
 166     */
 167    switch (VB->ClipPtr->size) {
 168    case 1:
 169       /* impossible */
 170    case 2:
 171       _mesa_vector4f_clean_elem( VB->ClipPtr, VB->Count, 2 );
 172       /* fall-through */
 173    case 3:
 174       _mesa_vector4f_clean_elem( VB->ClipPtr, VB->Count, 3 );
 175       /* fall-through */
 176    case 4:
 177       break;
 178    }
 179
 180
 181    /* Cliptest and perspective divide.  Clip functions must clear
 182     * the clipmask.
 183     */
 184    store->ormask = 0;
 185    store->andmask = CLIP_FRUSTUM_BITS;
 186
 187    if (tnl->NeedNdcCoords) {
 188       VB->NdcPtr =
 189          _mesa_clip_tab[VB->ClipPtr->size]( VB->ClipPtr,
 190                                             &store->proj,
 191                                             store->clipmask,
 192                                             &store->ormask,
 193                                             &store->andmask,
 194                                             !(ctx->Transform.DepthClampNear &&
 195                                               ctx->Transform.DepthClampFar) );
 196    }
 197    else {
 198       VB->NdcPtr = NULL;
 199       _mesa_clip_np_tab[VB->ClipPtr->size]( VB->ClipPtr,
 200                                             NULL,
 201                                             store->clipmask,
 202                                             &store->ormask,
 203                                             &store->andmask,
 204                                             !(ctx->Transform.DepthClampNear &&
 205                                               ctx->Transform.DepthClampFar) );
 206    }
 207
 208    if (store->andmask)
 209       return GL_FALSE;
 210
 211
 212    /* Test userclip planes.  This contributes to VB->ClipMask, so
 213     * is essentially required to be in this stage.
 214     */
 215    if (ctx->Transform.ClipPlanesEnabled) {
 216       usercliptab[VB->ClipPtr->size]( ctx,
 217                                       VB->ClipPtr,
 218                                       store->clipmask,
 219                                       &store->ormask,
 220                                       &store->andmask );
 221
 222       if (store->andmask)
 223          return GL_FALSE;
 224    }
 225
 226    VB->ClipAndMask = store->andmask;
 227    VB->ClipOrMask = store->ormask;
 228    VB->ClipMask = store->clipmask;
 229
 230    return GL_TRUE;
 231 }
 232
 233
 234 static GLboolean init_vertex_stage( struct gl_context *ctx,
 235                                     struct tnl_pipeline_stage *stage )
 236 {
 237    struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
 238    struct vertex_stage_data *store;
 239    GLuint size = VB->Size;
 240
 241    stage->privatePtr = calloc(1, sizeof(*store));
 242    store = VERTEX_STAGE_DATA(stage);
 243    if (!store)
 244       return GL_FALSE;
 245
 246    _mesa_vector4f_alloc( &store->eye, 0, size, 32 );
 247    _mesa_vector4f_alloc( &store->clip, 0, size, 32 );
 248    _mesa_vector4f_alloc( &store->proj, 0, size, 32 );
 249
 250    store->clipmask = _mesa_align_malloc(sizeof(GLubyte)*size, 32 );
 251
 252    if (!store->clipmask ||
 253        !store->eye.data ||
 254        !store->clip.data ||
 255        !store->proj.data)
 256       return GL_FALSE;
 257
 258    return GL_TRUE;
 259 }
 260
 261 static void dtr( struct tnl_pipeline_stage *stage )
 262 {
 263    struct vertex_stage_data *store = VERTEX_STAGE_DATA(stage);
 264
 265    if (store) {
 266       _mesa_vector4f_free( &store->eye );
 267       _mesa_vector4f_free( &store->clip );
 268       _mesa_vector4f_free( &store->proj );
 269       _mesa_align_free( store->clipmask );
 270       free(store);
 271       stage->privatePtr = NULL;
 272       stage->run = init_vertex_stage;
 273    }
 274 }
 275
 276
 277 const struct tnl_pipeline_stage _tnl_vertex_transform_stage =
 278 {
 279    "modelview/project/cliptest/divide",
 280    NULL,                        /* private data */
 281    init_vertex_stage,
 282    dtr,                         /* destructor */
 283    NULL,
 284    run_vertex_stage             /* run -- initially set to init */
 285 };