gl_matrix.cpp File Reference

#include "gl_globals.h"
#include "gfxlib.h"
#include "gfx/vec.h"
#include <stdio.h>
#include <math.h>
#include <string.h>
#include <assert.h>
#include "gfx/matrix.h"
#include "vs_globals.h"
#include "gl_matrix.h"

Go to the source code of this file.

Macros
#define	M(row, col)   m[col*4+row]
#define	M(row, col)   i[col*4+row]
#define	M(row, col)   m[col*4+row]
#define	M(row, col)   view.r[col*3+row]

Functions
void	getInverseProjection (float *&inv)
float	GFXGetXInvPerspective ()
	Screen to eye. More...
float	GFXGetYInvPerspective ()
void	MatrixToDoubles (double t[], const Matrix &m)
void	ViewToModel ()
static void	IdentityFloat (float id[])
void	MultFloatMatrix (float dest[], const float m1[], const Matrix &m2)
static void	RotateFloatMatrix (float dest[], const float m1[], const Matrix &m2)
void	ConstructAndLoadProjection ()
void	GFXTranslateView (const QVector &a)
void	GFXTranslateModel (const QVector &a)
void	GFXTranslateProjection (const Vector &a)
	Translates the current "mode" matrix by a given vector. More...
void	GFXMultMatrixModel (const Matrix &matrix)
	Multipliex the current "mode" matrix by a given matrix. More...
void	GFXLoadMatrixView (const Matrix &matrix)
void	GFXLoadMatrixModel (const Matrix &matrix)
	loads a given matrix to the current "mode" More...
void	GFXLoadMatrixProjection (const float matrix[16])
void	GFXViewPort (int minx, int miny, int maxx, int maxy)
	Sets the final translation to screen coordinates, Also adjusts range of clearing. More...
void	GFXCenterCamera (bool Enter)
void	GFXRestoreHudMode ()
void	GFXHudMode (const bool Enter)
void	GFXLoadIdentity (const MATRIXMODE mode)
	Loads the identity matrix for the given mode. More...
void	GFXGetMatrixView (Matrix &matrix)
void	GFXGetMatrixModel (Matrix &matrix)
	retrieves the matrix for a given mode. More...
static void	gl_Frustum (float left, float right, float bottom, float top, float nearval, float farval)
void	GFXFrustum (float *m, float *i, float left, float right, float bottom, float top, float nearval, float farval)
	Given matrices, calculates the matrix and inverse matrix of a projection matrix to go from screen to 3-space coordinates. More...
void	GFXPerspective (float fov, float aspect, float znear, float zfar, float cockpit_offset)
	Sets the Projection matrix to have fov and aspect as follows (fov is field of view in radians, aspect is width/height znear and zfar are clip planes. More...
void	GFXParallel (float left, float right, float bottom, float top, float nearval, float farval)
	Sets the Projection matrix to a parallel view with given paramters. More...
static void	LookAtHelper (float eyex, float eyey, float eyez, double centerx, double centery, double centerz, float upx, float upy, float upz)
void	GFXLookAt (Vector eye, QVector center, Vector up)
	Sets the VIEW matrix to look from center in direction of eye with up vector up. More...

Macro Definition Documentation

#define M	(		row,
			col
	)		m[col*4+row]

#define M	(		row,
			col
	)		i[col*4+row]

#define M	(		row,
			col
	)		m[col*4+row]

#define M	(		row,
			col
	)		view.r[col*3+row]

Function Documentation

void ConstructAndLoadProjection

(

)

Definition at line 157 of file gl_matrix.cpp.

References GFXMatrices::projection, RotateFloatMatrix(), and GFXMatrices::view.

Referenced by GFXLoadIdentity(), GFXLoadMatrixProjection(), GFXLoadMatrixView(), GFXPerspective(), and GFXTranslateProjection().

{
    float t[16];
    RotateFloatMatrix( t, projection, view );
    glMatrixMode( GL_PROJECTION );
    glLoadMatrixf( t );
}

void getInverseProjection

