/*
* Mesa 3-D graphics library
- * Version: 6.3
*
* Copyright (C) 1999-2005 Brian Paul All Rights Reserved.
*
* 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.
+ * THE AUTHORS OR COPYRIGHT HOLDERS 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.
*/
* -# Transformation of a point p by a matrix M is: p' = M * p
*/
+#include <stddef.h>
+#include "c99_math.h"
+#include "main/errors.h"
#include "main/glheader.h"
#include "main/imports.h"
#include "main/macros.h"
-#include "main/imports.h"
+#define MATH_ASM_PTR_SIZE sizeof(void *)
+#include "math/m_vector_asm.h"
#include "m_matrix.h"
* \defgroup MatFlags MAT_FLAG_XXX-flags
*
* Bitmasks to indicate different kinds of 4x4 matrices in GLmatrix::flags
- * It would be nice to make all these flags private to m_matrix.c
*/
/*@{*/
#define MAT_FLAG_IDENTITY 0 /**< is an identity matrix flag.
* (Not actually used - the identity
- * matrix is identified by the absense
+ * matrix is identified by the absence
* of all other flags.)
*/
#define MAT_FLAG_GENERAL 0x1 /**< is a general matrix flag */
/**
* Identity matrix.
*/
-static GLfloat Identity[16] = {
+static const GLfloat Identity[16] = {
1.0, 0.0, 0.0, 0.0,
0.0, 1.0, 0.0, 0.0,
0.0, 0.0, 1.0, 0.0,
void
_math_matrix_print( const GLmatrix *m )
{
+ GLfloat prod[16];
+
_mesa_debug(NULL, "Matrix type: %s, flags: %x\n", types[m->type], m->flags);
print_matrix_floats(m->m);
_mesa_debug(NULL, "Inverse: \n");
- if (m->inv) {
- GLfloat prod[16];
- print_matrix_floats(m->inv);
- matmul4(prod, m->m, m->inv);
- _mesa_debug(NULL, "Mat * Inverse:\n");
- print_matrix_floats(prod);
- }
- else {
- _mesa_debug(NULL, " - not available\n");
- }
+ print_matrix_floats(m->inv);
+ matmul4(prod, m->m, m->inv);
+ _mesa_debug(NULL, "Mat * Inverse:\n");
+ print_matrix_floats(prod);
}
/*@}*/
/*@{*/
/**
- * Swaps the values of two floating pointer variables.
+ * Swaps the values of two floating point variables.
*
* Used by invert_matrix_general() to swap the row pointers.
*/
r3[7] = 1.0, r3[4] = r3[5] = r3[6] = 0.0;
/* choose pivot - or die */
- if (FABSF(r3[0])>FABSF(r2[0])) SWAP_ROWS(r3, r2);
- if (FABSF(r2[0])>FABSF(r1[0])) SWAP_ROWS(r2, r1);
- if (FABSF(r1[0])>FABSF(r0[0])) SWAP_ROWS(r1, r0);
- if (0.0 == r0[0]) return GL_FALSE;
+ if (fabsf(r3[0])>fabsf(r2[0])) SWAP_ROWS(r3, r2);
+ if (fabsf(r2[0])>fabsf(r1[0])) SWAP_ROWS(r2, r1);
+ if (fabsf(r1[0])>fabsf(r0[0])) SWAP_ROWS(r1, r0);
+ if (0.0F == r0[0]) return GL_FALSE;
/* eliminate first variable */
m1 = r1[0]/r0[0]; m2 = r2[0]/r0[0]; m3 = r3[0]/r0[0];
s = r0[2]; r1[2] -= m1 * s; r2[2] -= m2 * s; r3[2] -= m3 * s;
s = r0[3]; r1[3] -= m1 * s; r2[3] -= m2 * s; r3[3] -= m3 * s;
s = r0[4];
- if (s != 0.0) { r1[4] -= m1 * s; r2[4] -= m2 * s; r3[4] -= m3 * s; }
+ if (s != 0.0F) { r1[4] -= m1 * s; r2[4] -= m2 * s; r3[4] -= m3 * s; }
s = r0[5];
- if (s != 0.0) { r1[5] -= m1 * s; r2[5] -= m2 * s; r3[5] -= m3 * s; }
+ if (s != 0.0F) { r1[5] -= m1 * s; r2[5] -= m2 * s; r3[5] -= m3 * s; }
s = r0[6];
- if (s != 0.0) { r1[6] -= m1 * s; r2[6] -= m2 * s; r3[6] -= m3 * s; }
+ if (s != 0.0F) { r1[6] -= m1 * s; r2[6] -= m2 * s; r3[6] -= m3 * s; }
s = r0[7];
- if (s != 0.0) { r1[7] -= m1 * s; r2[7] -= m2 * s; r3[7] -= m3 * s; }
+ if (s != 0.0F) { r1[7] -= m1 * s; r2[7] -= m2 * s; r3[7] -= m3 * s; }
/* choose pivot - or die */
- if (FABSF(r3[1])>FABSF(r2[1])) SWAP_ROWS(r3, r2);
- if (FABSF(r2[1])>FABSF(r1[1])) SWAP_ROWS(r2, r1);
- if (0.0 == r1[1]) return GL_FALSE;
+ if (fabsf(r3[1])>fabsf(r2[1])) SWAP_ROWS(r3, r2);
+ if (fabsf(r2[1])>fabsf(r1[1])) SWAP_ROWS(r2, r1);
+ if (0.0F == r1[1]) return GL_FALSE;
/* eliminate second variable */
m2 = r2[1]/r1[1]; m3 = r3[1]/r1[1];
r2[2] -= m2 * r1[2]; r3[2] -= m3 * r1[2];
r2[3] -= m2 * r1[3]; r3[3] -= m3 * r1[3];
- s = r1[4]; if (0.0 != s) { r2[4] -= m2 * s; r3[4] -= m3 * s; }
- s = r1[5]; if (0.0 != s) { r2[5] -= m2 * s; r3[5] -= m3 * s; }
- s = r1[6]; if (0.0 != s) { r2[6] -= m2 * s; r3[6] -= m3 * s; }
- s = r1[7]; if (0.0 != s) { r2[7] -= m2 * s; r3[7] -= m3 * s; }
+ s = r1[4]; if (0.0F != s) { r2[4] -= m2 * s; r3[4] -= m3 * s; }
+ s = r1[5]; if (0.0F != s) { r2[5] -= m2 * s; r3[5] -= m3 * s; }
+ s = r1[6]; if (0.0F != s) { r2[6] -= m2 * s; r3[6] -= m3 * s; }
+ s = r1[7]; if (0.0F != s) { r2[7] -= m2 * s; r3[7] -= m3 * s; }
/* choose pivot - or die */
- if (FABSF(r3[2])>FABSF(r2[2])) SWAP_ROWS(r3, r2);
- if (0.0 == r2[2]) return GL_FALSE;
+ if (fabsf(r3[2])>fabsf(r2[2])) SWAP_ROWS(r3, r2);
+ if (0.0F == r2[2]) return GL_FALSE;
/* eliminate third variable */
m3 = r3[2]/r2[2];
r3[7] -= m3 * r2[7];
/* last check */
- if (0.0 == r3[3]) return GL_FALSE;
+ if (0.0F == r3[3]) return GL_FALSE;
s = 1.0F/r3[3]; /* now back substitute row 3 */
r3[4] *= s; r3[5] *= s; r3[6] *= s; r3[7] *= s;
*/
pos = neg = 0.0;
t = MAT(in,0,0) * MAT(in,1,1) * MAT(in,2,2);
- if (t >= 0.0) pos += t; else neg += t;
+ if (t >= 0.0F) pos += t; else neg += t;
t = MAT(in,1,0) * MAT(in,2,1) * MAT(in,0,2);
- if (t >= 0.0) pos += t; else neg += t;
+ if (t >= 0.0F) pos += t; else neg += t;
t = MAT(in,2,0) * MAT(in,0,1) * MAT(in,1,2);
- if (t >= 0.0) pos += t; else neg += t;
+ if (t >= 0.0F) pos += t; else neg += t;
t = -MAT(in,2,0) * MAT(in,1,1) * MAT(in,0,2);
- if (t >= 0.0) pos += t; else neg += t;
+ if (t >= 0.0F) pos += t; else neg += t;
t = -MAT(in,1,0) * MAT(in,0,1) * MAT(in,2,2);
- if (t >= 0.0) pos += t; else neg += t;
+ if (t >= 0.0F) pos += t; else neg += t;
t = -MAT(in,0,0) * MAT(in,2,1) * MAT(in,1,2);
- if (t >= 0.0) pos += t; else neg += t;
+ if (t >= 0.0F) pos += t; else neg += t;
det = pos + neg;
- if (det*det < 1e-25)
+ if (fabsf(det) < 1e-25F)
return GL_FALSE;
det = 1.0F / det;
MAT(in,0,1) * MAT(in,0,1) +
MAT(in,0,2) * MAT(in,0,2));
- if (scale == 0.0)
+ if (scale == 0.0F)
return GL_FALSE;
scale = 1.0F / scale;
}
else {
/* pure translation */
- MEMCPY( out, Identity, sizeof(Identity) );
+ memcpy( out, Identity, sizeof(Identity) );
MAT(out,0,3) = - MAT(in,0,3);
MAT(out,1,3) = - MAT(in,1,3);
MAT(out,2,3) = - MAT(in,2,3);
*/
static GLboolean invert_matrix_identity( GLmatrix *mat )
{
- MEMCPY( mat->inv, Identity, sizeof(Identity) );
+ memcpy( mat->inv, Identity, sizeof(Identity) );
return GL_TRUE;
}
if (MAT(in,0,0) == 0 || MAT(in,1,1) == 0 || MAT(in,2,2) == 0 )
return GL_FALSE;
- MEMCPY( out, Identity, 16 * sizeof(GLfloat) );
+ memcpy( out, Identity, sizeof(Identity) );
MAT(out,0,0) = 1.0F / MAT(in,0,0);
MAT(out,1,1) = 1.0F / MAT(in,1,1);
MAT(out,2,2) = 1.0F / MAT(in,2,2);
if (MAT(in,0,0) == 0 || MAT(in,1,1) == 0)
return GL_FALSE;
- MEMCPY( out, Identity, 16 * sizeof(GLfloat) );
+ memcpy( out, Identity, sizeof(Identity) );
MAT(out,0,0) = 1.0F / MAT(in,0,0);
MAT(out,1,1) = 1.0F / MAT(in,1,1);
if (MAT(in,2,3) == 0)
return GL_FALSE;
- MEMCPY( out, Identity, 16 * sizeof(GLfloat) );
+ memcpy( out, Identity, sizeof(Identity) );
MAT(out,0,0) = 1.0F / MAT(in,0,0);
MAT(out,1,1) = 1.0F / MAT(in,1,1);
return GL_TRUE;
} else {
mat->flags |= MAT_FLAG_SINGULAR;
- MEMCPY( mat->inv, Identity, sizeof(Identity) );
+ memcpy( mat->inv, Identity, sizeof(Identity) );
return GL_FALSE;
}
}
GLfloat m[16];
GLboolean optimized;
- s = (GLfloat) _mesa_sin( angle * DEG2RAD );
- c = (GLfloat) _mesa_cos( angle * DEG2RAD );
+ s = sinf( angle * M_PI / 180.0 );
+ c = cosf( angle * M_PI / 180.0 );
- MEMCPY(m, Identity, sizeof(GLfloat)*16);
+ memcpy(m, Identity, sizeof(Identity));
optimized = GL_FALSE;
#define M(row,col) m[col*4+row]
}
if (!optimized) {
- const GLfloat mag = SQRTF(x * x + y * y + z * z);
+ const GLfloat mag = sqrtf(x * x + y * y + z * z);
- if (mag <= 1.0e-4) {
+ if (mag <= 1.0e-4F) {
/* no rotation, leave mat as-is */
return;
}
* Y-axis to bring the axis vector parallel with the X-axis. The
* rotation about the X-axis is then performed. Ry and Rz are
* simply the respective inverse transforms to bring the arbitrary
- * axis back to it's original orientation. The first transforms
+ * axis back to its original orientation. The first transforms
* Rz' and Ry' are considered inverses, since the data from the
* arbitrary axis gives you info on how to get to it, not how
* to get away from it, and an inverse must be applied.
m[2] *= x; m[6] *= y; m[10] *= z;
m[3] *= x; m[7] *= y; m[11] *= z;
- if (FABSF(x - y) < 1e-8 && FABSF(x - z) < 1e-8)
+ if (fabsf(x - y) < 1e-8F && fabsf(x - z) < 1e-8F)
mat->flags |= MAT_FLAG_UNIFORM_SCALE;
else
mat->flags |= MAT_FLAG_GENERAL_SCALE;
* Transforms Normalized Device Coords to window/Z values.
*/
void
-_math_matrix_viewport(GLmatrix *m, GLint x, GLint y, GLint width, GLint height,
- GLfloat zNear, GLfloat zFar, GLfloat depthMax)
+_math_matrix_viewport(GLmatrix *m, const float scale[3],
+ const float translate[3], double depthMax)
{
- m->m[MAT_SX] = (GLfloat) width / 2.0F;
- m->m[MAT_TX] = m->m[MAT_SX] + x;
- m->m[MAT_SY] = (GLfloat) height / 2.0F;
- m->m[MAT_TY] = m->m[MAT_SY] + y;
- m->m[MAT_SZ] = depthMax * ((zFar - zNear) / 2.0F);
- m->m[MAT_TZ] = depthMax * ((zFar - zNear) / 2.0F + zNear);
+ m->m[MAT_SX] = scale[0];
+ m->m[MAT_TX] = translate[0];
+ m->m[MAT_SY] = scale[1];
+ m->m[MAT_TY] = translate[1];
+ m->m[MAT_SZ] = depthMax*scale[2];
+ m->m[MAT_TZ] = depthMax*translate[2];
m->flags = MAT_FLAG_GENERAL_SCALE | MAT_FLAG_TRANSLATION;
m->type = MATRIX_3D_NO_ROT;
}
void
_math_matrix_set_identity( GLmatrix *mat )
{
- MEMCPY( mat->m, Identity, 16*sizeof(GLfloat) );
+ STATIC_ASSERT(MATRIX_M == offsetof(GLmatrix, m));
+ STATIC_ASSERT(MATRIX_INV == offsetof(GLmatrix, inv));
- if (mat->inv)
- MEMCPY( mat->inv, Identity, 16*sizeof(GLfloat) );
+ memcpy( mat->m, Identity, sizeof(Identity) );
+ memcpy( mat->inv, Identity, sizeof(Identity) );
mat->type = MATRIX_IDENTITY;
mat->flags &= ~(MAT_DIRTY_FLAGS|
GLuint i;
for (i = 0 ; i < 16 ; i++) {
- if (m[i] == 0.0) mask |= (1<<i);
+ if (m[i] == 0.0F) mask |= (1<<i);
}
if (m[0] == 1.0F) mask |= (1<<16);
mat->type = MATRIX_2D;
/* Check for scale */
- if (SQ(mm-1) > SQ(1e-6) ||
- SQ(m4m4-1) > SQ(1e-6))
+ if (SQ(mm-1) > SQ(1e-6F) ||
+ SQ(m4m4-1) > SQ(1e-6F))
mat->flags |= MAT_FLAG_GENERAL_SCALE;
/* Check for rotation */
- if (SQ(mm4) > SQ(1e-6))
+ if (SQ(mm4) > SQ(1e-6F))
mat->flags |= MAT_FLAG_GENERAL_3D;
else
mat->flags |= MAT_FLAG_ROTATION;
mat->type = MATRIX_3D_NO_ROT;
/* Check for scale */
- if (SQ(m[0]-m[5]) < SQ(1e-6) &&
- SQ(m[0]-m[10]) < SQ(1e-6)) {
- if (SQ(m[0]-1.0) > SQ(1e-6)) {
+ if (SQ(m[0]-m[5]) < SQ(1e-6F) &&
+ SQ(m[0]-m[10]) < SQ(1e-6F)) {
+ if (SQ(m[0]-1.0F) > SQ(1e-6F)) {
mat->flags |= MAT_FLAG_UNIFORM_SCALE;
}
}
mat->type = MATRIX_3D;
/* Check for scale */
- if (SQ(c1-c2) < SQ(1e-6) && SQ(c1-c3) < SQ(1e-6)) {
- if (SQ(c1-1.0) > SQ(1e-6))
+ if (SQ(c1-c2) < SQ(1e-6F) && SQ(c1-c3) < SQ(1e-6F)) {
+ if (SQ(c1-1.0F) > SQ(1e-6F))
mat->flags |= MAT_FLAG_UNIFORM_SCALE;
/* else no scale at all */
}
}
/* Check for rotation */
- if (SQ(d1) < SQ(1e-6)) {
+ if (SQ(d1) < SQ(1e-6F)) {
CROSS3( cp, m, m+4 );
SUB_3V( cp, cp, (m+8) );
- if (LEN_SQUARED_3FV(cp) < SQ(1e-6))
+ if (LEN_SQUARED_3FV(cp) < SQ(1e-6F))
mat->flags |= MAT_FLAG_ROTATION;
else
mat->flags |= MAT_FLAG_GENERAL_3D;
if (mat->inv && (mat->flags & MAT_DIRTY_INVERSE)) {
matrix_invert( mat );
+ mat->flags &= ~MAT_DIRTY_INVERSE;
}
- mat->flags &= ~(MAT_DIRTY_FLAGS|
- MAT_DIRTY_TYPE|
- MAT_DIRTY_INVERSE);
+ mat->flags &= ~(MAT_DIRTY_FLAGS | MAT_DIRTY_TYPE);
}
/*@}*/
void
_math_matrix_copy( GLmatrix *to, const GLmatrix *from )
{
- MEMCPY( to->m, from->m, sizeof(Identity) );
+ memcpy(to->m, from->m, 16 * sizeof(GLfloat));
+ memcpy(to->inv, from->inv, 16 * sizeof(GLfloat));
to->flags = from->flags;
to->type = from->type;
-
- if (to->inv != 0) {
- if (from->inv == 0) {
- matrix_invert( to );
- }
- else {
- MEMCPY(to->inv, from->inv, sizeof(GLfloat)*16);
- }
- }
}
/**
void
_math_matrix_loadf( GLmatrix *mat, const GLfloat *m )
{
- MEMCPY( mat->m, m, 16*sizeof(GLfloat) );
+ memcpy( mat->m, m, 16*sizeof(GLfloat) );
mat->flags = (MAT_FLAG_GENERAL | MAT_DIRTY);
}
void
_math_matrix_ctr( GLmatrix *m )
{
- m->m = (GLfloat *) ALIGN_MALLOC( 16 * sizeof(GLfloat), 16 );
+ m->m = _mesa_align_malloc( 16 * sizeof(GLfloat), 16 );
if (m->m)
- MEMCPY( m->m, Identity, sizeof(Identity) );
- m->inv = NULL;
+ memcpy( m->m, Identity, sizeof(Identity) );
+ m->inv = _mesa_align_malloc( 16 * sizeof(GLfloat), 16 );
+ if (m->inv)
+ memcpy( m->inv, Identity, sizeof(Identity) );
m->type = MATRIX_IDENTITY;
m->flags = 0;
}
void
_math_matrix_dtr( GLmatrix *m )
{
- if (m->m) {
- ALIGN_FREE( m->m );
- m->m = NULL;
- }
- if (m->inv) {
- ALIGN_FREE( m->inv );
- m->inv = NULL;
- }
-}
+ _mesa_align_free( m->m );
+ m->m = NULL;
-/**
- * Allocate a matrix inverse.
- *
- * \param m matrix.
- *
- * Allocates the matrix inverse, GLmatrix::inv, and sets it to Identity.
- */
-void
-_math_matrix_alloc_inv( GLmatrix *m )
-{
- if (!m->inv) {
- m->inv = (GLfloat *) ALIGN_MALLOC( 16 * sizeof(GLfloat), 16 );
- if (m->inv)
- MEMCPY( m->inv, Identity, 16 * sizeof(GLfloat) );
- }
+ _mesa_align_free( m->inv );
+ m->inv = NULL;
}
/*@}*/
/*@}*/
+
+/**
+ * Transform a 4-element row vector (1x4 matrix) by a 4x4 matrix. This
+ * function is used for transforming clipping plane equations and spotlight
+ * directions.
+ * Mathematically, u = v * m.
+ * Input: v - input vector
+ * m - transformation matrix
+ * Output: u - transformed vector
+ */
+void
+_mesa_transform_vector( GLfloat u[4], const GLfloat v[4], const GLfloat m[16] )
+{
+ const GLfloat v0 = v[0], v1 = v[1], v2 = v[2], v3 = v[3];
+#define M(row,col) m[row + col*4]
+ u[0] = v0 * M(0,0) + v1 * M(1,0) + v2 * M(2,0) + v3 * M(3,0);
+ u[1] = v0 * M(0,1) + v1 * M(1,1) + v2 * M(2,1) + v3 * M(3,1);
+ u[2] = v0 * M(0,2) + v1 * M(1,2) + v2 * M(2,2) + v3 * M(3,2);
+ u[3] = v0 * M(0,3) + v1 * M(1,3) + v2 * M(2,3) + v3 * M(3,3);
+#undef M
+}
projects / mesa.git / blobdiff