Details | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
5563 | serge | 1 | /* |
2 | * Mesa 3-D graphics library |
||
3 | * |
||
4 | * Copyright (C) 1999-2005 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 | |||
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 | #include "main/glheader.h" |
||
36 | |||
37 | |||
38 | #ifdef __cplusplus |
||
39 | extern "C" { |
||
40 | #endif |
||
41 | |||
42 | |||
43 | /** |
||
44 | * \name Symbolic names to some of the entries in the matrix |
||
45 | * |
||
46 | * These are handy for the viewport mapping, which is expressed as a matrix. |
||
47 | */ |
||
48 | /*@{*/ |
||
49 | #define MAT_SX 0 |
||
50 | #define MAT_SY 5 |
||
51 | #define MAT_SZ 10 |
||
52 | #define MAT_TX 12 |
||
53 | #define MAT_TY 13 |
||
54 | #define MAT_TZ 14 |
||
55 | /*@}*/ |
||
56 | |||
57 | |||
58 | /** |
||
59 | * Different kinds of 4x4 transformation matrices. |
||
60 | * We use these to select specific optimized vertex transformation routines. |
||
61 | */ |
||
62 | enum GLmatrixtype { |
||
63 | MATRIX_GENERAL, /**< general 4x4 matrix */ |
||
64 | MATRIX_IDENTITY, /**< identity matrix */ |
||
65 | MATRIX_3D_NO_ROT, /**< orthogonal projection and others... */ |
||
66 | MATRIX_PERSPECTIVE, /**< perspective projection matrix */ |
||
67 | MATRIX_2D, /**< 2-D transformation */ |
||
68 | MATRIX_2D_NO_ROT, /**< 2-D scale & translate only */ |
||
69 | MATRIX_3D /**< 3-D transformation */ |
||
70 | } ; |
||
71 | |||
72 | /** |
||
73 | * Matrix type to represent 4x4 transformation matrices. |
||
74 | */ |
||
75 | typedef struct { |
||
76 | GLfloat *m; /**< 16 matrix elements (16-byte aligned) */ |
||
77 | GLfloat *inv; /**< 16-element inverse (16-byte aligned) */ |
||
78 | GLuint flags; /**< possible values determined by (of \link |
||
79 | * MatFlags MAT_FLAG_* flags\endlink) |
||
80 | */ |
||
81 | enum GLmatrixtype type; |
||
82 | } GLmatrix; |
||
83 | |||
84 | |||
85 | |||
86 | |||
87 | extern void |
||
88 | _math_matrix_ctr( GLmatrix *m ); |
||
89 | |||
90 | extern void |
||
91 | _math_matrix_dtr( GLmatrix *m ); |
||
92 | |||
93 | extern void |
||
94 | _math_matrix_mul_matrix( GLmatrix *dest, const GLmatrix *a, const GLmatrix *b ); |
||
95 | |||
96 | extern void |
||
97 | _math_matrix_mul_floats( GLmatrix *dest, const GLfloat *b ); |
||
98 | |||
99 | extern void |
||
100 | _math_matrix_loadf( GLmatrix *mat, const GLfloat *m ); |
||
101 | |||
102 | extern void |
||
103 | _math_matrix_translate( GLmatrix *mat, GLfloat x, GLfloat y, GLfloat z ); |
||
104 | |||
105 | extern void |
||
106 | _math_matrix_rotate( GLmatrix *m, GLfloat angle, |
||
107 | GLfloat x, GLfloat y, GLfloat z ); |
||
108 | |||
109 | extern void |
||
110 | _math_matrix_scale( GLmatrix *mat, GLfloat x, GLfloat y, GLfloat z ); |
||
111 | |||
112 | extern void |
||
113 | _math_matrix_ortho( GLmatrix *mat, |
||
114 | GLfloat left, GLfloat right, |
||
115 | GLfloat bottom, GLfloat top, |
||
116 | GLfloat nearval, GLfloat farval ); |
||
117 | |||
118 | extern void |
||
119 | _math_matrix_frustum( GLmatrix *mat, |
||
120 | GLfloat left, GLfloat right, |
||
121 | GLfloat bottom, GLfloat top, |
||
122 | GLfloat nearval, GLfloat farval ); |
||
123 | |||
124 | extern void |
||
125 | _math_matrix_viewport(GLmatrix *m, GLint x, GLint y, GLint width, GLint height, |
||
126 | GLfloat zNear, GLfloat zFar, GLfloat depthMax); |
||
127 | |||
128 | extern void |
||
129 | _math_matrix_set_identity( GLmatrix *dest ); |
||
130 | |||
131 | extern void |
||
132 | _math_matrix_copy( GLmatrix *to, const GLmatrix *from ); |
||
133 | |||
134 | extern void |
||
135 | _math_matrix_analyse( GLmatrix *mat ); |
||
136 | |||
137 | extern void |
||
138 | _math_matrix_print( const GLmatrix *m ); |
||
139 | |||
140 | extern GLboolean |
||
141 | _math_matrix_is_length_preserving( const GLmatrix *m ); |
||
142 | |||
143 | extern GLboolean |
||
144 | _math_matrix_has_rotation( const GLmatrix *m ); |
||
145 | |||
146 | extern GLboolean |
||
147 | _math_matrix_is_general_scale( const GLmatrix *m ); |
||
148 | |||
149 | extern GLboolean |
||
150 | _math_matrix_is_dirty( const GLmatrix *m ); |
||
151 | |||
152 | |||
153 | /** |
||
154 | * \name Related functions that don't actually operate on GLmatrix structs |
||
155 | */ |
||
156 | /*@{*/ |
||
157 | |||
158 | extern void |
||
159 | _math_transposef( GLfloat to[16], const GLfloat from[16] ); |
||
160 | |||
161 | extern void |
||
162 | _math_transposed( GLdouble to[16], const GLdouble from[16] ); |
||
163 | |||
164 | extern void |
||
165 | _math_transposefd( GLfloat to[16], const GLdouble from[16] ); |
||
166 | |||
167 | |||
168 | /* |
||
169 | * Transform a point (column vector) by a matrix: Q = M * P |
||
170 | */ |
||
171 | #define TRANSFORM_POINT( Q, M, P ) \ |
||
172 | Q[0] = M[0] * P[0] + M[4] * P[1] + M[8] * P[2] + M[12] * P[3]; \ |
||
173 | Q[1] = M[1] * P[0] + M[5] * P[1] + M[9] * P[2] + M[13] * P[3]; \ |
||
174 | Q[2] = M[2] * P[0] + M[6] * P[1] + M[10] * P[2] + M[14] * P[3]; \ |
||
175 | Q[3] = M[3] * P[0] + M[7] * P[1] + M[11] * P[2] + M[15] * P[3]; |
||
176 | |||
177 | |||
178 | #define TRANSFORM_POINT3( Q, M, P ) \ |
||
179 | Q[0] = M[0] * P[0] + M[4] * P[1] + M[8] * P[2] + M[12]; \ |
||
180 | Q[1] = M[1] * P[0] + M[5] * P[1] + M[9] * P[2] + M[13]; \ |
||
181 | Q[2] = M[2] * P[0] + M[6] * P[1] + M[10] * P[2] + M[14]; \ |
||
182 | Q[3] = M[3] * P[0] + M[7] * P[1] + M[11] * P[2] + M[15]; |
||
183 | |||
184 | |||
185 | /* |
||
186 | * Transform a normal (row vector) by a matrix: [NX NY NZ] = N * MAT |
||
187 | */ |
||
188 | #define TRANSFORM_NORMAL( TO, N, MAT ) \ |
||
189 | do { \ |
||
190 | TO[0] = N[0] * MAT[0] + N[1] * MAT[1] + N[2] * MAT[2]; \ |
||
191 | TO[1] = N[0] * MAT[4] + N[1] * MAT[5] + N[2] * MAT[6]; \ |
||
192 | TO[2] = N[0] * MAT[8] + N[1] * MAT[9] + N[2] * MAT[10]; \ |
||
193 | } while (0) |
||
194 | |||
195 | |||
196 | /** |
||
197 | * Transform a direction by a matrix. |
||
198 | */ |
||
199 | #define TRANSFORM_DIRECTION( TO, DIR, MAT ) \ |
||
200 | do { \ |
||
201 | TO[0] = DIR[0] * MAT[0] + DIR[1] * MAT[4] + DIR[2] * MAT[8]; \ |
||
202 | TO[1] = DIR[0] * MAT[1] + DIR[1] * MAT[5] + DIR[2] * MAT[9]; \ |
||
203 | TO[2] = DIR[0] * MAT[2] + DIR[1] * MAT[6] + DIR[2] * MAT[10];\ |
||
204 | } while (0) |
||
205 | |||
206 | |||
207 | extern void |
||
208 | _mesa_transform_vector(GLfloat u[4], const GLfloat v[4], const GLfloat m[16]); |
||
209 | |||
210 | |||
211 | /*@}*/ |
||
212 | |||
213 | |||
214 | #ifdef __cplusplus |
||
215 | } |
||
216 | #endif |
||
217 | |||
218 | #endif>>>>>>>>>> |