isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-11-22 16:10:41 -05:00
Code Issues Packages Projects Releases Wiki Activity

matrix-mesa: remove unused macros functions and cruft

Browse Source 
The aim is to flatten cogl-matrix-mesa.[ch] code back into
cogl-matrix.[ch] and removing cruft first makes sense. This removes
several un-used macros and vector related functions and also replaces
the use of doxygen style comment markup with the gtk-doc style we use
throughout the reset of cogl.

Signed-off-by: Neil Roberts <neil@linux.intel.com>
This commit is contained in:
Robert Bragg 2011-06-30 17:30:20 +01:00
parent 367fbba052
commit 7b747cff01
2 changed files with 71 additions and 288 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

275
cogl/cogl-matrix-mesa.c
View File

@ -105,7 +105,6 @@ do { \
* *
* Bitmasks to indicate different kinds of 4x4 matrices in CoglMatrix::flags * Bitmasks to indicate different kinds of 4x4 matrices in CoglMatrix::flags
*/ */
/*@{*/
#define MAT_FLAG_IDENTITY 0 /*< is an identity matrix flag. #define MAT_FLAG_IDENTITY 0 /*< is an identity matrix flag.
* (Not actually used - the identity * (Not actually used - the identity
* matrix is identified by the absense * matrix is identified by the absense
@ -155,16 +154,14 @@ do { \
MAT_DIRTY_FLAGS | \ MAT_DIRTY_FLAGS | \
MAT_DIRTY_INVERSE) MAT_DIRTY_INVERSE)
/*@}*/
/* /*
* Test geometry related matrix flags. * Test geometry related matrix flags.
* *
* \param mat a pointer to a CoglMatrix structure. * @mat a pointer to a CoglMatrix structure.
* \param a flags mask. * @a flags mask.
* *
* \returns non-zero if all geometry related matrix flags are contained within * Returns: non-zero if all geometry related matrix flags are contained within
* the mask, or zero otherwise. * the mask, or zero otherwise.
*/ */
#define TEST_MAT_FLAGS(mat, a) \ #define TEST_MAT_FLAGS(mat, a) \
@ -197,11 +194,6 @@ static float identity[16] = {
}; };
/**********************************************************************/
/* \name Matrix multiplication */
/*@{*/
#define A(row,col) a[(col<<2)+row] #define A(row,col) a[(col<<2)+row]
#define B(row,col) b[(col<<2)+row] #define B(row,col) b[(col<<2)+row]
#define R(row,col) result[(col<<2)+row] #define R(row,col) result[(col<<2)+row]
@ -209,15 +201,13 @@ static float identity[16] = {
/* /*
* Perform a full 4x4 matrix multiplication. * Perform a full 4x4 matrix multiplication.
* *
* \param a matrix. * @a matrix.
* \param b matrix. * @b matrix.
* \param product will receive the product of \p a and \p b. * @product will receive the product of \p a and \p b.
* *
* \warning Is assumed that \p product != \p b. \p product == \p a is allowed. * <note>It'ss assumed that @product != @b. @product == @a is allowed.</note>
* *
* \note KW: 4*16 = 64 multiplications * <note>KW: 4*16 = 64 multiplications</note>
*
* \author This \c matmul was contributed by Thomas Malik
*/ */
static void static void
matrix_multiply4x4 (float *result, const float *a, const float *b) matrix_multiply4x4 (float *result, const float *a, const float *b)
@ -237,9 +227,9 @@ matrix_multiply4x4 (float *result, const float *a, const float *b)
* Multiply two matrices known to occupy only the top three rows, such * Multiply two matrices known to occupy only the top three rows, such
* as typical model matrices, and orthogonal matrices. * as typical model matrices, and orthogonal matrices.
* *
* \param a matrix. * @a matrix.
* \param b matrix. * @b matrix.
* \param product will receive the product of \p a and \p b. * @product will receive the product of \p a and \p b.
*/ */
static void static void
matrix_multiply3x4 (float *result, const float *a, const float *b) matrix_multiply3x4 (float *result, const float *a, const float *b)
@ -266,10 +256,10 @@ matrix_multiply3x4 (float *result, const float *a, const float *b)
/* /*
* Multiply a matrix by an array of floats with known properties. * Multiply a matrix by an array of floats with known properties.
* *
* \param mat pointer to a CoglMatrix structure containing the left multiplication * @mat pointer to a CoglMatrix structure containing the left multiplication
* matrix, and that will receive the product result. * matrix, and that will receive the product result.
* \param m right multiplication matrix array. * @m right multiplication matrix array.
* \param flags flags of the matrix \p m. * @flags flags of the matrix \p m.
* *
* Joins both flags and marks the type and inverse as dirty. Calls * Joins both flags and marks the type and inverse as dirty. Calls
* matrix_multiply3x4() if both matrices are 3D, or matrix_multiply4x4() * matrix_multiply3x4() if both matrices are 3D, or matrix_multiply4x4()
@ -291,9 +281,9 @@ matrix_multiply_array_with_flags (CoglMatrix *result,
/* /*
* Matrix multiplication. * Matrix multiplication.
* *
* \param dest destination matrix. * @dest destination matrix.
* \param a left matrix. * @a left matrix.
* \param b right matrix. * @b right matrix.
* *
* Joins both flags and marks the type and inverse as dirty. Calls * Joins both flags and marks the type and inverse as dirty. Calls
* matrix_multiply3x4() if both matrices are 3D, or matrix_multiply4x4() * matrix_multiply3x4() if both matrices are 3D, or matrix_multiply4x4()
@ -318,8 +308,8 @@ _math_matrix_multiply (CoglMatrix *result,
/* /*
* Matrix multiplication. * Matrix multiplication.
* *
* \param dest left and destination matrix. * @dest left and destination matrix.
* \param m right matrix array. * @m right matrix array.
* *
* Marks the matrix flags with general flag, and type and inverse dirty flags. * Marks the matrix flags with general flag, and type and inverse dirty flags.
* Calls matrix_multiply4x4() for the multiplication. * Calls matrix_multiply4x4() for the multiplication.
@ -335,17 +325,10 @@ _math_matrix_multiply_array (CoglMatrix *result, const float *array)
matrix_multiply4x4 ((float *)result, (float *)result, (float *)array); matrix_multiply4x4 ((float *)result, (float *)result, (float *)array);
} }
/*@}*/
/**********************************************************************/
/* \name Matrix output */
/*@{*/
/* /*
* Print a matrix array. * Print a matrix array.
* *
* \param m matrix array. * @m matrix array.
* *
* Called by _math_matrix_print() to print a matrix or its inverse. * Called by _math_matrix_print() to print a matrix or its inverse.
*/ */
@ -360,7 +343,7 @@ print_matrix_floats (const float m[16])
/* /*
* Dumps the contents of a CoglMatrix structure. * Dumps the contents of a CoglMatrix structure.
* *
* \param m pointer to the CoglMatrix structure. * @m pointer to the CoglMatrix structure.
*/ */
void void
_math_matrix_print (const CoglMatrix *matrix) _math_matrix_print (const CoglMatrix *matrix)
@ -381,27 +364,19 @@ _math_matrix_print (const CoglMatrix *matrix)
g_print (" - not available\n"); g_print (" - not available\n");
} }
/*@}*/
/* /*
* References an element of 4x4 matrix. * References an element of 4x4 matrix.
* *
* \param m matrix array. * @m matrix array.
* \param c column of the desired element. * @c column of the desired element.
* \param r row of the desired element. * @r row of the desired element.
* *
* \return value of the desired element. * Returns: value of the desired element.
* *
* Calculate the linear storage index of the element and references it. * Calculate the linear storage index of the element and references it.
*/ */
#define MAT(m,r,c) (m)[(c)*4+(r)] #define MAT(m,r,c) (m)[(c)*4+(r)]
/**********************************************************************/
/* \name Matrix inversion */
/*@{*/
/* /*
* Swaps the values of two floating pointer variables. * Swaps the values of two floating pointer variables.
* *
@ -412,10 +387,10 @@ _math_matrix_print (const CoglMatrix *matrix)
/* /*
* Compute inverse of 4x4 transformation matrix. * Compute inverse of 4x4 transformation matrix.
* *
* \param mat pointer to a CoglMatrix structure. The matrix inverse will be * @mat pointer to a CoglMatrix structure. The matrix inverse will be
* stored in the CoglMatrix::inv attribute. * stored in the CoglMatrix::inv attribute.
* *
* \return TRUE for success, FALSE for failure (\p singular matrix). * Returns: %TRUE for success, %FALSE for failure (\p singular matrix).
* *
* \author * \author
* Code contributed by Jacques Leroy jle@star.be * Code contributed by Jacques Leroy jle@star.be
@ -551,10 +526,10 @@ invert_matrix_general (CoglMatrix *matrix)
/* /*
* Compute inverse of a general 3d transformation matrix. * Compute inverse of a general 3d transformation matrix.
* *
* \param mat pointer to a CoglMatrix structure. The matrix inverse will be * @mat pointer to a CoglMatrix structure. The matrix inverse will be
* stored in the CoglMatrix::inv attribute. * stored in the CoglMatrix::inv attribute.
* *
* \return TRUE for success, FALSE for failure (\p singular matrix). * Returns: %TRUE for success, %FALSE for failure (\p singular matrix).
* *
* \author Adapted from graphics gems II. * \author Adapted from graphics gems II.
* *
@ -635,10 +610,10 @@ invert_matrix_3d_general (CoglMatrix *matrix)
/* /*
* Compute inverse of a 3d transformation matrix. * Compute inverse of a 3d transformation matrix.
* *
* \param mat pointer to a CoglMatrix structure. The matrix inverse will be * @mat pointer to a CoglMatrix structure. The matrix inverse will be
* stored in the CoglMatrix::inv attribute. * stored in the CoglMatrix::inv attribute.
* *
* \return TRUE for success, FALSE for failure (\p singular matrix). * Returns: %TRUE for success, %FALSE for failure (\p singular matrix).
* *
* If the matrix is not an angle preserving matrix then calls * If the matrix is not an angle preserving matrix then calls
* invert_matrix_3d_general for the actual calculation. Otherwise calculates * invert_matrix_3d_general for the actual calculation. Otherwise calculates
@ -721,10 +696,10 @@ invert_matrix_3d (CoglMatrix *matrix)
/* /*
* Compute inverse of an identity transformation matrix. * Compute inverse of an identity transformation matrix.
* *
* \param mat pointer to a CoglMatrix structure. The matrix inverse will be * @mat pointer to a CoglMatrix structure. The matrix inverse will be
* stored in the CoglMatrix::inv attribute. * stored in the CoglMatrix::inv attribute.
* *
* \return always TRUE. * Returns: always %TRUE.
* *
* Simply copies identity into CoglMatrix::inv. * Simply copies identity into CoglMatrix::inv.
*/ */
@ -738,10 +713,10 @@ invert_matrix_identity (CoglMatrix *matrix)
/* /*
* Compute inverse of a no-rotation 3d transformation matrix. * Compute inverse of a no-rotation 3d transformation matrix.
* *
* \param mat pointer to a CoglMatrix structure. The matrix inverse will be * @mat pointer to a CoglMatrix structure. The matrix inverse will be
* stored in the CoglMatrix::inv attribute. * stored in the CoglMatrix::inv attribute.
* *
* \return TRUE for success, FALSE for failure (\p singular matrix). * Returns: %TRUE for success, %FALSE for failure (\p singular matrix).
* *
* Calculates the * Calculates the
*/ */
@ -772,10 +747,10 @@ invert_matrix_3d_no_rotation (CoglMatrix *matrix)
/* /*
* Compute inverse of a no-rotation 2d transformation matrix. * Compute inverse of a no-rotation 2d transformation matrix.
* *
* \param mat pointer to a CoglMatrix structure. The matrix inverse will be * @mat pointer to a CoglMatrix structure. The matrix inverse will be
* stored in the CoglMatrix::inv attribute. * stored in the CoglMatrix::inv attribute.
* *
* \return TRUE for success, FALSE for failure (\p singular matrix). * Returns: %TRUE for success, %FALSE for failure (\p singular matrix).
* *
* Calculates the inverse matrix by applying the inverse scaling and * Calculates the inverse matrix by applying the inverse scaling and
* translation to the identity matrix. * translation to the identity matrix.
@ -859,10 +834,10 @@ static inv_mat_func inv_mat_tab[7] = {
/* /*
* Compute inverse of a transformation matrix. * Compute inverse of a transformation matrix.
* *
* \param mat pointer to a CoglMatrix structure. The matrix inverse will be * @mat pointer to a CoglMatrix structure. The matrix inverse will be
* stored in the CoglMatrix::inv attribute. * stored in the CoglMatrix::inv attribute.
* *
* \return TRUE for success, FALSE for failure (\p singular matrix). * Returns: %TRUE for success, %FALSE for failure (\p singular matrix).
* *
* Calls the matrix inversion function in inv_mat_tab corresponding to the * Calls the matrix inversion function in inv_mat_tab corresponding to the
* given matrix type. In case of failure, updates the MAT_FLAG_SINGULAR flag, * given matrix type. In case of failure, updates the MAT_FLAG_SINGULAR flag,
@ -893,13 +868,6 @@ _math_matrix_update_inverse (CoglMatrix *matrix)
return TRUE; return TRUE;
} }
/*@}*/
/**********************************************************************/
/* \name Matrix generation */
/*@{*/
/* /*
* Generate a 4x4 transformation matrix from glRotate parameters, and * Generate a 4x4 transformation matrix from glRotate parameters, and
* post-multiply the input matrix by it. * post-multiply the input matrix by it.
@ -1098,13 +1066,13 @@ _math_matrix_rotate (CoglMatrix *matrix,
/* /*
* Apply a perspective projection matrix. * Apply a perspective projection matrix.
* *
* \param mat matrix to apply the projection. * @mat matrix to apply the projection.
* \param left left clipping plane coordinate. * @left left clipping plane coordinate.
* \param right right clipping plane coordinate. * @right right clipping plane coordinate.
* \param bottom bottom clipping plane coordinate. * @bottom bottom clipping plane coordinate.
* \param top top clipping plane coordinate. * @top top clipping plane coordinate.
* \param nearval distance to the near clipping plane. * @nearval distance to the near clipping plane.
* \param farval distance to the far clipping plane. * @farval distance to the far clipping plane.
* *
* Creates the projection matrix and multiplies it with \p mat, marking the * Creates the projection matrix and multiplies it with \p mat, marking the
* MAT_FLAG_PERSPECTIVE flag. * MAT_FLAG_PERSPECTIVE flag.
@ -1141,13 +1109,13 @@ _math_matrix_frustum (CoglMatrix *matrix,
/* /*
* Apply an orthographic projection matrix. * Apply an orthographic projection matrix.
* *
* \param mat matrix to apply the projection. * @mat matrix to apply the projection.
* \param left left clipping plane coordinate. * @left left clipping plane coordinate.
* \param right right clipping plane coordinate. * @right right clipping plane coordinate.
* \param bottom bottom clipping plane coordinate. * @bottom bottom clipping plane coordinate.
* \param top top clipping plane coordinate. * @top top clipping plane coordinate.
* \param nearval distance to the near clipping plane. * @nearval distance to the near clipping plane.
* \param farval distance to the far clipping plane. * @farval distance to the far clipping plane.
* *
* Creates the projection matrix and multiplies it with \p mat, marking the * Creates the projection matrix and multiplies it with \p mat, marking the
* MAT_FLAG_GENERAL_SCALE and MAT_FLAG_TRANSLATION flags. * MAT_FLAG_GENERAL_SCALE and MAT_FLAG_TRANSLATION flags.
@ -1193,10 +1161,10 @@ _math_matrix_ortho (CoglMatrix *matrix,
/* /*
* Multiply a matrix with a general scaling matrix. * Multiply a matrix with a general scaling matrix.
* *
* \param mat matrix. * @mat matrix.
* \param x x axis scale factor. * @x x axis scale factor.
* \param y y axis scale factor. * @y y axis scale factor.
* \param z z axis scale factor. * @z z axis scale factor.
* *
* Multiplies in-place the elements of \p mat by the scale factors. Checks if * Multiplies in-place the elements of \p mat by the scale factors. Checks if
* the scales factors are roughly the same, marking the MAT_FLAG_UNIFORM_SCALE * the scales factors are roughly the same, marking the MAT_FLAG_UNIFORM_SCALE
@ -1223,10 +1191,10 @@ _math_matrix_scale (CoglMatrix *matrix, float x, float y, float z)
/* /*
* Multiply a matrix with a translation matrix. * Multiply a matrix with a translation matrix.
* *
* \param mat matrix. * @mat matrix.
* \param x translation vector x coordinate. * @x translation vector x coordinate.
* \param y translation vector y coordinate. * @y translation vector y coordinate.
* \param z translation vector z coordinate. * @z translation vector z coordinate.
* *
* Adds the translation coordinates to the elements of \p mat in-place. Marks * Adds the translation coordinates to the elements of \p mat in-place. Marks
* the MAT_FLAG_TRANSLATION flag, and the MAT_DIRTY_TYPE and MAT_DIRTY_INVERSE * the MAT_FLAG_TRANSLATION flag, and the MAT_DIRTY_TYPE and MAT_DIRTY_INVERSE
@ -1246,7 +1214,6 @@ _math_matrix_translate (CoglMatrix *matrix, float x, float y, float z)
MAT_DIRTY_INVERSE); MAT_DIRTY_INVERSE);
} }
/* /*
* Set matrix to do viewport and depthrange mapping. * Set matrix to do viewport and depthrange mapping.
* Transforms Normalized Device Coords to window/Z values. * Transforms Normalized Device Coords to window/Z values.
@ -1272,7 +1239,7 @@ _math_matrix_viewport (CoglMatrix *matrix,
/* /*
* Set a matrix to the identity matrix. * Set a matrix to the identity matrix.
* *
* \param mat matrix. * @mat matrix.
* *
* Copies ::identity into \p CoglMatrix::m, and into CoglMatrix::inv if * Copies ::identity into \p CoglMatrix::m, and into CoglMatrix::inv if
* not NULL. Sets the matrix type to identity, resets the flags. It * not NULL. Sets the matrix type to identity, resets the flags. It
@ -1287,13 +1254,6 @@ _math_matrix_init_identity (CoglMatrix *matrix)
matrix->flags = MAT_DIRTY_INVERSE; matrix->flags = MAT_DIRTY_INVERSE;
} }
/*@}*/
/**********************************************************************/
/* \name Matrix analysis */
/*@{*/
#define ZERO(x) (1<<x) #define ZERO(x) (1<<x)
#define ONE(x) (1<<(x+16)) #define ONE(x) (1<<(x+16))
@ -1337,7 +1297,7 @@ _math_matrix_init_identity (CoglMatrix *matrix)
/* /*
* Determine type and flags from scratch. * Determine type and flags from scratch.
* *
* \param mat matrix. * @mat matrix.
* *
* This is expensive enough to only want to do it once. * This is expensive enough to only want to do it once.
*/ */
@ -1501,7 +1461,7 @@ analyse_from_flags (CoglMatrix *matrix)
/* /*
* Analyze and update the type and flags of a matrix. * Analyze and update the type and flags of a matrix.
* *
* \param mat matrix. * @mat matrix.
* *
* If the matrix type is dirty then calls either analyse_from_scratch() or * If the matrix type is dirty then calls either analyse_from_scratch() or
* analyse_from_flags() to determine its type, according to whether the flags * analyse_from_flags() to determine its type, according to whether the flags
@ -1522,9 +1482,6 @@ _math_matrix_update_type_and_flags (CoglMatrix *matrix)
matrix->flags &= ~(MAT_DIRTY_FLAGS | MAT_DIRTY_TYPE); matrix->flags &= ~(MAT_DIRTY_FLAGS | MAT_DIRTY_TYPE);
} }
/*@}*/
/* /*
* Test if the given matrix preserves vector lengths. * Test if the given matrix preserves vector lengths.
*/ */
@ -1534,7 +1491,6 @@ _math_matrix_is_length_preserving (const CoglMatrix *m)
return TEST_MAT_FLAGS (m, MAT_FLAGS_LENGTH_PRESERVING); return TEST_MAT_FLAGS (m, MAT_FLAGS_LENGTH_PRESERVING);
} }
/* /*
* Test if the given matrix does any rotation. * Test if the given matrix does any rotation.
* (or perhaps if the upper-left 3x3 is non-identity) * (or perhaps if the upper-left 3x3 is non-identity)
@ -1551,30 +1507,23 @@ _math_matrix_has_rotation (const CoglMatrix *matrix)
return FALSE; return FALSE;
} }
gboolean gboolean
_math_matrix_is_general_scale (const CoglMatrix *matrix) _math_matrix_is_general_scale (const CoglMatrix *matrix)
{ {
return (matrix->flags & MAT_FLAG_GENERAL_SCALE) ? TRUE : FALSE; return (matrix->flags & MAT_FLAG_GENERAL_SCALE) ? TRUE : FALSE;
} }
gboolean gboolean
_math_matrix_is_dirty (const CoglMatrix *matrix) _math_matrix_is_dirty (const CoglMatrix *matrix)
{ {
return (matrix->flags & MAT_DIRTY_ALL) ? TRUE : FALSE; return (matrix->flags & MAT_DIRTY_ALL) ? TRUE : FALSE;
} }
/**********************************************************************/
/* \name Matrix setup */
/*@{*/
/* /*
* Loads a matrix array into CoglMatrix. * Loads a matrix array into CoglMatrix.
* *
* \param m matrix array. * @m matrix array.
* \param mat matrix. * @mat matrix.
* *
* Copies \p m into CoglMatrix::m and marks the MAT_FLAG_GENERAL and * Copies \p m into CoglMatrix::m and marks the MAT_FLAG_GENERAL and
* MAT_DIRTY_ALL * MAT_DIRTY_ALL
@ -1587,8 +1536,6 @@ _math_matrix_init_from_array (CoglMatrix *matrix, const float *array)
matrix->flags = (MAT_FLAG_GENERAL | MAT_DIRTY_ALL); matrix->flags = (MAT_FLAG_GENERAL | MAT_DIRTY_ALL);
} }
/*
*/
void void
_math_matrix_init_from_quaternion (CoglMatrix *matrix, _math_matrix_init_from_quaternion (CoglMatrix *matrix,
CoglQuaternion *quaternion) CoglQuaternion *quaternion)
@ -1624,18 +1571,11 @@ _math_matrix_init_from_quaternion (CoglMatrix *matrix,
matrix->flags = (MAT_FLAG_GENERAL | MAT_DIRTY_ALL); matrix->flags = (MAT_FLAG_GENERAL | MAT_DIRTY_ALL);
} }
/*@}*/
/**********************************************************************/
/* \name Matrix transpose */
/*@{*/
/* /*
* Transpose a float matrix. * Transpose a float matrix.
* *
* \param to destination array. * @to destination array.
* \param from source array. * @from source array.
*/ */
void void
_math_transposef (float to[16], const float from[16]) _math_transposef (float to[16], const float from[16])
@ -1657,82 +1597,3 @@ _math_transposef (float to[16], const float from[16])
to[14] = from[11]; to[14] = from[11];
to[15] = from[15]; to[15] = from[15];
} }
/*
* Transpose a double matrix.
*
* \param to destination array.
* \param from source array.
*/
void
_math_transposed (double to[16], const double from[16])
{
to[0] = from[0];
to[1] = from[4];
to[2] = from[8];
to[3] = from[12];
to[4] = from[1];
to[5] = from[5];
to[6] = from[9];
to[7] = from[13];
to[8] = from[2];
to[9] = from[6];
to[10] = from[10];
to[11] = from[14];
to[12] = from[3];
to[13] = from[7];
to[14] = from[11];
to[15] = from[15];
}
/*
* Transpose a double matrix and convert to float.
*
* \param to destination array.
* \param from source array.
*/
void
_math_transposefd (float to[16], const double from[16])
{
to[0] = (float)from[0];
to[1] = (float)from[4];
to[2] = (float)from[8];
to[3] = (float)from[12];
to[4] = (float)from[1];
to[5] = (float)from[5];
to[6] = (float)from[9];
to[7] = (float)from[13];
to[8] = (float)from[2];
to[9] = (float)from[6];
to[10] = (float)from[10];
to[11] = (float)from[14];
to[12] = (float)from[3];
to[13] = (float)from[7];
to[14] = (float)from[11];
to[15] = (float)from[15];
}
/*@}*/
/*
* 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 (float u[4], const float v[4], const float m[16])
{
const float 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
}

84
cogl/cogl-matrix-mesa.h
View File

@ -56,23 +56,20 @@
#include <glib.h> #include <glib.h>
/* /*
* \name Symbolic names to some of the entries in the matrix * Symbolic names to some of the entries in the matrix
* *
* These are handy for the viewport mapping, which is expressed as a matrix. * These are handy for the viewport mapping, which is expressed as a matrix.
*/ */
/*@{*/
#define MAT_SX 0 #define MAT_SX 0
#define MAT_SY 5 #define MAT_SY 5
#define MAT_SZ 10 #define MAT_SZ 10
#define MAT_TX 12 #define MAT_TX 12
#define MAT_TY 13 #define MAT_TY 13
#define MAT_TZ 14 #define MAT_TZ 14
/*@}*/
/* /*
* Different kinds of 4x4 transformation matrices. * These identify different kinds of 4x4 transformation matrices and we use
* We use these to select specific optimized vertex transformation routines. * this information to find fast-paths when available.
*/ */
enum CoglMatrixType { enum CoglMatrixType {
COGL_MATRIX_TYPE_GENERAL, /**< general 4x4 matrix */ COGL_MATRIX_TYPE_GENERAL, /**< general 4x4 matrix */
@ -84,22 +81,6 @@ enum CoglMatrixType {
COGL_MATRIX_TYPE_3D /**< 3-D transformation */ COGL_MATRIX_TYPE_3D /**< 3-D transformation */
} ; } ;
#if 0
/*
* Matrix type to represent 4x4 transformation matrices.
*/
typedef struct {
float *m; /**< 16 matrix elements (16-byte aligned) */
float *inv; /**< optional 16-element inverse (16-byte aligned) */
unsigned int flags; /**< possible values determined by (of \link
* MatFlags MAT_FLAG_* flags\endlink)
*/
enum CoglMatrixType type;
} CoglMatrix;
#endif
void void
_math_matrix_multiply (CoglMatrix *result, _math_matrix_multiply (CoglMatrix *result,
const CoglMatrix *a, const CoglMatrix *a,
@ -166,66 +147,7 @@ _math_matrix_is_general_scale (const CoglMatrix *matrix);
gboolean gboolean
_math_matrix_is_dirty (const CoglMatrix *matrix); _math_matrix_is_dirty (const CoglMatrix *matrix);
/*
* \name Related functions that don't actually operate on CoglMatrix structs
*/
/*@{*/
void void
_math_transposef ( float to[16], const float from[16]); _math_transposef ( float to[16], const float from[16]);
void
_math_transposed (double to[16], const double from[16]);
void
_math_transposefd (float to[16], const double from[16]);
/*
* 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)
/*
* Transform a direction by a matrix.
*/
#define TRANSFORM_DIRECTION( TO, DIR, MAT ) \
do { \
TO[0] = DIR[0] * MAT[0] + DIR[1] * MAT[4] + DIR[2] * MAT[8]; \
TO[1] = DIR[0] * MAT[1] + DIR[1] * MAT[5] + DIR[2] * MAT[9]; \
TO[2] = DIR[0] * MAT[2] + DIR[1] * MAT[6] + DIR[2] * MAT[10];\
} while (0)
void
_mesa_transform_vector (float u[4], const float v[4], const float m[16]);
/*@}*/
#endif #endif