(

float *&

inv)

Definition at line 46 of file gl_matrix.cpp.

References GFXMatrices::invprojection.

{
    inv = invprojection;
}

void GFXCenterCamera

(

bool

Enter)

Definition at line 224 of file gl_matrix.cpp.

References GFXLoadIdentity(), MODEL, Matrix::p, QVector, and GFXMatrices::view.

Referenced by Background::Draw(), and Mesh::DrawNow().

{
    static QVector tmp;
    if (Enter) {
        tmp = view.p;
        view.p.Set( 0, 0, 0 );
        glMatrixMode( GL_MODELVIEW );
        glLoadIdentity();
    } else {
        view.p = tmp;
        GFXLoadIdentity( MODEL );
    }
}

void GFXFrustum	(	float *	m,
		float *	i,
		float	left,
		float	right,
		float	bottom,
		float	top,
		float	nearval,
		float	farval
	)

Given matrices, calculates the matrix and inverse matrix of a projection matrix to go from screen to 3-space coordinates.

Definition at line 303 of file gl_matrix.cpp.

References a, b, c, d, float, M, x, and y.

{
    GLfloat x, y, a, b, c, d;
    x = ( ( (float) 2.0 )*nearval )/(right-left);
    y = ( ( (float) 2.0 )*nearval )/(top-bottom);
    a = (right+left)/(right-left);
    b = (top+bottom)/(top-bottom);
    //If farval == 0, we'll build an infinite-farplane projection matrix.
    if (farval == 0) {
        c = -1.0;
        d = -1.99*nearval;         //-2*nearval, but using exactly -2 might create artifacts
    } else {
        c = -(farval+nearval)/(farval-nearval);
        d = -( ( (float) 2.0 )*farval*nearval )/(farval-nearval);
    }
#define M( row, col ) m[col*4+row]
    M( 0, 0 ) = x;
    M( 0, 1 ) = 0.0F;
    M( 0, 2 ) = a;
    M( 0, 3 ) = 0.0F;
    M( 1, 0 ) = 0.0F;
    M( 1, 1 ) = y;
    M( 1, 2 ) = b;
    M( 1, 3 ) = 0.0F;
    M( 2, 0 ) = 0.0F;
    M( 2, 1 ) = 0.0F;
    M( 2, 2 ) = c;
    M( 2, 3 ) = d;
    M( 3, 0 ) = 0.0F;
    M( 3, 1 ) = 0.0F;
    M( 3, 2 ) = -1.0F;
    M( 3, 3 ) = 0.0F;
#undef M
#define M( row, col ) i[col*4+row]
    M( 0, 0 ) = 1./x;
    M( 0, 1 ) = 0.0F;
    M( 0, 2 ) = 0.0F;
    M( 0, 3 ) = a/x;
    M( 1, 0 ) = 0.0F;
    M( 1, 1 ) = 1./y;
    M( 1, 2 ) = 0.0F;
    M( 1, 3 ) = b/y;
    M( 2, 0 ) = 0.0F;
    M( 2, 1 ) = 0.0F;
    M( 2, 2 ) = 0.0F;
    M( 2, 3 ) = -1.0F;
    M( 3, 0 ) = 0.0F;
    M( 3, 1 ) = 0.0F;
    M( 3, 2 ) = 1.F/d;
    M( 3, 3 ) = (float) c/d;
#undef M
}

void GFXGetMatrixModel

(

Matrix &

matrix)

retrieves the matrix for a given mode.

Definition at line 292 of file gl_matrix.cpp.

References CopyMatrix(), and GFXMatrices::model.

Referenced by LocationSelect::Draw(), and GFXUploadLightState().

{
    CopyMatrix( matrix, model );
}

void GFXGetMatrixView

(

Matrix &

matrix)

Definition at line 288 of file gl_matrix.cpp.

References CopyMatrix(), and GFXMatrices::view.

Referenced by LocationSelect::Draw(), and Camera::GetView().

{
    CopyMatrix( matrix, view );
}

float GFXGetXInvPerspective

(

)

