home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 6 / AACD06.ISO / AACD / System / Mesa-3.1 / src / xform.h < prev    next >
C/C++ Source or Header  |  2000-01-07  |  6KB  |  175 lines
  1. /* $Id: xform.h,v 1.1.1.1 1999/08/19 00:55:41 jtg Exp $ */
  2.  
  3. /*
  4.  * Mesa 3-D graphics library
  5.  * Version:  3.1
  6.  * 
  7.  * Copyright (C) 1999  Brian Paul   All Rights Reserved.
  8.  * 
  9.  * Permission is hereby granted, free of charge, to any person obtaining a
  10.  * copy of this software and associated documentation files (the "Software"),
  11.  * to deal in the Software without restriction, including without limitation
  12.  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  13.  * and/or sell copies of the Software, and to permit persons to whom the
  14.  * Software is furnished to do so, subject to the following conditions:
  15.  * 
  16.  * The above copyright notice and this permission notice shall be included
  17.  * in all copies or substantial portions of the Software.
  18.  * 
  19.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  20.  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  22.  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  23.  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  24.  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25.  */
  26.  
  27.  
  28.  
  29.  
  30.  
  31. #ifndef XFORM_H
  32. #define XFORM_H
  33.  
  34.  
  35. #include "types.h"
  36.  
  37.  
  38. /*
  39.  * Transform a point (column vector) by a matrix:   Q = M * P
  40.  */
  41. #define TRANSFORM_POINT( Q, M, P )                    \
  42.    Q[0] = M[0] * P[0] + M[4] * P[1] + M[8] *  P[2] + M[12] * P[3];    \
  43.    Q[1] = M[1] * P[0] + M[5] * P[1] + M[9] *  P[2] + M[13] * P[3];    \
  44.    Q[2] = M[2] * P[0] + M[6] * P[1] + M[10] * P[2] + M[14] * P[3];    \
  45.    Q[3] = M[3] * P[0] + M[7] * P[1] + M[11] * P[2] + M[15] * P[3];
  46.  
  47.  
  48. #define TRANSFORM_POINT3( Q, M, P )                \
  49.    Q[0] = M[0] * P[0] + M[4] * P[1] + M[8] *  P[2] + M[12];    \
  50.    Q[1] = M[1] * P[0] + M[5] * P[1] + M[9] *  P[2] + M[13];    \
  51.    Q[2] = M[2] * P[0] + M[6] * P[1] + M[10] * P[2] + M[14];    \
  52.    Q[3] = M[3] * P[0] + M[7] * P[1] + M[11] * P[2] + M[15];
  53.  
  54.  
  55. /*
  56.  * Transform a normal (row vector) by a matrix:  [NX NY NZ] = N * MAT
  57.  */
  58. #define TRANSFORM_NORMAL( TO, N, MAT )                \
  59. do {                                \
  60.    TO[0] = N[0] * MAT[0] + N[1] * MAT[1] + N[2] * MAT[2];    \
  61.    TO[1] = N[0] * MAT[4] + N[1] * MAT[5] + N[2] * MAT[6];    \
  62.    TO[2] = N[0] * MAT[8] + N[1] * MAT[9] + N[2] * MAT[10];    \
  63. } while (0)
  64.  
  65.  
  66. extern void gl_transform_vector( GLfloat u[4],
  67.                  const GLfloat v[4],
  68.                                  const GLfloat m[16] );
  69.  
  70.  
  71. extern void gl_init_transformation( void );
  72.  
  73.  
  74. /* KW: Clip functions now do projective divide as well.  The projected
  75.  * coordinates are very useful to us because they let us cull
  76.  * backfaces and eliminate vertices from lighting, fogging, etc
  77.  * calculations.  Despite the fact that this divide could be done one
  78.  * day in hardware, we would still have a reason to want to do it here
  79.  * as long as those other calculations remain in software.
  80.  *
  81.  * Clipping is a convenient place to do the divide on x86 as it should be
  82.  * possible to overlap with integer outcode calculations.
  83.  *
  84.  * There are two cases where we wouldn't want to do the divide in cliptest:
  85.  *    - When we aren't clipping.  We still might want to cull backfaces
  86.  *      so the divide should be done elsewhere.  This currently never 
  87.  *      happens.
  88.  *
  89.  *    - When culling isn't likely to help us, such as when the GL culling
  90.  *      is disabled and we not lighting or are only lighting
  91.  *      one-sided.  In this situation, backface determination provides
  92.  *      us with no useful information.  A tricky case to detect is when
  93.  *      all input data is already culled, although hopefully the
  94.  *      application wouldn't turn on culling in such cases.
  95.  *
  96.  * We supply a buffer to hold the [x/w,y/w,z/w,1/w] values which
  97.  * are the result of the projection.  This is only used in the 
  98.  * 4-vector case - in other cases, we just use the clip coordinates
  99.  * as the projected coordinates - they are identical.
  100.  * 
  101.  * This is doubly convenient because it means the Win[] array is now
  102.  * of the same stride as all the others, so I can now turn map_vertices
  103.  * into a straight-forward matrix transformation, with asm acceleration
  104.  * automatically available.  
  105.  */
  106. typedef GLvector4f *(*clip_func)( GLvector4f *vClip, 
  107.                   GLvector4f *vProj, 
  108.                   GLubyte clipMask[],
  109.                   GLubyte *orMask, 
  110.                   GLubyte *andMask );
  111.  
  112.  
  113. typedef void (*dotprod_func)( GLvector4f *out_vec, 
  114.                   GLuint elt,
  115.                   const GLvector4f *coord_vec, 
  116.                   const GLfloat plane[4], 
  117.                   const GLubyte mask[]);
  118.  
  119. typedef void (*vec_copy_func)( GLvector4f *to, 
  120.                    const GLvector4f *from, 
  121.                    const GLubyte mask[]);
  122.  
  123.  
  124.  
  125.  
  126. /* KW: New versions of the transform function allow a mask array
  127.  *     specifying that individual vector transform should be skipped
  128.  *     when the mask byte is zero.  This is always present as a
  129.  *     parameter, to allow a unified interface.  
  130.  */
  131. typedef void (*transform_func)( GLvector4f *to_vec, 
  132.                 const GLmatrix *mat, 
  133.                 const GLvector4f *from_vec, 
  134.                 const GLubyte *clipmask,
  135.                 const GLubyte flag );
  136.  
  137.  
  138. extern GLvector4f *gl_project_points( GLvector4f *to,
  139.                    const GLvector4f *from );
  140.  
  141. extern void gl_transform_bounds3( GLubyte *orMask, GLubyte *andMask,
  142.                const GLmatrix *mat,
  143.                CONST GLfloat src[][3] );
  144.  
  145. extern void gl_transform_bounds2( GLubyte *orMask, GLubyte *andMask,
  146.                const GLmatrix *mat,
  147.                CONST GLfloat src[][3] );
  148.  
  149.  
  150. extern dotprod_func  gl_dotprod_tab[2][5];
  151. extern vec_copy_func gl_copy_tab[2][0x10];
  152. extern clip_func     gl_clip_tab[5];
  153. extern normal_func   gl_normal_tab[0xf][0x4];
  154.  
  155. /* Use of 3 layers of linked 1-dimensional arrays to reduce
  156.  * cost of lookup.
  157.  */
  158. extern transform_func **(gl_transform_tab[2]);
  159.  
  160.  
  161. extern void gl_transform_point_sz( GLfloat Q[4], const GLfloat M[16],
  162.                    const GLfloat P[4], GLuint sz );
  163.  
  164.  
  165. #define TransformRaw( to, mat, from ) \
  166.       ( (*gl_transform_tab[0][(from)->size][(mat)->type])( to, mat, from, 0, 0 ), \
  167.         (to) )
  168.  
  169. #define Transform( to, mat, from, mask, cull ) \
  170.       ( (*gl_transform_tab[cull!=0][(from)->size][(mat)->type])( to, mat, from, mask, cull ), \
  171.     (to) )
  172.  
  173.  
  174. #endif
  175.