src/mesa/tnl_dd/imm/t_dd_imm_vapi.h

   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  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  22  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  23  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  24  *
  25  * Authors:
  26  *    Gareth Hughes <gareth@valinux.com>
  27  *    Keith Whitwell <keithw@valinux.com>
  28  */
  29
  30 /* Template for immediate mode vertex functions.
  31  */
  32
  33 #define DBG 0
  34
  35 #define VERTEX( ox, oy, oz, ow )
  36 do {
  37    GET_CURRENT_VERTEX;
  38    GLfloat w;
  39    GLuint mask;
  40    const GLfloat * const m = ctx->_ModelProjectMatrix.m;
  41
  42    if (DO_FULL_MATRIX) {
  43       VERTEX_CLIP(0) = m[0] * ox + m[4] * oy + m[8]  * oz + m[12] * ow;
  44       VERTEX_CLIP(1) = m[1] * ox + m[5] * oy + m[9]  * oz + m[13] * ow;
  45       VERTEX_CLIP(2) = m[2] * ox + m[6] * oy + m[10] * oz + m[14] * ow;
  46       VERTEX_CLIP(3) = m[3] * ox + m[7] * oy + m[11] * oz + m[15] * ow;
  47       w = VERTEX_CLIP(3);
  48    }
  49    else if (DO_NOROT_MATRIX) {
  50       VERTEX_CLIP(0) = m[0] * ox                          + m[12] * ow;
  51       VERTEX_CLIP(1) =             m[5] * oy              + m[13] * ow;
  52       VERTEX_CLIP(2) =                         m[10] * oz + m[14] * ow;
  53       VERTEX_CLIP(3) =                                              ow;
  54       w = ow;
  55    }
  56    else {
  57       ASSERT (DO_IDENTITY_MATRIX);
  58       VERTEX_CLIP(0) = ox;
  59       VERTEX_CLIP(1) = oy;
  60       VERTEX_CLIP(2) = oz;
  61       VERTEX_CLIP(3) = ow;
  62       w = ow;
  63    }
  64
  65    mask = 0;
  66    if (DO_CLIP_TEST) {
  67       if ( VERTEX_CLIP(0) >  w ) mask |= CLIP_RIGHT_BIT;
  68       if ( VERTEX_CLIP(0) < -w ) mask |= CLIP_LEFT_BIT;
  69       if ( VERTEX_CLIP(1) >  w ) mask |= CLIP_TOP_BIT;
  70       if ( VERTEX_CLIP(1) < -w ) mask |= CLIP_BOTTOM_BIT;
  71       if ( VERTEX_CLIP(2) >  w ) mask |= CLIP_FAR_BIT;
  72       if ( VERTEX_CLIP(2) < -w ) mask |= CLIP_NEAR_BIT;
  73       VERTEX_MASK(v) = mask;
  74    }
  75
  76    if (!mask) {
  77       if (HAVE_VERTEX_WIN) {
  78          if (!HAVE_HW_VIEWPORT) {
  79             const GLfloat *s = GET_VIEWPORT_MATRIX();
  80             if (HAVE_W && HAVE_HW_DIVIDE) {
  81                VERTEX_WIN( 0 ) = s[0]  * VERTEX_CLIP( 0 ) + s[12];
  82                VERTEX_WIN( 1 ) = s[5]  * VERTEX_CLIP( 1 ) + s[13];
  83                VERTEX_WIN( 2 ) = s[10] * VERTEX_CLIP( 2 ) + s[14];
  84                VERTEX_WIN( 3 ) = w;
  85             }
  86             else {
  87                const GLfloat oow = 1.0/w; /* possibly opt away */
  88                VERTEX_WIN( 0 ) = s[0]  * VERTEX_CLIP( 0 ) * oow + s[12];
  89                VERTEX_WIN( 1 ) = s[5]  * VERTEX_CLIP( 1 ) * oow + s[13];
  90                VERTEX_WIN( 2 ) = s[10] * VERTEX_CLIP( 2 ) * oow + s[14];
  91                if (HAVE_W)
  92                   VERTEX_WIN( 3 ) = oow;
  93             }
  94          }
  95          else if (HAVE_W && HAVE_HW_DIVIDE) {
  96             if (!VERTEX_WIN_IS_VERTEX_CLIP) {
  97                VERTEX_WIN( 0 ) = VERTEX_CLIP( 0 );
  98                VERTEX_WIN( 1 ) = VERTEX_CLIP( 1 );
  99                VERTEX_WIN( 2 ) = VERTEX_CLIP( 2 );
 100                VERTEX_WIN( 3 ) = w;
 101             }
 102          }
 103          else {
 104             const GLfloat oow = 1.0/w; /* possibly opt away */
 105             VERTEX_WIN( 0 ) = VERTEX_CLIP( 0 ) * oow;
 106             VERTEX_WIN( 1 ) = VERTEX_CLIP( 1 ) * oow;
 107             VERTEX_WIN( 2 ) = VERTEX_CLIP( 2 ) * oow;
 108             if (HAVE_W)
 109                VERTEX_WIN( 3 ) = oow;
 110          }
 111       }
 112    } else if (!FALLBACK_OR_CLIPPING) {
 113       SET_CLIPPING();           /* transition to clipping */
 114    }
 115
 116    COPY_VERTEX_FROM_CURRENT;
 117    BUILD_PRIM_FROM_VERTEX;
 118 }
 119
 120 /* Let the compiler optimize away the constant operations:
 121  */
 122 static void VTAG(Vertex2f)( GLfloat ox, GLfloat oy )
 123 {
 124    /* Cliptest on clip[2] could also be eliminated...
 125     */
 126    VERTEX( ox, oy, 0, 1 );
 127 }
 128
 129 static void VTAG(Vertex2fv)( const GLfloat *obj )
 130 {
 131    /* Cliptest on clip[2] could also be eliminated...
 132     */
 133    VERTEX( obj[0], obj[1], 0, 1 );
 134 }
 135
 136 static void VTAG(Vertex3f)( GLfloat ox, GLfloat oy, GLfloat oz )
 137 {
 138    VERTEX( ox, oy, oz, 1 );
 139 }
 140
 141 static void VTAG(Vertex3fv)( const GLfloat *obj )
 142 {
 143    VERTEX( obj[0], obj[1], obj[2], 1 );
 144 }
 145
 146 static void VTAG(Vertex4f)( GLfloat ox, GLfloat oy, GLfloat oz, GLfloat ow )
 147 {
 148    VERTEX( ox, oy, oz, ow );
 149 }
 150
 151 static void VTAG(Vertex4fv)( const GLfloat *obj )
 152 {
 153    VERTEX( obj[0], obj[1], obj[2], obj[3] );
 154 }
 155
 156
 157 #undef DO_FULL_MATRIX
 158 #undef VTAG
 159 #undef VERTEX