Screen to eye.

Definition at line 51 of file gl_matrix.cpp.

References GFXMatrices::invprojection.

{
    return /*invprojection[11]*  */ invprojection[0];     //invprojection[15];//should be??  c/d == invproj[15]
}

float GFXGetYInvPerspective

(

)

Definition at line 56 of file gl_matrix.cpp.

References GFXMatrices::invprojection.

{
    return /*invprojection[11]*  */ invprojection[5];     //invprojection[15];//should be??  c/d == invproj[15]
}

void GFXHudMode

(

const bool

Enter)

Hud Mode saves the current matrices and sets projection and view matrices to identity. Caution: use of other matrix functions in HudMode could alter state.

Definition at line 246 of file gl_matrix.cpp.

{
    if (Enter) {
        glMatrixMode( GL_MODELVIEW );
        glPushMatrix();
        glLoadIdentity();
        glMatrixMode( GL_PROJECTION );
        glPushMatrix();
        glLoadIdentity();
    } else {
        glMatrixMode( GL_PROJECTION );
        glPopMatrix();
        glMatrixMode( GL_MODELVIEW );
        glPopMatrix();
    }
}

void GFXLoadIdentity

(

const MATRIXMODE

mode)

Loads the identity matrix for the given mode.

Definition at line 263 of file gl_matrix.cpp.

References ConstructAndLoadProjection(), GFX_SCALE, Identity(), IdentityFloat(), GFXMatrices::model, MODEL, Matrix::p, GFXMatrices::projection, PROJECTION, GFXMatrices::view, VIEW, and ViewToModel().

{
    switch (mode)
    {
    case MODEL:
        Identity( model );
        glMatrixMode( GL_MODELVIEW );
        //glLoadMatrixf(transview);
        glLoadIdentity();
        glTranslated( -view.p.i*GFX_SCALE, -view.p.j*GFX_SCALE, -view.p.k*GFX_SCALE );
        glScalef( GFX_SCALE, GFX_SCALE, GFX_SCALE );
        break;
    case PROJECTION:
        IdentityFloat( projection );
        ConstructAndLoadProjection();
        break;
    case VIEW:
        Identity( view );
        ViewToModel();
        glMatrixMode( GL_PROJECTION );
        glLoadMatrixf( projection );
        break;
    }
}

void GFXLoadMatrixModel

(

const Matrix &

matrix)

loads a given matrix to the current "mode"

Definition at line 207 of file gl_matrix.cpp.

References CopyMatrix(), GFXMatrices::model, and ViewToModel().

Referenced by bootstrap_draw(), Bolt::Draw(), Background::Draw(), Atmosphere::Draw(), Animation::DrawNow(), Mesh::DrawNow(), GFXUploadLightState(), Box::ProcessDrawQueue(), Logo::ProcessDrawQueue(), Beam::ProcessDrawQueue(), and QuadTree::Render().

{
    CopyMatrix( model, matrix );
    ViewToModel();
}

void GFXLoadMatrixProjection

(

const float

matrix[16])

Definition at line 213 of file gl_matrix.cpp.

References ConstructAndLoadProjection(), VsnetOSS::memcpy(), and GFXMatrices::projection.

Referenced by GFXParallel().

{
    memcpy( projection, matrix, 16*sizeof (float) );
    ConstructAndLoadProjection();
}

void GFXLoadMatrixView

(

const Matrix &

matrix)

Definition at line 200 of file gl_matrix.cpp.

References ConstructAndLoadProjection(), CopyMatrix(), GFXMatrices::view, and ViewToModel().

Referenced by GFXLookAt().

{
    CopyMatrix( view, matrix );
    ViewToModel();
    ConstructAndLoadProjection();
}

void GFXLookAt	(	Vector	eye,
		QVector	center,
		Vector	up
	)

Sets the VIEW matrix to look from center in direction of eye with up vector up.

Definition at line 495 of file gl_matrix.cpp.

References GFXLoadMatrixView(), LookAtHelper(), and GFXMatrices::view.

