Mac OS X work...lots of little changes that touch a lot of random places.
Still work to be done, but this at least matches the PowerPC Linux status now. MacOS-specific directory (and XCode project) is gone...this now uses SDL, OpenAL, and the Unix Makefiles. --ryan.
This commit is contained in:
Ryan C. Gordon
parent
b20b86bbbe
commit
721b9a7d01
61 changed files with 877 additions and 22868 deletions
|
|
@ -46,7 +46,22 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|||
|
||||
#elif defined(MACOS_X)
|
||||
|
||||
#include "macosx_glimp.h"
|
||||
#include <OpenGL/OpenGL.h>
|
||||
#include <OpenGL/gl.h>
|
||||
#include <OpenGL/glu.h>
|
||||
#ifndef GL_EXT_abgr
|
||||
#include <OpenGL/glext.h>
|
||||
#endif
|
||||
|
||||
// This can be defined to use the CGLMacro.h support which avoids looking up
|
||||
// the current context.
|
||||
//#define USE_CGLMACROS
|
||||
|
||||
#ifdef USE_CGLMACROS
|
||||
#include "macosx_local.h"
|
||||
#define cgl_ctx glw_state._cgl_ctx
|
||||
#include <OpenGL/CGLMacro.h>
|
||||
#endif
|
||||
|
||||
#elif defined( __linux__ ) || defined(__FreeBSD__)
|
||||
|
||||
|
|
@ -164,7 +179,7 @@ extern void ( APIENTRY * qglUnlockArraysEXT) (void);
|
|||
|
||||
#include "qgl_linked.h"
|
||||
|
||||
#elif defined(MACOS_X)
|
||||
#elif (defined(MACOS_X) && !defined(USE_SDL_VIDEO))
|
||||
// This includes #ifdefs for optional logging and GL error checking after every GL call as well as #defines to prevent incorrect usage of the non-'qgl' versions of the GL API.
|
||||
#include "macosx_qgl.h"
|
||||
|
||||
|
|
|
|||
|
|
@ -113,7 +113,7 @@ static void MakeMeshNormals( int width, int height, drawVert_t ctrl[MAX_GRID_SIZ
|
|||
int i, j, k, dist;
|
||||
vec3_t normal;
|
||||
vec3_t sum;
|
||||
int count;
|
||||
int count = 0;
|
||||
vec3_t base;
|
||||
vec3_t delta;
|
||||
int x, y;
|
||||
|
|
|
|||
|
|
@ -150,12 +150,15 @@ int max_polys;
|
|||
cvar_t *r_maxpolyverts;
|
||||
int max_polyverts;
|
||||
|
||||
/* !!! FIXME: Why are these here?! */
|
||||
#if 0
|
||||
void ( APIENTRY * qglMultiTexCoord2fARB )( GLenum texture, GLfloat s, GLfloat t );
|
||||
void ( APIENTRY * qglActiveTextureARB )( GLenum texture );
|
||||
void ( APIENTRY * qglClientActiveTextureARB )( GLenum texture );
|
||||
|
||||
void ( APIENTRY * qglLockArraysEXT)( GLint, GLint);
|
||||
void ( APIENTRY * qglUnlockArraysEXT) ( void );
|
||||
#endif
|
||||
|
||||
static void AssertCvarRange( cvar_t *cv, float minVal, float maxVal, qboolean shouldBeIntegral )
|
||||
{
|
||||
|
|
|
|||
|
|
@ -402,9 +402,9 @@ ProjectDlightTexture
|
|||
Perform dynamic lighting with another rendering pass
|
||||
===================
|
||||
*/
|
||||
static void ProjectDlightTexture( void ) {
|
||||
int i, l;
|
||||
#if idppc_altivec
|
||||
static void ProjectDlightTexture_altivec( void ) {
|
||||
int i, l;
|
||||
vec_t origin0, origin1, origin2;
|
||||
float texCoords0, texCoords1;
|
||||
vector float floatColorVec0, floatColorVec1;
|
||||
|
|
@ -412,13 +412,10 @@ static void ProjectDlightTexture( void ) {
|
|||
vector short colorShort;
|
||||
vector signed int colorInt;
|
||||
vector unsigned char floatColorVecPerm, modulatePerm, colorChar;
|
||||
vector unsigned char vSel = (vector unsigned char){0x00, 0x00, 0x00, 0xff,
|
||||
0x00, 0x00, 0x00, 0xff,
|
||||
0x00, 0x00, 0x00, 0xff,
|
||||
0x00, 0x00, 0x00, 0xff};
|
||||
#else
|
||||
vec3_t origin;
|
||||
#endif
|
||||
vector unsigned char vSel = VECCONST_UINT8(0x00, 0x00, 0x00, 0xff,
|
||||
0x00, 0x00, 0x00, 0xff,
|
||||
0x00, 0x00, 0x00, 0xff,
|
||||
0x00, 0x00, 0x00, 0xff);
|
||||
float *texCoords;
|
||||
byte *colors;
|
||||
byte clipBits[SHADER_MAX_VERTEXES];
|
||||
|
|
@ -429,20 +426,18 @@ static void ProjectDlightTexture( void ) {
|
|||
float scale;
|
||||
float radius;
|
||||
vec3_t floatColor;
|
||||
float modulate;
|
||||
float modulate = 0.0f;
|
||||
|
||||
if ( !backEnd.refdef.num_dlights ) {
|
||||
return;
|
||||
}
|
||||
|
||||
#if idppc_altivec
|
||||
// There has to be a better way to do this so that floatColor
|
||||
// There has to be a better way to do this so that floatColor
|
||||
// and/or modulate are already 16-byte aligned.
|
||||
floatColorVecPerm = vec_lvsl(0,(float *)floatColor);
|
||||
modulatePerm = vec_lvsl(0,(float *)&modulate);
|
||||
modulatePerm = (vector unsigned char)vec_splat((vector unsigned int)modulatePerm,0);
|
||||
zero = (vector float)vec_splat_s8(0);
|
||||
#endif
|
||||
|
||||
for ( l = 0 ; l < backEnd.refdef.num_dlights ; l++ ) {
|
||||
dlight_t *dl;
|
||||
|
|
@ -454,27 +449,20 @@ static void ProjectDlightTexture( void ) {
|
|||
colors = colorArray[0];
|
||||
|
||||
dl = &backEnd.refdef.dlights[l];
|
||||
#if idppc_altivec
|
||||
origin0 = dl->transformed[0];
|
||||
origin1 = dl->transformed[1];
|
||||
origin2 = dl->transformed[2];
|
||||
#else
|
||||
VectorCopy( dl->transformed, origin );
|
||||
#endif
|
||||
radius = dl->radius;
|
||||
scale = 1.0f / radius;
|
||||
|
||||
floatColor[0] = dl->color[0] * 255.0f;
|
||||
floatColor[1] = dl->color[1] * 255.0f;
|
||||
floatColor[2] = dl->color[2] * 255.0f;
|
||||
#if idppc_altivec
|
||||
floatColorVec0 = vec_ld(0, floatColor);
|
||||
floatColorVec1 = vec_ld(11, floatColor);
|
||||
floatColorVec0 = vec_perm(floatColorVec0,floatColorVec0,floatColorVecPerm);
|
||||
#endif
|
||||
for ( i = 0 ; i < tess.numVertexes ; i++, texCoords += 2, colors += 4 ) {
|
||||
int clip = 0;
|
||||
#if idppc_altivec
|
||||
#define DIST0 dist0
|
||||
#define DIST1 dist1
|
||||
#define DIST2 dist2
|
||||
|
|
@ -485,16 +473,6 @@ static void ProjectDlightTexture( void ) {
|
|||
dist0 = origin0 - tess.xyz[i][0];
|
||||
dist1 = origin1 - tess.xyz[i][1];
|
||||
dist2 = origin2 - tess.xyz[i][2];
|
||||
#else
|
||||
#define DIST0 dist[0]
|
||||
#define DIST1 dist[1]
|
||||
#define DIST2 dist[2]
|
||||
#define TEXCOORDS0 texCoords[0]
|
||||
#define TEXCOORDS1 texCoords[1]
|
||||
vec3_t dist;
|
||||
|
||||
VectorSubtract( origin, tess.xyz[i], dist );
|
||||
#endif
|
||||
|
||||
backEnd.pc.c_dlightVertexes++;
|
||||
|
||||
|
|
@ -539,7 +517,6 @@ static void ProjectDlightTexture( void ) {
|
|||
}
|
||||
clipBits[i] = clip;
|
||||
|
||||
#if idppc_altivec
|
||||
modulateVec = vec_ld(0,(float *)&modulate);
|
||||
modulateVec = vec_perm(modulateVec,modulateVec,modulatePerm);
|
||||
colorVec = vec_madd(floatColorVec0,modulateVec,zero);
|
||||
|
|
@ -548,12 +525,6 @@ static void ProjectDlightTexture( void ) {
|
|||
colorChar = vec_packsu(colorShort,colorShort); // RGBxRGBxRGBxRGBx
|
||||
colorChar = vec_sel(colorChar,vSel,vSel); // RGBARGBARGBARGBA replace alpha with 255
|
||||
vec_ste((vector unsigned int)colorChar,0,(unsigned int *)colors); // store color
|
||||
#else
|
||||
colors[0] = myftol(floatColor[0] * modulate);
|
||||
colors[1] = myftol(floatColor[1] * modulate);
|
||||
colors[2] = myftol(floatColor[2] * modulate);
|
||||
colors[3] = 255;
|
||||
#endif
|
||||
}
|
||||
#undef DIST0
|
||||
#undef DIST1
|
||||
|
|
@ -602,6 +573,162 @@ static void ProjectDlightTexture( void ) {
|
|||
backEnd.pc.c_dlightIndexes += numIndexes;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
static void ProjectDlightTexture_scalar( void ) {
|
||||
int i, l;
|
||||
vec3_t origin;
|
||||
float *texCoords;
|
||||
byte *colors;
|
||||
byte clipBits[SHADER_MAX_VERTEXES];
|
||||
float texCoordsArray[SHADER_MAX_VERTEXES][2];
|
||||
byte colorArray[SHADER_MAX_VERTEXES][4];
|
||||
unsigned hitIndexes[SHADER_MAX_INDEXES];
|
||||
int numIndexes;
|
||||
float scale;
|
||||
float radius;
|
||||
vec3_t floatColor;
|
||||
float modulate = 0.0f;
|
||||
|
||||
if ( !backEnd.refdef.num_dlights ) {
|
||||
return;
|
||||
}
|
||||
|
||||
for ( l = 0 ; l < backEnd.refdef.num_dlights ; l++ ) {
|
||||
dlight_t *dl;
|
||||
|
||||
if ( !( tess.dlightBits & ( 1 << l ) ) ) {
|
||||
continue; // this surface definately doesn't have any of this light
|
||||
}
|
||||
texCoords = texCoordsArray[0];
|
||||
colors = colorArray[0];
|
||||
|
||||
dl = &backEnd.refdef.dlights[l];
|
||||
VectorCopy( dl->transformed, origin );
|
||||
radius = dl->radius;
|
||||
scale = 1.0f / radius;
|
||||
|
||||
floatColor[0] = dl->color[0] * 255.0f;
|
||||
floatColor[1] = dl->color[1] * 255.0f;
|
||||
floatColor[2] = dl->color[2] * 255.0f;
|
||||
for ( i = 0 ; i < tess.numVertexes ; i++, texCoords += 2, colors += 4 ) {
|
||||
int clip = 0;
|
||||
#define DIST0 dist[0]
|
||||
#define DIST1 dist[1]
|
||||
#define DIST2 dist[2]
|
||||
#define TEXCOORDS0 texCoords[0]
|
||||
#define TEXCOORDS1 texCoords[1]
|
||||
vec3_t dist;
|
||||
|
||||
VectorSubtract( origin, tess.xyz[i], dist );
|
||||
|
||||
backEnd.pc.c_dlightVertexes++;
|
||||
|
||||
TEXCOORDS0 = 0.5f + DIST0 * scale;
|
||||
TEXCOORDS1 = 0.5f + DIST1 * scale;
|
||||
|
||||
if( !r_dlightBacks->integer &&
|
||||
// dist . tess.normal[i]
|
||||
( DIST0 * tess.normal[i][0] +
|
||||
DIST1 * tess.normal[i][1] +
|
||||
DIST2 * tess.normal[i][2] ) < 0.0f ) {
|
||||
clip = 63;
|
||||
} else {
|
||||
if ( TEXCOORDS0 < 0.0f ) {
|
||||
clip |= 1;
|
||||
} else if ( TEXCOORDS0 > 1.0f ) {
|
||||
clip |= 2;
|
||||
}
|
||||
if ( TEXCOORDS1 < 0.0f ) {
|
||||
clip |= 4;
|
||||
} else if ( TEXCOORDS1 > 1.0f ) {
|
||||
clip |= 8;
|
||||
}
|
||||
texCoords[0] = TEXCOORDS0;
|
||||
texCoords[1] = TEXCOORDS1;
|
||||
|
||||
// modulate the strength based on the height and color
|
||||
if ( DIST2 > radius ) {
|
||||
clip |= 16;
|
||||
modulate = 0.0f;
|
||||
} else if ( DIST2 < -radius ) {
|
||||
clip |= 32;
|
||||
modulate = 0.0f;
|
||||
} else {
|
||||
DIST2 = Q_fabs(DIST2);
|
||||
if ( DIST2 < radius * 0.5f ) {
|
||||
modulate = 1.0f;
|
||||
} else {
|
||||
modulate = 2.0f * (radius - DIST2) * scale;
|
||||
}
|
||||
}
|
||||
}
|
||||
clipBits[i] = clip;
|
||||
colors[0] = myftol(floatColor[0] * modulate);
|
||||
colors[1] = myftol(floatColor[1] * modulate);
|
||||
colors[2] = myftol(floatColor[2] * modulate);
|
||||
colors[3] = 255;
|
||||
}
|
||||
#undef DIST0
|
||||
#undef DIST1
|
||||
#undef DIST2
|
||||
#undef TEXCOORDS0
|
||||
#undef TEXCOORDS1
|
||||
|
||||
// build a list of triangles that need light
|
||||
numIndexes = 0;
|
||||
for ( i = 0 ; i < tess.numIndexes ; i += 3 ) {
|
||||
int a, b, c;
|
||||
|
||||
a = tess.indexes[i];
|
||||
b = tess.indexes[i+1];
|
||||
c = tess.indexes[i+2];
|
||||
if ( clipBits[a] & clipBits[b] & clipBits[c] ) {
|
||||
continue; // not lighted
|
||||
}
|
||||
hitIndexes[numIndexes] = a;
|
||||
hitIndexes[numIndexes+1] = b;
|
||||
hitIndexes[numIndexes+2] = c;
|
||||
numIndexes += 3;
|
||||
}
|
||||
|
||||
if ( !numIndexes ) {
|
||||
continue;
|
||||
}
|
||||
|
||||
qglEnableClientState( GL_TEXTURE_COORD_ARRAY );
|
||||
qglTexCoordPointer( 2, GL_FLOAT, 0, texCoordsArray[0] );
|
||||
|
||||
qglEnableClientState( GL_COLOR_ARRAY );
|
||||
qglColorPointer( 4, GL_UNSIGNED_BYTE, 0, colorArray );
|
||||
|
||||
GL_Bind( tr.dlightImage );
|
||||
// include GLS_DEPTHFUNC_EQUAL so alpha tested surfaces don't add light
|
||||
// where they aren't rendered
|
||||
if ( dl->additive ) {
|
||||
GL_State( GLS_SRCBLEND_ONE | GLS_DSTBLEND_ONE | GLS_DEPTHFUNC_EQUAL );
|
||||
}
|
||||
else {
|
||||
GL_State( GLS_SRCBLEND_DST_COLOR | GLS_DSTBLEND_ONE | GLS_DEPTHFUNC_EQUAL );
|
||||
}
|
||||
R_DrawElements( numIndexes, hitIndexes );
|
||||
backEnd.pc.c_totalIndexes += numIndexes;
|
||||
backEnd.pc.c_dlightIndexes += numIndexes;
|
||||
}
|
||||
}
|
||||
|
||||
static void ProjectDlightTexture( void ) {
|
||||
#if idppc_altivec
|
||||
extern cvar_t *com_altivec;
|
||||
if (com_altivec->integer) {
|
||||
// must be in a seperate function or G3 systems will crash.
|
||||
ProjectDlightTexture_altivec();
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
ProjectDlightTexture_scalar();
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
|
|
|
|||
|
|
@ -1097,22 +1097,19 @@ void RB_CalcSpecularAlpha( unsigned char *alphas ) {
|
|||
**
|
||||
** The basic vertex lighting calc
|
||||
*/
|
||||
void RB_CalcDiffuseColor( unsigned char *colors )
|
||||
#if idppc_altivec
|
||||
static void RB_CalcDiffuseColor_altivec( unsigned char *colors )
|
||||
{
|
||||
int i, j;
|
||||
int i;
|
||||
float *v, *normal;
|
||||
float incoming;
|
||||
trRefEntity_t *ent;
|
||||
int ambientLightInt;
|
||||
vec3_t ambientLight;
|
||||
vec3_t lightDir;
|
||||
vec3_t directedLight;
|
||||
int numVertexes;
|
||||
#if idppc_altivec
|
||||
vector unsigned char vSel = (vector unsigned char){0x00, 0x00, 0x00, 0xff,
|
||||
0x00, 0x00, 0x00, 0xff,
|
||||
0x00, 0x00, 0x00, 0xff,
|
||||
0x00, 0x00, 0x00, 0xff};
|
||||
vector unsigned char vSel = VECCONST_UINT8(0x00, 0x00, 0x00, 0xff,
|
||||
0x00, 0x00, 0x00, 0xff,
|
||||
0x00, 0x00, 0x00, 0xff,
|
||||
0x00, 0x00, 0x00, 0xff);
|
||||
vector float ambientLightVec;
|
||||
vector float directedLightVec;
|
||||
vector float lightDirVec;
|
||||
|
|
@ -1122,10 +1119,8 @@ void RB_CalcDiffuseColor( unsigned char *colors )
|
|||
vector signed int jVecInt;
|
||||
vector signed short jVecShort;
|
||||
vector unsigned char jVecChar, normalPerm;
|
||||
#endif
|
||||
ent = backEnd.currentEntity;
|
||||
ambientLightInt = ent->ambientLightInt;
|
||||
#if idppc_altivec
|
||||
// A lot of this could be simplified if we made sure
|
||||
// entities light info was 16-byte aligned.
|
||||
jVecChar = vec_lvsl(0, ent->ambientLight);
|
||||
|
|
@ -1145,21 +1140,13 @@ void RB_CalcDiffuseColor( unsigned char *colors )
|
|||
|
||||
zero = (vector float)vec_splat_s8(0);
|
||||
VectorCopy( ent->lightDir, lightDir );
|
||||
#else
|
||||
VectorCopy( ent->ambientLight, ambientLight );
|
||||
VectorCopy( ent->directedLight, directedLight );
|
||||
VectorCopy( ent->lightDir, lightDir );
|
||||
#endif
|
||||
|
||||
v = tess.xyz[0];
|
||||
normal = tess.normal[0];
|
||||
|
||||
#if idppc_altivec
|
||||
normalPerm = vec_lvsl(0,normal);
|
||||
#endif
|
||||
numVertexes = tess.numVertexes;
|
||||
for (i = 0 ; i < numVertexes ; i++, v += 4, normal += 4) {
|
||||
#if idppc_altivec
|
||||
normalVec0 = vec_ld(0,(vector float *)normal);
|
||||
normalVec1 = vec_ld(11,(vector float *)normal);
|
||||
normalVec0 = vec_perm(normalVec0,normalVec1,normalPerm);
|
||||
|
|
@ -1177,7 +1164,32 @@ void RB_CalcDiffuseColor( unsigned char *colors )
|
|||
jVecChar = vec_packsu(jVecShort,jVecShort); // RGBxRGBxRGBxRGBx
|
||||
jVecChar = vec_sel(jVecChar,vSel,vSel); // RGBARGBARGBARGBA replace alpha with 255
|
||||
vec_ste((vector unsigned int)jVecChar,0,(unsigned int *)&colors[i*4]); // store color
|
||||
#else
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
static void RB_CalcDiffuseColor_scalar( unsigned char *colors )
|
||||
{
|
||||
int i, j;
|
||||
float *v, *normal;
|
||||
float incoming;
|
||||
trRefEntity_t *ent;
|
||||
int ambientLightInt;
|
||||
vec3_t ambientLight;
|
||||
vec3_t lightDir;
|
||||
vec3_t directedLight;
|
||||
int numVertexes;
|
||||
ent = backEnd.currentEntity;
|
||||
ambientLightInt = ent->ambientLightInt;
|
||||
VectorCopy( ent->ambientLight, ambientLight );
|
||||
VectorCopy( ent->directedLight, directedLight );
|
||||
VectorCopy( ent->lightDir, lightDir );
|
||||
|
||||
v = tess.xyz[0];
|
||||
normal = tess.normal[0];
|
||||
|
||||
numVertexes = tess.numVertexes;
|
||||
for (i = 0 ; i < numVertexes ; i++, v += 4, normal += 4) {
|
||||
incoming = DotProduct (normal, lightDir);
|
||||
if ( incoming <= 0 ) {
|
||||
*(int *)&colors[i*4] = ambientLightInt;
|
||||
|
|
@ -1202,7 +1214,19 @@ void RB_CalcDiffuseColor( unsigned char *colors )
|
|||
colors[i*4+2] = j;
|
||||
|
||||
colors[i*4+3] = 255;
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
void RB_CalcDiffuseColor( unsigned char *colors )
|
||||
{
|
||||
#if idppc_altivec
|
||||
extern cvar_t *com_altivec;
|
||||
if (com_altivec->integer) {
|
||||
// must be in a seperate function or G3 systems will crash.
|
||||
RB_CalcDiffuseColor_altivec( colors );
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
RB_CalcDiffuseColor_scalar( colors );
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -610,7 +610,8 @@ static void VectorArrayNormalize(vec4_t *normals, unsigned int count)
|
|||
/*
|
||||
** LerpMeshVertexes
|
||||
*/
|
||||
static void LerpMeshVertexes (md3Surface_t *surf, float backlerp)
|
||||
#if idppc_altivec
|
||||
static void LerpMeshVertexes_altivec(md3Surface_t *surf, float backlerp)
|
||||
{
|
||||
short *oldXyz, *newXyz, *oldNormals, *newNormals;
|
||||
float *outXyz, *outNormal;
|
||||
|
|
@ -633,7 +634,6 @@ static void LerpMeshVertexes (md3Surface_t *surf, float backlerp)
|
|||
numVerts = surf->numVerts;
|
||||
|
||||
if ( backlerp == 0 ) {
|
||||
#if idppc_altivec
|
||||
vector signed short newNormalsVec0;
|
||||
vector signed short newNormalsVec1;
|
||||
vector signed int newNormalsIntVec;
|
||||
|
|
@ -687,34 +687,6 @@ static void LerpMeshVertexes (md3Surface_t *surf, float backlerp)
|
|||
vec_ste(newNormalsFloatVec,4,outXyz);
|
||||
vec_ste(newNormalsFloatVec,8,outXyz);
|
||||
}
|
||||
|
||||
#else
|
||||
//
|
||||
// just copy the vertexes
|
||||
//
|
||||
for (vertNum=0 ; vertNum < numVerts ; vertNum++,
|
||||
newXyz += 4, newNormals += 4,
|
||||
outXyz += 4, outNormal += 4)
|
||||
{
|
||||
|
||||
outXyz[0] = newXyz[0] * newXyzScale;
|
||||
outXyz[1] = newXyz[1] * newXyzScale;
|
||||
outXyz[2] = newXyz[2] * newXyzScale;
|
||||
|
||||
lat = ( newNormals[0] >> 8 ) & 0xff;
|
||||
lng = ( newNormals[0] & 0xff );
|
||||
lat *= (FUNCTABLE_SIZE/256);
|
||||
lng *= (FUNCTABLE_SIZE/256);
|
||||
|
||||
// decode X as cos( lat ) * sin( long )
|
||||
// decode Y as sin( lat ) * sin( long )
|
||||
// decode Z as cos( long )
|
||||
|
||||
outNormal[0] = tr.sinTable[(lat+(FUNCTABLE_SIZE/4))&FUNCTABLE_MASK] * tr.sinTable[lng];
|
||||
outNormal[1] = tr.sinTable[lat] * tr.sinTable[lng];
|
||||
outNormal[2] = tr.sinTable[(lng+(FUNCTABLE_SIZE/4))&FUNCTABLE_MASK];
|
||||
}
|
||||
#endif
|
||||
} else {
|
||||
//
|
||||
// interpolate and copy the vertex and normal
|
||||
|
|
@ -764,6 +736,132 @@ static void LerpMeshVertexes (md3Surface_t *surf, float backlerp)
|
|||
VectorArrayNormalize((vec4_t *)tess.normal[tess.numVertexes], numVerts);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
static void LerpMeshVertexes_scalar(md3Surface_t *surf, float backlerp)
|
||||
{
|
||||
short *oldXyz, *newXyz, *oldNormals, *newNormals;
|
||||
float *outXyz, *outNormal;
|
||||
float oldXyzScale, newXyzScale;
|
||||
float oldNormalScale, newNormalScale;
|
||||
int vertNum;
|
||||
unsigned lat, lng;
|
||||
int numVerts;
|
||||
|
||||
outXyz = tess.xyz[tess.numVertexes];
|
||||
outNormal = tess.normal[tess.numVertexes];
|
||||
|
||||
newXyz = (short *)((byte *)surf + surf->ofsXyzNormals)
|
||||
+ (backEnd.currentEntity->e.frame * surf->numVerts * 4);
|
||||
newNormals = newXyz + 3;
|
||||
|
||||
newXyzScale = MD3_XYZ_SCALE * (1.0 - backlerp);
|
||||
newNormalScale = 1.0 - backlerp;
|
||||
|
||||
numVerts = surf->numVerts;
|
||||
|
||||
if ( backlerp == 0 ) {
|
||||
//
|
||||
// just copy the vertexes
|
||||
//
|
||||
for (vertNum=0 ; vertNum < numVerts ; vertNum++,
|
||||
newXyz += 4, newNormals += 4,
|
||||
outXyz += 4, outNormal += 4)
|
||||
{
|
||||
|
||||
outXyz[0] = newXyz[0] * newXyzScale;
|
||||
outXyz[1] = newXyz[1] * newXyzScale;
|
||||
outXyz[2] = newXyz[2] * newXyzScale;
|
||||
|
||||
lat = ( newNormals[0] >> 8 ) & 0xff;
|
||||
lng = ( newNormals[0] & 0xff );
|
||||
lat *= (FUNCTABLE_SIZE/256);
|
||||
lng *= (FUNCTABLE_SIZE/256);
|
||||
|
||||
// decode X as cos( lat ) * sin( long )
|
||||
// decode Y as sin( lat ) * sin( long )
|
||||
// decode Z as cos( long )
|
||||
|
||||
outNormal[0] = tr.sinTable[(lat+(FUNCTABLE_SIZE/4))&FUNCTABLE_MASK] * tr.sinTable[lng];
|
||||
outNormal[1] = tr.sinTable[lat] * tr.sinTable[lng];
|
||||
outNormal[2] = tr.sinTable[(lng+(FUNCTABLE_SIZE/4))&FUNCTABLE_MASK];
|
||||
}
|
||||
} else {
|
||||
//
|
||||
// interpolate and copy the vertex and normal
|
||||
//
|
||||
oldXyz = (short *)((byte *)surf + surf->ofsXyzNormals)
|
||||
+ (backEnd.currentEntity->e.oldframe * surf->numVerts * 4);
|
||||
oldNormals = oldXyz + 3;
|
||||
|
||||
oldXyzScale = MD3_XYZ_SCALE * backlerp;
|
||||
oldNormalScale = backlerp;
|
||||
|
||||
for (vertNum=0 ; vertNum < numVerts ; vertNum++,
|
||||
oldXyz += 4, newXyz += 4, oldNormals += 4, newNormals += 4,
|
||||
outXyz += 4, outNormal += 4)
|
||||
{
|
||||
vec3_t uncompressedOldNormal, uncompressedNewNormal;
|
||||
|
||||
// interpolate the xyz
|
||||
outXyz[0] = oldXyz[0] * oldXyzScale + newXyz[0] * newXyzScale;
|
||||
outXyz[1] = oldXyz[1] * oldXyzScale + newXyz[1] * newXyzScale;
|
||||
outXyz[2] = oldXyz[2] * oldXyzScale + newXyz[2] * newXyzScale;
|
||||
|
||||
// FIXME: interpolate lat/long instead?
|
||||
lat = ( newNormals[0] >> 8 ) & 0xff;
|
||||
lng = ( newNormals[0] & 0xff );
|
||||
lat *= 4;
|
||||
lng *= 4;
|
||||
uncompressedNewNormal[0] = tr.sinTable[(lat+(FUNCTABLE_SIZE/4))&FUNCTABLE_MASK] * tr.sinTable[lng];
|
||||
uncompressedNewNormal[1] = tr.sinTable[lat] * tr.sinTable[lng];
|
||||
uncompressedNewNormal[2] = tr.sinTable[(lng+(FUNCTABLE_SIZE/4))&FUNCTABLE_MASK];
|
||||
|
||||
lat = ( oldNormals[0] >> 8 ) & 0xff;
|
||||
lng = ( oldNormals[0] & 0xff );
|
||||
lat *= 4;
|
||||
lng *= 4;
|
||||
|
||||
uncompressedOldNormal[0] = tr.sinTable[(lat+(FUNCTABLE_SIZE/4))&FUNCTABLE_MASK] * tr.sinTable[lng];
|
||||
uncompressedOldNormal[1] = tr.sinTable[lat] * tr.sinTable[lng];
|
||||
uncompressedOldNormal[2] = tr.sinTable[(lng+(FUNCTABLE_SIZE/4))&FUNCTABLE_MASK];
|
||||
|
||||
outNormal[0] = uncompressedOldNormal[0] * oldNormalScale + uncompressedNewNormal[0] * newNormalScale;
|
||||
outNormal[1] = uncompressedOldNormal[1] * oldNormalScale + uncompressedNewNormal[1] * newNormalScale;
|
||||
outNormal[2] = uncompressedOldNormal[2] * oldNormalScale + uncompressedNewNormal[2] * newNormalScale;
|
||||
|
||||
// VectorNormalize (outNormal);
|
||||
}
|
||||
VectorArrayNormalize((vec4_t *)tess.normal[tess.numVertexes], numVerts);
|
||||
}
|
||||
}
|
||||
|
||||
static void LerpMeshVertexes(md3Surface_t *surf, float backlerp)
|
||||
{
|
||||
#if idppc_altivec
|
||||
|
||||
// !!! FIXME: figure out what's broken and remove this.
|
||||
#ifndef NDEBUG
|
||||
static int already_complained = 0;
|
||||
if (!already_complained)
|
||||
{
|
||||
already_complained = 1;
|
||||
Com_Printf("WARNING! FIXME! Altivec mesh lerping broken in debug builds!\n");
|
||||
}
|
||||
#else
|
||||
extern cvar_t *com_altivec;
|
||||
if (com_altivec->integer) {
|
||||
// must be in a seperate function or G3 systems will crash.
|
||||
LerpMeshVertexes_altivec( surf, backlerp );
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif // idppc_altivec
|
||||
|
||||
LerpMeshVertexes_scalar( surf, backlerp );
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
=============
|
||||
|
|
|
|||
|
|
@ -218,6 +218,11 @@ typedef struct {
|
|||
#define _3DFX_DRIVER_NAME "3dfxvgl"
|
||||
#define OPENGL_DRIVER_NAME "opengl32"
|
||||
|
||||
#elif defined(MACOS_X)
|
||||
|
||||
#define _3DFX_DRIVER_NAME "libMesaVoodooGL.dylib"
|
||||
#define OPENGL_DRIVER_NAME "/System/Library/Frameworks/OpenGL.framework/Libraries/libGL.dylib"
|
||||
|
||||
#else
|
||||
|
||||
#define _3DFX_DRIVER_NAME "libMesaVoodooGL.so"
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue