mirror of
https://github.com/brl/mutter.git
synced 2024-12-23 19:42:05 +00:00
[cogl-matrix] Import Mesa's matrix manipulation code
This pulls in code from Mesa to improve our matrix manipulation support. It includes support for calculating the inverse of matrices based on top of a matrix categorizing system that allows optimizing certain matrix types. (the main thing we were after) but also adds some optimisations for rotations. Changes compared to the original code from Mesa: - Coding style is consistent with the rest of Cogl - Instead of allocating matrix->m and matrix->inv using malloc, our public CoglMatrix typedef is large enough to directly contain the matrix, its inverse, a type and a set of flags. - Instead of having a _math_matrix_analyse which updates the type, flags and inverse, we have _math_matrix_update_inverse which essentially does the same thing (internally making use of _math_matrix_update_type_and_flags()) but with additional guards in place to bail out when the inverse matrix is still valid. - When initializing a matrix with the identity matrix we don't immediately initialize the inverse matrix; rather we just set the dirty flag for the inverse (since it's likely the user won't request the inverse of the identity matrix)
This commit is contained in:
Robert Bragg
parent
d38d888f78
commit
eb438dd499
@ -122,6 +122,8 @@ libclutter_cogl_la_SOURCES = \
|
||||
$(srcdir)/cogl-journal.c \
|
||||
$(srcdir)/cogl-draw-buffer-private.h \
|
||||
$(srcdir)/cogl-draw-buffer.c \
|
||||
$(srcdir)/cogl-matrix-mesa.h \
|
||||
$(srcdir)/cogl-matrix-mesa.c \
|
||||
$(BUILT_SOURCES) \
|
||||
$(NULL)
|
||||
|
||||
|
||||
1698
clutter/cogl/cogl/cogl-matrix-mesa.c
Normal file
1698
clutter/cogl/cogl/cogl-matrix-mesa.c
Normal file
File diff suppressed because it is too large
Load Diff
226
clutter/cogl/cogl/cogl-matrix-mesa.h
Normal file
226
clutter/cogl/cogl/cogl-matrix-mesa.h
Normal file
@ -0,0 +1,226 @@
|
||||
/*
|
||||
* Cogl
|
||||
*
|
||||
* An object oriented GL/GLES Abstraction/Utility Layer
|
||||
*
|
||||
* Copyright (C) 2009 Intel Corporation.
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
*/
|
||||
/*
|
||||
* Copyright (C) 1999-2005 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.
|
||||
*/
|
||||
|
||||
|
||||
/**
|
||||
* \file math/m_matrix.h
|
||||
* Defines basic structures for matrix-handling.
|
||||
*/
|
||||
|
||||
#ifndef _M_MATRIX_H
|
||||
#define _M_MATRIX_H
|
||||
|
||||
#include <cogl-matrix.h>
|
||||
|
||||
#include <glib.h>
|
||||
|
||||
/**
|
||||
* \name Symbolic names to some of the entries in the matrix
|
||||
*
|
||||
* These are handy for the viewport mapping, which is expressed as a matrix.
|
||||
*/
|
||||
/*@{*/
|
||||
#define MAT_SX 0
|
||||
#define MAT_SY 5
|
||||
#define MAT_SZ 10
|
||||
#define MAT_TX 12
|
||||
#define MAT_TY 13
|
||||
#define MAT_TZ 14
|
||||
/*@}*/
|
||||
|
||||
|
||||
/**
|
||||
* Different kinds of 4x4 transformation matrices.
|
||||
* We use these to select specific optimized vertex transformation routines.
|
||||
*/
|
||||
enum CoglMatrixType {
|
||||
COGL_MATRIX_TYPE_GENERAL, /**< general 4x4 matrix */
|
||||
COGL_MATRIX_TYPE_IDENTITY, /**< identity matrix */
|
||||
COGL_MATRIX_TYPE_3D_NO_ROT, /**< orthogonal projection and others... */
|
||||
COGL_MATRIX_TYPE_PERSPECTIVE, /**< perspective projection matrix */
|
||||
COGL_MATRIX_TYPE_2D, /**< 2-D transformation */
|
||||
COGL_MATRIX_TYPE_2D_NO_ROT, /**< 2-D scale & translate only */
|
||||
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
|
||||
_math_matrix_multiply (CoglMatrix *result,
|
||||
const CoglMatrix *a,
|
||||
const CoglMatrix *b);
|
||||
|
||||
void
|
||||
_math_matrix_multiply_array (CoglMatrix *result, const float *b);
|
||||
|
||||
void
|
||||
_math_matrix_init_from_array (CoglMatrix *matrix, const float *array);
|
||||
|
||||
void
|
||||
_math_matrix_translate (CoglMatrix *matrix, float x, float y, float z);
|
||||
|
||||
void
|
||||
_math_matrix_rotate (CoglMatrix *matrix, float angle,
|
||||
float x, float y, float z);
|
||||
|
||||
void
|
||||
_math_matrix_scale (CoglMatrix *matrix, float x, float y, float z);
|
||||
|
||||
void
|
||||
_math_matrix_ortho (CoglMatrix *matrix,
|
||||
float left, float right,
|
||||
float bottom, float top,
|
||||
float nearval, float farval);
|
||||
|
||||
void
|
||||
_math_matrix_frustum (CoglMatrix *matrix,
|
||||
float left, float right,
|
||||
float bottom, float top,
|
||||
float nearval, float farval);
|
||||
|
||||
void
|
||||
_math_matrix_viewport (CoglMatrix *matrix,
|
||||
int x, int y, int width, int height,
|
||||
float z_near, float z_far, float depth_max);
|
||||
|
||||
void
|
||||
_math_matrix_init_identity (CoglMatrix *matrix);
|
||||
|
||||
gboolean
|
||||
_math_matrix_update_inverse (CoglMatrix *matrix);
|
||||
|
||||
void
|
||||
_math_matrix_update_type_and_flags (CoglMatrix *matrix);
|
||||
|
||||
void
|
||||
_math_matrix_print (const CoglMatrix *matrix);
|
||||
|
||||
gboolean
|
||||
_math_matrix_is_length_preserving (const CoglMatrix *matrix);
|
||||
|
||||
gboolean
|
||||
_math_matrix_has_rotation (const CoglMatrix *matrix);
|
||||
|
||||
gboolean
|
||||
_math_matrix_is_general_scale (const CoglMatrix *matrix);
|
||||
|
||||
gboolean
|
||||
_math_matrix_is_dirty (const CoglMatrix *matrix);
|
||||
|
||||
|
||||
/**
|
||||
* \name Related functions that don't actually operate on CoglMatrix structs
|
||||
*/
|
||||
/*@{*/
|
||||
|
||||
void
|
||||
_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
|
||||
@ -24,8 +24,13 @@
|
||||
* Robert Bragg <robert@linux.intel.com>
|
||||
*/
|
||||
|
||||
#define USE_MESA_MATRIX_API
|
||||
|
||||
#include <cogl.h>
|
||||
#include <cogl-matrix.h>
|
||||
#ifdef USE_MESA_MATRIX_API
|
||||
#include <cogl-matrix-mesa.h>
|
||||
#endif
|
||||
|
||||
#include <glib.h>
|
||||
#include <math.h>
|
||||
@ -34,10 +39,14 @@
|
||||
void
|
||||
cogl_matrix_init_identity (CoglMatrix *matrix)
|
||||
{
|
||||
#ifndef USE_MESA_MATRIX_API
|
||||
matrix->xx = 1; matrix->xy = 0; matrix->xz = 0; matrix->xw = 0;
|
||||
matrix->yx = 0; matrix->yy = 1; matrix->yz = 0; matrix->yw = 0;
|
||||
matrix->zx = 0; matrix->zy = 0; matrix->zz = 1; matrix->zw = 0;
|
||||
matrix->wx = 0; matrix->wy = 0; matrix->wz = 0; matrix->ww = 1;
|
||||
#else
|
||||
_math_matrix_init_identity (matrix);
|
||||
#endif
|
||||
}
|
||||
|
||||
void
|
||||
@ -45,6 +54,7 @@ cogl_matrix_multiply (CoglMatrix *result,
|
||||
const CoglMatrix *a,
|
||||
const CoglMatrix *b)
|
||||
{
|
||||
#ifndef USE_MESA_MATRIX_API
|
||||
CoglMatrix r;
|
||||
|
||||
/* row 0 */
|
||||
@ -73,10 +83,13 @@ cogl_matrix_multiply (CoglMatrix *result,
|
||||
|
||||
/* The idea was that having this unrolled; it might be easier for the
|
||||
* compiler to vectorize, but that's probably not true. Mesa does it
|
||||
* using a single for (i=0; i<4; i++) approach, may that's better...
|
||||
* using a single for (i=0; i<4; i++) approach, maybe that's better...
|
||||
*/
|
||||
|
||||
*result = r;
|
||||
#else
|
||||
_math_matrix_multiply (result, a, b);
|
||||
#endif
|
||||
}
|
||||
|
||||
void
|
||||
@ -86,6 +99,7 @@ cogl_matrix_rotate (CoglMatrix *matrix,
|
||||
float y,
|
||||
float z)
|
||||
{
|
||||
#ifndef USE_MESA_MATRIX_API
|
||||
CoglMatrix rotation;
|
||||
CoglMatrix result;
|
||||
float c, s;
|
||||
@ -116,6 +130,9 @@ cogl_matrix_rotate (CoglMatrix *matrix,
|
||||
|
||||
cogl_matrix_multiply (&result, matrix, &rotation);
|
||||
*matrix = result;
|
||||
#else
|
||||
_math_matrix_rotate (matrix, angle, x, y, z);
|
||||
#endif
|
||||
}
|
||||
|
||||
void
|
||||
@ -124,10 +141,14 @@ cogl_matrix_translate (CoglMatrix *matrix,
|
||||
float y,
|
||||
float z)
|
||||
{
|
||||
#ifndef USE_MESA_MATRIX_API
|
||||
matrix->xw = matrix->xx * x + matrix->xy * y + matrix->xz * z + matrix->xw;
|
||||
matrix->yw = matrix->yx * x + matrix->yy * y + matrix->yz * z + matrix->yw;
|
||||
matrix->zw = matrix->zx * x + matrix->zy * y + matrix->zz * z + matrix->zw;
|
||||
matrix->ww = matrix->wx * x + matrix->wy * y + matrix->wz * z + matrix->ww;
|
||||
#else
|
||||
_math_matrix_translate (matrix, x, y, z);
|
||||
#endif
|
||||
}
|
||||
|
||||
void
|
||||
@ -136,10 +157,14 @@ cogl_matrix_scale (CoglMatrix *matrix,
|
||||
float sy,
|
||||
float sz)
|
||||
{
|
||||
#ifndef USE_MESA_MATRIX_API
|
||||
matrix->xx *= sx; matrix->xy *= sy; matrix->xz *= sz;
|
||||
matrix->yx *= sx; matrix->yy *= sy; matrix->yz *= sz;
|
||||
matrix->zx *= sx; matrix->zy *= sy; matrix->zz *= sz;
|
||||
matrix->wx *= sx; matrix->wy *= sy; matrix->wz *= sz;
|
||||
#else
|
||||
_math_matrix_scale (matrix, sx, sy, sz);
|
||||
#endif
|
||||
}
|
||||
|
||||
#if 0
|
||||
@ -163,6 +188,7 @@ cogl_matrix_frustum (CoglMatrix *matrix,
|
||||
float z_near,
|
||||
float z_far)
|
||||
{
|
||||
#ifndef USE_MESA_MATRIX_API
|
||||
float x, y, a, b, c, d;
|
||||
CoglMatrix frustum;
|
||||
|
||||
@ -194,6 +220,9 @@ cogl_matrix_frustum (CoglMatrix *matrix,
|
||||
frustum.ww = 0.0f;
|
||||
|
||||
cogl_matrix_multiply (matrix, matrix, &frustum);
|
||||
#else
|
||||
_math_matrix_frustum (matrix, left, right, bottom, top, z_near, z_far);
|
||||
#endif
|
||||
}
|
||||
|
||||
void
|
||||
@ -223,6 +252,7 @@ cogl_matrix_ortho (CoglMatrix *matrix,
|
||||
float near_val,
|
||||
float far_val)
|
||||
{
|
||||
#ifndef USE_MESA_MATRIX_API
|
||||
CoglMatrix ortho;
|
||||
|
||||
/* column 0 */
|
||||
@ -250,12 +280,19 @@ cogl_matrix_ortho (CoglMatrix *matrix,
|
||||
ortho.ww = 1.0;
|
||||
|
||||
cogl_matrix_multiply (matrix, matrix, &ortho);
|
||||
#else
|
||||
_math_matrix_ortho (matrix, left, right, bottom, top, near_val, far_val);
|
||||
#endif
|
||||
}
|
||||
|
||||
void
|
||||
cogl_matrix_init_from_array (CoglMatrix *matrix, const float *array)
|
||||
{
|
||||
#ifndef USE_MESA_MATRIX_API
|
||||
memcpy (matrix, array, sizeof (float) * 16);
|
||||
#else
|
||||
_math_matrix_init_from_array (matrix, array);
|
||||
#endif
|
||||
}
|
||||
|
||||
const float *
|
||||
|
||||
@ -101,9 +101,9 @@ struct _CoglMatrix
|
||||
|
||||
/* Note: we may want to extend this later with private flags
|
||||
* and a cache of the inverse transform matrix. */
|
||||
float _padding0[16];
|
||||
gulong _padding1;
|
||||
gulong _padding2;
|
||||
float inv[16];
|
||||
gulong type;
|
||||
gulong flags;
|
||||
gulong _padding3;
|
||||
};
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user