Referenced by Camera::UpdateGFX(), and Camera::UpdateGLCenter().

{
    LookAtHelper( eye.i, eye.j, eye.k, center.i, center.j, center.k, up.i, up.j, up.k );
    GFXLoadMatrixView( view );
}

void GFXMultMatrixModel

(

const Matrix &

matrix)

Multipliex the current "mode" matrix by a given matrix.

Definition at line 189 of file gl_matrix.cpp.

References CopyMatrix(), GFXMatrices::model, MultMatrix(), and ViewToModel().

Referenced by LocationSelect::Draw().

{
    Matrix t;
    MultMatrix( t, model, matrix );
    CopyMatrix( model, t );
    ViewToModel();
}

void GFXParallel	(	float	left,
		float	right,
		float	bottom,
		float	top,
		float	nearval,
		float	farval
	)

Sets the Projection matrix to a parallel view with given paramters.

Definition at line 376 of file gl_matrix.cpp.

References GFXGetFrustumVars(), GFXLoadMatrixProjection(), M, GFXMatrices::projection, x, y, and z.

{
    float *m = projection, x, y, z, tx, ty, tz;
    x  = 2.0/(right-left);
    y  = 2.0/(top-bottom);
    z  = -2.0/(farval-nearval);
    tx = -(right+left)/(right-left);
    ty = -(top+bottom)/(top-bottom);
    tz = -(farval+nearval)/(farval-nearval);

#define M( row, col ) m[col*4+row]
    M( 0, 0 ) = x;
    M( 0, 1 ) = 0.0F;
    M( 0, 2 ) = 0.0F;
    M( 0, 3 ) = tx;
    M( 1, 0 ) = 0.0F;
    M( 1, 1 ) = y;
    M( 1, 2 ) = 0.0F;
    M( 1, 3 ) = ty;
    M( 2, 0 ) = 0.0F;
    M( 2, 1 ) = 0.0F;
    M( 2, 2 ) = z;
    M( 2, 3 ) = tz;
    M( 3, 0 ) = 0.0F;
    M( 3, 1 ) = 0.0F;
    M( 3, 2 ) = 0.0F;
    M( 3, 3 ) = 1.0F;
#undef M
    GFXLoadMatrixProjection( projection );
    GFXGetFrustumVars( false, &left, &right, &bottom, &top, &nearval, &farval );
}

void GFXPerspective	(	float	fov,
		float	aspect,
		float	znear,
		float	zfar,
		float	cockpit_offset
	)

