/* $Id: m_xform.h,v 1.1 2000/11/16 21:05:41 keithw Exp $ */ /* * Mesa 3-D graphics library * Version: 3.3 * * Copyright (C) 1999 Brian Paul All Rights Reserved. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #ifndef _M_XFORM_H #define _M_XFORM_H #include "glheader.h" #include "config.h" #include "math/m_vector.h" #include "math/m_matrix.h" #ifdef USE_X86_ASM #define _XFORMAPI _ASMAPI #define _XFORMAPIP _ASMAPIP #else #define _XFORMAPI #define _XFORMAPIP * #endif /* * Transform a point (column vector) by a matrix: Q = M * P */ #define TRANSFORM_POINT( Q, M, P ) \ Q[0] = M[0] * P[0] + M[4] * P[1] + M[8] * P[2] + M[12] * P[3]; \ Q[1] = M[1] * P[0] + M[5] * P[1] + M[9] * P[2] + M[13] * P[3]; \ Q[2] = M[2] * P[0] + M[6] * P[1] + M[10] * P[2] + M[14] * P[3]; \ Q[3] = M[3] * P[0] + M[7] * P[1] + M[11] * P[2] + M[15] * P[3]; #define TRANSFORM_POINT3( Q, M, P ) \ Q[0] = M[0] * P[0] + M[4] * P[1] + M[8] * P[2] + M[12]; \ Q[1] = M[1] * P[0] + M[5] * P[1] + M[9] * P[2] + M[13]; \ Q[2] = M[2] * P[0] + M[6] * P[1] + M[10] * P[2] + M[14]; \ Q[3] = M[3] * P[0] + M[7] * P[1] + M[11] * P[2] + M[15]; /* * Transform a normal (row vector) by a matrix: [NX NY NZ] = N * MAT */ #define TRANSFORM_NORMAL( TO, N, MAT ) \ do { \ TO[0] = N[0] * MAT[0] + N[1] * MAT[1] + N[2] * MAT[2]; \ TO[1] = N[0] * MAT[4] + N[1] * MAT[5] + N[2] * MAT[6]; \ TO[2] = N[0] * MAT[8] + N[1] * MAT[9] + N[2] * MAT[10]; \ } while (0) extern void gl_transform_vector( GLfloat u[4], const GLfloat v[4], const GLfloat m[16] ); extern void gl_init_transformation( void ); /* KW: Clip functions now do projective divide as well. The projected * coordinates are very useful to us because they let us cull * backfaces and eliminate vertices from lighting, fogging, etc * calculations. Despite the fact that this divide could be done one * day in hardware, we would still have a reason to want to do it here * as long as those other calculations remain in software. * * Clipping is a convenient place to do the divide on x86 as it should be * possible to overlap with integer outcode calculations. * * There are two cases where we wouldn't want to do the divide in cliptest: * - When we aren't clipping. We still might want to cull backfaces * so the divide should be done elsewhere. This currently never * happens. * * - When culling isn't likely to help us, such as when the GL culling * is disabled and we not lighting or are only lighting * one-sided. In this situation, backface determination provides * us with no useful information. A tricky case to detect is when * all input data is already culled, although hopefully the * application wouldn't turn on culling in such cases. * * We supply a buffer to hold the [x/w,y/w,z/w,1/w] values which * are the result of the projection. This is only used in the * 4-vector case - in other cases, we just use the clip coordinates * as the projected coordinates - they are identical. * * This is doubly convenient because it means the Win[] array is now * of the same stride as all the others, so I can now turn map_vertices * into a straight-forward matrix transformation, with asm acceleration * automatically available. */ /* Vertex buffer clipping flags */ #define CLIP_RIGHT_SHIFT 0 #define CLIP_LEFT_SHIFT 1 #define CLIP_TOP_SHIFT 2 #define CLIP_BOTTOM_SHIFT 3 #define CLIP_NEAR_SHIFT 4 #define CLIP_FAR_SHIFT 5 #define CLIP_RIGHT_BIT 0x01 #define CLIP_LEFT_BIT 0x02 #define CLIP_TOP_BIT 0x04 #define CLIP_BOTTOM_BIT 0x08 #define CLIP_NEAR_BIT 0x10 #define CLIP_FAR_BIT 0x20 #define CLIP_USER_BIT 0x40 #define CLIP_CULLED_BIT 0x80 /* Vertex has been culled */ #define CLIP_ALL_BITS 0x3f typedef GLvector4f * (_XFORMAPIP clip_func)( GLvector4f *vClip, GLvector4f *vProj, GLubyte clipMask[], GLubyte *orMask, GLubyte *andMask ); typedef void (*dotprod_func)( GLvector4f *out_vec, GLuint elt, const GLvector4f *coord_vec, const GLfloat plane[4], const GLubyte mask[]); typedef void (*vec_copy_func)( GLvector4f *to, const GLvector4f *from, const GLubyte mask[]); /* * Functions for transformation of normals in the VB. */ typedef void (_NORMAPIP normal_func)( const GLmatrix *mat, GLfloat scale, const GLvector3f *in, const GLfloat lengths[], const GLubyte mask[], GLvector3f *dest ); /* Flags for selecting a normal transformation function. */ #define NORM_RESCALE 0x1 /* apply the scale factor */ #define NORM_NORMALIZE 0x2 /* normalize */ #define NORM_TRANSFORM 0x4 /* apply the transformation matrix */ #define NORM_TRANSFORM_NO_ROT 0x8 /* apply the transformation matrix */ /* KW: New versions of the transform function allow a mask array * specifying that individual vector transform should be skipped * when the mask byte is zero. This is always present as a * parameter, to allow a unified interface. */ typedef void (_XFORMAPIP transform_func)( GLvector4f *to_vec, const GLfloat m[16], const GLvector4f *from_vec, const GLubyte *clipmask, const GLubyte flag ); extern GLvector4f *gl_project_points( GLvector4f *to, const GLvector4f *from ); extern void gl_transform_bounds3( GLubyte *orMask, GLubyte *andMask, const GLfloat m[16], CONST GLfloat src[][3] ); extern void gl_transform_bounds2( GLubyte *orMask, GLubyte *andMask, const GLfloat m[16], CONST GLfloat src[][3] ); extern dotprod_func gl_dotprod_tab[2][5]; extern vec_copy_func gl_copy_tab[2][0x10]; extern clip_func gl_clip_tab[5]; extern normal_func gl_normal_tab[0xf][0x4]; /* Use of 3 layers of linked 1-dimensional arrays to reduce * cost of lookup. */ extern transform_func **(gl_transform_tab[2]); extern void gl_transform_point_sz( GLfloat Q[4], const GLfloat M[16], const GLfloat P[4], GLuint sz ); #define TransformRaw( to, mat, from ) \ ( (*gl_transform_tab[0][(from)->size][(mat)->type])( to, (mat)->m, from, 0, 0 ), \ (to) ) #define Transform( to, mat, from, mask, cull ) \ ( (*gl_transform_tab[cull!=0][(from)->size][(mat)->type])( to, (mat)->m, from, mask, cull ), \ (to) ) #endif