You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2238 lines
75 KiB
2238 lines
75 KiB
/*
|
|
** Copyright 1991, Silicon Graphics, Inc.
|
|
** All Rights Reserved.
|
|
**
|
|
** This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, Inc.;
|
|
** the contents of this file may not be disclosed to third parties, copied or
|
|
** duplicated in any form, in whole or in part, without the prior written
|
|
** permission of Silicon Graphics, Inc.
|
|
**
|
|
** RESTRICTED RIGHTS LEGEND:
|
|
** Use, duplication or disclosure by the Government is subject to restrictions
|
|
** as set forth in subdivision (c)(1)(ii) of the Rights in Technical Data
|
|
** and Computer Software clause at DFARS 252.227-7013, and/or in similar or
|
|
** successor clauses in the FAR, DOD or NASA FAR Supplement. Unpublished -
|
|
** rights reserved under the Copyright Laws of the United States.
|
|
**
|
|
** Transformation procedures.
|
|
**
|
|
** $Revision: 1.38 $
|
|
** $Date: 1993/11/29 20:34:48 $
|
|
*/
|
|
#include "precomp.h"
|
|
#pragma hdrstop
|
|
|
|
#define __glGenericPickIdentityMatrixProcs(gc, m) \
|
|
{ \
|
|
(m)->xf1 = __glXForm1_2DNRW; \
|
|
(m)->xf2 = __glXForm2_2DNRW; \
|
|
(m)->xf3 = __glXForm3_2DNRW; \
|
|
(m)->xf4 = __glXForm4_2DNRW; \
|
|
(m)->xfNorm = __glXForm3_2DNRW; \
|
|
(m)->xf1Batch = __glXForm1_2DNRWBatch; \
|
|
(m)->xf2Batch = __glXForm2_2DNRWBatch; \
|
|
(m)->xf3Batch = __glXForm3_2DNRWBatch; \
|
|
(m)->xf4Batch = __glXForm4_2DNRWBatch; \
|
|
(m)->xfNormBatch = __glXForm3_2DNRWBatchNormal; \
|
|
(m)->xfNormBatchN = __glXForm3_2DNRWBatchNormalN; \
|
|
}
|
|
|
|
void FASTCALL __glScaleMatrix(__GLcontext *gc, __GLmatrix *m, void *data);
|
|
void FASTCALL __glTranslateMatrix(__GLcontext *gc, __GLmatrix *m, void *data);
|
|
void FASTCALL __glMultiplyMatrix(__GLcontext *gc, __GLmatrix *m, void *data);
|
|
|
|
// Bit flags that identify matrix entries that contain 0 or 1.
|
|
|
|
#define _M00_0 0x00000001
|
|
#define _M01_0 0x00000002
|
|
#define _M02_0 0x00000004
|
|
#define _M03_0 0x00000008
|
|
#define _M10_0 0x00000010
|
|
#define _M11_0 0x00000020
|
|
#define _M12_0 0x00000040
|
|
#define _M13_0 0x00000080
|
|
#define _M20_0 0x00000100
|
|
#define _M21_0 0x00000200
|
|
#define _M22_0 0x00000400
|
|
#define _M23_0 0x00000800
|
|
#define _M30_0 0x00001000
|
|
#define _M31_0 0x00002000
|
|
#define _M32_0 0x00004000
|
|
#define _M33_0 0x00008000
|
|
|
|
#define _M00_1 0x00010000
|
|
#define _M01_1 0x00020000
|
|
#define _M02_1 0x00040000
|
|
#define _M03_1 0x00080000
|
|
#define _M10_1 0x00100000
|
|
#define _M11_1 0x00200000
|
|
#define _M12_1 0x00400000
|
|
#define _M13_1 0x00800000
|
|
#define _M20_1 0x01000000
|
|
#define _M21_1 0x02000000
|
|
#define _M22_1 0x04000000
|
|
#define _M23_1 0x08000000
|
|
#define _M30_1 0x10000000
|
|
#define _M31_1 0x20000000
|
|
#define _M32_1 0x40000000
|
|
#define _M33_1 0x80000000
|
|
|
|
// Pre-defined matrix types.
|
|
#define _MT_IDENTITY \
|
|
(_M00_1 | _M01_0 | _M02_0 | _M03_0 | \
|
|
_M10_0 | _M11_1 | _M12_0 | _M13_0 | \
|
|
_M20_0 | _M21_0 | _M22_1 | _M23_0 | \
|
|
_M30_0 | _M31_0 | _M32_0 | _M33_1)
|
|
|
|
#define _MT_IS2DNR \
|
|
( _M01_0 | _M02_0 | _M03_0 | \
|
|
_M10_0 | _M12_0 | _M13_0 | \
|
|
_M20_0 | _M21_0 | _M23_0 | \
|
|
_M33_1)
|
|
|
|
#define _MT_IS2D \
|
|
( _M02_0 | _M03_0 | \
|
|
_M12_0 | _M13_0 | \
|
|
_M20_0 | _M21_0 | _M23_0 | \
|
|
_M33_1)
|
|
|
|
#define _MT_W0001 \
|
|
( _M03_0 | \
|
|
_M13_0 | \
|
|
_M23_0 | \
|
|
_M33_1)
|
|
|
|
#define GET_MATRIX_MASK(m,i,j) \
|
|
if ((m)->matrix[i][j] == zer) rowMask |= _M##i##j##_0; \
|
|
else if ((m)->matrix[i][j] == one) rowMask |= _M##i##j##_1;
|
|
|
|
// Note: If you are adding a new type, make sure all functions
|
|
// using matrixType are correct! (__glScaleMatrix, __glTranslateMatrix,
|
|
// __glInvertTransposeMatrix, and __glGenericPickVertexProcs)
|
|
|
|
void FASTCALL __glUpdateMatrixType(__GLmatrix *m)
|
|
{
|
|
register __GLfloat zer = __glZero;
|
|
register __GLfloat one = __glOne;
|
|
DWORD rowMask = 0; // identifies 0 and 1 entries
|
|
|
|
GET_MATRIX_MASK(m,0,0);
|
|
GET_MATRIX_MASK(m,0,1);
|
|
GET_MATRIX_MASK(m,0,2);
|
|
GET_MATRIX_MASK(m,0,3);
|
|
GET_MATRIX_MASK(m,1,0);
|
|
GET_MATRIX_MASK(m,1,1);
|
|
GET_MATRIX_MASK(m,1,2);
|
|
GET_MATRIX_MASK(m,1,3);
|
|
GET_MATRIX_MASK(m,2,0);
|
|
GET_MATRIX_MASK(m,2,1);
|
|
GET_MATRIX_MASK(m,2,2);
|
|
GET_MATRIX_MASK(m,2,3);
|
|
GET_MATRIX_MASK(m,3,0);
|
|
GET_MATRIX_MASK(m,3,1);
|
|
GET_MATRIX_MASK(m,3,2);
|
|
GET_MATRIX_MASK(m,3,3);
|
|
|
|
// Some common cases.
|
|
// Order of finding matrix type is important!
|
|
|
|
if ((rowMask & _MT_IDENTITY) == _MT_IDENTITY)
|
|
m->matrixType = __GL_MT_IDENTITY;
|
|
else if ((rowMask & _MT_IS2DNR) == _MT_IS2DNR)
|
|
m->matrixType = __GL_MT_IS2DNR;
|
|
else if ((rowMask & _MT_IS2D) == _MT_IS2D)
|
|
m->matrixType = __GL_MT_IS2D;
|
|
else if ((rowMask & _MT_W0001) == _MT_W0001)
|
|
m->matrixType = __GL_MT_W0001;
|
|
else
|
|
m->matrixType = __GL_MT_GENERAL;
|
|
}
|
|
|
|
static void SetDepthRange(__GLcontext *gc, double zNear, double zFar)
|
|
{
|
|
__GLviewport *vp = &gc->state.viewport;
|
|
double scale, zero = __glZero, one = __glOne;
|
|
|
|
/* Clamp depth range to legal values */
|
|
if (zNear < zero) zNear = zero;
|
|
if (zNear > one) zNear = one;
|
|
if (zFar < zero) zFar = zero;
|
|
if (zFar > one) zFar = one;
|
|
vp->zNear = zNear;
|
|
vp->zFar = zFar;
|
|
|
|
/* Compute viewport values for the new depth range */
|
|
if (((__GLGENcontext *)gc)->pMcdState)
|
|
scale = GENACCEL(gc).zDevScale * __glHalf;
|
|
else
|
|
scale = gc->depthBuffer.scale * __glHalf;
|
|
gc->state.viewport.zScale = (zFar - zNear) * scale;
|
|
gc->state.viewport.zCenter = (zFar + zNear) * scale;
|
|
|
|
#ifdef _MCD_
|
|
MCD_STATE_DIRTY(gc, VIEWPORT);
|
|
#endif
|
|
}
|
|
|
|
void FASTCALL __glInitTransformState(__GLcontext *gc)
|
|
{
|
|
GLint i, numClipPlanes, numClipTemp;
|
|
__GLtransform *tr;
|
|
__GLtransformP *ptr;
|
|
__GLtransformT *ttr;
|
|
__GLvertex *vx;
|
|
|
|
/* Allocate memory for clip planes */
|
|
numClipPlanes = gc->constants.numberOfClipPlanes;
|
|
numClipTemp = (numClipPlanes + 6) * 2;
|
|
|
|
gc->state.transform.eyeClipPlanes = (__GLcoord *)
|
|
GCALLOCZ(gc, 2 * numClipPlanes * sizeof(__GLcoord));
|
|
#ifdef NT
|
|
if (NULL == gc->state.transform.eyeClipPlanes)
|
|
return;
|
|
#endif
|
|
gc->state.transform.eyeClipPlanesSet =
|
|
gc->state.transform.eyeClipPlanes + numClipPlanes;
|
|
|
|
/* Allocate memory for matrix stacks */
|
|
gc->transform.modelViewStack = (__GLtransform*)
|
|
GCALLOCZ(gc, __GL_WGL_MAX_MODELVIEW_STACK_DEPTH*sizeof(__GLtransform));
|
|
#ifdef NT
|
|
if (NULL == gc->transform.modelViewStack)
|
|
return;
|
|
#endif
|
|
|
|
gc->transform.projectionStack = (__GLtransformP*)
|
|
GCALLOCZ(gc, __GL_WGL_MAX_PROJECTION_STACK_DEPTH*
|
|
sizeof(__GLtransformP));
|
|
#ifdef NT
|
|
if (NULL == gc->transform.projectionStack)
|
|
return;
|
|
#endif
|
|
|
|
gc->transform.textureStack = (__GLtransformT*)
|
|
GCALLOCZ(gc, __GL_WGL_MAX_TEXTURE_STACK_DEPTH*
|
|
sizeof(__GLtransformT));
|
|
#ifdef NT
|
|
if (NULL == gc->transform.textureStack)
|
|
return;
|
|
#endif
|
|
|
|
/* Allocate memory for clipping temporaries */
|
|
gc->transform.clipTemp = (__GLvertex*)
|
|
GCALLOCZ(gc, numClipTemp * sizeof(__GLvertex));
|
|
#ifdef NT
|
|
if (NULL == gc->transform.clipTemp)
|
|
return;
|
|
#endif
|
|
|
|
|
|
gc->state.transform.matrixMode = GL_MODELVIEW;
|
|
SetDepthRange(gc, __glZero, __glOne);
|
|
|
|
gc->transform.modelView = tr = &gc->transform.modelViewStack[0];
|
|
__glMakeIdentity(&tr->matrix);
|
|
__glGenericPickIdentityMatrixProcs(gc, &tr->matrix);
|
|
__glMakeIdentity(&tr->inverseTranspose);
|
|
__glGenericPickIdentityMatrixProcs(gc, &tr->inverseTranspose);
|
|
tr->flags = XFORM_CHANGED;
|
|
|
|
__glMakeIdentity(&tr->mvp);
|
|
gc->transform.projection = ptr = &gc->transform.projectionStack[0];
|
|
__glMakeIdentity((__GLmatrix *) &ptr->matrix);
|
|
__glGenericPickMvpMatrixProcs(gc, &tr->mvp);
|
|
|
|
gc->transform.texture = ttr = &gc->transform.textureStack[0];
|
|
__glMakeIdentity(&ttr->matrix);
|
|
__glGenericPickIdentityMatrixProcs(gc, &ttr->matrix);
|
|
|
|
vx = &gc->transform.clipTemp[0];
|
|
for (i = 0; i < numClipTemp; i++, vx++) {/*XXX*/
|
|
vx->color = &vx->colors[__GL_FRONTFACE];
|
|
}
|
|
|
|
gc->state.current.normal.z = __glOne;
|
|
}
|
|
|
|
/************************************************************************/
|
|
|
|
void APIPRIVATE __glim_MatrixMode(GLenum mode)
|
|
{
|
|
__GL_SETUP_NOT_IN_BEGIN();
|
|
|
|
switch (mode) {
|
|
case GL_MODELVIEW:
|
|
case GL_PROJECTION:
|
|
case GL_TEXTURE:
|
|
break;
|
|
default:
|
|
__glSetError(GL_INVALID_ENUM);
|
|
return;
|
|
}
|
|
gc->state.transform.matrixMode = mode;
|
|
}
|
|
|
|
void APIPRIVATE __glim_LoadIdentity(void)
|
|
{
|
|
__GL_SETUP_NOT_IN_BEGIN();
|
|
__glDoLoadMatrix(gc, NULL, TRUE);
|
|
}
|
|
|
|
void APIPRIVATE __glim_LoadMatrixf(const GLfloat m[16])
|
|
{
|
|
__GL_SETUP_NOT_IN_BEGIN();
|
|
__glDoLoadMatrix(gc, (__GLfloat (*)[4])m, FALSE);
|
|
}
|
|
|
|
void APIPRIVATE __glim_MultMatrixf(const GLfloat m[16])
|
|
{
|
|
__GL_SETUP_NOT_IN_BEGIN();
|
|
__glDoMultMatrix(gc, (void *) m, __glMultiplyMatrix);
|
|
}
|
|
|
|
void APIPRIVATE __glim_Rotatef(GLfloat angle, GLfloat ax, GLfloat ay, GLfloat az)
|
|
{
|
|
__GLmatrix m;
|
|
__GLfloat radians, sine, cosine, ab, bc, ca, t;
|
|
__GLfloat av[4], axis[4];
|
|
|
|
__GL_SETUP_NOT_IN_BEGIN();
|
|
|
|
av[0] = ax;
|
|
av[1] = ay;
|
|
av[2] = az;
|
|
av[3] = 0;
|
|
__glNormalize(axis, av);
|
|
|
|
radians = angle * __glDegreesToRadians;
|
|
sine = __GL_SINF(radians);
|
|
cosine = __GL_COSF(radians);
|
|
ab = axis[0] * axis[1] * (1 - cosine);
|
|
bc = axis[1] * axis[2] * (1 - cosine);
|
|
ca = axis[2] * axis[0] * (1 - cosine);
|
|
|
|
#ifdef NT
|
|
m.matrix[0][3] = __glZero;
|
|
m.matrix[1][3] = __glZero;
|
|
m.matrix[2][3] = __glZero;
|
|
m.matrix[3][0] = __glZero;
|
|
m.matrix[3][1] = __glZero;
|
|
m.matrix[3][2] = __glZero;
|
|
m.matrix[3][3] = __glOne;
|
|
#else
|
|
__glMakeIdentity(&m);
|
|
#endif // NT
|
|
t = axis[0] * axis[0];
|
|
m.matrix[0][0] = t + cosine * (1 - t);
|
|
m.matrix[2][1] = bc - axis[0] * sine;
|
|
m.matrix[1][2] = bc + axis[0] * sine;
|
|
|
|
t = axis[1] * axis[1];
|
|
m.matrix[1][1] = t + cosine * (1 - t);
|
|
m.matrix[2][0] = ca + axis[1] * sine;
|
|
m.matrix[0][2] = ca - axis[1] * sine;
|
|
|
|
t = axis[2] * axis[2];
|
|
m.matrix[2][2] = t + cosine * (1 - t);
|
|
m.matrix[1][0] = ab - axis[2] * sine;
|
|
m.matrix[0][1] = ab + axis[2] * sine;
|
|
__glDoMultMatrix(gc, &m, __glMultiplyMatrix);
|
|
}
|
|
|
|
struct __glScaleRec {
|
|
__GLfloat x,y,z;
|
|
};
|
|
|
|
void APIPRIVATE __glim_Scalef(GLfloat x, GLfloat y, GLfloat z)
|
|
{
|
|
struct __glScaleRec scale;
|
|
__GL_SETUP_NOT_IN_BEGIN();
|
|
|
|
scale.x = x;
|
|
scale.y = y;
|
|
scale.z = z;
|
|
__glDoMultMatrix(gc, &scale, __glScaleMatrix);
|
|
}
|
|
|
|
struct __glTranslationRec {
|
|
__GLfloat x,y,z;
|
|
};
|
|
|
|
void APIPRIVATE __glim_Translatef(GLfloat x, GLfloat y, GLfloat z)
|
|
{
|
|
struct __glTranslationRec trans;
|
|
__GL_SETUP_NOT_IN_BEGIN();
|
|
|
|
trans.x = x;
|
|
trans.y = y;
|
|
trans.z = z;
|
|
__glDoMultMatrix(gc, &trans, __glTranslateMatrix);
|
|
}
|
|
|
|
void APIPRIVATE __glim_PushMatrix(void)
|
|
{
|
|
#ifdef NT
|
|
__GL_SETUP_NOT_IN_BEGIN(); // no need to validate
|
|
switch (gc->state.transform.matrixMode)
|
|
{
|
|
case GL_MODELVIEW:
|
|
__glPushModelViewMatrix(gc);
|
|
break;
|
|
case GL_PROJECTION:
|
|
__glPushProjectionMatrix(gc);
|
|
break;
|
|
case GL_TEXTURE:
|
|
__glPushTextureMatrix(gc);
|
|
break;
|
|
}
|
|
#else
|
|
__GL_SETUP_NOT_IN_BEGIN_VALIDATE();
|
|
(*gc->procs.pushMatrix)(gc);
|
|
#endif
|
|
}
|
|
|
|
void APIPRIVATE __glim_PopMatrix(void)
|
|
{
|
|
#ifdef NT
|
|
__GL_SETUP_NOT_IN_BEGIN(); // no need to validate
|
|
switch (gc->state.transform.matrixMode)
|
|
{
|
|
case GL_MODELVIEW:
|
|
__glPopModelViewMatrix(gc);
|
|
break;
|
|
case GL_PROJECTION:
|
|
__glPopProjectionMatrix(gc);
|
|
break;
|
|
case GL_TEXTURE:
|
|
__glPopTextureMatrix(gc);
|
|
break;
|
|
}
|
|
#else
|
|
__GL_SETUP_NOT_IN_BEGIN_VALIDATE();
|
|
(*gc->procs.popMatrix)(gc);
|
|
#endif
|
|
}
|
|
|
|
void APIPRIVATE __glim_Frustum(GLdouble left, GLdouble right,
|
|
GLdouble bottom, GLdouble top,
|
|
GLdouble zNear, GLdouble zFar)
|
|
{
|
|
__GLmatrix m;
|
|
__GLfloat deltaX, deltaY, deltaZ;
|
|
__GL_SETUP_NOT_IN_BEGIN();
|
|
|
|
deltaX = right - left;
|
|
deltaY = top - bottom;
|
|
deltaZ = zFar - zNear;
|
|
if ((zNear <= (GLdouble) __glZero) || (zFar <= (GLdouble) __glZero) || (deltaX == __glZero) ||
|
|
(deltaY == __glZero) || (deltaZ == __glZero)) {
|
|
__glSetError(GL_INVALID_VALUE);
|
|
return;
|
|
}
|
|
|
|
#ifdef NT
|
|
m.matrix[0][1] = __glZero;
|
|
m.matrix[0][2] = __glZero;
|
|
m.matrix[0][3] = __glZero;
|
|
m.matrix[1][0] = __glZero;
|
|
m.matrix[1][2] = __glZero;
|
|
m.matrix[1][3] = __glZero;
|
|
m.matrix[3][0] = __glZero;
|
|
m.matrix[3][1] = __glZero;
|
|
#else
|
|
__glMakeIdentity(&m);
|
|
#endif
|
|
m.matrix[0][0] = zNear * __glDoubleTwo / deltaX;
|
|
m.matrix[1][1] = zNear * __glDoubleTwo / deltaY;
|
|
m.matrix[2][0] = (right + left) / deltaX;
|
|
m.matrix[2][1] = (top + bottom) / deltaY;
|
|
m.matrix[2][2] = -(zFar + zNear) / deltaZ;
|
|
m.matrix[2][3] = __glMinusOne;
|
|
m.matrix[3][2] = __glDoubleMinusTwo * zNear * zFar / deltaZ;
|
|
m.matrix[3][3] = __glZero;
|
|
__glDoMultMatrix(gc, &m, __glMultiplyMatrix);
|
|
}
|
|
|
|
void APIPRIVATE __glim_Ortho(GLdouble left, GLdouble right, GLdouble bottom,
|
|
GLdouble top, GLdouble zNear, GLdouble zFar)
|
|
{
|
|
__GLmatrix m;
|
|
GLdouble deltax, deltay, deltaz;
|
|
__GL_SETUP_NOT_IN_BEGIN();
|
|
|
|
deltax = right - left;
|
|
deltay = top - bottom;
|
|
deltaz = zFar - zNear;
|
|
if ((deltax == (GLdouble) __glZero) || (deltay == (GLdouble) __glZero) || (deltaz == (GLdouble) __glZero)) {
|
|
__glSetError(GL_INVALID_VALUE);
|
|
return;
|
|
}
|
|
|
|
#ifdef NT
|
|
m.matrix[0][1] = __glZero;
|
|
m.matrix[0][2] = __glZero;
|
|
m.matrix[0][3] = __glZero;
|
|
m.matrix[1][0] = __glZero;
|
|
m.matrix[1][2] = __glZero;
|
|
m.matrix[1][3] = __glZero;
|
|
m.matrix[2][0] = __glZero;
|
|
m.matrix[2][1] = __glZero;
|
|
m.matrix[2][3] = __glZero;
|
|
m.matrix[3][3] = __glOne;
|
|
#else
|
|
__glMakeIdentity(&m);
|
|
#endif
|
|
m.matrix[0][0] = __glDoubleTwo / deltax;
|
|
m.matrix[3][0] = -(right + left) / deltax;
|
|
m.matrix[1][1] = __glDoubleTwo / deltay;
|
|
m.matrix[3][1] = -(top + bottom) / deltay;
|
|
m.matrix[2][2] = __glDoubleMinusTwo / deltaz;
|
|
m.matrix[3][2] = -(zFar + zNear) / deltaz;
|
|
|
|
__glDoMultMatrix(gc, &m, __glMultiplyMatrix);
|
|
}
|
|
|
|
void FASTCALL __glUpdateViewport(__GLcontext *gc)
|
|
{
|
|
__GLfloat ww, hh, w2, h2;
|
|
|
|
/* Compute operational viewport values */
|
|
w2 = gc->state.viewport.width * __glHalf;
|
|
h2 = gc->state.viewport.height * __glHalf;
|
|
ww = w2 - gc->constants.viewportEpsilon;
|
|
hh = h2 - gc->constants.viewportEpsilon;
|
|
gc->state.viewport.xScale = ww;
|
|
gc->state.viewport.xCenter = gc->state.viewport.x + w2 +
|
|
gc->constants.fviewportXAdjust;
|
|
if (gc->constants.yInverted) {
|
|
gc->state.viewport.yScale = -hh;
|
|
gc->state.viewport.yCenter =
|
|
gc->constants.height - (gc->state.viewport.y + h2) +
|
|
gc->constants.fviewportYAdjust;
|
|
|
|
#if 0
|
|
DbgPrint("UV ys %.3lf, yc %.3lf (%.3lf)\n",
|
|
-hh, gc->state.viewport.yCenter,
|
|
gc->constants.height - (gc->state.viewport.y + h2));
|
|
#endif
|
|
} else {
|
|
gc->state.viewport.yScale = hh;
|
|
gc->state.viewport.yCenter = gc->state.viewport.y + h2 +
|
|
gc->constants.fviewportYAdjust;
|
|
}
|
|
}
|
|
|
|
void FASTCALL __glUpdateViewportDependents(__GLcontext *gc)
|
|
{
|
|
/*
|
|
** Now that the implementation may have found us a new window size,
|
|
** we compute these offsets...
|
|
*/
|
|
gc->transform.minx = gc->state.viewport.x + gc->constants.viewportXAdjust;
|
|
gc->transform.maxx = gc->transform.minx + gc->state.viewport.width;
|
|
gc->transform.fminx = gc->transform.minx;
|
|
gc->transform.fmaxx = gc->transform.maxx;
|
|
|
|
gc->transform.miny =
|
|
(gc->constants.height -
|
|
(gc->state.viewport.y + gc->state.viewport.height)) +
|
|
gc->constants.viewportYAdjust;
|
|
gc->transform.maxy = gc->transform.miny + gc->state.viewport.height;
|
|
gc->transform.fminy = gc->transform.miny;
|
|
gc->transform.fmaxy = gc->transform.maxy;
|
|
}
|
|
|
|
void APIPRIVATE __glim_Viewport(GLint x, GLint y, GLsizei w, GLsizei h)
|
|
{
|
|
__GLfloat ww, hh;
|
|
__GL_SETUP_NOT_IN_BEGIN();
|
|
|
|
if ((w < 0) || (h < 0)) {
|
|
__glSetError(GL_INVALID_VALUE);
|
|
return;
|
|
}
|
|
|
|
if ((gc->state.viewport.x == x) && (gc->state.viewport.y == y) &&
|
|
(gc->state.viewport.width == w) && (gc->state.viewport.height == h))
|
|
return;
|
|
|
|
if (h > gc->constants.maxViewportHeight) {
|
|
h = gc->constants.maxViewportHeight;
|
|
}
|
|
if (w > gc->constants.maxViewportWidth) {
|
|
w = gc->constants.maxViewportWidth;
|
|
}
|
|
|
|
gc->state.viewport.x = x;
|
|
gc->state.viewport.y = y;
|
|
gc->state.viewport.width = w;
|
|
gc->state.viewport.height = h;
|
|
|
|
__glUpdateViewport(gc);
|
|
|
|
(*gc->procs.applyViewport)(gc);
|
|
|
|
__glUpdateViewportDependents(gc);
|
|
|
|
/*
|
|
** Pickers that notice when the transformation matches the viewport
|
|
** exactly need to be revalidated. Ugh.
|
|
*/
|
|
__GL_DELAY_VALIDATE(gc);
|
|
}
|
|
|
|
void APIPRIVATE __glim_DepthRange(GLdouble zNear, GLdouble zFar)
|
|
{
|
|
__GL_SETUP_NOT_IN_BEGIN();
|
|
|
|
SetDepthRange(gc, zNear, zFar);
|
|
__GL_DELAY_VALIDATE_MASK(gc, __GL_DIRTY_DEPTH);
|
|
}
|
|
|
|
void APIPRIVATE __glim_Scissor(GLint x, GLint y, GLsizei w, GLsizei h)
|
|
{
|
|
__GL_SETUP_NOT_IN_BEGIN();
|
|
|
|
if ((w < 0) || (h < 0)) {
|
|
__glSetError(GL_INVALID_VALUE);
|
|
return;
|
|
}
|
|
|
|
gc->state.scissor.scissorX = x;
|
|
gc->state.scissor.scissorY = y;
|
|
gc->state.scissor.scissorWidth = w;
|
|
gc->state.scissor.scissorHeight = h;
|
|
|
|
#ifdef NT
|
|
#ifdef _MCD_
|
|
MCD_STATE_DIRTY(gc, SCISSOR);
|
|
#endif
|
|
|
|
// applyViewport does both
|
|
(*gc->procs.applyViewport)(gc);
|
|
#else
|
|
(*gc->procs.applyScissor)(gc);
|
|
(*gc->procs.computeClipBox)(gc);
|
|
#endif
|
|
}
|
|
|
|
void APIPRIVATE __glim_ClipPlane(GLenum pi, const GLdouble pv[])
|
|
{
|
|
__GLtransform *tr;
|
|
__GL_SETUP_NOT_IN_BEGIN();
|
|
|
|
pi -= GL_CLIP_PLANE0;
|
|
#ifdef NT
|
|
// pi is unsigned!
|
|
if (pi >= (GLenum) gc->constants.numberOfClipPlanes) {
|
|
#else
|
|
if ((pi < 0) || (pi >= gc->constants.numberOfClipPlanes)) {
|
|
#endif // NT
|
|
__glSetError(GL_INVALID_ENUM);
|
|
return;
|
|
}
|
|
|
|
gc->state.transform.eyeClipPlanesSet[pi].x = pv[0];
|
|
gc->state.transform.eyeClipPlanesSet[pi].y = pv[1];
|
|
gc->state.transform.eyeClipPlanesSet[pi].z = pv[2];
|
|
gc->state.transform.eyeClipPlanesSet[pi].w = pv[3];
|
|
|
|
/*
|
|
** Project user clip plane into eye space.
|
|
*/
|
|
tr = gc->transform.modelView;
|
|
if (tr->flags & XFORM_UPDATE_INVERSE) {
|
|
__glComputeInverseTranspose(gc, tr);
|
|
}
|
|
(*tr->inverseTranspose.xf4)(&gc->state.transform.eyeClipPlanes[pi],
|
|
&gc->state.transform.eyeClipPlanesSet[pi].x,
|
|
&tr->inverseTranspose);
|
|
|
|
__GL_DELAY_VALIDATE(gc);
|
|
#ifdef _MCD_
|
|
MCD_STATE_DIRTY(gc, CLIPCTRL);
|
|
#endif
|
|
}
|
|
|
|
/************************************************************************/
|
|
|
|
void FASTCALL __glPushModelViewMatrix(__GLcontext *gc)
|
|
{
|
|
__GLtransform **trp, *tr, *stack;
|
|
|
|
trp = &gc->transform.modelView;
|
|
stack = gc->transform.modelViewStack;
|
|
tr = *trp;
|
|
if (tr < &stack[__GL_WGL_MAX_MODELVIEW_STACK_DEPTH-1]) {
|
|
tr[1] = tr[0];
|
|
*trp = tr + 1;
|
|
} else {
|
|
__glSetError(GL_STACK_OVERFLOW);
|
|
}
|
|
}
|
|
|
|
void FASTCALL __glPopModelViewMatrix(__GLcontext *gc)
|
|
{
|
|
__GLtransform **trp, *tr, *stack, *mvtr;
|
|
__GLtransformP *ptr;
|
|
|
|
trp = &gc->transform.modelView;
|
|
stack = gc->transform.modelViewStack;
|
|
tr = *trp;
|
|
if (tr > &stack[0]) {
|
|
*trp = tr - 1;
|
|
|
|
/*
|
|
** See if sequence number of modelView matrix is the same as the
|
|
** sequence number of the projection matrix. If not, then
|
|
** recompute the mvp matrix.
|
|
*/
|
|
mvtr = gc->transform.modelView;
|
|
ptr = gc->transform.projection;
|
|
if (mvtr->sequence != ptr->sequence) {
|
|
mvtr->sequence = ptr->sequence;
|
|
__glMultMatrix(&mvtr->mvp, &mvtr->matrix, (__GLmatrix *) &ptr->matrix);
|
|
__glUpdateMatrixType(&mvtr->mvp);
|
|
}
|
|
__glGenericPickMvpMatrixProcs(gc, &mvtr->mvp);
|
|
} else {
|
|
__glSetError(GL_STACK_UNDERFLOW);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void FASTCALL __glComputeInverseTranspose(__GLcontext *gc, __GLtransform *tr)
|
|
{
|
|
__GLmatrix inv;
|
|
|
|
__glInvertTransposeMatrix(&tr->inverseTranspose, &tr->matrix);
|
|
__glUpdateMatrixType(&tr->inverseTranspose);
|
|
__glGenericPickMatrixProcs(gc, &tr->inverseTranspose);
|
|
tr->flags &= ~XFORM_UPDATE_INVERSE;
|
|
}
|
|
|
|
/************************************************************************/
|
|
|
|
void FASTCALL __glPushProjectionMatrix(__GLcontext *gc)
|
|
{
|
|
__GLtransformP **trp, *tr, *stack;
|
|
|
|
trp = &gc->transform.projection;
|
|
stack = gc->transform.projectionStack;
|
|
tr = *trp;
|
|
if (tr < &stack[__GL_WGL_MAX_PROJECTION_STACK_DEPTH-1]) {
|
|
tr[1] = tr[0];
|
|
*trp = tr + 1;
|
|
} else {
|
|
__glSetError(GL_STACK_OVERFLOW);
|
|
}
|
|
}
|
|
|
|
void FASTCALL __glPopProjectionMatrix(__GLcontext *gc)
|
|
{
|
|
__GLtransform *mvtr;
|
|
__GLtransformP **trp, *tr, *stack, *ptr;
|
|
|
|
trp = &gc->transform.projection;
|
|
stack = gc->transform.projectionStack;
|
|
tr = *trp;
|
|
if (tr > &stack[0]) {
|
|
*trp = tr - 1;
|
|
|
|
/*
|
|
** See if sequence number of modelView matrix is the same as the
|
|
** sequence number of the projection matrix. If not, then
|
|
** recompute the mvp matrix.
|
|
*/
|
|
mvtr = gc->transform.modelView;
|
|
ptr = gc->transform.projection;
|
|
if (mvtr->sequence != ptr->sequence) {
|
|
mvtr->sequence = ptr->sequence;
|
|
__glMultMatrix(&mvtr->mvp, &mvtr->matrix, (__GLmatrix *) &ptr->matrix);
|
|
__glUpdateMatrixType(&mvtr->mvp);
|
|
}
|
|
__glGenericPickMvpMatrixProcs(gc, &mvtr->mvp);
|
|
} else {
|
|
__glSetError(GL_STACK_UNDERFLOW);
|
|
return;
|
|
}
|
|
}
|
|
|
|
/************************************************************************/
|
|
|
|
void FASTCALL __glPushTextureMatrix(__GLcontext *gc)
|
|
{
|
|
__GLtransformT **trp, *tr, *stack;
|
|
|
|
trp = &gc->transform.texture;
|
|
stack = gc->transform.textureStack;
|
|
tr = *trp;
|
|
if (tr < &stack[__GL_WGL_MAX_TEXTURE_STACK_DEPTH-1]) {
|
|
tr[1] = tr[0];
|
|
*trp = tr + 1;
|
|
} else {
|
|
__glSetError(GL_STACK_OVERFLOW);
|
|
}
|
|
}
|
|
|
|
void FASTCALL __glPopTextureMatrix(__GLcontext *gc)
|
|
{
|
|
__GLtransformT **trp, *tr, *stack;
|
|
|
|
trp = &gc->transform.texture;
|
|
stack = gc->transform.textureStack;
|
|
tr = *trp;
|
|
if (tr > &stack[0]) {
|
|
*trp = tr - 1;
|
|
MCD_STATE_DIRTY(gc, TEXTRANSFORM);
|
|
} else {
|
|
__glSetError(GL_STACK_UNDERFLOW);
|
|
return;
|
|
}
|
|
}
|
|
|
|
/************************************************************************/
|
|
|
|
|
|
void FASTCALL __glDoLoadMatrix(__GLcontext *gc, const __GLfloat m[4][4], BOOL bIsIdentity)
|
|
{
|
|
__GLtransform *mvtr;
|
|
__GLtransformP *ptr;
|
|
__GLtransformT *ttr;
|
|
|
|
switch (gc->state.transform.matrixMode) {
|
|
case GL_MODELVIEW:
|
|
mvtr = gc->transform.modelView;
|
|
if (bIsIdentity)
|
|
{
|
|
__glMakeIdentity(&mvtr->matrix);
|
|
__glGenericPickIdentityMatrixProcs(gc, &mvtr->matrix);
|
|
__glMakeIdentity(&mvtr->inverseTranspose);
|
|
__glGenericPickIdentityMatrixProcs(gc, &mvtr->inverseTranspose);
|
|
mvtr->flags = XFORM_CHANGED;
|
|
}
|
|
else
|
|
{
|
|
*(__GLmatrixBase *)mvtr->matrix.matrix = *(__GLmatrixBase *)m;
|
|
__glUpdateMatrixType(&mvtr->matrix);
|
|
__glGenericPickMatrixProcs(gc, &mvtr->matrix);
|
|
mvtr->flags = XFORM_CHANGED | XFORM_UPDATE_INVERSE;
|
|
}
|
|
|
|
/* Update mvp matrix */
|
|
ptr = gc->transform.projection;
|
|
ASSERTOPENGL(mvtr->sequence == ptr->sequence,
|
|
"__glDoLoadMatrix: bad projection sequence\n");
|
|
if (bIsIdentity)
|
|
{
|
|
*(__GLmatrixBase *)mvtr->mvp.matrix = *(__GLmatrixBase *)ptr->matrix.matrix;
|
|
mvtr->mvp.matrixType = ptr->matrix.matrixType;
|
|
}
|
|
else
|
|
{
|
|
__glMultMatrix(&mvtr->mvp, &mvtr->matrix, (__GLmatrix *) &ptr->matrix);
|
|
__glUpdateMatrixType(&mvtr->mvp);
|
|
}
|
|
__glGenericPickMvpMatrixProcs(gc, &mvtr->mvp);
|
|
break;
|
|
|
|
case GL_PROJECTION:
|
|
ptr = gc->transform.projection;
|
|
if (bIsIdentity)
|
|
{
|
|
__glMakeIdentity((__GLmatrix *) &ptr->matrix);
|
|
}
|
|
else
|
|
{
|
|
*(__GLmatrixBase *)ptr->matrix.matrix = *(__GLmatrixBase *)m;
|
|
__glUpdateMatrixType((__GLmatrix *) &ptr->matrix);
|
|
}
|
|
|
|
#ifdef NT
|
|
ptr->sequence = ++gc->transform.projectionSequence;
|
|
#else
|
|
if (++gc->transform.projectionSequence == 0) {
|
|
__glInvalidateSequenceNumbers(gc);
|
|
} else {
|
|
ptr->sequence = gc->transform.projectionSequence;
|
|
}
|
|
#endif // NT
|
|
|
|
/* Update mvp matrix */
|
|
mvtr = gc->transform.modelView;
|
|
mvtr->sequence = ptr->sequence;
|
|
mvtr->flags |= XFORM_CHANGED;
|
|
if (bIsIdentity)
|
|
{
|
|
*(__GLmatrixBase *)mvtr->mvp.matrix = *(__GLmatrixBase *)mvtr->matrix.matrix;
|
|
mvtr->mvp.matrixType = mvtr->matrix.matrixType;
|
|
}
|
|
else
|
|
{
|
|
__glMultMatrix(&mvtr->mvp, &mvtr->matrix, (__GLmatrix *) &ptr->matrix);
|
|
__glUpdateMatrixType(&mvtr->mvp);
|
|
}
|
|
__glGenericPickMvpMatrixProcs(gc, &mvtr->mvp);
|
|
break;
|
|
|
|
case GL_TEXTURE:
|
|
ttr = gc->transform.texture;
|
|
if (bIsIdentity)
|
|
{
|
|
__glMakeIdentity(&ttr->matrix);
|
|
__glGenericPickIdentityMatrixProcs(gc, &ttr->matrix);
|
|
}
|
|
else
|
|
{
|
|
*(__GLmatrixBase *)ttr->matrix.matrix = *(__GLmatrixBase *)m;
|
|
__glUpdateMatrixType(&ttr->matrix);
|
|
__glGenericPickMatrixProcs(gc, &ttr->matrix);
|
|
}
|
|
MCD_STATE_DIRTY(gc, TEXTRANSFORM);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void FASTCALL __glDoMultMatrix(__GLcontext *gc, void *data,
|
|
void (FASTCALL *multiply)(__GLcontext *gc, __GLmatrix *m, void *data))
|
|
{
|
|
__GLtransform *mvtr;
|
|
__GLtransformT *ttr;
|
|
__GLtransformP *ptr;
|
|
|
|
switch (gc->state.transform.matrixMode) {
|
|
case GL_MODELVIEW:
|
|
mvtr = gc->transform.modelView;
|
|
(*multiply)(gc, &mvtr->matrix, data);
|
|
mvtr->flags = XFORM_CHANGED | XFORM_UPDATE_INVERSE;
|
|
__glGenericPickMatrixProcs(gc, &mvtr->matrix);
|
|
|
|
/* Update mvp matrix */
|
|
ASSERTOPENGL(mvtr->sequence == gc->transform.projection->sequence,
|
|
"__glDoMultMatrix: bad projection sequence\n");
|
|
(*multiply)(gc, &mvtr->mvp, data);
|
|
__glGenericPickMvpMatrixProcs(gc, &mvtr->mvp);
|
|
break;
|
|
|
|
case GL_PROJECTION:
|
|
ptr = gc->transform.projection;
|
|
(*multiply)(gc, (__GLmatrix *) &ptr->matrix, data);
|
|
#ifdef NT
|
|
ptr->sequence = ++gc->transform.projectionSequence;
|
|
#else
|
|
if (++gc->transform.projectionSequence == 0) {
|
|
__glInvalidateSequenceNumbers(gc);
|
|
} else {
|
|
ptr->sequence = gc->transform.projectionSequence;
|
|
}
|
|
#endif
|
|
|
|
/* Update mvp matrix */
|
|
mvtr = gc->transform.modelView;
|
|
mvtr->sequence = ptr->sequence;
|
|
mvtr->flags |= XFORM_CHANGED;
|
|
__glMultMatrix(&mvtr->mvp, &mvtr->matrix, (__GLmatrix *) &ptr->matrix);
|
|
__glUpdateMatrixType(&mvtr->mvp);
|
|
__glGenericPickMvpMatrixProcs(gc, &mvtr->mvp);
|
|
break;
|
|
|
|
case GL_TEXTURE:
|
|
ttr = gc->transform.texture;
|
|
(*multiply)(gc, &ttr->matrix, data);
|
|
__glGenericPickMatrixProcs(gc, &ttr->matrix);
|
|
MCD_STATE_DIRTY(gc, TEXTRANSFORM);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/************************************************************************/
|
|
|
|
/*
|
|
** Muliply the first matrix by the second one keeping track of the matrix
|
|
** type of the newly combined matrix.
|
|
*/
|
|
void FASTCALL __glMultiplyMatrix(__GLcontext *gc, __GLmatrix *m, void *data)
|
|
{
|
|
__GLmatrix *tm;
|
|
|
|
tm = data;
|
|
__glMultMatrix(m, tm, m);
|
|
__glUpdateMatrixType(m);
|
|
}
|
|
|
|
void FASTCALL __glScaleMatrix(__GLcontext *gc, __GLmatrix *m, void *data)
|
|
{
|
|
struct __glScaleRec *scale;
|
|
__GLfloat x,y,z;
|
|
__GLfloat M0, M1, M2, M3;
|
|
|
|
if (m->matrixType > __GL_MT_IS2DNR) {
|
|
m->matrixType = __GL_MT_IS2DNR;
|
|
}
|
|
scale = data;
|
|
x = scale->x;
|
|
y = scale->y;
|
|
z = scale->z;
|
|
|
|
M0 = x * m->matrix[0][0];
|
|
M1 = x * m->matrix[0][1];
|
|
M2 = x * m->matrix[0][2];
|
|
M3 = x * m->matrix[0][3];
|
|
m->matrix[0][0] = M0;
|
|
m->matrix[0][1] = M1;
|
|
m->matrix[0][2] = M2;
|
|
m->matrix[0][3] = M3;
|
|
|
|
M0 = y * m->matrix[1][0];
|
|
M1 = y * m->matrix[1][1];
|
|
M2 = y * m->matrix[1][2];
|
|
M3 = y * m->matrix[1][3];
|
|
m->matrix[1][0] = M0;
|
|
m->matrix[1][1] = M1;
|
|
m->matrix[1][2] = M2;
|
|
m->matrix[1][3] = M3;
|
|
|
|
M0 = z * m->matrix[2][0];
|
|
M1 = z * m->matrix[2][1];
|
|
M2 = z * m->matrix[2][2];
|
|
M3 = z * m->matrix[2][3];
|
|
m->matrix[2][0] = M0;
|
|
m->matrix[2][1] = M1;
|
|
m->matrix[2][2] = M2;
|
|
m->matrix[2][3] = M3;
|
|
}
|
|
|
|
/*
|
|
** Matrix type of m stays the same.
|
|
*/
|
|
void FASTCALL __glTranslateMatrix(__GLcontext *gc, __GLmatrix *m, void *data)
|
|
{
|
|
struct __glTranslationRec *trans;
|
|
__GLfloat x,y,z;
|
|
__GLfloat M30, M31, M32, M33;
|
|
|
|
if (m->matrixType > __GL_MT_IS2DNR) {
|
|
m->matrixType = __GL_MT_IS2DNR;
|
|
}
|
|
trans = data;
|
|
x = trans->x;
|
|
y = trans->y;
|
|
z = trans->z;
|
|
M30 = x * m->matrix[0][0] + y * m->matrix[1][0] + z * m->matrix[2][0] +
|
|
m->matrix[3][0];
|
|
M31 = x * m->matrix[0][1] + y * m->matrix[1][1] + z * m->matrix[2][1] +
|
|
m->matrix[3][1];
|
|
M32 = x * m->matrix[0][2] + y * m->matrix[1][2] + z * m->matrix[2][2] +
|
|
m->matrix[3][2];
|
|
M33 = x * m->matrix[0][3] + y * m->matrix[1][3] + z * m->matrix[2][3] +
|
|
m->matrix[3][3];
|
|
m->matrix[3][0] = M30;
|
|
m->matrix[3][1] = M31;
|
|
m->matrix[3][2] = M32;
|
|
m->matrix[3][3] = M33;
|
|
}
|
|
|
|
/************************************************************************/
|
|
|
|
#define __GLXFORM1_INIT(v) \
|
|
__GLfloat x = (v)[0]; \
|
|
__GLfloat mat00, mat01, mat02, mat03; \
|
|
__GLfloat mat30, mat31, mat32, mat33; \
|
|
__GLfloat a0, a1, a2, a3; \
|
|
\
|
|
mat00 = m->matrix[0][0]; \
|
|
mat01 = m->matrix[0][1]; \
|
|
mat02 = m->matrix[0][2]; \
|
|
mat03 = m->matrix[0][3]; \
|
|
\
|
|
mat30 = m->matrix[3][0]; \
|
|
mat31 = m->matrix[3][1]; \
|
|
mat32 = m->matrix[3][2]; \
|
|
mat33 = m->matrix[3][3];
|
|
|
|
#define __GLXFORM1_CONT(v) \
|
|
x = (v)[0];
|
|
|
|
#define __GLXFORM1(res) \
|
|
a0 = x * mat00; \
|
|
a1 = x * mat01; \
|
|
a2 = x * mat02; \
|
|
a3 = x * mat03; \
|
|
\
|
|
res->x = a0 + mat30; \
|
|
res->y = a1 + mat31; \
|
|
res->z = a2 + mat32; \
|
|
res->w = a3 + mat33;
|
|
|
|
|
|
#define __GLXFORM1_W_INIT(v) \
|
|
__GLfloat x = (v)[0]; \
|
|
__GLfloat mat00, mat01, mat02; \
|
|
__GLfloat mat30, mat31, mat32; \
|
|
__GLfloat a0, a1, a2; \
|
|
\
|
|
mat00 = m->matrix[0][0]; \
|
|
mat01 = m->matrix[0][1]; \
|
|
mat02 = m->matrix[0][2]; \
|
|
\
|
|
mat30 = m->matrix[3][0]; \
|
|
mat31 = m->matrix[3][1]; \
|
|
mat32 = m->matrix[3][2];
|
|
|
|
#define __GLXFORM1_W(res) \
|
|
a0 = x * mat00; \
|
|
a1 = x * mat01; \
|
|
a2 = x * mat02; \
|
|
\
|
|
res->x = a0 + mat30; \
|
|
res->y = a1 + mat31; \
|
|
res->z = a2 + mat32; \
|
|
res->w = ((__GLfloat) 1.0);
|
|
|
|
|
|
#define __GLXFORM1_2DW_INIT(v) \
|
|
__GLfloat x = (v)[0]; \
|
|
__GLfloat mat00, mat01; \
|
|
__GLfloat mat30, mat31, mat32; \
|
|
__GLfloat a0, a1; \
|
|
\
|
|
mat00 = m->matrix[0][0]; \
|
|
mat01 = m->matrix[0][1]; \
|
|
\
|
|
mat30 = m->matrix[3][0]; \
|
|
mat31 = m->matrix[3][1]; \
|
|
\
|
|
mat32 = m->matrix[3][2];
|
|
|
|
|
|
|
|
#define __GLXFORM1_2DW(res) \
|
|
a0 = x * mat00; \
|
|
a1 = x * mat01; \
|
|
\
|
|
res->x = a0 + mat30; \
|
|
res->y = a1 + mat31; \
|
|
res->z = mat32; \
|
|
res->w = ((__GLfloat) 1.0);
|
|
|
|
|
|
#define __GLXFORM1_2DNRW_INIT(v) \
|
|
__GLfloat x = (v)[0]; \
|
|
__GLfloat mat00, mat01; \
|
|
__GLfloat mat30, mat31, mat32; \
|
|
__GLfloat a0; \
|
|
\
|
|
mat00 = m->matrix[0][0]; \
|
|
mat01 = m->matrix[0][1]; \
|
|
\
|
|
mat30 = m->matrix[3][0]; \
|
|
mat31 = m->matrix[3][1]; \
|
|
\
|
|
mat32 = m->matrix[3][2];
|
|
|
|
|
|
#define __GLXFORM1_2DNRW(res) \
|
|
a0 = x * mat00; \
|
|
\
|
|
res->x = a0 + mat30; \
|
|
res->y = mat31; \
|
|
res->z = mat32; \
|
|
res->w = ((__GLfloat) 1.0);
|
|
|
|
|
|
#define __GLXFORM2_INIT(v) \
|
|
__GLfloat x = (v)[0]; \
|
|
__GLfloat y = (v)[1]; \
|
|
__GLfloat mat00, mat01, mat02, mat03; \
|
|
__GLfloat mat10, mat11, mat12, mat13; \
|
|
__GLfloat mat30, mat31, mat32, mat33; \
|
|
__GLfloat a0, a1, a2, a3; \
|
|
__GLfloat b0, b1, b2, b3; \
|
|
\
|
|
mat00 = m->matrix[0][0]; \
|
|
mat01 = m->matrix[0][1]; \
|
|
mat02 = m->matrix[0][2]; \
|
|
mat03 = m->matrix[0][3]; \
|
|
\
|
|
mat10 = m->matrix[1][0]; \
|
|
mat11 = m->matrix[1][1]; \
|
|
mat12 = m->matrix[1][2]; \
|
|
mat13 = m->matrix[1][3]; \
|
|
\
|
|
mat30 = m->matrix[3][0]; \
|
|
mat31 = m->matrix[3][1]; \
|
|
mat32 = m->matrix[3][2]; \
|
|
mat33 = m->matrix[3][3];
|
|
|
|
#define __GLXFORM2_CONT(v) \
|
|
x = (v)[0]; \
|
|
y = (v)[1];
|
|
|
|
|
|
#define __GLXFORM2(res) \
|
|
a0 = x * mat00; \
|
|
a1 = x * mat01; \
|
|
a2 = x * mat02; \
|
|
a3 = x * mat03; \
|
|
\
|
|
b0 = y * mat10; \
|
|
b1 = y * mat11; \
|
|
b2 = y * mat12; \
|
|
b3 = y * mat13; \
|
|
\
|
|
a0 += mat30; \
|
|
a1 += mat31; \
|
|
a2 += mat32; \
|
|
a3 += mat33; \
|
|
\
|
|
res->x = a0 + b0; \
|
|
res->y = a1 + b1; \
|
|
res->z = a2 + b2; \
|
|
res->w = a3 + b3;
|
|
|
|
|
|
#define __GLXFORM2_W_INIT(v) \
|
|
__GLfloat x = (v)[0]; \
|
|
__GLfloat y = (v)[1]; \
|
|
__GLfloat mat00, mat01, mat02; \
|
|
__GLfloat mat10, mat11, mat12; \
|
|
__GLfloat mat30, mat31, mat32; \
|
|
__GLfloat a0, a1, a2; \
|
|
__GLfloat b0, b1, b2; \
|
|
\
|
|
mat00 = m->matrix[0][0]; \
|
|
mat01 = m->matrix[0][1]; \
|
|
mat02 = m->matrix[0][2]; \
|
|
\
|
|
mat10 = m->matrix[1][0]; \
|
|
mat11 = m->matrix[1][1]; \
|
|
mat12 = m->matrix[1][2]; \
|
|
\
|
|
mat30 = m->matrix[3][0]; \
|
|
mat31 = m->matrix[3][1]; \
|
|
mat32 = m->matrix[3][2];
|
|
|
|
|
|
#define __GLXFORM2_W(res) \
|
|
a0 = x * mat00; \
|
|
a1 = x * mat01; \
|
|
a2 = x * mat02; \
|
|
\
|
|
b0 = y * mat10; \
|
|
b1 = y * mat11; \
|
|
b2 = y * mat12; \
|
|
\
|
|
a0 += mat30; \
|
|
a1 += mat31; \
|
|
a2 += mat32; \
|
|
\
|
|
res->x = a0 + b0; \
|
|
res->y = a1 + b1; \
|
|
res->z = a2 + b2; \
|
|
res->w = ((__GLfloat) 1.0);
|
|
|
|
|
|
#define __GLXFORM2_2DW_INIT(v) \
|
|
__GLfloat x = (v)[0]; \
|
|
__GLfloat y = (v)[1]; \
|
|
__GLfloat mat00, mat01; \
|
|
__GLfloat mat10, mat11; \
|
|
__GLfloat mat30, mat31, mat32; \
|
|
__GLfloat a0, a1; \
|
|
__GLfloat b0, b1; \
|
|
\
|
|
mat00 = m->matrix[0][0]; \
|
|
mat01 = m->matrix[0][1]; \
|
|
\
|
|
mat10 = m->matrix[1][0]; \
|
|
mat11 = m->matrix[1][1]; \
|
|
\
|
|
mat30 = m->matrix[3][0]; \
|
|
mat31 = m->matrix[3][1]; \
|
|
mat32 = m->matrix[3][2];
|
|
|
|
|
|
#define __GLXFORM2_2DW(res) \
|
|
a0 = x * mat00; \
|
|
a1 = x * mat01; \
|
|
\
|
|
b0 = y * mat10; \
|
|
b1 = y * mat11; \
|
|
\
|
|
a0 += mat30; \
|
|
a1 += mat31; \
|
|
\
|
|
res->x = a0 + b0; \
|
|
res->y = a1 + b1; \
|
|
res->z = mat32; \
|
|
res->w = ((__GLfloat) 1.0);
|
|
|
|
|
|
|
|
#define __GLXFORM2_2DNRW_INIT(v) \
|
|
__GLfloat x = (v)[0]; \
|
|
__GLfloat y = (v)[1]; \
|
|
__GLfloat mat00; \
|
|
__GLfloat mat11; \
|
|
__GLfloat mat30, mat31, mat32; \
|
|
__GLfloat a0, b0; \
|
|
\
|
|
mat00 = m->matrix[0][0]; \
|
|
\
|
|
mat11 = m->matrix[1][1]; \
|
|
\
|
|
mat30 = m->matrix[3][0]; \
|
|
mat31 = m->matrix[3][1]; \
|
|
mat32 = m->matrix[3][2];
|
|
|
|
|
|
#define __GLXFORM2_2DNRW(res) \
|
|
a0 = x * mat00; \
|
|
\
|
|
b0 = y * mat11; \
|
|
\
|
|
res->x = a0 + mat30; \
|
|
res->y = b0 + mat31; \
|
|
res->z = mat32; \
|
|
res->w = ((__GLfloat) 1.0);
|
|
|
|
|
|
#define __GLXFORM3_INIT(v) \
|
|
__GLfloat x = (v)[0]; \
|
|
__GLfloat y = (v)[1]; \
|
|
__GLfloat z = (v)[2]; \
|
|
__GLfloat mat00, mat01, mat02, mat03; \
|
|
__GLfloat mat10, mat11, mat12, mat13; \
|
|
__GLfloat mat20, mat21, mat22, mat23; \
|
|
__GLfloat mat30, mat31, mat32, mat33; \
|
|
__GLfloat a0, a1, a2, a3; \
|
|
__GLfloat b0, b1, b2, b3; \
|
|
__GLfloat c0, c1, c2, c3; \
|
|
\
|
|
mat00 = m->matrix[0][0]; \
|
|
mat01 = m->matrix[0][1]; \
|
|
mat02 = m->matrix[0][2]; \
|
|
mat03 = m->matrix[0][3]; \
|
|
\
|
|
mat10 = m->matrix[1][0]; \
|
|
mat11 = m->matrix[1][1]; \
|
|
mat12 = m->matrix[1][2]; \
|
|
mat13 = m->matrix[1][3]; \
|
|
\
|
|
mat20 = m->matrix[2][0]; \
|
|
mat21 = m->matrix[2][1]; \
|
|
mat22 = m->matrix[2][2]; \
|
|
mat23 = m->matrix[2][3]; \
|
|
\
|
|
mat30 = m->matrix[3][0]; \
|
|
mat31 = m->matrix[3][1]; \
|
|
mat32 = m->matrix[3][2]; \
|
|
mat33 = m->matrix[3][3];
|
|
|
|
#define __GLXFORM3_CONT(v) \
|
|
x = (v)[0]; \
|
|
y = (v)[1]; \
|
|
z = (v)[2];
|
|
|
|
#define __GLXFORM3(res) \
|
|
a0 = mat00 * x; \
|
|
a1 = mat01 * x; \
|
|
a2 = mat02 * x; \
|
|
a3 = mat03 * x; \
|
|
\
|
|
b0 = mat10 * y; \
|
|
b1 = mat11 * y; \
|
|
b2 = mat12 * y; \
|
|
b3 = mat13 * y; \
|
|
\
|
|
c0 = mat20 * z; \
|
|
c1 = mat21 * z; \
|
|
c2 = mat22 * z; \
|
|
c3 = mat23 * z; \
|
|
\
|
|
a0 += mat30; \
|
|
a1 += mat31; \
|
|
a2 += mat32; \
|
|
a3 += mat33; \
|
|
\
|
|
a0 += b0; \
|
|
a1 += b1; \
|
|
a2 += b2; \
|
|
a3 += b3; \
|
|
\
|
|
res->x = a0 + c0; \
|
|
res->y = a1 + c1; \
|
|
res->z = a2 + c2; \
|
|
res->w = a3 + c3;
|
|
|
|
|
|
#define __GLXFORM3_W_INIT(v) \
|
|
__GLfloat x = (v)[0]; \
|
|
__GLfloat y = (v)[1]; \
|
|
__GLfloat z = (v)[2]; \
|
|
__GLfloat mat00, mat01, mat02; \
|
|
__GLfloat mat10, mat11, mat12; \
|
|
__GLfloat mat20, mat21, mat22; \
|
|
__GLfloat mat30, mat31, mat32; \
|
|
__GLfloat a0, a1, a2; \
|
|
__GLfloat b0, b1, b2; \
|
|
__GLfloat c0, c1, c2; \
|
|
\
|
|
mat00 = m->matrix[0][0]; \
|
|
mat01 = m->matrix[0][1]; \
|
|
mat02 = m->matrix[0][2]; \
|
|
\
|
|
mat10 = m->matrix[1][0]; \
|
|
mat11 = m->matrix[1][1]; \
|
|
mat12 = m->matrix[1][2]; \
|
|
\
|
|
mat20 = m->matrix[2][0]; \
|
|
mat21 = m->matrix[2][1]; \
|
|
mat22 = m->matrix[2][2]; \
|
|
\
|
|
mat30 = m->matrix[3][0]; \
|
|
mat31 = m->matrix[3][1]; \
|
|
mat32 = m->matrix[3][2];
|
|
|
|
#define __GLXFORM3x3_INIT(v) \
|
|
__GLfloat x = (v)[0]; \
|
|
__GLfloat y = (v)[1]; \
|
|
__GLfloat z = (v)[2]; \
|
|
__GLfloat mat00, mat01, mat02; \
|
|
__GLfloat mat10, mat11, mat12; \
|
|
__GLfloat mat20, mat21, mat22; \
|
|
__GLfloat a0, a1, a2; \
|
|
__GLfloat b0, b1, b2; \
|
|
__GLfloat c0, c1, c2; \
|
|
\
|
|
mat00 = m->matrix[0][0]; \
|
|
mat01 = m->matrix[0][1]; \
|
|
mat02 = m->matrix[0][2]; \
|
|
\
|
|
mat10 = m->matrix[1][0]; \
|
|
mat11 = m->matrix[1][1]; \
|
|
mat12 = m->matrix[1][2]; \
|
|
\
|
|
mat20 = m->matrix[2][0]; \
|
|
mat21 = m->matrix[2][1]; \
|
|
mat22 = m->matrix[2][2]; \
|
|
\
|
|
|
|
#define __GLXFORM3x3(res) \
|
|
a0 = mat00 * x; \
|
|
a1 = mat01 * x; \
|
|
a2 = mat02 * x; \
|
|
\
|
|
b0 = mat10 * y; \
|
|
b1 = mat11 * y; \
|
|
b2 = mat12 * y; \
|
|
\
|
|
c0 = mat20 * z; \
|
|
c1 = mat21 * z; \
|
|
c2 = mat22 * z; \
|
|
\
|
|
a0 += b0; \
|
|
a1 += b1; \
|
|
a2 += b2; \
|
|
\
|
|
res->x = a0 + c0; \
|
|
res->y = a1 + c1; \
|
|
res->z = a2 + c2;
|
|
|
|
#define __GLXFORM3_W(res) \
|
|
a0 = mat00 * x; \
|
|
a1 = mat01 * x; \
|
|
a2 = mat02 * x; \
|
|
\
|
|
b0 = mat10 * y; \
|
|
b1 = mat11 * y; \
|
|
b2 = mat12 * y; \
|
|
\
|
|
c0 = mat20 * z; \
|
|
c1 = mat21 * z; \
|
|
c2 = mat22 * z; \
|
|
\
|
|
a0 += mat30; \
|
|
a1 += mat31; \
|
|
a2 += mat32; \
|
|
\
|
|
a0 += b0; \
|
|
a1 += b1; \
|
|
a2 += b2; \
|
|
\
|
|
res->x = a0 + c0; \
|
|
res->y = a1 + c1; \
|
|
res->z = a2 + c2; \
|
|
res->w = ((__GLfloat) 1.0);
|
|
|
|
#define __GLXFORM3_2DW_INIT(v) \
|
|
__GLfloat x = (v)[0]; \
|
|
__GLfloat y = (v)[1]; \
|
|
__GLfloat z = (v)[2]; \
|
|
__GLfloat mat00, mat01; \
|
|
__GLfloat mat10, mat11; \
|
|
__GLfloat mat22; \
|
|
__GLfloat mat30, mat31, mat32; \
|
|
__GLfloat a0, a1; \
|
|
__GLfloat b0, b1; \
|
|
__GLfloat c0; \
|
|
\
|
|
mat00 = m->matrix[0][0]; \
|
|
mat01 = m->matrix[0][1]; \
|
|
mat22 = m->matrix[2][2]; \
|
|
\
|
|
mat10 = m->matrix[1][0]; \
|
|
mat11 = m->matrix[1][1]; \
|
|
\
|
|
mat30 = m->matrix[3][0]; \
|
|
mat31 = m->matrix[3][1]; \
|
|
mat32 = m->matrix[3][2];
|
|
|
|
#define __GLXFORM3_2DW(res) \
|
|
a0 = mat00 * x; \
|
|
a1 = mat01 * x; \
|
|
\
|
|
c0 = mat22 * z; \
|
|
\
|
|
b0 = mat10 * y; \
|
|
b1 = mat11 * y; \
|
|
\
|
|
a0 += mat30; \
|
|
a1 += mat31; \
|
|
\
|
|
res->x = a0 + b0; \
|
|
res->y = a1 + b1; \
|
|
res->z = c0 + mat32; \
|
|
res->w = ((__GLfloat) 1.0);
|
|
|
|
|
|
#define __GLXFORM3_2DNRW_INIT(v) \
|
|
__GLfloat x = (v)[0]; \
|
|
__GLfloat y = (v)[1]; \
|
|
__GLfloat z = (v)[2]; \
|
|
__GLfloat mat00, mat11, mat22; \
|
|
__GLfloat mat30, mat31, mat32; \
|
|
__GLfloat a0; \
|
|
__GLfloat b0; \
|
|
__GLfloat c0; \
|
|
\
|
|
mat00 = m->matrix[0][0]; \
|
|
mat11 = m->matrix[1][1]; \
|
|
mat22 = m->matrix[2][2]; \
|
|
\
|
|
mat30 = m->matrix[3][0]; \
|
|
mat31 = m->matrix[3][1]; \
|
|
mat32 = m->matrix[3][2];
|
|
|
|
#define __GLXFORM3_2DNRW(res) \
|
|
a0 = mat00 * x; \
|
|
b0 = mat11 * y; \
|
|
c0 = mat22 * z; \
|
|
\
|
|
res->x = a0 + mat30; \
|
|
res->y = b0 + mat31; \
|
|
res->z = c0 + mat32; \
|
|
res->w = ((__GLfloat) 1.0);
|
|
|
|
|
|
#define __GLXFORM4_INIT(v) \
|
|
__GLfloat x = (v)[0]; \
|
|
__GLfloat y = (v)[1]; \
|
|
__GLfloat z = (v)[2]; \
|
|
__GLfloat w = (v)[3]; \
|
|
\
|
|
__GLfloat mat00, mat01, mat02, mat03; \
|
|
__GLfloat mat10, mat11, mat12, mat13; \
|
|
__GLfloat mat20, mat21, mat22, mat23; \
|
|
__GLfloat mat30, mat31, mat32, mat33; \
|
|
__GLfloat a0, a1, a2, a3; \
|
|
__GLfloat b0, b1, b2, b3; \
|
|
__GLfloat c0, c1, c2, c3; \
|
|
__GLfloat d0, d1, d2, d3; \
|
|
\
|
|
mat00 = m->matrix[0][0]; \
|
|
mat01 = m->matrix[0][1]; \
|
|
mat02 = m->matrix[0][2]; \
|
|
mat03 = m->matrix[0][3]; \
|
|
\
|
|
mat10 = m->matrix[1][0]; \
|
|
mat11 = m->matrix[1][1]; \
|
|
mat12 = m->matrix[1][2]; \
|
|
mat13 = m->matrix[1][3]; \
|
|
\
|
|
mat20 = m->matrix[2][0]; \
|
|
mat21 = m->matrix[2][1]; \
|
|
mat22 = m->matrix[2][2]; \
|
|
mat23 = m->matrix[2][3]; \
|
|
\
|
|
mat30 = m->matrix[3][0]; \
|
|
mat31 = m->matrix[3][1]; \
|
|
mat32 = m->matrix[3][2]; \
|
|
mat33 = m->matrix[3][3];
|
|
|
|
#define __GLXFORM4_CONT(v) \
|
|
x = (v)[0]; \
|
|
y = (v)[1]; \
|
|
z = (v)[2]; \
|
|
w = (v)[3];
|
|
|
|
|
|
#define __GLXFORM4(res) \
|
|
a0 = mat00 * x; \
|
|
a1 = mat01 * x; \
|
|
a2 = mat02 * x; \
|
|
a3 = mat03 * x; \
|
|
\
|
|
b0 = mat10 * y; \
|
|
b1 = mat11 * y; \
|
|
b2 = mat12 * y; \
|
|
b3 = mat13 * y; \
|
|
\
|
|
c0 = mat20 * z; \
|
|
c1 = mat21 * z; \
|
|
c2 = mat22 * z; \
|
|
c3 = mat23 * z; \
|
|
\
|
|
d0 = mat30 * w; \
|
|
d1 = mat31 * w; \
|
|
d2 = mat32 * w; \
|
|
d3 = mat33 * w; \
|
|
\
|
|
a0 += b0; \
|
|
a1 += b1; \
|
|
a2 += b2; \
|
|
a3 += b3; \
|
|
\
|
|
a0 += c0; \
|
|
a1 += c1; \
|
|
a2 += c2; \
|
|
a3 += c3; \
|
|
\
|
|
res->x = a0 + d0; \
|
|
res->y = a1 + d1; \
|
|
res->z = a2 + d2; \
|
|
res->w = a3 + d3;
|
|
|
|
#define __GLXFORM4_W_INIT(v) \
|
|
__GLfloat x = (v)[0]; \
|
|
__GLfloat y = (v)[1]; \
|
|
__GLfloat z = (v)[2]; \
|
|
__GLfloat w = (v)[3]; \
|
|
__GLfloat mat00, mat01, mat02; \
|
|
__GLfloat mat10, mat11, mat12; \
|
|
__GLfloat mat20, mat21, mat22; \
|
|
__GLfloat mat30, mat31, mat32; \
|
|
__GLfloat a0, a1, a2; \
|
|
__GLfloat b0, b1, b2; \
|
|
__GLfloat c0, c1, c2; \
|
|
__GLfloat d0, d1, d2; \
|
|
\
|
|
mat00 = m->matrix[0][0]; \
|
|
mat01 = m->matrix[0][1]; \
|
|
mat02 = m->matrix[0][2]; \
|
|
\
|
|
mat10 = m->matrix[1][0]; \
|
|
mat11 = m->matrix[1][1]; \
|
|
mat12 = m->matrix[1][2]; \
|
|
\
|
|
mat20 = m->matrix[2][0]; \
|
|
mat21 = m->matrix[2][1]; \
|
|
mat22 = m->matrix[2][2]; \
|
|
\
|
|
mat30 = m->matrix[3][0]; \
|
|
mat31 = m->matrix[3][1]; \
|
|
mat32 = m->matrix[3][2];
|
|
|
|
|
|
#define __GLXFORM4_W(res) \
|
|
a0 = mat00 * x; \
|
|
a1 = mat01 * x; \
|
|
a2 = mat02 * x; \
|
|
\
|
|
b0 = mat10 * y; \
|
|
b1 = mat11 * y; \
|
|
b2 = mat12 * y; \
|
|
\
|
|
c0 = mat20 * z; \
|
|
c1 = mat21 * z; \
|
|
c2 = mat22 * z; \
|
|
\
|
|
d0 = mat30 * w; \
|
|
d1 = mat31 * w; \
|
|
d2 = mat32 * w; \
|
|
\
|
|
a0 += b0; \
|
|
a1 += b1; \
|
|
a2 += b2; \
|
|
\
|
|
a0 += c0; \
|
|
a1 += c1; \
|
|
a2 += c2; \
|
|
\
|
|
res->x = a0 + d0; \
|
|
res->y = a1 + d1; \
|
|
res->z = a2 + d2; \
|
|
res->w = w;
|
|
|
|
#define __GLXFORM4_2DW_INIT(v) \
|
|
__GLfloat x = (v)[0]; \
|
|
__GLfloat y = (v)[1]; \
|
|
__GLfloat z = (v)[2]; \
|
|
__GLfloat w = (v)[3]; \
|
|
__GLfloat mat00, mat01; \
|
|
__GLfloat mat10, mat11; \
|
|
__GLfloat mat22; \
|
|
__GLfloat mat30, mat31, mat32; \
|
|
__GLfloat a0, a1; \
|
|
__GLfloat b0, b1; \
|
|
__GLfloat c0; \
|
|
__GLfloat d0; \
|
|
\
|
|
mat00 = m->matrix[0][0]; \
|
|
mat01 = m->matrix[0][1]; \
|
|
mat22 = m->matrix[2][2]; \
|
|
\
|
|
mat10 = m->matrix[1][0]; \
|
|
mat11 = m->matrix[1][1]; \
|
|
\
|
|
mat30 = m->matrix[3][0]; \
|
|
mat31 = m->matrix[3][1]; \
|
|
mat32 = m->matrix[3][2];
|
|
|
|
|
|
#define __GLXFORM4_2DW(res) \
|
|
a0 = mat00 * x; \
|
|
a1 = mat01 * x; \
|
|
c0 = mat22 * z; \
|
|
\
|
|
b0 = mat10 * y; \
|
|
b1 = mat11 * y; \
|
|
\
|
|
d0 = mat32 * w; \
|
|
\
|
|
a0 += mat30; \
|
|
a1 += mat31; \
|
|
\
|
|
res->x = a0 + b0; \
|
|
res->y = a1 + b1; \
|
|
res->z = c0 + d0; \
|
|
res->w = w;
|
|
|
|
#define __GLXFORM4_2DNRW_INIT(v) \
|
|
__GLfloat x = (v)[0]; \
|
|
__GLfloat y = (v)[1]; \
|
|
__GLfloat z = (v)[2]; \
|
|
__GLfloat w = (v)[3]; \
|
|
__GLfloat mat00; \
|
|
__GLfloat mat11; \
|
|
__GLfloat mat22; \
|
|
__GLfloat mat30, mat31, mat32; \
|
|
__GLfloat a0; \
|
|
__GLfloat b0; \
|
|
__GLfloat c0; \
|
|
__GLfloat d0, d1, d2; \
|
|
\
|
|
mat00 = m->matrix[0][0]; \
|
|
mat11 = m->matrix[1][1]; \
|
|
mat22 = m->matrix[2][2]; \
|
|
\
|
|
mat30 = m->matrix[3][0]; \
|
|
mat31 = m->matrix[3][1]; \
|
|
mat32 = m->matrix[3][2];
|
|
|
|
#define __GLXFORM4_2DNRW(res) \
|
|
a0 = mat00 * x; \
|
|
b0 = mat11 * y; \
|
|
c0 = mat22 * z; \
|
|
\
|
|
d0 = mat30 * w; \
|
|
d1 = mat31 * w; \
|
|
d2 = mat32 * w; \
|
|
\
|
|
res->x = a0 + d0; \
|
|
res->y = b0 + d1; \
|
|
res->z = c0 + d2; \
|
|
res->w = w;
|
|
|
|
#define __GLXFORM_NORMAL_BATCH(funcName, initFunc, workFunc, continueFunc) \
|
|
void FASTCALL funcName(POLYARRAY *pa, const __GLmatrix *m) \
|
|
{ \
|
|
POLYDATA *pd = pa->pd0; \
|
|
POLYDATA *pdLast = pa->pdNextVertex; \
|
|
\
|
|
for (;pd < pdLast; pd++) { \
|
|
if (pd->flags & POLYDATA_NORMAL_VALID) \
|
|
{ \
|
|
__GLcoord *res = &pd->normal; \
|
|
initFunc((__GLfloat *)res); \
|
|
workFunc(res); \
|
|
continueFunc((__GLfloat *)res); \
|
|
} \
|
|
} \
|
|
}
|
|
|
|
#define __GLXFORM_NORMAL_BATCHN(funcName, initFunc, workFunc, continueFunc) \
|
|
void FASTCALL funcName(POLYARRAY *pa, const __GLmatrix *m) \
|
|
{ \
|
|
POLYDATA *pd = pa->pd0; \
|
|
POLYDATA *pdLast = pa->pdNextVertex; \
|
|
\
|
|
for (;pd < pdLast; pd++) { \
|
|
if (pd->flags & POLYDATA_NORMAL_VALID) \
|
|
{ \
|
|
__GLcoord *res = &pd->normal; \
|
|
initFunc((__GLfloat *)res); \
|
|
workFunc(res); \
|
|
continueFunc((__GLfloat *)res); \
|
|
__glNormalize((__GLfloat *)res, (__GLfloat *)res); \
|
|
} \
|
|
} \
|
|
}
|
|
|
|
#define __GLXFORM_BATCH(funcName, initFunc, workFunc, continueFunc) \
|
|
void FASTCALL funcName(__GLcoord *res, __GLcoord *end, const __GLmatrix *m) \
|
|
{ \
|
|
initFunc((__GLfloat *)res); \
|
|
\
|
|
for (;;) { \
|
|
workFunc(res); \
|
|
(char *)res += sizeof(POLYDATA); \
|
|
if (res > end) \
|
|
break; \
|
|
continueFunc((__GLfloat *)res); \
|
|
} \
|
|
}
|
|
|
|
/*
|
|
** Note: These xform routines must allow for the case where the result
|
|
** vector is equal to the source vector.
|
|
*/
|
|
|
|
#ifndef __GL_ASM_XFORM1
|
|
/*
|
|
** Avoid some transformation computations by knowing that the incoming
|
|
** vertex has y=0, z=0 and w=1.
|
|
*/
|
|
void FASTCALL __glXForm1(__GLcoord *res, const __GLfloat v[1], const __GLmatrix *m)
|
|
{
|
|
__GLXFORM1_INIT(v)
|
|
|
|
__GLXFORM1(res);
|
|
}
|
|
#endif /* !__GL_ASM_XFORM1 */
|
|
|
|
#ifndef __GL_ASM_XFORM1BATCH
|
|
__GLXFORM_BATCH(__glXForm1Batch, __GLXFORM1_INIT, __GLXFORM1, __GLXFORM1_CONT);
|
|
#endif /* !__GL_ASM_XFORM1BATCH */
|
|
|
|
#ifndef __GL_ASM_XFORM2
|
|
/*
|
|
** Avoid some transformation computations by knowing that the incoming
|
|
** vertex has z=0 and w=1
|
|
*/
|
|
void FASTCALL __glXForm2(__GLcoord *res, const __GLfloat v[2], const __GLmatrix *m)
|
|
{
|
|
__GLXFORM2_INIT(v)
|
|
|
|
__GLXFORM2(res);
|
|
}
|
|
#endif /* !__GL_ASM_XFORM2 */
|
|
|
|
#ifndef __GL_ASM_XFORM2BATCH
|
|
__GLXFORM_BATCH (__glXForm2Batch, __GLXFORM2_INIT, __GLXFORM2, __GLXFORM2_CONT);
|
|
#endif /* !__GL_ASM_XFORM2BATCH */
|
|
|
|
#ifndef __GL_ASM_XFORM3
|
|
/*
|
|
** Avoid some transformation computations by knowing that the incoming
|
|
** vertex has w=1.
|
|
*/
|
|
void FASTCALL __glXForm3(__GLcoord *res, const __GLfloat v[3], const __GLmatrix *m)
|
|
{
|
|
__GLXFORM3_INIT(v)
|
|
|
|
__GLXFORM3(res);
|
|
}
|
|
#endif /* !__GL_ASM_XFORM3 */
|
|
|
|
#ifndef __GL_ASM_XFORM3BATCH
|
|
__GLXFORM_BATCH (__glXForm3Batch, __GLXFORM3_INIT, __GLXFORM3, __GLXFORM3_CONT);
|
|
#endif /* !__GL_ASM_XFORM3BATCH */
|
|
|
|
#ifndef __GL_ASM_XFORM4
|
|
/*
|
|
** Full 4x4 transformation.
|
|
*/
|
|
void FASTCALL __glXForm4(__GLcoord *res, const __GLfloat v[4], const __GLmatrix *m)
|
|
{
|
|
__GLXFORM4_INIT(v)
|
|
|
|
__GLXFORM4(res);
|
|
}
|
|
#endif /* !__GL_ASM_XFORM4 */
|
|
|
|
#ifndef __GL_ASM_XFORM4BATCH
|
|
__GLXFORM_BATCH (__glXForm4Batch, __GLXFORM4_INIT, __GLXFORM4, __GLXFORM4_CONT);
|
|
#endif /* !__GL_ASM_XFORM4BATCH */
|
|
|
|
/************************************************************************/
|
|
|
|
#ifndef __GL_ASM_XFORM1_W
|
|
/*
|
|
** Avoid some transformation computations by knowing that the incoming
|
|
** vertex has y=0, z=0 and w=1. The w column of the matrix is [0 0 0 1].
|
|
*/
|
|
void FASTCALL __glXForm1_W(__GLcoord *res, const __GLfloat v[1], const __GLmatrix *m)
|
|
{
|
|
__GLXFORM1_W_INIT(v)
|
|
|
|
__GLXFORM1_W(res);
|
|
}
|
|
#endif /* !__GL_ASM_XFORM1_W */
|
|
|
|
#ifndef __GL_ASM_XFORM1_WBATCH
|
|
__GLXFORM_BATCH (__glXForm1_WBatch, __GLXFORM1_W_INIT, __GLXFORM1_W, __GLXFORM1_CONT);
|
|
#endif /* !__GL_ASM_XFORM1_WBATCH */
|
|
|
|
#ifndef __GL_ASM_XFORM2_W
|
|
/*
|
|
** Avoid some transformation computations by knowing that the incoming
|
|
** vertex has z=0 and w=1. The w column of the matrix is [0 0 0 1].
|
|
*/
|
|
void FASTCALL __glXForm2_W(__GLcoord *res, const __GLfloat v[2], const __GLmatrix *m)
|
|
{
|
|
__GLXFORM2_W_INIT(v)
|
|
|
|
__GLXFORM2_W(res);
|
|
}
|
|
#endif /* !__GL_ASM_XFORM2_W */
|
|
|
|
#ifndef __GL_ASM_XFORM2_WBATCH
|
|
__GLXFORM_BATCH (__glXForm2_WBatch, __GLXFORM2_W_INIT, __GLXFORM2_W, __GLXFORM2_CONT);
|
|
#endif /* !__GL_ASM_XFORM2_WBATCH */
|
|
|
|
#ifndef __GL_ASM_XFORM3_W
|
|
/*
|
|
** Avoid some transformation computations by knowing that the incoming
|
|
** vertex has w=1. The w column of the matrix is [0 0 0 1].
|
|
*/
|
|
void FASTCALL __glXForm3_W(__GLcoord *res, const __GLfloat v[3], const __GLmatrix *m)
|
|
{
|
|
__GLXFORM3_W_INIT(v)
|
|
|
|
__GLXFORM3_W(res);
|
|
}
|
|
#endif /* !__GL_ASM_XFORM3_W */
|
|
|
|
#ifndef __GL_ASM_XFORM3_WBATCH
|
|
__GLXFORM_BATCH (__glXForm3_WBatch, __GLXFORM3_W_INIT, __GLXFORM3_W, __GLXFORM3_CONT);
|
|
#endif /* !__GL_ASM_XFORM3_WBATCH */
|
|
|
|
#ifndef __GL_ASM_XFORM3x3
|
|
/*
|
|
** Avoid some transformation computations by knowing that the incoming
|
|
** vertex is a normal. This is allowed according to the OpenGL spec.
|
|
*/
|
|
void FASTCALL __glXForm3x3(__GLcoord *res, const __GLfloat v[3], const __GLmatrix *m)
|
|
{
|
|
__GLXFORM3x3_INIT(v);
|
|
|
|
__GLXFORM3x3(res);
|
|
}
|
|
#endif /* !__GL_ASM_XFORM3x3 */
|
|
|
|
#ifndef __GL_ASM_XFORM3x3BATCH
|
|
__GLXFORM_BATCH (__glXForm3x3Batch, __GLXFORM3x3_INIT, __GLXFORM3x3, __GLXFORM3_CONT);
|
|
#endif /* !__GL_ASM_XFORM3x3BATCH */
|
|
|
|
#ifndef __GL_ASM_XFORM4_W
|
|
/*
|
|
** Full 4x4 transformation. The w column of the matrix is [0 0 0 1].
|
|
*/
|
|
void FASTCALL __glXForm4_W(__GLcoord *res, const __GLfloat v[4], const __GLmatrix *m)
|
|
{
|
|
__GLXFORM4_W_INIT(v)
|
|
|
|
__GLXFORM4_W(res);
|
|
}
|
|
#endif /* !__GL_ASM_XFORM4_W */
|
|
|
|
#ifndef __GL_ASM_XFORM4_WBATCH
|
|
__GLXFORM_BATCH (__glXForm4_WBatch, __GLXFORM4_W_INIT, __GLXFORM4_W, __GLXFORM4_CONT);
|
|
#endif /* !__GL_ASM_XFORM4_WBATCH */
|
|
|
|
#ifndef __GL_ASM_XFORM1_2DW
|
|
/*
|
|
** Avoid some transformation computations by knowing that the incoming
|
|
** vertex has y=0, z=0 and w=1.
|
|
**
|
|
** The matrix looks like:
|
|
** | . . 0 0 |
|
|
** | . . 0 0 |
|
|
** | 0 0 . 0 |
|
|
** | . . . 1 |
|
|
*/
|
|
void FASTCALL __glXForm1_2DW(__GLcoord *res, const __GLfloat v[1], const __GLmatrix *m)
|
|
{
|
|
__GLXFORM1_2DW_INIT(v)
|
|
|
|
__GLXFORM1_2DW(res);
|
|
}
|
|
#endif /* !__GL_ASM_XFORM1_2DW */
|
|
|
|
#ifndef __GL_ASM_XFORM1_2DWBATCH
|
|
__GLXFORM_BATCH (__glXForm1_2DWBatch, __GLXFORM1_2DW_INIT, __GLXFORM1_2DW, __GLXFORM1_CONT);
|
|
#endif /* !__GL_ASM_XFORM1_2DWBATCH */
|
|
|
|
#ifndef __GL_ASM_XFORM2_2DW
|
|
/*
|
|
** Avoid some transformation computations by knowing that the incoming
|
|
** vertex has z=0 and w=1.
|
|
**
|
|
** The matrix looks like:
|
|
** | . . 0 0 |
|
|
** | . . 0 0 |
|
|
** | 0 0 . 0 |
|
|
** | . . . 1 |
|
|
*/
|
|
void FASTCALL __glXForm2_2DW(__GLcoord *res, const __GLfloat v[2],
|
|
const __GLmatrix *m)
|
|
{
|
|
__GLXFORM2_2DW_INIT(v)
|
|
|
|
__GLXFORM2_2DW(res);
|
|
}
|
|
#endif /* !__GL_ASM_XFORM2_2DW */
|
|
|
|
#ifndef __GL_ASM_XFORM2_2DWBATCH
|
|
__GLXFORM_BATCH (__glXForm2_2DWBatch, __GLXFORM2_2DW_INIT, __GLXFORM2_2DW, __GLXFORM2_CONT);
|
|
#endif /* !__GL_ASM_XFORM2_2DWBATCH */
|
|
|
|
#ifndef __GL_ASM_XFORM3_2DW
|
|
/*
|
|
** Avoid some transformation computations by knowing that the incoming
|
|
** vertex has w=1.
|
|
**
|
|
** The matrix looks like:
|
|
** | . . 0 0 |
|
|
** | . . 0 0 |
|
|
** | 0 0 . 0 |
|
|
** | . . . 1 |
|
|
*/
|
|
void FASTCALL __glXForm3_2DW(__GLcoord *res, const __GLfloat v[3],
|
|
const __GLmatrix *m)
|
|
{
|
|
__GLXFORM3_2DW_INIT(v)
|
|
|
|
__GLXFORM3_2DW(res);
|
|
}
|
|
#endif /* !__GL_ASM_XFORM3_2DW */
|
|
|
|
#ifndef __GL_ASM_XFORM3_2DWBATCH
|
|
__GLXFORM_BATCH (__glXForm3_2DWBatch, __GLXFORM3_2DW_INIT, __GLXFORM3_2DW, __GLXFORM3_CONT);
|
|
#endif /* !__GL_ASM_XFORM3_2DWBATCH */
|
|
|
|
#ifndef __GL_ASM_XFORM4_2DW
|
|
/*
|
|
** Full 4x4 transformation.
|
|
**
|
|
** The matrix looks like:
|
|
** | . . 0 0 |
|
|
** | . . 0 0 |
|
|
** | 0 0 . 0 |
|
|
** | . . . 1 |
|
|
*/
|
|
void FASTCALL __glXForm4_2DW(__GLcoord *res, const __GLfloat v[4],
|
|
const __GLmatrix *m)
|
|
{
|
|
__GLXFORM4_2DW_INIT(v)
|
|
|
|
__GLXFORM4_2DW(res);
|
|
}
|
|
#endif /* !__GL_ASM_XFORM4_2DW */
|
|
|
|
#ifndef __GL_ASM_XFORM4_2DWBATCH
|
|
__GLXFORM_BATCH (__glXForm4_2DWBatch, __GLXFORM4_2DW_INIT, __GLXFORM4_2DW, __GLXFORM4_CONT);
|
|
#endif /* !__GL_ASM_XFORM4_2DWBATCH */
|
|
|
|
#ifndef __GL_ASM_XFORM1_2DNRW
|
|
/*
|
|
** Avoid some transformation computations by knowing that the incoming
|
|
** vertex has y=0, z=0 and w=1.
|
|
**
|
|
** The matrix looks like:
|
|
** | . 0 0 0 |
|
|
** | 0 . 0 0 |
|
|
** | 0 0 . 0 |
|
|
** | . . . 1 |
|
|
*/
|
|
void FASTCALL __glXForm1_2DNRW(__GLcoord *res, const __GLfloat v[1], const __GLmatrix *m)
|
|
{
|
|
__GLXFORM1_2DNRW_INIT(v)
|
|
|
|
__GLXFORM1_2DNRW(res);
|
|
}
|
|
#endif /* !__GL_ASM_XFORM1_2DNRW */
|
|
|
|
#ifndef __GL_ASM_XFORM1_2DNRWBATCH
|
|
__GLXFORM_BATCH (__glXForm1_2DNRWBatch, __GLXFORM1_2DNRW_INIT, __GLXFORM1_2DNRW, __GLXFORM1_CONT);
|
|
#endif /* !__GL_ASM_XFORM1_2DNRWBATCH */
|
|
|
|
#ifndef __GL_ASM_XFORM2_2DNRW
|
|
/*
|
|
** Avoid some transformation computations by knowing that the incoming
|
|
** vertex has z=0 and w=1.
|
|
**
|
|
** The matrix looks like:
|
|
** | . 0 0 0 |
|
|
** | 0 . 0 0 |
|
|
** | 0 0 . 0 |
|
|
** | . . . 1 |
|
|
*/
|
|
void FASTCALL __glXForm2_2DNRW(__GLcoord *res, const __GLfloat v[2],
|
|
const __GLmatrix *m)
|
|
{
|
|
__GLXFORM2_2DNRW_INIT(v)
|
|
|
|
__GLXFORM2_2DNRW(res);
|
|
}
|
|
#endif /* !__GL_ASM_XFORM2_2DNRW */
|
|
|
|
#ifndef __GL_ASM_XFORM2_2DNRWBATCH
|
|
__GLXFORM_BATCH (__glXForm2_2DNRWBatch, __GLXFORM2_2DNRW_INIT, __GLXFORM2_2DNRW, __GLXFORM2_CONT);
|
|
#endif /* !__GL_ASM_XFORM2_2DNRWBATCH */
|
|
|
|
#ifndef __GL_ASM_XFORM3_2DNRW
|
|
/*
|
|
** Avoid some transformation computations by knowing that the incoming
|
|
** vertex has w=1.
|
|
**
|
|
** The matrix looks like:
|
|
** | . 0 0 0 |
|
|
** | 0 . 0 0 |
|
|
** | 0 0 . 0 |
|
|
** | . . . 1 |
|
|
*/
|
|
void FASTCALL __glXForm3_2DNRW(__GLcoord *res, const __GLfloat v[3],
|
|
const __GLmatrix *m)
|
|
{
|
|
__GLXFORM3_2DNRW_INIT(v)
|
|
|
|
__GLXFORM3_2DNRW(res);
|
|
}
|
|
#endif /* !__GL_ASM_XFORM3_2DNRW */
|
|
|
|
#ifndef __GL_ASM_XFORM3_2DNRWBATCH
|
|
__GLXFORM_BATCH (__glXForm3_2DNRWBatch, __GLXFORM3_2DNRW_INIT, __GLXFORM3_2DNRW, __GLXFORM3_CONT);
|
|
#endif /* !__GL_ASM_XFORM3_2DNRWBATCH */
|
|
|
|
#ifndef __GL_ASM_XFORM4_2DNRW
|
|
/*
|
|
** Full 4x4 transformation.
|
|
**
|
|
** The matrix looks like:
|
|
** | . 0 0 0 |
|
|
** | 0 . 0 0 |
|
|
** | 0 0 . 0 |
|
|
** | . . . 1 |
|
|
*/
|
|
void FASTCALL __glXForm4_2DNRW(__GLcoord *res, const __GLfloat v[4],
|
|
const __GLmatrix *m)
|
|
{
|
|
__GLXFORM4_2DNRW_INIT(v)
|
|
|
|
__GLXFORM4_2DNRW(res);
|
|
}
|
|
#endif /* !__GL_ASM_XFORM4_2DNRW */
|
|
|
|
#ifndef __GL_ASM_XFORM4_2DNRWBATCH
|
|
__GLXFORM_BATCH (__glXForm4_2DNRWBatch, __GLXFORM4_2DNRW_INIT, __GLXFORM4_2DNRW, __GLXFORM4_CONT);
|
|
#endif /* !__GL_ASM_XFORM4_2DNRWBATCH */
|
|
|
|
#ifndef __GL_ASM_NORMAL_BATCH
|
|
|
|
__GLXFORM_NORMAL_BATCH (__glXForm3_2DNRWBatchNormal, __GLXFORM3x3_INIT, __GLXFORM3x3, __GLXFORM3_CONT);
|
|
__GLXFORM_NORMAL_BATCHN(__glXForm3_2DNRWBatchNormalN, __GLXFORM3x3_INIT, __GLXFORM3x3, __GLXFORM3_CONT);
|
|
|
|
__GLXFORM_NORMAL_BATCH (__glXForm3_2DWBatchNormal, __GLXFORM3x3_INIT, __GLXFORM3x3, __GLXFORM3_CONT);
|
|
__GLXFORM_NORMAL_BATCHN(__glXForm3_2DWBatchNormalN, __GLXFORM3x3_INIT, __GLXFORM3x3, __GLXFORM3_CONT);
|
|
|
|
__GLXFORM_NORMAL_BATCH (__glXForm3x3BatchNormal, __GLXFORM3x3_INIT, __GLXFORM3x3, __GLXFORM3_CONT);
|
|
__GLXFORM_NORMAL_BATCHN(__glXForm3x3BatchNormalN, __GLXFORM3x3_INIT, __GLXFORM3x3, __GLXFORM3_CONT);
|
|
|
|
#endif // __GL_ASM_NORMAL_BATCH
|
|
|
|
/************************************************************************/
|
|
/*
|
|
** A special picker for the mvp matrix which picks the mvp matrix, then
|
|
** calls the vertex picker, because the vertex picker depends upon the mvp
|
|
** matrix.
|
|
*/
|
|
void FASTCALL __glGenericPickMvpMatrixProcs(__GLcontext *gc, __GLmatrix *m)
|
|
{
|
|
__glGenericPickMatrixProcs(gc, m);
|
|
(*gc->procs.pickVertexProcs)(gc);
|
|
}
|
|
|
|
void FASTCALL __glGenericPickMatrixProcs(__GLcontext *gc, __GLmatrix *m)
|
|
{
|
|
switch(m->matrixType)
|
|
{
|
|
case __GL_MT_GENERAL:
|
|
m->xf1 = __glXForm1;
|
|
m->xf2 = __glXForm2;
|
|
m->xf3 = __glXForm3;
|
|
m->xf4 = __glXForm4;
|
|
m->xfNorm = __glXForm3x3;
|
|
m->xf1Batch = __glXForm1Batch;
|
|
m->xf2Batch = __glXForm2Batch;
|
|
m->xf3Batch = __glXForm3Batch;
|
|
m->xf4Batch = __glXForm4Batch;
|
|
m->xfNormBatch = __glXForm3x3BatchNormal;
|
|
m->xfNormBatchN = __glXForm3x3BatchNormalN;
|
|
break;
|
|
case __GL_MT_W0001:
|
|
m->xf1 = __glXForm1_W;
|
|
m->xf2 = __glXForm2_W;
|
|
m->xf3 = __glXForm3_W;
|
|
m->xf4 = __glXForm4_W;
|
|
m->xfNorm = __glXForm3x3;
|
|
m->xf1Batch = __glXForm1_WBatch;
|
|
m->xf2Batch = __glXForm2_WBatch;
|
|
m->xf3Batch = __glXForm3_WBatch;
|
|
m->xf4Batch = __glXForm4_WBatch;
|
|
m->xfNormBatch = __glXForm3x3BatchNormal;
|
|
m->xfNormBatchN = __glXForm3x3BatchNormalN;
|
|
break;
|
|
case __GL_MT_IS2D:
|
|
m->xf1 = __glXForm1_2DW;
|
|
m->xf2 = __glXForm2_2DW;
|
|
m->xf3 = __glXForm3_2DW;
|
|
m->xf4 = __glXForm4_2DW;
|
|
m->xfNorm = __glXForm3_2DW;
|
|
m->xf1Batch = __glXForm1_2DWBatch;
|
|
m->xf2Batch = __glXForm2_2DWBatch;
|
|
m->xf3Batch = __glXForm3_2DWBatch;
|
|
m->xf4Batch = __glXForm4_2DWBatch;
|
|
m->xfNormBatch = __glXForm3_2DWBatchNormal;
|
|
m->xfNormBatchN = __glXForm3_2DWBatchNormalN;
|
|
break;
|
|
case __GL_MT_IS2DNR:
|
|
case __GL_MT_IDENTITY: /* probably never hit */
|
|
// Update __glGenericPickIdentityMatrixProcs if we change __GL_MT_IDENTITY
|
|
// procs!
|
|
m->xf1 = __glXForm1_2DNRW;
|
|
m->xf2 = __glXForm2_2DNRW;
|
|
m->xf3 = __glXForm3_2DNRW;
|
|
m->xf4 = __glXForm4_2DNRW;
|
|
m->xfNorm = __glXForm3_2DNRW;
|
|
m->xf1Batch = __glXForm1_2DNRWBatch;
|
|
m->xf2Batch = __glXForm2_2DNRWBatch;
|
|
m->xf3Batch = __glXForm3_2DNRWBatch;
|
|
m->xf4Batch = __glXForm4_2DNRWBatch;
|
|
m->xfNormBatch = __glXForm3_2DNRWBatchNormal;
|
|
m->xfNormBatchN = __glXForm3_2DNRWBatchNormalN;
|
|
break;
|
|
}
|
|
}
|