Sets the Projection matrix to have fov and aspect as follows (fov is field of view in radians, aspect is width/height znear and zfar are clip planes.

Definition at line 356 of file gl_matrix.cpp.

References ConstructAndLoadProjection(), GFX_SCALE, gl_Frustum(), and M_PI.

{
    znear *= GFX_SCALE;
    zfar  *= GFX_SCALE;
    cockpit_offset *= GFX_SCALE;
    //gluPerspective (fov,aspect,znear,zfar);

    float xmin, xmax, ymin, ymax;

    ymax  = znear*tanf( fov*M_PI/( (float) 360.0 ) );       //78.0 --> 4.7046

    ymin  = -ymax;     //-4.7046

    xmin  = (ymin-cockpit_offset/2)*aspect;       //-6.2571
    xmax  = (ymax+cockpit_offset/2)*aspect;       //6.2571
    ymin -= cockpit_offset;
    gl_Frustum( xmin, xmax, ymin, ymax, znear, zfar );
    ConstructAndLoadProjection();
}

void GFXRestoreHudMode

(

)

Definition at line 238 of file gl_matrix.cpp.

{
    glMatrixMode( GL_MODELVIEW );
    glLoadIdentity();
    glMatrixMode( GL_PROJECTION );
    glLoadIdentity();
}

void GFXTranslateModel

(

const QVector &

a)

Definition at line 175 of file gl_matrix.cpp.

References GFXMatrices::model, Matrix::p, TransformNormal(), and ViewToModel().

Referenced by Stars::Draw(), and ParticleTrail::DrawAndUpdate().

{
    model.p += TransformNormal( model, a );
    ViewToModel();
}

void GFXTranslateProjection

(

const Vector &

a)

Translates the current "mode" matrix by a given vector.

Definition at line 181 of file gl_matrix.cpp.

References ConstructAndLoadProjection(), and GFXMatrices::projection.

{
    projection[12] += a.i*projection[0]+a.j*projection[4]+a.k*projection[8];
    projection[13] += a.i*projection[1]+a.j*projection[5]+a.k*projection[9];
    projection[14] += a.i*projection[2]+a.j*projection[6]+a.k*projection[10];
    ConstructAndLoadProjection();
}

void GFXTranslateView

(

const QVector &

a)

Definition at line 165 of file gl_matrix.cpp.

References Matrix::p, TransformNormal(), GFXMatrices::view, and ViewToModel().

{
    view.p += TransformNormal( view, a );
    //glPopMatrix();
    //glLoadIdentity();
    //glTranslatef(-view[12],-view[13],-view[14]);
    //glPushMatrix();
    ViewToModel();
}

void GFXViewPort	(	int	minx,
		int	miny,
		int	maxx,
		int	maxy
	)

Sets the final translation to screen coordinates, Also adjusts range of clearing.

Definition at line 219 of file gl_matrix.cpp.

{
    glViewport( minx, miny, maxx, maxy );
}

static void gl_Frustum ( float  left, float  right, float  bottom, float  top, float  nearval, float  farval  )

static

Definition at line 297 of file gl_matrix.cpp.

References GFXFrustum(), GFXGetFrustumVars(), GFXMatrices::invprojection, and GFXMatrices::projection.

Referenced by GFXPerspective().

{
    GFXGetFrustumVars( false, &left, &right, &bottom, &top, &nearval, &farval );
    GFXFrustum( projection, invprojection, left, right, bottom, top, nearval, farval );
}

static void IdentityFloat ( float  id[])

static

Definition at line 105 of file gl_matrix.cpp.

Referenced by GFXLoadIdentity().

{
    id[0] = id[5] = id[10] = id[15] = 1;
    id[1] = id[2] = id[3] = id[4] = id[6] = id[7] = id[8] = id[9] = id[11] = id[12] = id[13] = id[14] = 0;
}

static void LookAtHelper ( float  eyex, float  eyey, float  eyez, double  centerx, double  centery, double  centerz, float  upx, float  upy, float  upz  )

static

Definition at line 408 of file gl_matrix.cpp.

References M, Matrix::p, GFXMatrices::view, x, y, and z.

Referenced by GFXLookAt().

{
    //Matrix m;
    double x[3], y[3], z[3];
    double mag;

    /* Make rotation matrix */

    /* Z vector */
    z[0] = eyex;
    z[1] = eyey;
    z[2] = eyez;
    mag  = sqrtf( z[0]*z[0]+z[1]*z[1]+z[2]*z[2] );
    if (mag) {
        /* mpichler, 19950515 */
        z[0] /= mag;
        z[1] /= mag;
        z[2] /= mag;
    }
    /* Y vector */
    y[0] = upx;
    y[1] = upy;
    y[2] = upz;

    /* X vector = Y cross Z */
    //x[0] =  z[1]*y[2] - z[2]*y[1];
    //x[1] = -z[0]*y[2] + z[2]*y[0];
    //x[2] =  z[0]*y[1] - z[1]*y[0];
    x[0] = y[1]*z[2]-y[2]*z[1];
    x[1] = -y[0]*z[2]+y[2]*z[0];
    x[2] = y[0]*z[1]-y[1]*z[0];

    /* Recompute Y = Z cross X */
    //y[0] =  x[1]*z[2] - x[2]*z[1];
    //y[1] = -x[0]*z[2] + x[2]*z[0];
    //y[2] =  x[0]*z[1] - x[1]*z[0];
    y[0] = z[1]*x[2]-z[2]*x[1];
    y[1] = -z[0]*x[2]+z[2]*x[0];
    y[2] = z[0]*x[1]-z[1]*x[0];

    /* mpichler, 19950515 */
    /* cross product gives area of parallelogram, which is < 1.0 for
     * non-perpendicular unit-length vectors; so normalize x, y here
     */

    mag = sqrtf( x[0]*x[0]+x[1]*x[1]+x[2]*x[2] );
    if (mag) {
        x[0] /= mag;
        x[1] /= mag;
        x[2] /= mag;
    }
    mag = sqrtf( y[0]*y[0]+y[1]*y[1]+y[2]*y[2] );
    if (mag) {
        y[0] /= mag;
        y[1] /= mag;
        y[2] /= mag;
    }
#define M( row, col ) view.r[col*3+row]
    M( 0, 0 ) = x[0];
    M( 0, 1 ) = x[1];
    M( 0, 2 ) = x[2];                                  //M(0,3) = 0.0;
    M( 1, 0 ) = y[0];
    M( 1, 1 ) = y[1];
    M( 1, 2 ) = y[2];                                  //M(1,3) = 0.0;
    M( 2, 0 ) = z[0];
    M( 2, 1 ) = z[1];
    M( 2, 2 ) = z[2];                                  //M(2,3) = 0.0;
#undef M
    //M(3,0) = 0.0;   M(3,1) = 0.0;   M(3,2) = 0.0;   M(3,3) = 1.0;

    //Matrix tm;
    //Identity(tm);
    view.p.i = centerx+eyex;
    view.p.j = centery+eyey;
    view.p.k = centerz+eyez;
    //CopyMatrix (view,m);
    //MultMatrix(view, m, tm);
}

void MatrixToDoubles	(	double	t[],
		const Matrix &	m
	)

Definition at line 61 of file gl_matrix.cpp.

References Matrix::p, and Matrix::r.

{
    t[0]  = m.r[0];     //possible performance hit?!?!
    t[1]  = m.r[1];
    t[2]  = m.r[2];
    t[3]  = 0;
    t[4]  = m.r[3];
    t[5]  = m.r[4];
    t[6]  = m.r[5];
    t[7]  = 0;
    t[8]  = m.r[6];
    t[9]  = m.r[7];
    t[10] = m.r[8];
    t[11] = 0;
    t[12] = (m.p.i);
    t[13] = (m.p.j);
    t[14] = (m.p.k);
    t[15] = 1;
}

void MultFloatMatrix	(	float	dest[],
		const float	m1[],
		const Matrix &	m2
	)

Definition at line 111 of file gl_matrix.cpp.

References Matrix::p, and Matrix::r.

{
    dest[0]  = m1[0]*m2.r[0]+m1[4]*m2.r[1]+m1[8]*m2.r[2];
    dest[1]  = m1[1]*m2.r[0]+m1[5]*m2.r[1]+m1[9]*m2.r[2];
    dest[2]  = m1[2]*m2.r[0]+m1[6]*m2.r[1]+m1[10]*m2.r[2];
    dest[3]  = m1[3]*m2.r[0]+m1[7]*m2.r[1]+m1[11]*m2.r[2];

    dest[4]  = m1[0]*m2.r[3]+m1[4]*m2.r[4]+m1[8]*m2.r[5];
    dest[5]  = m1[1]*m2.r[3]+m1[5]*m2.r[4]+m1[9]*m2.r[5];
    dest[6]  = m1[2]*m2.r[3]+m1[6]*m2.r[4]+m1[10]*m2.r[5];
    dest[7]  = m1[3]*m2.r[3]+m1[7]*m2.r[4]+m1[11]*m2.r[5];

    dest[8]  = m1[0]*m2.r[6]+m1[4]*m2.r[7]+m1[8]*m2.r[8];
    dest[9]  = m1[1]*m2.r[6]+m1[5]*m2.r[7]+m1[9]*m2.r[8];
    dest[10] = m1[2]*m2.r[6]+m1[6]*m2.r[7]+m1[10]*m2.r[8];
    dest[11] = m1[3]*m2.r[6]+m1[7]*m2.r[7]+m1[11]*m2.r[8];

    dest[12] = m1[0]*m2.p.i+m1[4]*m2.p.j+m1[8]*m2.p.k+m1[12];
    dest[13] = m1[1]*m2.p.i+m1[5]*m2.p.j+m1[9]*m2.p.k+m1[13];
    dest[14] = m1[2]*m2.p.i+m1[6]*m2.p.j+m1[10]*m2.p.k+m1[14];
    dest[15] = m1[3]*m2.p.i+m1[7]*m2.p.j+m1[11]*m2.p.k+m1[15];
}

static void RotateFloatMatrix ( float  dest[], const float  m1[], const Matrix &  m2  )

static

Definition at line 134 of file gl_matrix.cpp.

References Matrix::r.

Referenced by ConstructAndLoadProjection().

{
    dest[0]  = (m1[0]*m2.r[0]+m1[4]*m2.r[1]+m1[8]*m2.r[2]);
    dest[1]  = (m1[1]*m2.r[0]+m1[5]*m2.r[1]+m1[9]*m2.r[2]);
    dest[2]  = (m1[2]*m2.r[0]+m1[6]*m2.r[1]+m1[10]*m2.r[2]);
    dest[3]  = (m1[3]*m2.r[0]+m1[7]*m2.r[1]+m1[11]*m2.r[2]);

    dest[4]  = (m1[0]*m2.r[3]+m1[4]*m2.r[4]+m1[8]*m2.r[5]);
    dest[5]  = (m1[1]*m2.r[3]+m1[5]*m2.r[4]+m1[9]*m2.r[5]);
    dest[6]  = (m1[2]*m2.r[3]+m1[6]*m2.r[4]+m1[10]*m2.r[5]);
    dest[7]  = (m1[3]*m2.r[3]+m1[7]*m2.r[4]+m1[11]*m2.r[5]);

    dest[8]  = (m1[0]*m2.r[6]+m1[4]*m2.r[7]+m1[8]*m2.r[8]);
    dest[9]  = (m1[1]*m2.r[6]+m1[5]*m2.r[7]+m1[9]*m2.r[8]);
    dest[10] = (m1[2]*m2.r[6]+m1[6]*m2.r[7]+m1[10]*m2.r[8]);
    dest[11] = (m1[3]*m2.r[6]+m1[7]*m2.r[7]+m1[11]*m2.r[8]);

    dest[12] = m1[12];
    dest[13] = m1[13];
    dest[14] = m1[14];
    dest[15] = m1[15];
}

void ViewToModel ( )

inline

Definition at line 81 of file gl_matrix.cpp.

References GFX_SCALE, GFXMatrices::model, Matrix::p, Matrix::r, and GFXMatrices::view.

Referenced by GFXLoadIdentity(), GFXLoadMatrixModel(), GFXLoadMatrixView(), GFXMultMatrixModel(), GFXTranslateModel(), and GFXTranslateView().

{
    double t[16];
    t[0]  = model.r[0]*GFX_SCALE;     //possible performance hit?!?!
    t[1]  = model.r[1]*GFX_SCALE;
    t[2]  = model.r[2]*GFX_SCALE;
    t[3]  = 0;
    t[4]  = model.r[3]*GFX_SCALE;
    t[5]  = model.r[4]*GFX_SCALE;
    t[6]  = model.r[5]*GFX_SCALE;
    t[7]  = 0;
    t[8]  = model.r[6]*GFX_SCALE;
    t[9]  = model.r[7]*GFX_SCALE;
    t[10] = model.r[8]*GFX_SCALE;
    t[11] = 0;
    t[12] = (model.p.i-view.p.i)*GFX_SCALE;
    t[13] = (model.p.j-view.p.j)*GFX_SCALE;
    t[14] = (model.p.k-view.p.k)*GFX_SCALE;
    t[15] = 1;
    //MatrixToDoubles (t,model);
    glMatrixMode( GL_MODELVIEW );
    glLoadMatrixd( t );
}