m_matrix.h revision 7dc9a8827d7c248826adc5db0d1bf148d2e233f7 
1/*
2 * Mesa 3-D graphics library
3 * Version:  6.2
4 *
5 * Copyright (C) 1999-2004  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
25
26/**
27 * \file math/m_matrix.h
28 * Defines basic structures for matrix-handling.
29 */
30
31#ifndef _M_MATRIX_H
32#define _M_MATRIX_H
33
34
35
36/**
37 * \name Symbolic names to some of the entries in the matrix
38 *
39 * These are handy for the viewport mapping, which is expressed as a matrix.
40 */
41/*@{*/
42#define MAT_SX 0
43#define MAT_SY 5
44#define MAT_SZ 10
45#define MAT_TX 12
46#define MAT_TY 13
47#define MAT_TZ 14
48/*@}*/
49
50
51/**
52 * \defgroup MatFlags MAT_FLAG_XXX-flags
53 *
54 * Bitmasks to indicate different kinds of 4x4 matrices in GLmatrix::flags
55 * It would be nice to make all these flags private to m_matrix.c
56 */
57/*@{*/
58#define MAT_FLAG_IDENTITY       0     /**< is an identity matrix flag.
59                                       *   (Not actually used - the identity
60                                       *   matrix is identified by the absense
61                                       *   of all other flags.)
62                                       */
63#define MAT_FLAG_GENERAL        0x1   /**< is a general matrix flag */
64#define MAT_FLAG_ROTATION       0x2   /**< is a rotation matrix flag */
65#define MAT_FLAG_TRANSLATION    0x4   /**< is a translation matrix flag */
66#define MAT_FLAG_UNIFORM_SCALE  0x8   /**< is an uniform scaling matrix flag */
67#define MAT_FLAG_GENERAL_SCALE  0x10  /**< is a general scaling matrix flag */
68#define MAT_FLAG_GENERAL_3D     0x20  /**< general 3D matrix flag */
69#define MAT_FLAG_PERSPECTIVE    0x40  /**< is a perspective proj matrix flag */
70#define MAT_FLAG_SINGULAR       0x80  /**< is a singular matrix flag */
71#define MAT_DIRTY_TYPE          0x100  /**< matrix type is dirty */
72#define MAT_DIRTY_FLAGS         0x200  /**< matrix flags are dirty */
73#define MAT_DIRTY_INVERSE       0x400  /**< matrix inverse is dirty */
74
75/** angle preserving matrix flags mask */
76#define MAT_FLAGS_ANGLE_PRESERVING (MAT_FLAG_ROTATION | \
77				    MAT_FLAG_TRANSLATION | \
78				    MAT_FLAG_UNIFORM_SCALE)
79
80/** length preserving matrix flags mask */
81#define MAT_FLAGS_LENGTH_PRESERVING (MAT_FLAG_ROTATION | \
82				     MAT_FLAG_TRANSLATION)
83
84/** 3D (non-perspective) matrix flags mask */
85#define MAT_FLAGS_3D (MAT_FLAG_ROTATION | \
86		      MAT_FLAG_TRANSLATION | \
87		      MAT_FLAG_UNIFORM_SCALE | \
88		      MAT_FLAG_GENERAL_SCALE | \
89		      MAT_FLAG_GENERAL_3D)
90
91/** geometry related matrix flags mask */
92#define MAT_FLAGS_GEOMETRY (MAT_FLAG_GENERAL | \
93			    MAT_FLAG_ROTATION | \
94			    MAT_FLAG_TRANSLATION | \
95			    MAT_FLAG_UNIFORM_SCALE | \
96			    MAT_FLAG_GENERAL_SCALE | \
97			    MAT_FLAG_GENERAL_3D | \
98			    MAT_FLAG_PERSPECTIVE | \
99	                    MAT_FLAG_SINGULAR)
100
101/** dirty matrix flags mask */
102#define MAT_DIRTY          (MAT_DIRTY_TYPE | \
103			    MAT_DIRTY_FLAGS | \
104			    MAT_DIRTY_INVERSE)
105
106/*@}*/
107
108
109/**
110 * Test geometry related matrix flags.
111 *
112 * \param mat a pointer to a GLmatrix structure.
113 * \param a flags mask.
114 *
115 * \returns non-zero if all geometry related matrix flags are contained within
116 * the mask, or zero otherwise.
117 */
118#define TEST_MAT_FLAGS(mat, a)  \
119    ((MAT_FLAGS_GEOMETRY & (~(a)) & ((mat)->flags) ) == 0)
120
121
122/**
123 * Different kinds of 4x4 transformation matrices.
124 * We use these to select specific optimized vertex transformation routines.
125 */
126enum GLmatrixtype {
127   MATRIX_GENERAL,	/**< general 4x4 matrix */
128   MATRIX_IDENTITY,	/**< identity matrix */
129   MATRIX_3D_NO_ROT,	/**< orthogonal projection and others... */
130   MATRIX_PERSPECTIVE,	/**< perspective projection matrix */
131   MATRIX_2D,		/**< 2-D transformation */
132   MATRIX_2D_NO_ROT,	/**< 2-D scale & translate only */
133   MATRIX_3D		/**< 3-D transformation */
134} ;
135
136/**
137 * Matrix type to represent 4x4 transformation matrices.
138 */
139typedef struct {
140   GLfloat *m;		/**< 16 matrix elements (16-byte aligned) */
141   GLfloat *inv;	/**< optional 16-element inverse (16-byte aligned) */
142   GLuint flags;        /**< possible values determined by (of \link
143                         * MatFlags MAT_FLAG_* flags\endlink)
144                         */
145   enum GLmatrixtype type;
146} GLmatrix;
147
148
149
150
151extern void
152_math_matrix_ctr( GLmatrix *m );
153
154extern void
155_math_matrix_dtr( GLmatrix *m );
156
157extern void
158_math_matrix_alloc_inv( GLmatrix *m );
159
160extern void
161_math_matrix_mul_matrix( GLmatrix *dest, const GLmatrix *a, const GLmatrix *b );
162
163extern void
164_math_matrix_mul_floats( GLmatrix *dest, const GLfloat *b );
165
166extern void
167_math_matrix_loadf( GLmatrix *mat, const GLfloat *m );
168
169extern void
170_math_matrix_translate( GLmatrix *mat, GLfloat x, GLfloat y, GLfloat z );
171
172extern void
173_math_matrix_rotate( GLmatrix *m, GLfloat angle,
174		     GLfloat x, GLfloat y, GLfloat z );
175
176extern void
177_math_matrix_scale( GLmatrix *mat, GLfloat x, GLfloat y, GLfloat z );
178
179extern void
180_math_matrix_ortho( GLmatrix *mat,
181		    GLfloat left, GLfloat right,
182		    GLfloat bottom, GLfloat top,
183		    GLfloat nearval, GLfloat farval );
184
185extern void
186_math_matrix_frustum( GLmatrix *mat,
187		      GLfloat left, GLfloat right,
188		      GLfloat bottom, GLfloat top,
189		      GLfloat nearval, GLfloat farval );
190
191extern void
192_math_matrix_set_identity( GLmatrix *dest );
193
194extern void
195_math_matrix_copy( GLmatrix *to, const GLmatrix *from );
196
197extern void
198_math_matrix_analyse( GLmatrix *mat );
199
200extern void
201_math_matrix_print( const GLmatrix *m );
202
203
204
205/**
206 * \name Related functions that don't actually operate on GLmatrix structs
207 */
208/*@{*/
209
210extern void
211_math_transposef( GLfloat to[16], const GLfloat from[16] );
212
213extern void
214_math_transposed( GLdouble to[16], const GLdouble from[16] );
215
216extern void
217_math_transposefd( GLfloat to[16], const GLdouble from[16] );
218
219
220/*
221 * Transform a point (column vector) by a matrix:   Q = M * P
222 */
223#define TRANSFORM_POINT( Q, M, P )					\
224   Q[0] = M[0] * P[0] + M[4] * P[1] + M[8] *  P[2] + M[12] * P[3];	\
225   Q[1] = M[1] * P[0] + M[5] * P[1] + M[9] *  P[2] + M[13] * P[3];	\
226   Q[2] = M[2] * P[0] + M[6] * P[1] + M[10] * P[2] + M[14] * P[3];	\
227   Q[3] = M[3] * P[0] + M[7] * P[1] + M[11] * P[2] + M[15] * P[3];
228
229
230#define TRANSFORM_POINT3( Q, M, P )				\
231   Q[0] = M[0] * P[0] + M[4] * P[1] + M[8] *  P[2] + M[12];	\
232   Q[1] = M[1] * P[0] + M[5] * P[1] + M[9] *  P[2] + M[13];	\
233   Q[2] = M[2] * P[0] + M[6] * P[1] + M[10] * P[2] + M[14];	\
234   Q[3] = M[3] * P[0] + M[7] * P[1] + M[11] * P[2] + M[15];
235
236
237/*
238 * Transform a normal (row vector) by a matrix:  [NX NY NZ] = N * MAT
239 */
240#define TRANSFORM_NORMAL( TO, N, MAT )				\
241do {								\
242   TO[0] = N[0] * MAT[0] + N[1] * MAT[1] + N[2] * MAT[2];	\
243   TO[1] = N[0] * MAT[4] + N[1] * MAT[5] + N[2] * MAT[6];	\
244   TO[2] = N[0] * MAT[8] + N[1] * MAT[9] + N[2] * MAT[10];	\
245} while (0)
246
247
248/*@}*/
249
250
251#endif
252