/*
* R_DrawSkyportal
*/
static void R_DrawSkyportal( const entity_t *e, skyportal_t *skyportal ) {
if( !R_PushRefInst() ) {
return;
}
rn.renderFlags = ( rn.renderFlags | RF_PORTALVIEW );
//rn.renderFlags &= ~RF_SOFT_PARTICLES;
VectorCopy( skyportal->vieworg, rn.pvsOrigin );
rn.nearClip = Z_NEAR;
rn.farClip = R_DefaultFarClip();
rn.polygonFactor = POLYOFFSET_FACTOR;
rn.polygonUnits = POLYOFFSET_UNITS;
rn.clipFlags = 15;
rn.meshlist = &r_skyportallist;
rn.portalmasklist = NULL;
rn.rtLight = NULL;
//Vector4Set( rn.scissor, rn.refdef.x + x, rn.refdef.y + y, w, h );
if( skyportal->noEnts ) {
rn.renderFlags |= RF_ENVVIEW;
}
if( skyportal->scale ) {
vec3_t centre, diff;
VectorAdd( rsh.worldModel->mins, rsh.worldModel->maxs, centre );
VectorScale( centre, 0.5f, centre );
VectorSubtract( centre, rn.viewOrigin, diff );
VectorMA( skyportal->vieworg, -skyportal->scale, diff, rn.refdef.vieworg );
} else {
VectorCopy( skyportal->vieworg, rn.refdef.vieworg );
}
// FIXME
if( !VectorCompare( skyportal->viewanglesOffset, vec3_origin ) ) {
vec3_t angles;
mat3_t axis;
Matrix3_Copy( rn.refdef.viewaxis, axis );
VectorInverse( &axis[AXIS_RIGHT] );
Matrix3_ToAngles( axis, angles );
VectorAdd( angles, skyportal->viewanglesOffset, angles );
AnglesToAxis( angles, axis );
Matrix3_Copy( axis, rn.refdef.viewaxis );
}
rn.refdef.rdflags &= ~( RDF_UNDERWATER | RDF_CROSSINGWATER | RDF_SKYPORTALINVIEW );
if( skyportal->fov ) {
rn.refdef.fov_y = WidescreenFov( skyportal->fov );
rn.refdef.fov_x = CalcHorizontalFov( rn.refdef.fov_y, rn.refdef.width, rn.refdef.height );
}
R_SetupViewMatrices( &rn.refdef );
R_SetupFrustum( &rn.refdef, rn.nearClip, rn.farClip, rn.frustum, rn.frustumCorners );
R_SetupPVS( &rn.refdef );
R_RenderView( &rn.refdef );
// restore modelview and projection matrices, scissoring, etc for the main view
R_PopRefInst();
}
/*
========================
RB_CalcDeformVertexes
========================
*/
void RB_CalcDeformVertexes( deformStage_t *ds ) {
int i;
vec3_t offset;
float scale;
float *xyz = ( float * ) tess.xyz;
float *normal = ( float * ) tess.normal;
float *table;
// Ridah
if ( ds->deformationWave.frequency < 0 ) {
qboolean inverse = qfalse;
vec3_t worldUp;
//static vec3_t up = {0,0,1};
if ( VectorCompare( backEnd.currentEntity->e.fireRiseDir, vec3_origin ) ) {
VectorSet( backEnd.currentEntity->e.fireRiseDir, 0, 0, 1 );
}
// get the world up vector in local coordinates
if ( backEnd.currentEntity->e.hModel ) { // world surfaces dont have an axis
VectorRotate( backEnd.currentEntity->e.fireRiseDir, backEnd.currentEntity->e.axis, worldUp );
} else {
VectorCopy( backEnd.currentEntity->e.fireRiseDir, worldUp );
}
// don't go so far if sideways, since they must be moving
VectorScale( worldUp, 0.4 + 0.6 * fabs( backEnd.currentEntity->e.fireRiseDir[2] ), worldUp );
ds->deformationWave.frequency *= -1;
if ( ds->deformationWave.frequency > 999 ) { // hack for negative Z deformation (ack)
inverse = qtrue;
ds->deformationWave.frequency -= 999;
}
table = TableForFunc( ds->deformationWave.func );
for ( i = 0; i < tess.numVertexes; i++, xyz += 4, normal += 4 )
{
float off = ( xyz[0] + xyz[1] + xyz[2] ) * ds->deformationSpread;
float dot;
scale = WAVEVALUE( table, ds->deformationWave.base,
ds->deformationWave.amplitude,
ds->deformationWave.phase + off,
ds->deformationWave.frequency );
dot = DotProduct( worldUp, normal );
if ( dot * scale > 0 ) {
if ( inverse ) {
scale *= -1;
}
VectorMA( xyz, dot * scale, worldUp, xyz );
}
}
if ( inverse ) {
ds->deformationWave.frequency += 999;
}
ds->deformationWave.frequency *= -1;
}
// done.
else if ( ds->deformationWave.frequency == 0 ) {
scale = EvalWaveForm( &ds->deformationWave );
for ( i = 0; i < tess.numVertexes; i++, xyz += 4, normal += 4 )
{
VectorScale( normal, scale, offset );
xyz[0] += offset[0];
xyz[1] += offset[1];
xyz[2] += offset[2];
}
} else
{
table = TableForFunc( ds->deformationWave.func );
for ( i = 0; i < tess.numVertexes; i++, xyz += 4, normal += 4 )
{
float off = ( xyz[0] + xyz[1] + xyz[2] ) * ds->deformationSpread;
scale = WAVEVALUE( table, ds->deformationWave.base,
ds->deformationWave.amplitude,
ds->deformationWave.phase + off,
ds->deformationWave.frequency );
VectorScale( normal, scale, offset );
xyz[0] += offset[0];
xyz[1] += offset[1];
xyz[2] += offset[2];
}
}
}
static void GM_CheckFireState( void )
{
if ( enemyCS4 )
{//if have a clear shot, always try
return;
}
if ( !VectorCompare( NPC->client->ps.velocity, vec3_origin ) )
{//if moving at all, don't do this
return;
}
//See if we should continue to fire on their last position
if ( !hitAlly4 && NPCInfo->enemyLastSeenTime > 0 )
{
if ( level.time - NPCInfo->enemyLastSeenTime < 10000 )
{
if ( !Q_irand( 0, 10 ) )
{
//Fire on the last known position
vec3_t muzzle, dir, angles;
qboolean tooClose = qfalse;
qboolean tooFar = qfalse;
float distThreshold;
float dist;
CalcEntitySpot( NPC, SPOT_HEAD, muzzle );
if ( VectorCompare( impactPos4, vec3_origin ) )
{//never checked ShotEntity this frame, so must do a trace...
trace_t tr;
//vec3_t mins = {-2,-2,-2}, maxs = {2,2,2};
vec3_t forward, end;
AngleVectors( NPC->client->ps.viewangles, forward, NULL, NULL );
VectorMA( muzzle, 8192, forward, end );
trap_Trace( &tr, muzzle, vec3_origin, vec3_origin, end, NPC->s.number, MASK_SHOT );
VectorCopy( tr.endpos, impactPos4 );
}
//see if impact would be too close to me
distThreshold = 16384/*128*128*/;//default
if ( NPC->s.weapon == WP_REPEATER )
{
if ( NPCInfo->scriptFlags&SCF_ALT_FIRE )
{
distThreshold = 65536/*256*256*/;
}
}
dist = DistanceSquared( impactPos4, muzzle );
if ( dist < distThreshold )
{//impact would be too close to me
tooClose = qtrue;
}
else if ( level.time - NPCInfo->enemyLastSeenTime > 5000 )
{//we've haven't seen them in the last 5 seconds
//see if it's too far from where he is
distThreshold = 65536/*256*256*/;//default
if ( NPC->s.weapon == WP_REPEATER )
{
if ( NPCInfo->scriptFlags&SCF_ALT_FIRE )
{
distThreshold = 262144/*512*512*/;
}
}
dist = DistanceSquared( impactPos4, NPCInfo->enemyLastSeenLocation );
if ( dist > distThreshold )
{//impact would be too far from enemy
tooFar = qtrue;
}
}
if ( !tooClose && !tooFar )
{//okay too shoot at last pos
VectorSubtract( NPCInfo->enemyLastSeenLocation, muzzle, dir );
VectorNormalize( dir );
vectoangles( dir, angles );
NPCInfo->desiredYaw = angles[YAW];
NPCInfo->desiredPitch = angles[PITCH];
shoot4 = qtrue;
faceEnemy4 = qfalse;
return;
}
}
}
}
}
/*
===============
ComputeColors
===============
*/
static void ComputeColors( shaderStage_t *pStage ) {
int i;
//
// rgbGen
//
switch ( pStage->rgbGen )
{
case CGEN_IDENTITY:
memset( tess.svars.colors, 0xff, tess.numVertexes * 4 );
break;
default:
case CGEN_IDENTITY_LIGHTING:
memset( tess.svars.colors, tr.identityLightByte, tess.numVertexes * 4 );
break;
case CGEN_LIGHTING_DIFFUSE:
RB_CalcDiffuseColor( ( unsigned char * ) tess.svars.colors );
break;
case CGEN_EXACT_VERTEX:
memcpy( tess.svars.colors, tess.vertexColors, tess.numVertexes * sizeof( tess.vertexColors[0] ) );
break;
case CGEN_CONST:
for ( i = 0; i < tess.numVertexes; i++ ) {
*(int *)tess.svars.colors[i] = *(int *)pStage->constantColor;
}
break;
case CGEN_VERTEX:
if ( tr.identityLight == 1 ) {
memcpy( tess.svars.colors, tess.vertexColors, tess.numVertexes * sizeof( tess.vertexColors[0] ) );
} else
{
for ( i = 0; i < tess.numVertexes; i++ )
{
tess.svars.colors[i][0] = tess.vertexColors[i][0] * tr.identityLight;
tess.svars.colors[i][1] = tess.vertexColors[i][1] * tr.identityLight;
tess.svars.colors[i][2] = tess.vertexColors[i][2] * tr.identityLight;
tess.svars.colors[i][3] = tess.vertexColors[i][3];
}
}
break;
case CGEN_ONE_MINUS_VERTEX:
if ( tr.identityLight == 1 ) {
for ( i = 0; i < tess.numVertexes; i++ )
{
tess.svars.colors[i][0] = 255 - tess.vertexColors[i][0];
tess.svars.colors[i][1] = 255 - tess.vertexColors[i][1];
tess.svars.colors[i][2] = 255 - tess.vertexColors[i][2];
}
} else
{
for ( i = 0; i < tess.numVertexes; i++ )
{
tess.svars.colors[i][0] = ( 255 - tess.vertexColors[i][0] ) * tr.identityLight;
tess.svars.colors[i][1] = ( 255 - tess.vertexColors[i][1] ) * tr.identityLight;
tess.svars.colors[i][2] = ( 255 - tess.vertexColors[i][2] ) * tr.identityLight;
}
}
break;
case CGEN_FOG:
{
fog_t *fog;
fog = tr.world->fogs + tess.fogNum;
for ( i = 0; i < tess.numVertexes; i++ ) {
*( int * )&tess.svars.colors[i] = fog->colorInt;
}
}
break;
case CGEN_WAVEFORM:
RB_CalcWaveColor( &pStage->rgbWave, ( unsigned char * ) tess.svars.colors );
break;
case CGEN_ENTITY:
RB_CalcColorFromEntity( ( unsigned char * ) tess.svars.colors );
break;
case CGEN_ONE_MINUS_ENTITY:
RB_CalcColorFromOneMinusEntity( ( unsigned char * ) tess.svars.colors );
break;
}
//
// alphaGen
//
switch ( pStage->alphaGen )
{
case AGEN_SKIP:
break;
case AGEN_IDENTITY:
if ( pStage->rgbGen != CGEN_IDENTITY ) {
if ( ( pStage->rgbGen == CGEN_VERTEX && tr.identityLight != 1 ) ||
pStage->rgbGen != CGEN_VERTEX ) {
for ( i = 0; i < tess.numVertexes; i++ ) {
tess.svars.colors[i][3] = 0xff;
}
}
}
break;
case AGEN_CONST:
if ( pStage->rgbGen != CGEN_CONST ) {
for ( i = 0; i < tess.numVertexes; i++ ) {
tess.svars.colors[i][3] = pStage->constantColor[3];
}
}
break;
case AGEN_WAVEFORM:
RB_CalcWaveAlpha( &pStage->alphaWave, ( unsigned char * ) tess.svars.colors );
break;
case AGEN_LIGHTING_SPECULAR:
RB_CalcSpecularAlpha( ( unsigned char * ) tess.svars.colors );
break;
case AGEN_ENTITY:
RB_CalcAlphaFromEntity( ( unsigned char * ) tess.svars.colors );
break;
case AGEN_ONE_MINUS_ENTITY:
RB_CalcAlphaFromOneMinusEntity( ( unsigned char * ) tess.svars.colors );
break;
// Ridah
case AGEN_NORMALZFADE:
{
float alpha, range, lowest, highest, dot;
vec3_t worldUp;
qboolean zombieEffect = qfalse;
if ( VectorCompare( backEnd.currentEntity->e.fireRiseDir, vec3_origin ) ) {
VectorSet( backEnd.currentEntity->e.fireRiseDir, 0, 0, 1 );
}
if ( backEnd.currentEntity->e.hModel ) { // world surfaces dont have an axis
VectorRotate( backEnd.currentEntity->e.fireRiseDir, backEnd.currentEntity->e.axis, worldUp );
} else {
VectorCopy( backEnd.currentEntity->e.fireRiseDir, worldUp );
}
lowest = pStage->zFadeBounds[0];
if ( lowest == -1000 ) { // use entity alpha
lowest = backEnd.currentEntity->e.shaderTime;
zombieEffect = qtrue;
}
highest = pStage->zFadeBounds[1];
if ( highest == -1000 ) { // use entity alpha
highest = backEnd.currentEntity->e.shaderTime;
zombieEffect = qtrue;
}
range = highest - lowest;
for ( i = 0; i < tess.numVertexes; i++ ) {
dot = DotProduct( tess.normal[i], worldUp );
// special handling for Zombie fade effect
if ( zombieEffect ) {
alpha = (float)backEnd.currentEntity->e.shaderRGBA[3] * ( dot + 1.0 ) / 2.0;
alpha += ( 2.0 * (float)backEnd.currentEntity->e.shaderRGBA[3] ) * ( 1.0 - ( dot + 1.0 ) / 2.0 );
if ( alpha > 255.0 ) {
alpha = 255.0;
} else if ( alpha < 0.0 ) {
alpha = 0.0;
}
tess.svars.colors[i][3] = (byte)( alpha );
continue;
}
if ( dot < highest ) {
if ( dot > lowest ) {
if ( dot < lowest + range / 2 ) {
alpha = ( (float)pStage->constantColor[3] * ( ( dot - lowest ) / ( range / 2 ) ) );
} else {
alpha = ( (float)pStage->constantColor[3] * ( 1.0 - ( ( dot - lowest - range / 2 ) / ( range / 2 ) ) ) );
}
if ( alpha > 255.0 ) {
alpha = 255.0;
} else if ( alpha < 0.0 ) {
alpha = 0.0;
}
// finally, scale according to the entity's alpha
if ( backEnd.currentEntity->e.hModel ) {
alpha *= (float)backEnd.currentEntity->e.shaderRGBA[3] / 255.0;
}
tess.svars.colors[i][3] = (byte)( alpha );
} else {
tess.svars.colors[i][3] = 0;
}
} else {
tess.svars.colors[i][3] = 0;
}
}
}
break;
// done.
case AGEN_VERTEX:
if ( pStage->rgbGen != CGEN_VERTEX ) {
for ( i = 0; i < tess.numVertexes; i++ ) {
tess.svars.colors[i][3] = tess.vertexColors[i][3];
}
}
break;
case AGEN_ONE_MINUS_VERTEX:
for ( i = 0; i < tess.numVertexes; i++ )
{
tess.svars.colors[i][3] = 255 - tess.vertexColors[i][3];
}
break;
case AGEN_PORTAL:
{
unsigned char alpha;
for ( i = 0; i < tess.numVertexes; i++ )
{
float len;
vec3_t v;
VectorSubtract( tess.xyz[i], backEnd.viewParms.or.origin, v );
len = VectorLength( v );
len /= tess.shader->portalRange;
if ( len < 0 ) {
alpha = 0;
} else if ( len > 1 ) {
alpha = 0xff;
} else
{
alpha = len * 0xff;
}
tess.svars.colors[i][3] = alpha;
}
}
break;
}
//
// fog adjustment for colors to fade out as fog increases
//
if ( tess.fogNum ) {
switch ( pStage->adjustColorsForFog )
{
case ACFF_MODULATE_RGB:
RB_CalcModulateColorsByFog( ( unsigned char * ) tess.svars.colors );
break;
case ACFF_MODULATE_ALPHA:
RB_CalcModulateAlphasByFog( ( unsigned char * ) tess.svars.colors );
break;
case ACFF_MODULATE_RGBA:
RB_CalcModulateRGBAsByFog( ( unsigned char * ) tess.svars.colors );
break;
case ACFF_NONE:
break;
}
}
}
/*
=================
fire_lead
This is an internal support routine used for bullet/pellet based weapons.
=================
*/
static void fire_lead (edict_t *self, vec3_t start, vec3_t aimdir, int damage, int kick, int te_impact, int hspread, int vspread, int mod)
{
trace_t tr;
vec3_t dir;
vec3_t forward, right, up;
vec3_t end;
float r;
float u;
vec3_t water_start;
qboolean water = false;
int content_mask = MASK_SHOT | MASK_WATER;
tr = gi.trace (self->s.origin, NULL, NULL, start, self, MASK_SHOT);
if (!(tr.fraction < 1.0))
{
vectoangles (aimdir, dir);
AngleVectors (dir, forward, right, up);
r = crandom()*hspread;
u = crandom()*vspread;
VectorMA (start, 8192, forward, end);
VectorMA (end, r, right, end);
VectorMA (end, u, up, end);
if (gi.pointcontents (start) & MASK_WATER)
{
water = true;
VectorCopy (start, water_start);
content_mask &= ~MASK_WATER;
}
tr = gi.trace (start, NULL, NULL, end, self, content_mask);
// see if we hit water
if (tr.contents & MASK_WATER)
{
int color;
water = true;
VectorCopy (tr.endpos, water_start);
if (!VectorCompare (start, tr.endpos))
{
if (tr.contents & CONTENTS_WATER)
{
if (strcmp(tr.surface->name, "*brwater") == 0)
color = SPLASH_BROWN_WATER;
else
color = SPLASH_BLUE_WATER;
}
else if (tr.contents & CONTENTS_SLIME)
color = SPLASH_SLIME;
else if (tr.contents & CONTENTS_LAVA)
color = SPLASH_LAVA;
else
color = SPLASH_UNKNOWN;
if (color != SPLASH_UNKNOWN)
{
gi.WriteByte (svc_temp_entity);
gi.WriteByte (TE_SPLASH);
gi.WriteByte (8);
gi.WritePosition (tr.endpos);
gi.WriteDir (tr.plane.normal);
gi.WriteByte (color);
gi.multicast (tr.endpos, MULTICAST_PVS);
}
// change bullet's course when it enters water
VectorSubtract (end, start, dir);
vectoangles (dir, dir);
AngleVectors (dir, forward, right, up);
r = crandom()*hspread*2;
u = crandom()*vspread*2;
VectorMA (water_start, 8192, forward, end);
VectorMA (end, r, right, end);
VectorMA (end, u, up, end);
}
// re-trace ignoring water this time
tr = gi.trace (water_start, NULL, NULL, end, self, MASK_SHOT);
}
}
// send gun puff / flash
if (!((tr.surface) && (tr.surface->flags & SURF_SKY)))
{
if (tr.fraction < 1.0)
{
if (tr.ent->takedamage)
{
T_Damage (tr.ent, self, self, aimdir, tr.endpos, tr.plane.normal, damage, kick, DAMAGE_BULLET, mod);
}
else
{
if (strncmp (tr.surface->name, "sky", 3) != 0)
{
gi.WriteByte (svc_temp_entity);
gi.WriteByte (te_impact);
gi.WritePosition (tr.endpos);
gi.WriteDir (tr.plane.normal);
gi.multicast (tr.endpos, MULTICAST_PVS);
if (self->client)
PlayerNoise(self, tr.endpos, PNOISE_IMPACT);
}
}
}
}
// if went through water, determine where the end and make a bubble trail
if (water)
{
vec3_t pos;
VectorSubtract (tr.endpos, water_start, dir);
VectorNormalize (dir);
VectorMA (tr.endpos, -2, dir, pos);
if (gi.pointcontents (pos) & MASK_WATER)
VectorCopy (pos, tr.endpos);
else
tr = gi.trace (pos, NULL, NULL, water_start, tr.ent, MASK_WATER);
VectorAdd (water_start, tr.endpos, pos);
VectorScale (pos, 0.5, pos);
gi.WriteByte (svc_temp_entity);
gi.WriteByte (TE_BUBBLETRAIL);
gi.WritePosition (water_start);
gi.WritePosition (tr.endpos);
gi.multicast (pos, MULTICAST_PVS);
}
}
void WriteSurfaceExtraFile( const char *path )
{
char srfPath[ 1024 ];
FILE *sf;
surfaceExtra_t *se;
int i;
/* dummy check */
if( path == NULL || path[ 0 ] == '\0' )
return;
/* note it */
Sys_Printf( "--- WriteSurfaceExtraFile ---\n" );
/* open the file */
strcpy( srfPath, path );
StripExtension( srfPath );
strcat( srfPath, ".srf" );
Sys_Printf( "Writing %s\n", srfPath );
sf = fopen( srfPath, "w" );
if( sf == NULL )
Error( "Error opening %s for writing", srfPath );
/* lap through the extras list */
for( i = -1; i < numSurfaceExtras; i++ )
{
/* get extra */
se = GetSurfaceExtra( i );
/* default or surface num? */
if( i < 0 )
fprintf( sf, "default" );
else
fprintf( sf, "%d", i );
/* valid map drawsurf? */
if( se->mds == NULL )
fprintf( sf, "\n" );
else
{
fprintf( sf, " // %s V: %d I: %d %s\n",
surfaceTypes[ se->mds->type ],
se->mds->numVerts,
se->mds->numIndexes,
(se->mds->planar ? "planar" : "") );
}
/* open braces */
fprintf( sf, "{\n" );
/* shader */
if( se->si != NULL )
fprintf( sf, "\tshader %s\n", se->si->shader );
/* parent surface number */
if( se->parentSurfaceNum != seDefault.parentSurfaceNum )
fprintf( sf, "\tparent %d\n", se->parentSurfaceNum );
/* entity number */
if( se->entityNum != seDefault.entityNum )
fprintf( sf, "\tentity %d\n", se->entityNum );
/* cast shadows */
if( se->castShadows != seDefault.castShadows || se == &seDefault )
fprintf( sf, "\tcastShadows %d\n", se->castShadows );
/* recv shadows */
if( se->recvShadows != seDefault.recvShadows || se == &seDefault )
fprintf( sf, "\treceiveShadows %d\n", se->recvShadows );
/* lightmap sample size */
if( se->sampleSize != seDefault.sampleSize || se == &seDefault )
fprintf( sf, "\tsampleSize %d\n", se->sampleSize );
/* longest curve */
if( se->longestCurve != seDefault.longestCurve || se == &seDefault )
fprintf( sf, "\tlongestCurve %f\n", se->longestCurve );
/* lightmap axis vector */
if( VectorCompare( se->lightmapAxis, seDefault.lightmapAxis ) == qfalse )
fprintf( sf, "\tlightmapAxis ( %f %f %f )\n", se->lightmapAxis[ 0 ], se->lightmapAxis[ 1 ], se->lightmapAxis[ 2 ] );
/* close braces */
fprintf( sf, "}\n\n" );
}
/* close the file */
fclose( sf );
}
void PM_VehicleImpact(bgEntity_t *pEnt, trace_t *trace)
{
// See if the vehicle has crashed into the ground.
Vehicle_t *pSelfVeh = pEnt->m_pVehicle;
float magnitude = VectorLength( pm->ps->velocity ) * pSelfVeh->m_pVehicleInfo->mass / 50.0f;
qboolean forceSurfDestruction = qfalse;
#ifdef QAGAME
gentity_t *hitEnt = trace!=NULL?&g_entities[trace->entityNum]:NULL;
if (!hitEnt ||
(pSelfVeh && pSelfVeh->m_pPilot &&
hitEnt && hitEnt->s.eType == ET_MISSILE && hitEnt->inuse &&
hitEnt->r.ownerNum == pSelfVeh->m_pPilot->s.number)
)
{
return;
}
if ( pSelfVeh//I have a vehicle struct
&& pSelfVeh->m_iRemovedSurfaces )//vehicle has bits removed
{//spiralling to our deaths, explode on any solid impact
if ( hitEnt->s.NPC_class == CLASS_VEHICLE )
{//hit another vehicle, explode!
//Give credit to whoever got me into this death spiral state
gentity_t *parent = (gentity_t *)pSelfVeh->m_pParentEntity;
gentity_t *killer = NULL;
if (parent->client->ps.otherKiller < ENTITYNUM_WORLD &&
parent->client->ps.otherKillerTime > level.time)
{
gentity_t *potentialKiller = &g_entities[parent->client->ps.otherKiller];
if (potentialKiller->inuse && potentialKiller->client)
{ //he's valid I guess
killer = potentialKiller;
}
}
//FIXME: damage hitEnt, some, too? Our explosion should hurt them some, but...
G_Damage( (gentity_t *)pEnt, killer, killer, NULL, pm->ps->origin, 999999, DAMAGE_NO_ARMOR, MOD_FALLING );//FIXME: MOD_IMPACT
return;
}
else if ( !VectorCompare( trace->plane.normal, vec3_origin )
&& (trace->entityNum == ENTITYNUM_WORLD || hitEnt->r.bmodel ) )
{//have a valid hit plane and we hit a solid brush
vec3_t moveDir;
float impactDot;
VectorCopy( pm->ps->velocity, moveDir );
VectorNormalize( moveDir );
impactDot = DotProduct( moveDir, trace->plane.normal );
if ( impactDot <= -0.7f )//hit rather head-on and hard
{// Just DIE now
//Give credit to whoever got me into this death spiral state
gentity_t *parent = (gentity_t *)pSelfVeh->m_pParentEntity;
gentity_t *killer = NULL;
if (parent->client->ps.otherKiller < ENTITYNUM_WORLD &&
parent->client->ps.otherKillerTime > level.time)
{
gentity_t *potentialKiller = &g_entities[parent->client->ps.otherKiller];
if (potentialKiller->inuse && potentialKiller->client)
{ //he's valid I guess
killer = potentialKiller;
}
}
G_Damage( (gentity_t *)pEnt, killer, killer, NULL, pm->ps->origin, 999999, DAMAGE_NO_ARMOR, MOD_FALLING );//FIXME: MOD_IMPACT
return;
}
}
}
if ( trace->entityNum < ENTITYNUM_WORLD
&& hitEnt->s.eType == ET_MOVER
&& hitEnt->s.apos.trType != TR_STATIONARY//rotating
&& (hitEnt->spawnflags&16) //IMPACT
&& Q_stricmp( "func_rotating", hitEnt->classname ) == 0 )
{//hit a func_rotating that is supposed to destroy anything it touches!
//guarantee the hit will happen, thereby taking off a piece of the ship
forceSurfDestruction = qtrue;
}
else if ( (fabs(pm->ps->velocity[0])+fabs(pm->ps->velocity[1])) < 100.0f
&& pm->ps->velocity[2] > -100.0f )
#else
if ( (fabs(pm->ps->velocity[0])+fabs(pm->ps->velocity[1])) < 100.0f
&& pm->ps->velocity[2] > -100.0f )
#endif
/*
if ( (pSelfVeh->m_ulFlags&VEH_GEARSOPEN)
&& trace->plane.normal[2] > 0.7f
&& fabs(pSelfVeh->m_vOrientation[PITCH]) < 0.2f
&& fabs(pSelfVeh->m_vOrientation[ROLL]) < 0.2f )*/
{//we're landing, we're cool
//this was annoying me -rww
//FIXME: this shouldn't even be getting called when the vehicle is at rest!
#ifdef QAGAME
if (hitEnt && (hitEnt->s.eType == ET_PLAYER || hitEnt->s.eType == ET_NPC) && pSelfVeh->m_pVehicleInfo->type == VH_FIGHTER)
{ //always smack players
}
else
#endif
{
return;
}
}
if ( pSelfVeh &&
(pSelfVeh->m_pVehicleInfo->type == VH_SPEEDER || pSelfVeh->m_pVehicleInfo->type == VH_FIGHTER) && //this is kind of weird on tauntauns and atst's..
(magnitude >= 100||forceSurfDestruction) )
{
if ( pEnt->m_pVehicle->m_iHitDebounce < pm->cmd.serverTime
|| forceSurfDestruction )
{//a bit of a hack, may conflict with getting shot, but...
//FIXME: impact sound and effect should be gotten from g_vehicleInfo...?
//FIXME: should pass in trace.endpos and trace.plane.normal
vec3_t vehUp;
#ifndef QAGAME
bgEntity_t *hitEnt;
#endif
if ( trace && !pSelfVeh->m_iRemovedSurfaces && !forceSurfDestruction )
{
qboolean turnFromImpact = qfalse, turnHitEnt = qfalse;
float l = pm->ps->speed*0.5f;
vec3_t bounceDir;
#ifndef QAGAME
bgEntity_t *hitEnt = PM_BGEntForNum(trace->entityNum);
#endif
if ( (trace->entityNum == ENTITYNUM_WORLD || hitEnt->s.solid == SOLID_BMODEL)//bounce off any brush
&& !VectorCompare(trace->plane.normal, vec3_origin) )//have a valid plane to bounce off of
{ //bounce off in the opposite direction of the impact
if (pSelfVeh->m_pVehicleInfo->type == VH_SPEEDER)
{
pm->ps->speed *= pml.frametime;
VectorCopy(trace->plane.normal, bounceDir);
}
else if ( trace->plane.normal[2] >= MIN_LANDING_SLOPE//flat enough to land on
&& pSelfVeh->m_LandTrace.fraction < 1.0f //ground present
&& pm->ps->speed <= MIN_LANDING_SPEED )
{//could land here, don't bounce off, in fact, return altogether!
return;
}
else
{
if (pSelfVeh->m_pVehicleInfo->type == VH_FIGHTER)
{
turnFromImpact = qtrue;
}
VectorCopy(trace->plane.normal, bounceDir);
}
}
else if ( pSelfVeh->m_pVehicleInfo->type == VH_FIGHTER )
{//check for impact with another fighter
#ifndef QAGAME
bgEntity_t *hitEnt = PM_BGEntForNum(trace->entityNum);
#endif
if ( hitEnt->s.NPC_class == CLASS_VEHICLE
&& hitEnt->m_pVehicle
&& hitEnt->m_pVehicle->m_pVehicleInfo
&& hitEnt->m_pVehicle->m_pVehicleInfo->type == VH_FIGHTER )
{//two vehicles hit each other, turn away from the impact
turnFromImpact = qtrue;
turnHitEnt = qtrue;
#ifndef QAGAME
VectorSubtract( pm->ps->origin, hitEnt->s.origin, bounceDir );
#else
VectorSubtract( pm->ps->origin, hitEnt->r.currentOrigin, bounceDir );
#endif
VectorNormalize( bounceDir );
}
}
if ( turnFromImpact )
{//bounce off impact surf and turn away
vec3_t pushDir={0}, turnAwayAngles, turnDelta;
float turnStrength, pitchTurnStrength, yawTurnStrength;
vec3_t moveDir;
float bounceDot, turnDivider;
//bounce
if ( !turnHitEnt )
{//hit wall
VectorScale(bounceDir, (pm->ps->speed*0.25f/pSelfVeh->m_pVehicleInfo->mass), pushDir);
}
else
{//hit another fighter
#ifndef QAGAME
VectorScale( bounceDir, (pm->ps->speed+hitEnt->s.speed)*0.5f, bounceDir );
#else
if ( hitEnt->client )
{
VectorScale( bounceDir, (pm->ps->speed+hitEnt->client->ps.speed)*0.5f, pushDir );
}
else
{
VectorScale( bounceDir, (pm->ps->speed+hitEnt->s.speed)*0.5f, pushDir );
}
#endif
VectorScale(pushDir, (l/pSelfVeh->m_pVehicleInfo->mass), pushDir);
VectorScale(pushDir, 0.1f, pushDir);
}
VectorNormalize2( pm->ps->velocity, moveDir );
bounceDot = DotProduct( moveDir, bounceDir )*-1;
if ( bounceDot < 0.1f )
{
bounceDot = 0.1f;
}
VectorScale( pushDir, bounceDot, pushDir );
VectorAdd(pm->ps->velocity, pushDir, pm->ps->velocity);
//turn
turnDivider = (pSelfVeh->m_pVehicleInfo->mass/400.0f);
if ( turnHitEnt )
{//don't turn as much when hit another ship
turnDivider *= 4.0f;
}
if ( turnDivider < 0.5f )
{
turnDivider = 0.5f;
}
turnStrength = (magnitude/2000.0f);
if ( turnStrength < 0.1f )
{
turnStrength = 0.1f;
}
else if ( turnStrength > 2.0f )
{
turnStrength = 2.0f;
}
//get the angles we are going to turn towards
vectoangles( bounceDir, turnAwayAngles );
//get the delta from our current angles to those new angles
AnglesSubtract( turnAwayAngles, pSelfVeh->m_vOrientation, turnDelta );
//now do pitch
if ( !bounceDir[2] )
{//shouldn't be any pitch
}
else
{
pitchTurnStrength = turnStrength*turnDelta[PITCH];
if ( pitchTurnStrength > MAX_IMPACT_TURN_ANGLE )
{
pitchTurnStrength = MAX_IMPACT_TURN_ANGLE;
}
else if ( pitchTurnStrength < -MAX_IMPACT_TURN_ANGLE )
{
pitchTurnStrength = -MAX_IMPACT_TURN_ANGLE;
}
pSelfVeh->m_vFullAngleVelocity[PITCH] = AngleNormalize180(pSelfVeh->m_vOrientation[PITCH]+pitchTurnStrength/turnDivider*pSelfVeh->m_fTimeModifier);
}
//now do yaw
if ( !bounceDir[0]
&& !bounceDir[1] )
{//shouldn't be any yaw
}
else
{
yawTurnStrength = turnStrength*turnDelta[YAW];
if ( yawTurnStrength > MAX_IMPACT_TURN_ANGLE )
{
yawTurnStrength = MAX_IMPACT_TURN_ANGLE;
}
else if ( yawTurnStrength < -MAX_IMPACT_TURN_ANGLE )
{
yawTurnStrength = -MAX_IMPACT_TURN_ANGLE;
}
pSelfVeh->m_vFullAngleVelocity[ROLL] = AngleNormalize180(pSelfVeh->m_vOrientation[ROLL]-yawTurnStrength/turnDivider*pSelfVeh->m_fTimeModifier);
}
#ifdef QAGAME//server-side, turn the guy we hit away from us, too
if ( turnHitEnt//make the other guy turn and get pushed
&& hitEnt->client //must be a valid client
&& !FighterIsLanded( hitEnt->m_pVehicle, &hitEnt->client->ps )//but not if landed
&& !(hitEnt->spawnflags&2) )//and not if suspended
{
l = hitEnt->client->ps.speed;
//now bounce *them* away and turn them
//flip the bounceDir
VectorScale( bounceDir, -1, bounceDir );
//do bounce
VectorScale( bounceDir, (pm->ps->speed+l)*0.5f, pushDir );
VectorScale(pushDir, (l*0.5f/hitEnt->m_pVehicle->m_pVehicleInfo->mass), pushDir);
VectorNormalize2( hitEnt->client->ps.velocity, moveDir );
bounceDot = DotProduct( moveDir, bounceDir )*-1;
if ( bounceDot < 0.1f )
{
bounceDot = 0.1f;
}
VectorScale( pushDir, bounceDot, pushDir );
VectorAdd(hitEnt->client->ps.velocity, pushDir, hitEnt->client->ps.velocity);
//turn
turnDivider = (hitEnt->m_pVehicle->m_pVehicleInfo->mass/400.0f);
if ( turnHitEnt )
{//don't turn as much when hit another ship
turnDivider *= 4.0f;
}
if ( turnDivider < 0.5f )
{
turnDivider = 0.5f;
}
//get the angles we are going to turn towards
vectoangles( bounceDir, turnAwayAngles );
//get the delta from our current angles to those new angles
AnglesSubtract( turnAwayAngles, hitEnt->m_pVehicle->m_vOrientation, turnDelta );
//now do pitch
if ( !bounceDir[2] )
{//shouldn't be any pitch
}
else
{
pitchTurnStrength = turnStrength*turnDelta[PITCH];
if ( pitchTurnStrength > MAX_IMPACT_TURN_ANGLE )
{
pitchTurnStrength = MAX_IMPACT_TURN_ANGLE;
}
else if ( pitchTurnStrength < -MAX_IMPACT_TURN_ANGLE )
{
pitchTurnStrength = -MAX_IMPACT_TURN_ANGLE;
}
hitEnt->m_pVehicle->m_vFullAngleVelocity[PITCH] = AngleNormalize180(hitEnt->m_pVehicle->m_vOrientation[PITCH]+pitchTurnStrength/turnDivider*pSelfVeh->m_fTimeModifier);
}
//now do yaw
if ( !bounceDir[0]
&& !bounceDir[1] )
{//shouldn't be any yaw
}
else
{
yawTurnStrength = turnStrength*turnDelta[YAW];
if ( yawTurnStrength > MAX_IMPACT_TURN_ANGLE )
{
yawTurnStrength = MAX_IMPACT_TURN_ANGLE;
}
else if ( yawTurnStrength < -MAX_IMPACT_TURN_ANGLE )
{
yawTurnStrength = -MAX_IMPACT_TURN_ANGLE;
}
hitEnt->m_pVehicle->m_vFullAngleVelocity[ROLL] = AngleNormalize180(hitEnt->m_pVehicle->m_vOrientation[ROLL]-yawTurnStrength/turnDivider*pSelfVeh->m_fTimeModifier);
}
//NOTE: will these angle changes stick or will they be stomped
// when the vehicle goes through its own update and re-grabs
// its angles from its pilot...? Should we do a
// SetClientViewAngles on the pilot?
}
#endif
}
}
#ifdef QAGAME
if (!hitEnt)
{
return;
}
AngleVectors( pSelfVeh->m_vOrientation, NULL, NULL, vehUp );
if ( pSelfVeh->m_pVehicleInfo->iImpactFX )
{
//tempent use bad!
G_AddEvent((gentity_t *)pEnt, EV_PLAY_EFFECT_ID, pSelfVeh->m_pVehicleInfo->iImpactFX);
}
pEnt->m_pVehicle->m_iHitDebounce = pm->cmd.serverTime + 200;
magnitude /= pSelfVeh->m_pVehicleInfo->toughness * 50.0f;
if (hitEnt && (hitEnt->s.eType != ET_TERRAIN || !(hitEnt->spawnflags & 1) || pSelfVeh->m_pVehicleInfo->type == VH_FIGHTER))
{ //don't damage the vehicle from terrain that doesn't want to damage vehicles
if (pSelfVeh->m_pVehicleInfo->type == VH_FIGHTER)
{ //increase the damage...
float mult = (pSelfVeh->m_vOrientation[PITCH]*0.1f);
if (mult < 1.0f)
{
mult = 1.0f;
}
if (hitEnt->inuse && hitEnt->takedamage)
{ //if the other guy takes damage, don't hurt us a lot for ramming him
//unless it's a vehicle, then we get 1.5 times damage
if (hitEnt->s.eType == ET_NPC &&
hitEnt->s.NPC_class == CLASS_VEHICLE &&
hitEnt->m_pVehicle)
{
mult = 1.5f;
}
else
{
mult = 0.5f;
}
}
magnitude *= mult;
}
pSelfVeh->m_iLastImpactDmg = magnitude;
//FIXME: what about proper death credit to the guy who shot you down?
//FIXME: actually damage part of the ship that impacted?
G_Damage( (gentity_t *)pEnt, NULL, NULL, NULL, pm->ps->origin, magnitude*5, DAMAGE_NO_ARMOR, MOD_FALLING );//FIXME: MOD_IMPACT
if (pSelfVeh->m_pVehicleInfo->surfDestruction)
{
G_FlyVehicleSurfaceDestruction((gentity_t *)pEnt, trace, magnitude, forceSurfDestruction );
}
pSelfVeh->m_ulFlags |= VEH_CRASHING;
}
if (hitEnt &&
hitEnt->inuse &&
hitEnt->takedamage)
{ //damage this guy because we hit him
float pmult = 1.0f;
int finalD;
gentity_t *attackEnt;
if ( (hitEnt->s.eType == ET_PLAYER && hitEnt->s.number < MAX_CLIENTS) ||
(hitEnt->s.eType == ET_NPC && hitEnt->s.NPC_class != CLASS_VEHICLE) )
{ //probably a humanoid, or something
if (pSelfVeh->m_pVehicleInfo->type == VH_FIGHTER)
{ //player die good.. if me fighter
pmult = 2000.0f;
}
else
{
pmult = 40.0f;
}
if (hitEnt->client &&
BG_KnockDownable(&hitEnt->client->ps) &&
G_CanBeEnemy((gentity_t *)pEnt, hitEnt))
{ //smash!
if (hitEnt->client->ps.forceHandExtend != HANDEXTEND_KNOCKDOWN)
{
hitEnt->client->ps.forceHandExtend = HANDEXTEND_KNOCKDOWN;
hitEnt->client->ps.forceHandExtendTime = pm->cmd.serverTime + 1100;
hitEnt->client->ps.forceDodgeAnim = 0; //this toggles between 1 and 0, when it's 1 we should play the get up anim
}
hitEnt->client->ps.otherKiller = pEnt->s.number;
hitEnt->client->ps.otherKillerTime = pm->cmd.serverTime + 5000;
hitEnt->client->ps.otherKillerDebounceTime = pm->cmd.serverTime + 100;
//add my velocity into his to force him along in the correct direction from impact
VectorAdd(hitEnt->client->ps.velocity, pm->ps->velocity, hitEnt->client->ps.velocity);
//upward thrust
hitEnt->client->ps.velocity[2] += 200.0f;
}
}
if (pSelfVeh->m_pPilot)
{
attackEnt = (gentity_t *)pSelfVeh->m_pPilot;
}
else
{
attackEnt = (gentity_t *)pEnt;
}
finalD = magnitude*pmult;
if (finalD < 1)
{
finalD = 1;
}
G_Damage( hitEnt, attackEnt, attackEnt, NULL, pm->ps->origin, finalD, 0, MOD_MELEE );//FIXME: MOD_IMPACT
}
#else //this is gonna result in "double effects" for the client doing the prediction.
//it doesn't look bad though. could just use predicted events, but I'm too lazy.
hitEnt = PM_BGEntForNum(trace->entityNum);
if (!hitEnt || hitEnt->s.owner != pEnt->s.number)
{ //don't hit your own missiles!
AngleVectors( pSelfVeh->m_vOrientation, NULL, NULL, vehUp );
pEnt->m_pVehicle->m_iHitDebounce = pm->cmd.serverTime + 200;
trap_FX_PlayEffectID( pSelfVeh->m_pVehicleInfo->iImpactFX, pm->ps->origin, vehUp, -1, -1 );
pSelfVeh->m_ulFlags |= VEH_CRASHING;
}
#endif
}
}
}
/*
=================
RE_AddDecal
Adds a single decal to the decal list
=================
*/
void RE_GL_AddDecal (vec3_t origin, vec3_t dir, vec4_t color, float size, int type, int flags, float angle)
{
int i, j, numfragments;
vec3_t verts[MAX_DECAL_VERTS], shade, temp;
markFragment_t *fr, fragments[MAX_FRAGMENTS_PER_DECAL];
vec3_t axis[3];
cdecal_t *d;
float lightspot[3];
if (!gl_decals->value)
return;
// invalid decal size
if (size <= 0)
return;
// a hack to produce decals from explosions etc
if (VectorCompare(dir, vec3_origin))
{
float scale = 1.5 * size;
trace_t trace;
vec3_t end, dirs[6] = {
{ 1.0, 0.0, 0.0 },
{ -1.0, 0.0, 0.0 },
{ 0.0, 1.0, 0.0 },
{ 0.0, -1.0, 0.0 },
{ 0.0, 0.0, 1.0 },
{ 0.0, 0.0, -1.0 }
};
for (i = 0; i < 6; i++)
{
VectorMA(origin, scale, dirs[i], end);
trace = CL_Trace(origin, end, 0, MASK_SOLID);
if (trace.fraction != 1.0)
RE_GL_AddDecal(origin, trace.plane.normal, color, size, type, flags, angle);
}
return;
}
// calculate orientation matrix
VectorNormalize2(dir, axis[0]);
PerpendicularVector(axis[1], axis[0]);
RotatePointAroundVector(axis[2], axis[0], axis[1], angle);
CrossProduct(axis[0], axis[2], axis[1]);
// clip it against the world
numfragments = R_GetClippedFragments(origin, axis, size, MAX_DECAL_VERTS, verts, MAX_FRAGMENTS_PER_DECAL, fragments);
if (!numfragments)
return; // no valid fragments
// store out vertex data
size = 0.5f / size;
VectorScale(axis[1], size, axis[1]);
VectorScale(axis[2], size, axis[2]);
for (i = 0, fr = fragments; i < numfragments; i++, fr++)
{
// check if we have hit the max
if (fr->numPoints > MAX_DECAL_VERTS)
fr->numPoints = MAX_DECAL_VERTS;
else if (fr->numPoints <= 0)
continue;
d = R_AllocDecal();
d->time = r_newrefdef.time;
d->node = fr->node;
VectorCopy(fr->surf->plane->normal, d->direction);
if (!(fr->surf->flags & SURF_PLANEBACK))
VectorNegate(d->direction, d->direction); // reverse direction
Vector4Set(d->color, color[0], color[1], color[2], color[3]);
VectorCopy(origin, d->org);
//if (flags & DF_SHADE)
{
R_LightPoint(origin, shade, lightspot);
for (j = 0; j < 3; j++)
d->color[j] = (d->color[j] * shade[j] * 0.6) + (d->color[j] * 0.4);
}
d->type = type;
d->flags = flags;
// make the decal vert
d->numverts = fr->numPoints;
for (j = 0; j < fr->numPoints && j < MAX_VERTS_PER_FRAGMENT; j++)
{
// xyz
VectorCopy(verts[fr->firstPoint + j], d->verts[j]);
// st
VectorSubtract(d->verts[j], origin, temp);
d->stcoords[j][0] = DotProduct(temp, axis[1]) + 0.5f;
d->stcoords[j][1] = DotProduct(temp, axis[2]) + 0.5f;
}
}
}
void Winding::RemoveColinearPoints()
{
unsigned int i;
unsigned int nump;
int j;
vec3_t v1, v2;
vec3_t p[128];
//JK: Did the optimizations...
if (m_NumPoints>1)
{
VectorSubtract(m_Points[0], m_Points[m_NumPoints - 1], v2);
VectorNormalize(v2);
}
nump=0;
for (i = 0; i < m_NumPoints; i++)
{
j = (i + 1) % m_NumPoints; // i + 1
VectorSubtract(m_Points[i], m_Points[j], v1);
VectorNormalize(v1);
VectorAdd(v1, v2, v2);
if (!VectorCompare(v2, vec3_origin))
{
VectorCopy(m_Points[i], p[nump]);
nump++;
}
#if 0
else
{
Log("v3 was (%4.3f %4.3f %4.3f)\n", v2[0], v2[1], v2[2]);
}
#endif
//Set v2 for next round
v2[0]=-v1[0];
v2[1]=-v1[1];
v2[2]=-v1[2];
}
if (nump == m_NumPoints)
{
return;
}
#if 0
Warning("RemoveColinearPoints: Removed %u points, from %u to %u\n", m_NumPoints - nump, m_NumPoints, nump);
Warning("Before :\n");
Print();
#endif
m_NumPoints = nump;
memcpy(m_Points, p, nump * sizeof(vec3_t));
#if 0
Warning("After :\n");
Print();
Warning("==========\n");
#endif
}
TEST_F(GameTest, InventoryWithTwoDiedAliensOnTheSameGridTile)
{
const char* mapName = "test_game";
ASSERT_NE(-1, FS_CheckFile("maps/%s.bsp", mapName)) << "Map resource '" << mapName << ".bsp' for test is missing.";
Actor* diedEnt;
Actor* diedEnt2;
Actor* actor;
Edict* floorItems;
Item* invlist;
int count;
SV_Map(true, mapName, nullptr);
level.activeTeam = TEAM_ALIEN;
/* first alien that should die and drop its inventory */
diedEnt = G_EdictsGetNextLivingActorOfTeam(nullptr, TEAM_ALIEN);
ASSERT_TRUE(nullptr != diedEnt) << "No living actor in the alien team";
diedEnt->HP = 0;
G_ActorDieOrStun(diedEnt, nullptr);
ASSERT_TRUE(diedEnt->isDead()) << "Actor is not dead";
/* second alien that should die and drop its inventory */
diedEnt2 = G_EdictsGetNextLivingActorOfTeam(nullptr, TEAM_ALIEN);
ASSERT_TRUE(nullptr != diedEnt2) << "No living actor in the alien team";
/* move to the location of the first died alien to drop the inventory into the same floor container */
Player& player = diedEnt2->getPlayer();
ASSERT_TRUE(G_IsAIPlayer(&player));
G_ClientMove(player, 0, diedEnt2, diedEnt->pos);
ASSERT_TRUE(VectorCompare(diedEnt2->pos, diedEnt->pos));
diedEnt2->HP = 0;
G_ActorDieOrStun(diedEnt2, nullptr);
ASSERT_TRUE(diedEnt2->isDead()) << "Actor is not dead";
/* now try to collect the inventory with a third alien */
actor = G_EdictsGetNextLivingActorOfTeam(nullptr, TEAM_ALIEN);
ASSERT_TRUE(nullptr != actor) << "No living actor in the alien team";
player = actor->getPlayer();
ASSERT_TRUE(G_IsAIPlayer(&player)) << "Player is not ai controlled";
G_ClientMove(player, 0, actor, diedEnt->pos);
ASSERT_TRUE(VectorCompare(actor->pos, diedEnt->pos)) << "Actor is not at the same position as the died entity";
floorItems = G_GetFloorItems(actor);
ASSERT_TRUE(nullptr != floorItems);
ASSERT_EQ(floorItems->getFloor(), actor->getFloor());
/* drop everything to floor to make sure we have space in the backpack */
G_InventoryToFloor(actor);
ASSERT_EQ(0, GAMETEST_GetItemCount(actor, CID_BACKPACK));
invlist = actor->getContainer(CID_BACKPACK);
ASSERT_TRUE(nullptr == invlist);
count = GAMETEST_GetItemCount(actor, CID_FLOOR);
if (count > 0) {
Item* entryToMove = actor->getFloor();
int tx, ty;
actor->chr.inv.findSpace(INVDEF(CID_BACKPACK), entryToMove, &tx, &ty, entryToMove);
if (tx == NONE)
return;
Com_Printf("trying to move item %s from floor into backpack to pos %i:%i\n", entryToMove->def()->name, tx, ty);
ASSERT_TRUE(G_ActorInvMove(actor, INVDEF(CID_FLOOR), entryToMove, INVDEF(CID_BACKPACK), tx, ty, false));
ASSERT_EQ(GAMETEST_GetItemCount(actor, CID_FLOOR), count - 1) << "item " << entryToMove->def()->name << " could not get moved successfully from floor into backpack";
Com_Printf("item %s was removed from floor\n", entryToMove->def()->name);
ASSERT_EQ(GAMETEST_GetItemCount(actor, CID_BACKPACK), 1) << "item " << entryToMove->def()->name << " could not get moved successfully from floor into backpack";
Com_Printf("item %s was moved successfully into the backpack\n", entryToMove->def()->name);
invlist = actor->getContainer(CID_BACKPACK);
ASSERT_TRUE(nullptr != invlist);
}
}
void SV_LinkEntity(sharedEntity_t *gEnt)
{
worldSector_t *node;
int leafs[MAX_TOTAL_ENT_LEAFS];
int cluster;
int num_leafs;
int i, j, k;
int area;
int lastLeaf;
float *origin, *angles;
svEntity_t *ent;
ent = SV_SvEntityForGentity(gEnt);
// Ridah, sanity check for possible currentOrigin being reset bug
if(!gEnt->r.bmodel && VectorCompare(gEnt->r.currentOrigin, vec3_origin))
{
Com_DPrintf("WARNING: BBOX entity is being linked at world origin, this is probably a bug\n");
}
if(ent->worldSector)
{
SV_UnlinkEntity(gEnt); // unlink from old position
}
// encode the size into the entityState_t for client prediction
if(gEnt->r.bmodel)
{
gEnt->s.solid = SOLID_BMODEL; // a solid_box will never create this value
}
else if(gEnt->r.contents & (CONTENTS_SOLID | CONTENTS_BODY))
{
// assume that x/y are equal and symetric
i = gEnt->r.maxs[0];
if(i < 1)
{
i = 1;
}
if(i > 255)
{
i = 255;
}
// z is not symetric
j = (-gEnt->r.mins[2]);
if(j < 1)
{
j = 1;
}
if(j > 255)
{
j = 255;
}
// and z maxs can be negative...
k = (gEnt->r.maxs[2] + 32);
if(k < 1)
{
k = 1;
}
if(k > 255)
{
k = 255;
}
gEnt->s.solid = (k << 16) | (j << 8) | i;
}
else
{
gEnt->s.solid = 0;
}
// get the position
origin = gEnt->r.currentOrigin;
angles = gEnt->r.currentAngles;
// set the abs box
if(gEnt->r.bmodel && (angles[0] || angles[1] || angles[2]))
{
// expand for rotation
float max;
int i;
max = RadiusFromBounds(gEnt->r.mins, gEnt->r.maxs);
for(i = 0 ; i < 3 ; i++)
{
gEnt->r.absmin[i] = origin[i] - max;
gEnt->r.absmax[i] = origin[i] + max;
}
}
else
{
// normal
VectorAdd(origin, gEnt->r.mins, gEnt->r.absmin);
VectorAdd(origin, gEnt->r.maxs, gEnt->r.absmax);
}
// because movement is clipped an epsilon away from an actual edge,
// we must fully check even when bounding boxes don't quite touch
gEnt->r.absmin[0] -= 1;
gEnt->r.absmin[1] -= 1;
gEnt->r.absmin[2] -= 1;
gEnt->r.absmax[0] += 1;
gEnt->r.absmax[1] += 1;
gEnt->r.absmax[2] += 1;
// link to PVS leafs
ent->numClusters = 0;
ent->lastCluster = 0;
ent->areanum = -1;
ent->areanum2 = -1;
//get all leafs, including solids
num_leafs = CM_BoxLeafnums(gEnt->r.absmin, gEnt->r.absmax,
leafs, MAX_TOTAL_ENT_LEAFS, &lastLeaf);
// if none of the leafs were inside the map, the
// entity is outside the world and can be considered unlinked
if(!num_leafs)
{
return;
}
// set areas, even from clusters that don't fit in the entity array
for(i = 0 ; i < num_leafs ; i++)
{
area = CM_LeafArea(leafs[i]);
if(area != -1)
{
// doors may legally straggle two areas,
// but nothing should evern need more than that
if(ent->areanum != -1 && ent->areanum != area)
{
if(ent->areanum2 != -1 && ent->areanum2 != area && sv.state == SS_LOADING)
{
Com_DPrintf("Object %i touching 3 areas at %f %f %f\n",
gEnt->s.number,
gEnt->r.absmin[0], gEnt->r.absmin[1], gEnt->r.absmin[2]);
}
ent->areanum2 = area;
}
else
{
ent->areanum = area;
}
}
}
// store as many explicit clusters as we can
ent->numClusters = 0;
for(i = 0 ; i < num_leafs ; i++)
{
cluster = CM_LeafCluster(leafs[i]);
if(cluster != -1)
{
ent->clusternums[ent->numClusters++] = cluster;
if(ent->numClusters == MAX_ENT_CLUSTERS)
{
break;
}
}
}
// store off a last cluster if we need to
if(i != num_leafs)
{
ent->lastCluster = CM_LeafCluster(lastLeaf);
}
gEnt->r.linkcount++;
// find the first world sector node that the ent's box crosses
node = sv_worldSectors;
while(1)
{
if(node->axis == -1)
{
break;
}
if(gEnt->r.absmin[node->axis] > node->dist)
{
node = node->children[0];
}
else if(gEnt->r.absmax[node->axis] < node->dist)
{
node = node->children[1];
}
else
{
break; // crosses the node
}
}
// link it in
ent->worldSector = node;
ent->nextEntityInWorldSector = node->entities;
node->entities = ent;
gEnt->r.linked = qtrue;
}
/*
=================
R_LoadMD5
=================
*/
qboolean R_LoadMD5( model_t *mod, void *buffer, int bufferSize, const char *modName )
{
int i, j, k;
md5Model_t *md5;
md5Bone_t *bone;
md5Surface_t *surf;
md5Triangle_t *tri;
md5Vertex_t *v;
md5Weight_t *weight;
int version;
shader_t *sh;
char *buf_p;
char *token;
vec3_t boneOrigin;
quat_t boneQuat;
matrix_t boneMat;
buf_p = ( char * ) buffer;
// skip MD5Version indent string
COM_ParseExt2( &buf_p, qfalse );
// check version
token = COM_ParseExt2( &buf_p, qfalse );
version = atoi( token );
if ( version != MD5_VERSION )
{
ri.Printf( PRINT_WARNING, "R_LoadMD5: %s has wrong version (%i should be %i)\n", modName, version, MD5_VERSION );
return qfalse;
}
mod->type = MOD_MD5;
mod->dataSize += sizeof( md5Model_t );
md5 = mod->model.md5 = ri.Hunk_Alloc( sizeof( md5Model_t ), h_low );
// skip commandline <arguments string>
token = COM_ParseExt2( &buf_p, qtrue );
token = COM_ParseExt2( &buf_p, qtrue );
// ri.Printf(PRINT_ALL, "%s\n", token);
// parse numJoints <number>
token = COM_ParseExt2( &buf_p, qtrue );
if ( Q_stricmp( token, "numJoints" ) )
{
ri.Printf( PRINT_WARNING, "R_LoadMD5: expected 'numJoints' found '%s' in model '%s'\n", token, modName );
return qfalse;
}
token = COM_ParseExt2( &buf_p, qfalse );
md5->numBones = atoi( token );
// parse numMeshes <number>
token = COM_ParseExt2( &buf_p, qtrue );
if ( Q_stricmp( token, "numMeshes" ) )
{
ri.Printf( PRINT_WARNING, "R_LoadMD5: expected 'numMeshes' found '%s' in model '%s'\n", token, modName );
return qfalse;
}
token = COM_ParseExt2( &buf_p, qfalse );
md5->numSurfaces = atoi( token );
//ri.Printf(PRINT_ALL, "R_LoadMD5: '%s' has %i surfaces\n", modName, md5->numSurfaces);
if ( md5->numBones < 1 )
{
ri.Printf( PRINT_WARNING, "R_LoadMD5: '%s' has no bones\n", modName );
return qfalse;
}
if ( md5->numBones > MAX_BONES )
{
ri.Printf( PRINT_WARNING, "R_LoadMD5: '%s' has more than %i bones (%i)\n", modName, MAX_BONES, md5->numBones );
return qfalse;
}
//ri.Printf(PRINT_ALL, "R_LoadMD5: '%s' has %i bones\n", modName, md5->numBones);
// parse all the bones
md5->bones = ri.Hunk_Alloc( sizeof( *bone ) * md5->numBones, h_low );
// parse joints {
token = COM_ParseExt2( &buf_p, qtrue );
if ( Q_stricmp( token, "joints" ) )
{
ri.Printf( PRINT_WARNING, "R_LoadMD5: expected 'joints' found '%s' in model '%s'\n", token, modName );
return qfalse;
}
token = COM_ParseExt2( &buf_p, qfalse );
if ( Q_stricmp( token, "{" ) )
{
ri.Printf( PRINT_WARNING, "R_LoadMD5: expected '{' found '%s' in model '%s'\n", token, modName );
return qfalse;
}
for ( i = 0, bone = md5->bones; i < md5->numBones; i++, bone++ )
{
token = COM_ParseExt2( &buf_p, qtrue );
Q_strncpyz( bone->name, token, sizeof( bone->name ) );
//ri.Printf(PRINT_ALL, "R_LoadMD5: '%s' has bone '%s'\n", modName, bone->name);
token = COM_ParseExt2( &buf_p, qfalse );
bone->parentIndex = atoi( token );
//ri.Printf(PRINT_ALL, "R_LoadMD5: '%s' has bone '%s' with parent index %i\n", modName, bone->name, bone->parentIndex);
if ( bone->parentIndex >= md5->numBones )
{
ri.Error( ERR_DROP, "R_LoadMD5: '%s' has bone '%s' with bad parent index %i while numBones is %i\n", modName,
bone->name, bone->parentIndex, md5->numBones );
}
// skip (
token = COM_ParseExt2( &buf_p, qfalse );
if ( Q_stricmp( token, "(" ) )
{
ri.Printf( PRINT_WARNING, "R_LoadMD5: expected '(' found '%s' in model '%s'\n", token, modName );
return qfalse;
}
for ( j = 0; j < 3; j++ )
{
token = COM_ParseExt2( &buf_p, qfalse );
boneOrigin[ j ] = atof( token );
}
// skip )
token = COM_ParseExt2( &buf_p, qfalse );
if ( Q_stricmp( token, ")" ) )
{
ri.Printf( PRINT_WARNING, "R_LoadMD5: expected ')' found '%s' in model '%s'\n", token, modName );
return qfalse;
}
// skip (
token = COM_ParseExt2( &buf_p, qfalse );
if ( Q_stricmp( token, "(" ) )
{
ri.Printf( PRINT_WARNING, "R_LoadMD5: expected '(' found '%s' in model '%s'\n", token, modName );
return qfalse;
}
for ( j = 0; j < 3; j++ )
{
token = COM_ParseExt2( &buf_p, qfalse );
boneQuat[ j ] = atof( token );
}
QuatCalcW( boneQuat );
MatrixFromQuat( boneMat, boneQuat );
VectorCopy( boneOrigin, bone->origin );
QuatCopy( boneQuat, bone->rotation );
MatrixSetupTransformFromQuat( bone->inverseTransform, boneQuat, boneOrigin );
MatrixInverse( bone->inverseTransform );
// skip )
token = COM_ParseExt2( &buf_p, qfalse );
if ( Q_stricmp( token, ")" ) )
{
ri.Printf( PRINT_WARNING, "R_LoadMD5: expected '(' found '%s' in model '%s'\n", token, modName );
return qfalse;
}
}
// parse }
token = COM_ParseExt2( &buf_p, qtrue );
if ( Q_stricmp( token, "}" ) )
{
ri.Printf( PRINT_WARNING, "R_LoadMD5: expected '}' found '%s' in model '%s'\n", token, modName );
return qfalse;
}
// parse all the surfaces
if ( md5->numSurfaces < 1 )
{
ri.Printf( PRINT_WARNING, "R_LoadMD5: '%s' has no surfaces\n", modName );
return qfalse;
}
//ri.Printf(PRINT_ALL, "R_LoadMD5: '%s' has %i surfaces\n", modName, md5->numSurfaces);
md5->surfaces = ri.Hunk_Alloc( sizeof( *surf ) * md5->numSurfaces, h_low );
for ( i = 0, surf = md5->surfaces; i < md5->numSurfaces; i++, surf++ )
{
// parse mesh {
token = COM_ParseExt2( &buf_p, qtrue );
if ( Q_stricmp( token, "mesh" ) )
{
ri.Printf( PRINT_WARNING, "R_LoadMD5: expected 'mesh' found '%s' in model '%s'\n", token, modName );
return qfalse;
}
token = COM_ParseExt2( &buf_p, qfalse );
if ( Q_stricmp( token, "{" ) )
{
ri.Printf( PRINT_WARNING, "R_LoadMD5: expected '{' found '%s' in model '%s'\n", token, modName );
return qfalse;
}
// change to surface identifier
surf->surfaceType = SF_MD5;
// give pointer to model for Tess_SurfaceMD5
surf->model = md5;
// parse shader <name>
token = COM_ParseExt2( &buf_p, qtrue );
if ( Q_stricmp( token, "shader" ) )
{
Q_strncpyz( surf->shader, "<default>", sizeof( surf->shader ) );
surf->shaderIndex = 0;
}
else
{
token = COM_ParseExt2( &buf_p, qfalse );
Q_strncpyz( surf->shader, token, sizeof( surf->shader ) );
//ri.Printf(PRINT_ALL, "R_LoadMD5: '%s' uses shader '%s'\n", modName, surf->shader);
// FIXME .md5mesh meshes don't have surface names
// lowercase the surface name so skin compares are faster
//Q_strlwr(surf->name);
//ri.Printf(PRINT_ALL, "R_LoadMD5: '%s' has surface '%s'\n", modName, surf->name);
// register the shaders
sh = R_FindShader( surf->shader, LIGHTMAP_NONE, qtrue );
if ( sh->defaultShader )
{
surf->shaderIndex = 0;
}
else
{
surf->shaderIndex = sh->index;
}
token = COM_ParseExt2( &buf_p, qtrue );
}
// parse numVerts <number>
if ( Q_stricmp( token, "numVerts" ) )
{
ri.Printf( PRINT_WARNING, "R_LoadMD5: expected 'numVerts' found '%s' in model '%s'\n", token, modName );
return qfalse;
}
token = COM_ParseExt2( &buf_p, qfalse );
surf->numVerts = atoi( token );
if ( surf->numVerts > SHADER_MAX_VERTEXES )
{
ri.Error( ERR_DROP, "R_LoadMD5: '%s' has more than %i verts on a surface (%i)",
modName, SHADER_MAX_VERTEXES, surf->numVerts );
}
surf->verts = ri.Hunk_Alloc( sizeof( *v ) * surf->numVerts, h_low );
for ( j = 0, v = surf->verts; j < surf->numVerts; j++, v++ )
{
// skip vert <number>
token = COM_ParseExt2( &buf_p, qtrue );
if ( Q_stricmp( token, "vert" ) )
{
ri.Printf( PRINT_WARNING, "R_LoadMD5: expected 'vert' found '%s' in model '%s'\n", token, modName );
return qfalse;
}
COM_ParseExt2( &buf_p, qfalse );
// skip (
token = COM_ParseExt2( &buf_p, qfalse );
if ( Q_stricmp( token, "(" ) )
{
ri.Printf( PRINT_WARNING, "R_LoadMD5: expected '(' found '%s' in model '%s'\n", token, modName );
return qfalse;
}
for ( k = 0; k < 2; k++ )
{
token = COM_ParseExt2( &buf_p, qfalse );
v->texCoords[ k ] = atof( token );
}
// skip )
token = COM_ParseExt2( &buf_p, qfalse );
if ( Q_stricmp( token, ")" ) )
{
ri.Printf( PRINT_WARNING, "R_LoadMD5: expected ')' found '%s' in model '%s'\n", token, modName );
return qfalse;
}
token = COM_ParseExt2( &buf_p, qfalse );
v->firstWeight = atoi( token );
token = COM_ParseExt2( &buf_p, qfalse );
v->numWeights = atoi( token );
if ( v->numWeights > MAX_WEIGHTS )
{
ri.Error( ERR_DROP, "R_LoadMD5: vertex %i requires more than %i weights on surface (%i) in model '%s'",
j, MAX_WEIGHTS, i, modName );
}
}
// parse numTris <number>
token = COM_ParseExt2( &buf_p, qtrue );
if ( Q_stricmp( token, "numTris" ) )
{
ri.Printf( PRINT_WARNING, "R_LoadMD5: expected 'numTris' found '%s' in model '%s'\n", token, modName );
return qfalse;
}
token = COM_ParseExt2( &buf_p, qfalse );
surf->numTriangles = atoi( token );
if ( surf->numTriangles > SHADER_MAX_TRIANGLES )
{
ri.Error( ERR_DROP, "R_LoadMD5: '%s' has more than %i triangles on a surface (%i)",
modName, SHADER_MAX_TRIANGLES, surf->numTriangles );
}
surf->triangles = ri.Hunk_Alloc( sizeof( *tri ) * surf->numTriangles, h_low );
for ( j = 0, tri = surf->triangles; j < surf->numTriangles; j++, tri++ )
{
// skip tri <number>
token = COM_ParseExt2( &buf_p, qtrue );
if ( Q_stricmp( token, "tri" ) )
{
ri.Printf( PRINT_WARNING, "R_LoadMD5: expected 'tri' found '%s' in model '%s'\n", token, modName );
return qfalse;
}
COM_ParseExt2( &buf_p, qfalse );
for ( k = 0; k < 3; k++ )
{
token = COM_ParseExt2( &buf_p, qfalse );
tri->indexes[ k ] = atoi( token );
}
}
// parse numWeights <number>
token = COM_ParseExt2( &buf_p, qtrue );
if ( Q_stricmp( token, "numWeights" ) )
{
ri.Printf( PRINT_WARNING, "R_LoadMD5: expected 'numWeights' found '%s' in model '%s'\n", token, modName );
return qfalse;
}
token = COM_ParseExt2( &buf_p, qfalse );
surf->numWeights = atoi( token );
surf->weights = ri.Hunk_Alloc( sizeof( *weight ) * surf->numWeights, h_low );
for ( j = 0, weight = surf->weights; j < surf->numWeights; j++, weight++ )
{
// skip weight <number>
token = COM_ParseExt2( &buf_p, qtrue );
if ( Q_stricmp( token, "weight" ) )
{
ri.Printf( PRINT_WARNING, "R_LoadMD5: expected 'weight' found '%s' in model '%s'\n", token, modName );
return qfalse;
}
COM_ParseExt2( &buf_p, qfalse );
token = COM_ParseExt2( &buf_p, qfalse );
weight->boneIndex = atoi( token );
token = COM_ParseExt2( &buf_p, qfalse );
weight->boneWeight = atof( token );
// skip (
token = COM_ParseExt2( &buf_p, qfalse );
if ( Q_stricmp( token, "(" ) )
{
ri.Printf( PRINT_WARNING, "R_LoadMD5: expected '(' found '%s' in model '%s'\n", token, modName );
return qfalse;
}
for ( k = 0; k < 3; k++ )
{
token = COM_ParseExt2( &buf_p, qfalse );
weight->offset[ k ] = atof( token );
}
// skip )
token = COM_ParseExt2( &buf_p, qfalse );
if ( Q_stricmp( token, ")" ) )
{
ri.Printf( PRINT_WARNING, "R_LoadMD5: expected ')' found '%s' in model '%s'\n", token, modName );
return qfalse;
}
}
// parse }
token = COM_ParseExt2( &buf_p, qtrue );
if ( Q_stricmp( token, "}" ) )
{
ri.Printf( PRINT_WARNING, "R_LoadMD5: expected '}' found '%s' in model '%s'\n", token, modName );
return qfalse;
}
// loop trough all vertices and set up the vertex weights
for ( j = 0, v = surf->verts; j < surf->numVerts; j++, v++ )
{
v->weights = ri.Hunk_Alloc( sizeof( *v->weights ) * v->numWeights, h_low );
for ( k = 0; k < v->numWeights; k++ )
{
v->weights[ k ] = surf->weights + ( v->firstWeight + k );
}
}
}
// loading is done now calculate the bounding box and tangent spaces
ClearBounds( md5->bounds[ 0 ], md5->bounds[ 1 ] );
for ( i = 0, surf = md5->surfaces; i < md5->numSurfaces; i++, surf++ )
{
for ( j = 0, v = surf->verts; j < surf->numVerts; j++, v++ )
{
vec3_t tmpVert;
md5Weight_t *w;
VectorClear( tmpVert );
for ( k = 0, w = v->weights[ 0 ]; k < v->numWeights; k++, w++ )
{
vec3_t offsetVec;
bone = &md5->bones[ w->boneIndex ];
QuatTransformVector( bone->rotation, w->offset, offsetVec );
VectorAdd( bone->origin, offsetVec, offsetVec );
VectorMA( tmpVert, w->boneWeight, offsetVec, tmpVert );
}
VectorCopy( tmpVert, v->position );
AddPointToBounds( tmpVert, md5->bounds[ 0 ], md5->bounds[ 1 ] );
}
// calc normals
{
const float *v0, *v1, *v2;
const float *t0, *t1, *t2;
vec3_t normal;
for ( j = 0, v = surf->verts; j < surf->numVerts; j++, v++ )
{
VectorClear( v->tangent );
VectorClear( v->binormal );
VectorClear( v->normal );
}
for ( j = 0, tri = surf->triangles; j < surf->numTriangles; j++, tri++ )
{
v0 = surf->verts[ tri->indexes[ 0 ] ].position;
v1 = surf->verts[ tri->indexes[ 1 ] ].position;
v2 = surf->verts[ tri->indexes[ 2 ] ].position;
t0 = surf->verts[ tri->indexes[ 0 ] ].texCoords;
t1 = surf->verts[ tri->indexes[ 1 ] ].texCoords;
t2 = surf->verts[ tri->indexes[ 2 ] ].texCoords;
R_CalcNormalForTriangle( normal, v0, v1, v2 );
for ( k = 0; k < 3; k++ )
{
float *v;
v = surf->verts[ tri->indexes[ k ] ].normal;
VectorAdd( v, normal, v );
}
}
for ( j = 0, v = surf->verts; j < surf->numVerts; j++, v++ )
{
VectorNormalize( v->normal );
}
}
#if 0
// do another extra smoothing for normals to avoid flat shading
for ( j = 0; j < surf->numVerts; j++ )
{
for ( k = 0; k < surf->numVerts; k++ )
{
if ( j == k )
{
continue;
}
if ( VectorCompare( surf->verts[ j ].position, surf->verts[ k ].position ) )
{
VectorAdd( surf->verts[ j ].normal, surf->verts[ k ].normal, surf->verts[ j ].normal );
}
}
VectorNormalize( surf->verts[ j ].normal );
}
#endif
}
return qtrue;
}
void G_RunMissile( gentity_t *ent )
{
vec3_t oldOrg;
trace_t tr;
int trHitLoc=HL_NONE;
if ( (ent->s.eFlags&EF_HELD_BY_SAND_CREATURE) )
{//in a sand creature's mouth
if ( ent->activator )
{
mdxaBone_t boltMatrix;
// Getting the bolt here
//in hand
vec3_t scAngles = {0};
scAngles[YAW] = ent->activator->currentAngles[YAW];
gi.G2API_GetBoltMatrix( ent->activator->ghoul2, ent->activator->playerModel, ent->activator->gutBolt,
&boltMatrix, scAngles, ent->activator->currentOrigin, (cg.time?cg.time:level.time),
NULL, ent->activator->s.modelScale );
// Storing ent position, bolt position, and bolt axis
gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, ent->currentOrigin );
G_SetOrigin( ent, ent->currentOrigin );
}
// check think function
G_RunThink( ent );
return;
}
VectorCopy( ent->currentOrigin, oldOrg );
// get current position
if ( ent->s.pos.trType == TR_INTERPOLATE )
{//rolling missile?
//FIXME: WTF?!! Sticks to stick missiles?
//FIXME: they stick inside the player
G_RollMissile( ent );
if ( ent->s.eType != ET_GENERAL )
{//didn't explode
VectorCopy( ent->currentOrigin, ent->s.pos.trBase );
gi.trace( &tr, oldOrg, ent->mins, ent->maxs, ent->currentOrigin, ent->s.number, ent->clipmask, G2_RETURNONHIT, 10 );
if ( VectorCompare( ent->s.pos.trDelta, vec3_origin ) )
{
//VectorCopy( ent->currentAngles, ent->s.apos.trBase );
VectorClear( ent->s.apos.trDelta );
}
else
{
vec3_t ang, fwdDir, rtDir;
float speed;
ent->s.apos.trType = TR_INTERPOLATE;
VectorSet( ang, 0, ent->s.apos.trBase[1], 0 );
AngleVectors( ang, fwdDir, rtDir, NULL );
speed = VectorLength( ent->s.pos.trDelta )*4;
//HMM, this works along an axis-aligned dir, but not along diagonals
//This is because when roll gets to 90, pitch becomes yaw, and vice-versa
//Maybe need to just set the angles directly?
ent->s.apos.trDelta[0] = DotProduct( fwdDir, ent->s.pos.trDelta );
ent->s.apos.trDelta[1] = 0;//never spin!
ent->s.apos.trDelta[2] = DotProduct( rtDir, ent->s.pos.trDelta );
VectorNormalize( ent->s.apos.trDelta );
VectorScale( ent->s.apos.trDelta, speed, ent->s.apos.trDelta );
ent->s.apos.trTime = level.previousTime;
}
}
}
else
{
vec3_t origin;
EvaluateTrajectory( &ent->s.pos, level.time, origin );
// trace a line from the previous position to the current position,
// ignoring interactions with the missile owner
gi.trace( &tr, ent->currentOrigin, ent->mins, ent->maxs, origin,
ent->owner ? ent->owner->s.number : ent->s.number, ent->clipmask, G2_COLLIDE, 10 );
if ( tr.entityNum != ENTITYNUM_NONE )
{
gentity_t *other = &g_entities[tr.entityNum];
// check for hitting a lightsaber
if ( other->contents & CONTENTS_LIGHTSABER )
{//hit a lightsaber bbox
if ( other->owner
&& other->owner->client
&& !other->owner->client->ps.saberInFlight
&& ( Q_irand( 0, (other->owner->client->ps.forcePowerLevel[FP_SABER_DEFENSE]*other->owner->client->ps.forcePowerLevel[FP_SABER_DEFENSE]) ) == 0
|| !InFront( ent->currentOrigin, other->owner->currentOrigin, other->owner->client->ps.viewangles, SABER_REFLECT_MISSILE_CONE ) ) )//other->owner->s.number == 0 &&
{//Jedi cannot block shots from behind!
//re-trace from here, ignoring the lightsaber
gi.trace( &tr, tr.endpos, ent->mins, ent->maxs, origin, tr.entityNum, ent->clipmask, G2_RETURNONHIT, 10 );
}
}
}
VectorCopy( tr.endpos, ent->currentOrigin );
}
// get current angles
VectorMA( ent->s.apos.trBase, (level.time - ent->s.apos.trTime) * 0.001, ent->s.apos.trDelta, ent->s.apos.trBase );
//FIXME: Rolling things hitting G2 polys is weird
///////////////////////////////////////////////////////
//? if ( tr.fraction != 1 )
{
// did we hit or go near a Ghoul2 model?
// qboolean hitModel = qfalse;
for (int i=0; i < MAX_G2_COLLISIONS; i++)
{
if (tr.G2CollisionMap[i].mEntityNum == -1)
{
break;
}
CCollisionRecord &coll = tr.G2CollisionMap[i];
gentity_t *hitEnt = &g_entities[coll.mEntityNum];
// process collision records here...
// make sure we only do this once, not for all the entrance wounds we might generate
if ((coll.mFlags & G2_FRONTFACE)/* && !(hitModel)*/ && hitEnt->health)
{
if (trHitLoc==HL_NONE)
{
G_GetHitLocFromSurfName( &g_entities[coll.mEntityNum], gi.G2API_GetSurfaceName( &g_entities[coll.mEntityNum].ghoul2[coll.mModelIndex], coll.mSurfaceIndex ), &trHitLoc, coll.mCollisionPosition, NULL, NULL, ent->methodOfDeath );
}
break; // NOTE: the way this whole section was working, it would only get inside of this IF once anyway, might as well break out now
}
}
}
/////////////////////////////////////////////////////////
if ( tr.startsolid )
{
tr.fraction = 0;
}
gi.linkentity( ent );
if ( ent->s.pos.trType == TR_STATIONARY && (ent->s.eFlags&EF_MISSILE_STICK) )
{//stuck missiles should check some special stuff
G_RunStuckMissile( ent );
return;
}
// check think function
G_RunThink( ent );
if ( ent->s.eType != ET_MISSILE )
{
return; // exploded
}
if ( ent->mass )
{
G_MoverTouchPushTriggers( ent, oldOrg );
}
/*
if ( !(ent->s.eFlags & EF_TELEPORT_BIT) )
{
G_MoverTouchTeleportTriggers( ent, oldOrg );
if ( ent->s.eFlags & EF_TELEPORT_BIT )
{//was teleported
return;
}
}
else
{
ent->s.eFlags &= ~EF_TELEPORT_BIT;
}
*/
AddSightEvent( ent->owner, ent->currentOrigin, 512, AEL_DISCOVERED, 75 );//wakes them up when see a shot passes in front of them
if ( !Q_irand( 0, 10 ) )
{//not so often...
if ( ent->splashDamage && ent->splashRadius )
{//I'm an exploder, let people around me know danger is coming
if ( ent->s.weapon == WP_TRIP_MINE )
{//???
}
else
{
if ( ent->s.weapon == WP_ROCKET_LAUNCHER && ent->e_ThinkFunc == thinkF_rocketThink )
{//homing rocket- run like hell!
AddSightEvent( ent->owner, ent->currentOrigin, ent->splashRadius, AEL_DANGER_GREAT, 50 );
}
else
{
AddSightEvent( ent->owner, ent->currentOrigin, ent->splashRadius, AEL_DANGER, 50 );
}
AddSoundEvent( ent->owner, ent->currentOrigin, ent->splashRadius, AEL_DANGER );
}
}
else
{//makes them run from near misses
AddSightEvent( ent->owner, ent->currentOrigin, 48, AEL_DANGER, 50 );
}
}
if ( tr.fraction == 1 )
{
if ( ent->s.weapon == WP_THERMAL && ent->s.pos.trType == TR_INTERPOLATE )
{//a rolling thermal that didn't hit anything
G_MissileAddAlerts( ent );
}
return;
}
// never explode or bounce on sky
if ( tr.surfaceFlags & SURF_NOIMPACT )
{
G_FreeEntity( ent );
return;
}
G_MissileImpact( ent, &tr, trHitLoc );
}
/*
=================
CG_PredictPlayerState
Generates cg.cur_lc->predictedPlayerState for the current cg.time
cg.cur_lc->predictedPlayerState is guaranteed to be valid after exiting.
For demo playback, this will be an interpolation between two valid
playerState_t.
For normal gameplay, it will be the result of predicted usercmd_t on
top of the most recent playerState_t received from the server.
Each new snapshot will usually have one or more new usercmd over the last,
but we simulate all unacknowledged commands each time, not just the new ones.
This means that on an internet connection, quite a few pmoves may be issued
each frame.
OPTIMIZE: don't re-simulate unless the newly arrived snapshot playerState_t
differs from the predicted one. Would require saving all intermediate
playerState_t during prediction.
We detect prediction errors and allow them to be decayed off over several frames
to ease the jerk.
=================
*/
void CG_PredictPlayerState( void ) {
int cmdNum, current;
playerState_t oldPlayerState;
qboolean moved;
usercmd_t oldestCmd;
usercmd_t latestCmd;
cg.cur_lc->hyperspace = qfalse; // will be set if touching a trigger_teleport
// if this is the first frame we must guarantee
// predictedPlayerState is valid even if there is some
// other error condition
if ( !cg.cur_lc->validPPS ) {
cg.cur_lc->validPPS = qtrue;
cg.cur_lc->predictedPlayerState = *cg.cur_ps;
}
// demo playback just copies the moves
if ( cg.demoPlayback || (cg.cur_ps->pm_flags & PMF_FOLLOW) ) {
CG_InterpolatePlayerState( qfalse );
return;
}
// non-predicting local movement will grab the latest angles
if ( cg_nopredict.integer || cg_synchronousClients.integer ) {
CG_InterpolatePlayerState( qtrue );
return;
}
// prepare for pmove
cg_pmove.ps = &cg.cur_lc->predictedPlayerState;
if (cg.cur_lc->predictedPlayerState.capsule) {
cg_pmove.trace = CG_TraceCapsule;
} else {
cg_pmove.trace = CG_Trace;
}
cg_pmove.pointcontents = CG_PointContents;
if ( cg_pmove.ps->pm_type == PM_DEAD ) {
cg_pmove.tracemask = MASK_PLAYERSOLID & ~CONTENTS_BODY;
}
else {
cg_pmove.tracemask = MASK_PLAYERSOLID;
}
if ( cg.cur_ps->persistant[PERS_TEAM] == TEAM_SPECTATOR ) {
cg_pmove.tracemask &= ~CONTENTS_BODY; // spectators can fly through bodies
}
cg_pmove.noFootsteps = ( cgs.dmflags & DF_NO_FOOTSTEPS ) > 0;
// save the state before the pmove so we can detect transitions
oldPlayerState = cg.cur_lc->predictedPlayerState;
current = trap_GetCurrentCmdNumber();
// if we don't have the commands right after the snapshot, we
// can't accurately predict a current position, so just freeze at
// the last good position we had
cmdNum = current - CMD_BACKUP + 1;
trap_GetUserCmd( cmdNum, &oldestCmd, cg.cur_localClientNum );
if ( oldestCmd.serverTime > cg.cur_ps->commandTime
&& oldestCmd.serverTime < cg.time ) { // special check for map_restart
if ( cg_showmiss.integer ) {
CG_Printf ("exceeded PACKET_BACKUP on commands\n");
}
return;
}
// get the latest command so we can know which commands are from previous map_restarts
trap_GetUserCmd( current, &latestCmd, cg.cur_localClientNum );
// get the most recent information we have, even if
// the server time is beyond our current cg.time,
// because predicted player positions are going to
// be ahead of everything else anyway
if ( cg.nextSnap && !cg.nextFrameTeleport && !cg.thisFrameTeleport
&& cg.nextSnap->lcIndex[cg.cur_localClientNum] != -1) {
cg.cur_lc->predictedPlayerState = cg.nextSnap->pss[cg.nextSnap->lcIndex[cg.cur_localClientNum]];
cg.physicsTime = cg.nextSnap->serverTime;
} else {
cg.cur_lc->predictedPlayerState = *cg.cur_ps;
cg.physicsTime = cg.snap->serverTime;
}
if ( pmove_msec.integer < 8 ) {
trap_Cvar_Set("pmove_msec", "8");
}
else if (pmove_msec.integer > 33) {
trap_Cvar_Set("pmove_msec", "33");
}
cg_pmove.pmove_fixed = pmove_fixed.integer;// | cg_pmove_fixed.integer;
cg_pmove.pmove_msec = pmove_msec.integer;
// run cmds
moved = qfalse;
for ( cmdNum = current - CMD_BACKUP + 1 ; cmdNum <= current ; cmdNum++ ) {
// get the command
trap_GetUserCmd( cmdNum, &cg_pmove.cmd, cg.cur_localClientNum );
if ( cg_pmove.pmove_fixed ) {
PM_UpdateViewAngles( cg_pmove.ps, &cg_pmove.cmd );
}
// don't do anything if the time is before the snapshot player time
if ( cg_pmove.cmd.serverTime <= cg.cur_lc->predictedPlayerState.commandTime ) {
continue;
}
// don't do anything if the command was from a previous map_restart
if ( cg_pmove.cmd.serverTime > latestCmd.serverTime ) {
continue;
}
// check for a prediction error from last frame
// on a lan, this will often be the exact value
// from the snapshot, but on a wan we will have
// to predict several commands to get to the point
// we want to compare
if ( cg.cur_lc->predictedPlayerState.commandTime == oldPlayerState.commandTime ) {
vec3_t delta;
float len;
if ( cg.thisFrameTeleport ) {
// a teleport will not cause an error decay
VectorClear( cg.cur_lc->predictedError );
if ( cg_showmiss.integer ) {
CG_Printf( "PredictionTeleport\n" );
}
cg.thisFrameTeleport = qfalse;
} else {
vec3_t adjusted, new_angles;
CG_AdjustPositionForMover( cg.cur_lc->predictedPlayerState.origin,
cg.cur_lc->predictedPlayerState.groundEntityNum, cg.physicsTime, cg.oldTime, adjusted, cg.cur_lc->predictedPlayerState.viewangles, new_angles);
if ( cg_showmiss.integer ) {
if (!VectorCompare( oldPlayerState.origin, adjusted )) {
CG_Printf("prediction error\n");
}
}
VectorSubtract( oldPlayerState.origin, adjusted, delta );
len = VectorLength( delta );
if ( len > 0.1 ) {
if ( cg_showmiss.integer ) {
CG_Printf("Prediction miss: %f\n", len);
}
if ( cg_errorDecay.integer ) {
int t;
float f;
t = cg.time - cg.cur_lc->predictedErrorTime;
f = ( cg_errorDecay.value - t ) / cg_errorDecay.value;
if ( f < 0 ) {
f = 0;
}
if ( f > 0 && cg_showmiss.integer ) {
CG_Printf("Double prediction decay: %f\n", f);
}
VectorScale( cg.cur_lc->predictedError, f, cg.cur_lc->predictedError );
} else {
VectorClear( cg.cur_lc->predictedError );
}
VectorAdd( delta, cg.cur_lc->predictedError, cg.cur_lc->predictedError );
cg.cur_lc->predictedErrorTime = cg.oldTime;
}
}
}
// don't predict gauntlet firing, which is only supposed to happen
// when it actually inflicts damage
cg_pmove.gauntletHit = qfalse;
if ( cg_pmove.pmove_fixed ) {
cg_pmove.cmd.serverTime = ((cg_pmove.cmd.serverTime + pmove_msec.integer-1) / pmove_msec.integer) * pmove_msec.integer;
}
Pmove (&cg_pmove);
moved = qtrue;
// add push trigger movement effects
CG_TouchTriggerPrediction();
// check for predictable events that changed from previous predictions
//CG_CheckChangedPredictableEvents(&cg.cur_lc->predictedPlayerState);
}
if ( cg_showmiss.integer > 1 ) {
CG_Printf( "[%i : %i] ", cg_pmove.cmd.serverTime, cg.time );
}
if ( !moved ) {
if ( cg_showmiss.integer ) {
CG_Printf( "not moved\n" );
}
return;
}
// adjust for the movement of the groundentity
CG_AdjustPositionForMover( cg.cur_lc->predictedPlayerState.origin,
cg.cur_lc->predictedPlayerState.groundEntityNum,
cg.physicsTime, cg.time, cg.cur_lc->predictedPlayerState.origin, cg.cur_lc->predictedPlayerState.viewangles,cg.cur_lc->predictedPlayerState.viewangles);
if ( cg_showmiss.integer ) {
if (cg.cur_lc->predictedPlayerState.eventSequence > oldPlayerState.eventSequence + MAX_PS_EVENTS) {
CG_Printf("WARNING: dropped event\n");
}
}
// fire events and other transition triggered things
CG_TransitionPlayerState( &cg.cur_lc->predictedPlayerState, &oldPlayerState );
if ( cg_showmiss.integer ) {
if (cg.cur_lc->eventSequence > cg.cur_lc->predictedPlayerState.eventSequence) {
CG_Printf("WARNING: double event\n");
cg.cur_lc->eventSequence = cg.cur_lc->predictedPlayerState.eventSequence;
}
}
}
/*
=================
R_LoadPSK
=================
*/
qboolean R_LoadPSK(model_t * mod, byte *buffer, int bufferSize, const char *modName)
{
int i, j, k;
memStream_t *stream;
axChunkHeader_t chunkHeader;
int numPoints;
axPoint_t *point;
axPoint_t *points;
int numVertexes;
axVertex_t *vertex;
axVertex_t *vertexes;
//int numSmoothGroups;
int numTriangles;
axTriangle_t *triangle;
axTriangle_t *triangles;
int numMaterials;
axMaterial_t *material;
axMaterial_t *materials;
int numReferenceBones;
axReferenceBone_t *refBone;
axReferenceBone_t *refBones;
int numWeights;
axBoneWeight_t *axWeight;
axBoneWeight_t *axWeights;
md5Model_t *md5;
md5Bone_t *md5Bone;
md5Weight_t *weight;
vec3_t boneOrigin;
quat_t boneQuat;
//matrix_t boneMat;
int materialIndex, oldMaterialIndex;
int numRemaining;
growList_t sortedTriangles;
growList_t vboVertexes;
growList_t vboTriangles;
growList_t vboSurfaces;
int numBoneReferences;
int boneReferences[MAX_BONES];
matrix_t unrealToQuake;
//MatrixSetupScale(unrealToQuake, 1, -1, 1);
MatrixFromAngles(unrealToQuake, 0, 90, 0);
stream = AllocMemStream(buffer, bufferSize);
GetChunkHeader(stream, &chunkHeader);
// check indent again
if(Q_stricmpn(chunkHeader.ident, "ACTRHEAD", 8))
{
ri.Printf(PRINT_WARNING, "R_LoadPSK: '%s' has wrong chunk indent ('%s' should be '%s')\n", modName, chunkHeader.ident, "ACTRHEAD");
FreeMemStream(stream);
return qfalse;
}
PrintChunkHeader(&chunkHeader);
mod->type = MOD_MD5;
mod->dataSize += sizeof(md5Model_t);
md5 = mod->md5 = (md5Model_t*)ri.Hunk_Alloc(sizeof(md5Model_t), h_low);
// read points
GetChunkHeader(stream, &chunkHeader);
if(Q_stricmpn(chunkHeader.ident, "PNTS0000", 8))
{
ri.Printf(PRINT_WARNING, "R_LoadPSK: '%s' has wrong chunk indent ('%s' should be '%s')\n", modName, chunkHeader.ident, "PNTS0000");
FreeMemStream(stream);
return qfalse;
}
if(chunkHeader.dataSize != sizeof(axPoint_t))
{
ri.Printf(PRINT_WARNING, "R_LoadPSK: '%s' has wrong chunk dataSize ('%i' should be '%i')\n", modName, chunkHeader.dataSize, sizeof(axPoint_t));
FreeMemStream(stream);
return qfalse;
}
PrintChunkHeader(&chunkHeader);
numPoints = chunkHeader.numData;
points = (axPoint_t*)Com_Allocate(numPoints * sizeof(axPoint_t));
for(i = 0, point = points; i < numPoints; i++, point++)
{
point->point[0] = MemStreamGetFloat(stream);
point->point[1] = MemStreamGetFloat(stream);
point->point[2] = MemStreamGetFloat(stream);
#if 0
// Tr3B: HACK convert from Unreal coordinate system to the Quake one
MatrixTransformPoint2(unrealToQuake, point->point);
#endif
}
// read vertices
GetChunkHeader(stream, &chunkHeader);
if(Q_stricmpn(chunkHeader.ident, "VTXW0000", 8))
{
ri.Printf(PRINT_WARNING, "R_LoadPSK: '%s' has wrong chunk indent ('%s' should be '%s')\n", modName, chunkHeader.ident, "VTXW0000");
FreeMemStream(stream);
Com_Dealloc(points);
return qfalse;
}
if(chunkHeader.dataSize != sizeof(axVertex_t))
{
ri.Printf(PRINT_WARNING, "R_LoadPSK: '%s' has wrong chunk dataSize ('%i' should be '%i')\n", modName, chunkHeader.dataSize, sizeof(axVertex_t));
FreeMemStream(stream);
Com_Dealloc(points);
return qfalse;
}
PrintChunkHeader(&chunkHeader);
numVertexes = chunkHeader.numData;
vertexes = (axVertex_t*)Com_Allocate(numVertexes * sizeof(axVertex_t));
for(i = 0, vertex = vertexes; i < numVertexes; i++, vertex++)
{
vertex->pointIndex = MemStreamGetShort(stream);
if(vertex->pointIndex < 0 || vertex->pointIndex >= numPoints)
{
ri.Printf(PRINT_WARNING, "R_LoadPSK: '%s' has vertex with point index out of range (%i while max %i)\n", modName, vertex->pointIndex, numPoints);
FreeMemStream(stream);
Com_Dealloc(points);
Com_Dealloc(vertexes);
return qfalse;
}
vertex->unknownA = MemStreamGetShort(stream);
vertex->st[0] = MemStreamGetFloat(stream);
vertex->st[1] = MemStreamGetFloat(stream);
vertex->materialIndex = MemStreamGetC(stream);
vertex->reserved = MemStreamGetC(stream);
vertex->unknownB = MemStreamGetShort(stream);
#if 0
ri.Printf(PRINT_ALL, "R_LoadPSK: axVertex_t(%i):\n"
"axVertex:pointIndex: %i\n"
"axVertex:unknownA: %i\n"
"axVertex::st: %f %f\n"
"axVertex:materialIndex: %i\n"
"axVertex:reserved: %d\n"
"axVertex:unknownB: %d\n",
i,
vertex->pointIndex,
vertex->unknownA,
vertex->st[0], vertex->st[1],
vertex->materialIndex,
vertex->reserved,
vertex->unknownB);
#endif
}
// read triangles
GetChunkHeader(stream, &chunkHeader);
if(Q_stricmpn(chunkHeader.ident, "FACE0000", 8))
{
ri.Printf(PRINT_WARNING, "R_LoadPSK: '%s' has wrong chunk indent ('%s' should be '%s')\n", modName, chunkHeader.ident, "FACE0000");
FreeMemStream(stream);
Com_Dealloc(points);
Com_Dealloc(vertexes);
return qfalse;
}
if(chunkHeader.dataSize != sizeof(axTriangle_t))
{
ri.Printf(PRINT_WARNING, "R_LoadPSK: '%s' has wrong chunk dataSize ('%i' should be '%i')\n", modName, chunkHeader.dataSize, sizeof(axTriangle_t));
FreeMemStream(stream);
Com_Dealloc(points);
Com_Dealloc(vertexes);
return qfalse;
}
PrintChunkHeader(&chunkHeader);
numTriangles = chunkHeader.numData;
triangles = (axTriangle_t*)Com_Allocate(numTriangles * sizeof(axTriangle_t));
for(i = 0, triangle = triangles; i < numTriangles; i++, triangle++)
{
for(j = 0; j < 3; j++)
//for(j = 2; j >= 0; j--)
{
triangle->indexes[j] = MemStreamGetShort(stream);
if(triangle->indexes[j] < 0 || triangle->indexes[j] >= numVertexes)
{
ri.Printf(PRINT_WARNING, "R_LoadPSK: '%s' has triangle with vertex index out of range (%i while max %i)\n", modName, triangle->indexes[j], numVertexes);
FreeMemStream(stream);
Com_Dealloc(points);
Com_Dealloc(vertexes);
Com_Dealloc(triangles);
return qfalse;
}
}
triangle->materialIndex = MemStreamGetC(stream);
triangle->materialIndex2 = MemStreamGetC(stream);
triangle->smoothingGroups = MemStreamGetLong(stream);
}
// read materials
GetChunkHeader(stream, &chunkHeader);
if(Q_stricmpn(chunkHeader.ident, "MATT0000", 8))
{
ri.Printf(PRINT_WARNING, "R_LoadPSK: '%s' has wrong chunk indent ('%s' should be '%s')\n", modName, chunkHeader.ident, "MATT0000");
FreeMemStream(stream);
Com_Dealloc(points);
Com_Dealloc(vertexes);
Com_Dealloc(triangles);
return qfalse;
}
if(chunkHeader.dataSize != sizeof(axMaterial_t))
{
ri.Printf(PRINT_WARNING, "R_LoadPSK: '%s' has wrong chunk dataSize ('%i' should be '%i')\n", modName, chunkHeader.dataSize, sizeof(axMaterial_t));
FreeMemStream(stream);
Com_Dealloc(points);
Com_Dealloc(vertexes);
Com_Dealloc(triangles);
return qfalse;
}
PrintChunkHeader(&chunkHeader);
numMaterials = chunkHeader.numData;
materials = (axMaterial_t*)Com_Allocate(numMaterials * sizeof(axMaterial_t));
for(i = 0, material = materials; i < numMaterials; i++, material++)
{
MemStreamRead(stream, material->name, sizeof(material->name));
ri.Printf(PRINT_ALL, "R_LoadPSK: material name: '%s'\n", material->name);
material->shaderIndex = MemStreamGetLong(stream);
material->polyFlags = MemStreamGetLong(stream);
material->auxMaterial = MemStreamGetLong(stream);
material->auxFlags = MemStreamGetLong(stream);
material->lodBias = MemStreamGetLong(stream);
material->lodStyle = MemStreamGetLong(stream);
}
for(i = 0, vertex = vertexes; i < numVertexes; i++, vertex++)
{
if(vertex->materialIndex < 0 || vertex->materialIndex >= numMaterials)
{
ri.Printf(PRINT_WARNING, "R_LoadPSK: '%s' has vertex with material index out of range (%i while max %i)\n", modName, vertex->materialIndex, numMaterials);
FreeMemStream(stream);
Com_Dealloc(points);
Com_Dealloc(vertexes);
Com_Dealloc(triangles);
Com_Dealloc(materials);
return qfalse;
}
}
for(i = 0, triangle = triangles; i < numTriangles; i++, triangle++)
{
if(triangle->materialIndex < 0 || triangle->materialIndex >= numMaterials)
{
ri.Printf(PRINT_WARNING, "R_LoadPSK: '%s' has triangle with material index out of range (%i while max %i)\n", modName, triangle->materialIndex, numMaterials);
FreeMemStream(stream);
Com_Dealloc(points);
Com_Dealloc(vertexes);
Com_Dealloc(triangles);
Com_Dealloc(materials);
return qfalse;
}
}
// read reference bones
GetChunkHeader(stream, &chunkHeader);
if(Q_stricmpn(chunkHeader.ident, "REFSKELT", 8))
{
ri.Printf(PRINT_WARNING, "R_LoadPSK: '%s' has wrong chunk indent ('%s' should be '%s')\n", modName, chunkHeader.ident, "REFSKELT");
FreeMemStream(stream);
Com_Dealloc(points);
Com_Dealloc(vertexes);
Com_Dealloc(triangles);
Com_Dealloc(materials);
return qfalse;
}
if(chunkHeader.dataSize != sizeof(axReferenceBone_t))
{
ri.Printf(PRINT_WARNING, "R_LoadPSK: '%s' has wrong chunk dataSize ('%i' should be '%i')\n", modName, chunkHeader.dataSize, sizeof(axReferenceBone_t));
FreeMemStream(stream);
Com_Dealloc(points);
Com_Dealloc(vertexes);
Com_Dealloc(triangles);
Com_Dealloc(materials);
return qfalse;
}
PrintChunkHeader(&chunkHeader);
numReferenceBones = chunkHeader.numData;
refBones = (axReferenceBone_t*)Com_Allocate(numReferenceBones * sizeof(axReferenceBone_t));
for(i = 0, refBone = refBones; i < numReferenceBones; i++, refBone++)
{
MemStreamRead(stream, refBone->name, sizeof(refBone->name));
//ri.Printf(PRINT_ALL, "R_LoadPSK: reference bone name: '%s'\n", refBone->name);
refBone->flags = MemStreamGetLong(stream);
refBone->numChildren = MemStreamGetLong(stream);
refBone->parentIndex = MemStreamGetLong(stream);
GetBone(stream, &refBone->bone);
#if 0
ri.Printf(PRINT_ALL, "R_LoadPSK: axReferenceBone_t(%i):\n"
"axReferenceBone_t::name: '%s'\n"
"axReferenceBone_t::flags: %i\n"
"axReferenceBone_t::numChildren %i\n"
"axReferenceBone_t::parentIndex: %i\n"
"axReferenceBone_t::quat: %f %f %f %f\n"
"axReferenceBone_t::position: %f %f %f\n"
"axReferenceBone_t::length: %f\n"
"axReferenceBone_t::xSize: %f\n"
"axReferenceBone_t::ySize: %f\n"
"axReferenceBone_t::zSize: %f\n",
i,
refBone->name,
refBone->flags,
refBone->numChildren,
refBone->parentIndex,
refBone->bone.quat[0], refBone->bone.quat[1], refBone->bone.quat[2], refBone->bone.quat[3],
refBone->bone.position[0], refBone->bone.position[1], refBone->bone.position[2],
refBone->bone.length,
refBone->bone.xSize,
refBone->bone.ySize,
refBone->bone.zSize);
#endif
}
// read bone weights
GetChunkHeader(stream, &chunkHeader);
if(Q_stricmpn(chunkHeader.ident, "RAWWEIGHTS", 10))
{
ri.Printf(PRINT_WARNING, "R_LoadPSK: '%s' has wrong chunk indent ('%s' should be '%s')\n", modName, chunkHeader.ident, "RAWWEIGHTS");
FreeMemStream(stream);
Com_Dealloc(points);
Com_Dealloc(vertexes);
Com_Dealloc(triangles);
Com_Dealloc(materials);
Com_Dealloc(refBones);
return qfalse;
}
if(chunkHeader.dataSize != sizeof(axBoneWeight_t))
{
ri.Printf(PRINT_WARNING, "R_LoadPSK: '%s' has wrong chunk dataSize ('%i' should be '%i')\n", modName, chunkHeader.dataSize, sizeof(axBoneWeight_t));
FreeMemStream(stream);
Com_Dealloc(points);
Com_Dealloc(vertexes);
Com_Dealloc(triangles);
Com_Dealloc(materials);
Com_Dealloc(refBones);
return qfalse;
}
PrintChunkHeader(&chunkHeader);
numWeights = chunkHeader.numData;
axWeights = (axBoneWeight_t*)Com_Allocate(numWeights * sizeof(axBoneWeight_t));
for(i = 0, axWeight = axWeights; i < numWeights; i++, axWeight++)
{
axWeight->weight = MemStreamGetFloat(stream);
axWeight->pointIndex = MemStreamGetLong(stream);
axWeight->boneIndex = MemStreamGetLong(stream);
#if 0
ri.Printf(PRINT_ALL, "R_LoadPSK: axBoneWeight_t(%i):\n"
"axBoneWeight_t::weight: %f\n"
"axBoneWeight_t::pointIndex %i\n"
"axBoneWeight_t::boneIndex: %i\n",
i,
axWeight->weight,
axWeight->pointIndex,
axWeight->boneIndex);
#endif
}
//
// convert the model to an internal MD5 representation
//
md5->numBones = numReferenceBones;
// calc numMeshes <number>
/*
numSmoothGroups = 0;
for(i = 0, triangle = triangles; i < numTriangles; i++, triangle++)
{
if(triangle->smoothingGroups)
{
}
}
*/
if(md5->numBones < 1)
{
ri.Printf(PRINT_WARNING, "R_LoadPSK: '%s' has no bones\n", modName);
Com_Dealloc(points);
Com_Dealloc(vertexes);
Com_Dealloc(triangles);
Com_Dealloc(materials);
Com_Dealloc(refBones);
Com_Dealloc(axWeights);
return qfalse;
}
if(md5->numBones > MAX_BONES)
{
ri.Printf(PRINT_WARNING, "R_LoadPSK: '%s' has more than %i bones (%i)\n", modName, MAX_BONES, md5->numBones);
Com_Dealloc(points);
Com_Dealloc(vertexes);
Com_Dealloc(triangles);
Com_Dealloc(materials);
Com_Dealloc(refBones);
Com_Dealloc(axWeights);
return qfalse;
}
//ri.Printf(PRINT_ALL, "R_LoadPSK: '%s' has %i bones\n", modName, md5->numBones);
// copy all reference bones
md5->bones = (md5Bone_t*)ri.Hunk_Alloc(sizeof(*md5Bone) * md5->numBones, h_low);
for(i = 0, md5Bone = md5->bones, refBone = refBones; i < md5->numBones; i++, md5Bone++, refBone++)
{
Q_strncpyz(md5Bone->name, refBone->name, sizeof(md5Bone->name));
if(i == 0)
{
md5Bone->parentIndex = refBone->parentIndex -1;
}
else
{
md5Bone->parentIndex = refBone->parentIndex;
}
//ri.Printf(PRINT_ALL, "R_LoadPSK: '%s' has bone '%s' with parent index %i\n", modName, md5Bone->name, md5Bone->parentIndex);
if(md5Bone->parentIndex >= md5->numBones)
{
ri.Error(ERR_DROP, "R_LoadPSK: '%s' has bone '%s' with bad parent index %i while numBones is %i\n", modName,
md5Bone->name, md5Bone->parentIndex, md5->numBones);
}
for(j = 0; j < 3; j++)
{
boneOrigin[j] = refBone->bone.position[j];
}
// Tr3B: I have really no idea why the .psk format stores the first quaternion with inverted quats.
// Furthermore only the X and Z components of the first quat are inverted ?!?!
if(i == 0)
{
boneQuat[0] = refBone->bone.quat[0];
boneQuat[1] = -refBone->bone.quat[1];
boneQuat[2] = refBone->bone.quat[2];
boneQuat[3] = refBone->bone.quat[3];
}
else
{
boneQuat[0] = -refBone->bone.quat[0];
boneQuat[1] = -refBone->bone.quat[1];
boneQuat[2] = -refBone->bone.quat[2];
boneQuat[3] = refBone->bone.quat[3];
}
VectorCopy(boneOrigin, md5Bone->origin);
//MatrixTransformPoint(unrealToQuake, boneOrigin, md5Bone->origin);
QuatCopy(boneQuat, md5Bone->rotation);
//QuatClear(md5Bone->rotation);
#if 0
ri.Printf(PRINT_ALL, "R_LoadPSK: md5Bone_t(%i):\n"
"md5Bone_t::name: '%s'\n"
"md5Bone_t::parentIndex: %i\n"
"md5Bone_t::quat: %f %f %f %f\n"
"md5bone_t::position: %f %f %f\n",
i,
md5Bone->name,
md5Bone->parentIndex,
md5Bone->rotation[0], md5Bone->rotation[1], md5Bone->rotation[2], md5Bone->rotation[3],
md5Bone->origin[0], md5Bone->origin[1], md5Bone->origin[2]);
#endif
if(md5Bone->parentIndex >= 0)
{
vec3_t rotated;
quat_t quat;
md5Bone_t *parent;
parent = &md5->bones[md5Bone->parentIndex];
QuatTransformVector(parent->rotation, md5Bone->origin, rotated);
//QuatTransformVector(md5Bone->rotation, md5Bone->origin, rotated);
VectorAdd(parent->origin, rotated, md5Bone->origin);
QuatMultiply1(parent->rotation, md5Bone->rotation, quat);
QuatCopy(quat, md5Bone->rotation);
}
MatrixSetupTransformFromQuat(md5Bone->inverseTransform, md5Bone->rotation, md5Bone->origin);
MatrixInverse(md5Bone->inverseTransform);
#if 0
ri.Printf(PRINT_ALL, "R_LoadPSK: md5Bone_t(%i):\n"
"md5Bone_t::name: '%s'\n"
"md5Bone_t::parentIndex: %i\n"
"md5Bone_t::quat: %f %f %f %f\n"
"md5bone_t::position: %f %f %f\n",
i,
md5Bone->name,
md5Bone->parentIndex,
md5Bone->rotation[0], md5Bone->rotation[1], md5Bone->rotation[2], md5Bone->rotation[3],
md5Bone->origin[0], md5Bone->origin[1], md5Bone->origin[2]);
#endif
}
Com_InitGrowList(&vboVertexes, 10000);
for(i = 0, vertex = vertexes; i < numVertexes; i++, vertex++)
{
md5Vertex_t *vboVert = (md5Vertex_t*)Com_Allocate(sizeof(*vboVert));
for(j = 0; j < 3; j++)
{
vboVert->position[j] = points[vertex->pointIndex].point[j];
}
vboVert->texCoords[0] = vertex->st[0];
vboVert->texCoords[1] = vertex->st[1];
// find number of associated weights
vboVert->numWeights = 0;
for(j = 0, axWeight = axWeights; j < numWeights; j++, axWeight++)
{
if(axWeight->pointIndex == vertex->pointIndex && axWeight->weight > 0.0f)
{
vboVert->numWeights++;
}
}
if(vboVert->numWeights > MAX_WEIGHTS)
{
ri.Error(ERR_DROP, "R_LoadPSK: vertex %i requires more weights %i than the maximum of %i in model '%s'", i, vboVert->numWeights, MAX_WEIGHTS, modName);
//ri.Printf(PRINT_WARNING, "R_LoadPSK: vertex %i requires more weights %i than the maximum of %i in model '%s'\n", i, vboVert->numWeights, MAX_WEIGHTS, modName);
}
vboVert->weights = (md5Weight_t**)ri.Hunk_Alloc(sizeof(*vboVert->weights) * vboVert->numWeights, h_low);
for(j = 0, axWeight = axWeights, k = 0; j < numWeights; j++, axWeight++)
{
if(axWeight->pointIndex == vertex->pointIndex && axWeight->weight > 0.0f)
{
weight = (md5Weight_t*)ri.Hunk_Alloc(sizeof(*weight), h_low);
weight->boneIndex = axWeight->boneIndex;
weight->boneWeight = axWeight->weight;
// FIXME?
weight->offset[0] = refBones[axWeight->boneIndex].bone.xSize;
weight->offset[1] = refBones[axWeight->boneIndex].bone.ySize;
weight->offset[2] = refBones[axWeight->boneIndex].bone.zSize;
vboVert->weights[k++] = weight;
}
}
Com_AddToGrowList(&vboVertexes, vboVert);
}
ClearBounds(md5->bounds[0], md5->bounds[1]);
for(i = 0, vertex = vertexes; i < numVertexes; i++, vertex++)
{
AddPointToBounds(points[vertex->pointIndex].point, md5->bounds[0], md5->bounds[1]);
}
#if 0
ri.Printf(PRINT_ALL, "R_LoadPSK: AABB (%i %i %i) (%i %i %i)\n",
(int)md5->bounds[0][0],
(int)md5->bounds[0][1],
(int)md5->bounds[0][2],
(int)md5->bounds[1][0],
(int)md5->bounds[1][1],
(int)md5->bounds[1][2]);
#endif
// sort triangles
qsort(triangles, numTriangles, sizeof(axTriangle_t), CompareTrianglesByMaterialIndex);
Com_InitGrowList(&sortedTriangles, 1000);
for(i = 0, triangle = triangles; i < numTriangles; i++, triangle++)
{
skelTriangle_t *sortTri = (skelTriangle_t*)Com_Allocate(sizeof(*sortTri));
for(j = 0; j < 3; j++)
{
sortTri->indexes[j] = triangle->indexes[j];
sortTri->vertexes[j] = (md5Vertex_t*)Com_GrowListElement(&vboVertexes, triangle->indexes[j]);
}
sortTri->referenced = qfalse;
Com_AddToGrowList(&sortedTriangles, sortTri);
}
// calc tangent spaces
#if 1
{
md5Vertex_t *v0, *v1, *v2;
const float *p0, *p1, *p2;
const float *t0, *t1, *t2;
vec3_t tangent;
vec3_t binormal;
vec3_t normal;
for(j = 0; j < vboVertexes.currentElements; j++)
{
v0 = (md5Vertex_t*)Com_GrowListElement(&vboVertexes, j);
VectorClear(v0->tangent);
VectorClear(v0->binormal);
VectorClear(v0->normal);
}
for(j = 0; j < sortedTriangles.currentElements; j++)
{
skelTriangle_t *tri = (skelTriangle_t*)Com_GrowListElement(&sortedTriangles, j);
v0 = (md5Vertex_t*)Com_GrowListElement(&vboVertexes, tri->indexes[0]);
v1 = (md5Vertex_t*)Com_GrowListElement(&vboVertexes, tri->indexes[1]);
v2 = (md5Vertex_t*)Com_GrowListElement(&vboVertexes, tri->indexes[2]);
p0 = v0->position;
p1 = v1->position;
p2 = v2->position;
t0 = v0->texCoords;
t1 = v1->texCoords;
t2 = v2->texCoords;
#if 1
R_CalcTangentSpace(tangent, binormal, normal, p0, p1, p2, t0, t1, t2);
#else
R_CalcNormalForTriangle(normal, p0, p1, p2);
R_CalcTangentsForTriangle(tangent, binormal, p0, p1, p2, t0, t1, t2);
#endif
for(k = 0; k < 3; k++)
{
float *v;
v0 = (md5Vertex_t*)Com_GrowListElement(&vboVertexes, tri->indexes[k]);
v = v0->tangent;
VectorAdd(v, tangent, v);
v = v0->binormal;
VectorAdd(v, binormal, v);
v = v0->normal;
VectorAdd(v, normal, v);
}
}
for(j = 0; j < vboVertexes.currentElements; j++)
{
v0 = (md5Vertex_t*)Com_GrowListElement(&vboVertexes, j);
VectorNormalize(v0->tangent);
VectorNormalize(v0->binormal);
VectorNormalize(v0->normal);
}
}
#else
{
float bb, s, t;
vec3_t bary;
vec3_t faceNormal;
md5Vertex_t *dv[3];
for(j = 0; j < sortedTriangles.currentElements; j++)
{
skelTriangle_t *tri = Com_GrowListElement(&sortedTriangles, j);
dv[0] = Com_GrowListElement(&vboVertexes, tri->indexes[0]);
dv[1] = Com_GrowListElement(&vboVertexes, tri->indexes[1]);
dv[2] = Com_GrowListElement(&vboVertexes, tri->indexes[2]);
R_CalcNormalForTriangle(faceNormal, dv[0]->position, dv[1]->position, dv[2]->position);
// calculate barycentric basis for the triangle
bb = (dv[1]->texCoords[0] - dv[0]->texCoords[0]) * (dv[2]->texCoords[1] - dv[0]->texCoords[1]) - (dv[2]->texCoords[0] - dv[0]->texCoords[0]) * (dv[1]->texCoords[1] -
dv[0]->texCoords[1]);
if(fabs(bb) < 0.00000001f)
continue;
// do each vertex
for(k = 0; k < 3; k++)
{
// calculate s tangent vector
s = dv[k]->texCoords[0] + 10.0f;
t = dv[k]->texCoords[1];
bary[0] = ((dv[1]->texCoords[0] - s) * (dv[2]->texCoords[1] - t) - (dv[2]->texCoords[0] - s) * (dv[1]->texCoords[1] - t)) / bb;
bary[1] = ((dv[2]->texCoords[0] - s) * (dv[0]->texCoords[1] - t) - (dv[0]->texCoords[0] - s) * (dv[2]->texCoords[1] - t)) / bb;
bary[2] = ((dv[0]->texCoords[0] - s) * (dv[1]->texCoords[1] - t) - (dv[1]->texCoords[0] - s) * (dv[0]->texCoords[1] - t)) / bb;
dv[k]->tangent[0] = bary[0] * dv[0]->position[0] + bary[1] * dv[1]->position[0] + bary[2] * dv[2]->position[0];
dv[k]->tangent[1] = bary[0] * dv[0]->position[1] + bary[1] * dv[1]->position[1] + bary[2] * dv[2]->position[1];
dv[k]->tangent[2] = bary[0] * dv[0]->position[2] + bary[1] * dv[1]->position[2] + bary[2] * dv[2]->position[2];
VectorSubtract(dv[k]->tangent, dv[k]->position, dv[k]->tangent);
VectorNormalize(dv[k]->tangent);
// calculate t tangent vector (binormal)
s = dv[k]->texCoords[0];
t = dv[k]->texCoords[1] + 10.0f;
bary[0] = ((dv[1]->texCoords[0] - s) * (dv[2]->texCoords[1] - t) - (dv[2]->texCoords[0] - s) * (dv[1]->texCoords[1] - t)) / bb;
bary[1] = ((dv[2]->texCoords[0] - s) * (dv[0]->texCoords[1] - t) - (dv[0]->texCoords[0] - s) * (dv[2]->texCoords[1] - t)) / bb;
bary[2] = ((dv[0]->texCoords[0] - s) * (dv[1]->texCoords[1] - t) - (dv[1]->texCoords[0] - s) * (dv[0]->texCoords[1] - t)) / bb;
dv[k]->binormal[0] = bary[0] * dv[0]->position[0] + bary[1] * dv[1]->position[0] + bary[2] * dv[2]->position[0];
dv[k]->binormal[1] = bary[0] * dv[0]->position[1] + bary[1] * dv[1]->position[1] + bary[2] * dv[2]->position[1];
dv[k]->binormal[2] = bary[0] * dv[0]->position[2] + bary[1] * dv[1]->position[2] + bary[2] * dv[2]->position[2];
VectorSubtract(dv[k]->binormal, dv[k]->position, dv[k]->binormal);
VectorNormalize(dv[k]->binormal);
// calculate the normal as cross product N=TxB
#if 0
CrossProduct(dv[k]->tangent, dv[k]->binormal, dv[k]->normal);
VectorNormalize(dv[k]->normal);
// Gram-Schmidt orthogonalization process for B
// compute the cross product B=NxT to obtain
// an orthogonal basis
CrossProduct(dv[k]->normal, dv[k]->tangent, dv[k]->binormal);
if(DotProduct(dv[k]->normal, faceNormal) < 0)
{
VectorInverse(dv[k]->normal);
//VectorInverse(dv[k]->tangent);
//VectorInverse(dv[k]->binormal);
}
#else
VectorAdd(dv[k]->normal, faceNormal, dv[k]->normal);
#endif
}
}
#if 1
for(j = 0; j < vboVertexes.currentElements; j++)
{
dv[0] = Com_GrowListElement(&vboVertexes, j);
//VectorNormalize(dv[0]->tangent);
//VectorNormalize(dv[0]->binormal);
VectorNormalize(dv[0]->normal);
}
#endif
}
#endif
#if 0
{
md5Vertex_t *v0, *v1;
// do another extra smoothing for normals to avoid flat shading
for(j = 0; j < vboVertexes.currentElements; j++)
{
v0 = Com_GrowListElement(&vboVertexes, j);
for(k = 0; k < vboVertexes.currentElements; k++)
{
if(j == k)
continue;
v1 = Com_GrowListElement(&vboVertexes, k);
if(VectorCompare(v0->position, v1->position))
{
VectorAdd(v0->position, v1->normal, v0->normal);
}
}
VectorNormalize(v0->normal);
}
}
#endif
// split the surfaces into VBO surfaces by the maximum number of GPU vertex skinning bones
Com_InitGrowList(&vboSurfaces, 10);
materialIndex = oldMaterialIndex = -1;
for(i = 0; i < numTriangles; i++)
{
triangle = &triangles[i];
materialIndex = triangle->materialIndex;
if(materialIndex != oldMaterialIndex)
{
oldMaterialIndex = materialIndex;
numRemaining = sortedTriangles.currentElements - i;
while(numRemaining)
{
numBoneReferences = 0;
Com_Memset(boneReferences, 0, sizeof(boneReferences));
Com_InitGrowList(&vboTriangles, 1000);
for(j = i; j < sortedTriangles.currentElements; j++)
{
skelTriangle_t *sortTri;
triangle = &triangles[j];
materialIndex = triangle->materialIndex;
if(materialIndex != oldMaterialIndex)
continue;
sortTri = (skelTriangle_t*)Com_GrowListElement(&sortedTriangles, j);
if(sortTri->referenced)
continue;
if(AddTriangleToVBOTriangleList(&vboTriangles, sortTri, &numBoneReferences, boneReferences))
{
sortTri->referenced = qtrue;
}
}
for(j = 0; j < MAX_BONES; j++)
{
if(boneReferences[j] > 0)
{
ri.Printf(PRINT_ALL, "R_LoadPSK: referenced bone: '%s'\n", (j < numReferenceBones) ? refBones[j].name : NULL);
}
}
if(!vboTriangles.currentElements)
{
ri.Printf(PRINT_WARNING, "R_LoadPSK: could not add triangles to a remaining VBO surface for model '%s'\n", modName);
break;
}
// FIXME skinIndex
AddSurfaceToVBOSurfacesList2(&vboSurfaces, &vboTriangles, &vboVertexes, md5, vboSurfaces.currentElements, materials[oldMaterialIndex].name, numBoneReferences, boneReferences);
numRemaining -= vboTriangles.currentElements;
Com_DestroyGrowList(&vboTriangles);
}
}
}
for(j = 0; j < sortedTriangles.currentElements; j++)
{
skelTriangle_t *sortTri = (skelTriangle_t*)Com_GrowListElement(&sortedTriangles, j);
Com_Dealloc(sortTri);
}
Com_DestroyGrowList(&sortedTriangles);
for(j = 0; j < vboVertexes.currentElements; j++)
{
md5Vertex_t *v = (md5Vertex_t*)Com_GrowListElement(&vboVertexes, j);
Com_Dealloc(v);
}
Com_DestroyGrowList(&vboVertexes);
// move VBO surfaces list to hunk
md5->numVBOSurfaces = vboSurfaces.currentElements;
md5->vboSurfaces = (srfVBOMD5Mesh_t**)ri.Hunk_Alloc(md5->numVBOSurfaces * sizeof(*md5->vboSurfaces), h_low);
for(i = 0; i < md5->numVBOSurfaces; i++)
{
md5->vboSurfaces[i] = (srfVBOMD5Mesh_t *) Com_GrowListElement(&vboSurfaces, i);
}
Com_DestroyGrowList(&vboSurfaces);
FreeMemStream(stream);
Com_Dealloc(points);
Com_Dealloc(vertexes);
Com_Dealloc(triangles);
Com_Dealloc(materials);
Com_Dealloc(refBones);
Com_Dealloc(axWeights);
ri.Printf(PRINT_ALL, "%i VBO surfaces created for PSK model '%s'\n", md5->numVBOSurfaces, modName);
return qtrue;
}
// =================
void sphere_chase (edict_t *self, int stupidChase)
{
vec3_t dest;
vec3_t dir;
float dist;
if(level.time >= self->wait || (self->enemy && self->enemy->health < 1))
{
sphere_think_explode(self);
return;
}
VectorCopy (self->enemy->s.origin, dest);
if(self->enemy->client)
dest[2] += self->enemy->viewheight;
if(visible(self, self->enemy) || stupidChase)
{
// if moving, hunter sphere uses active sound
if(!stupidChase)
self->s.sound = gi.soundindex ("spheres/h_active.wav");
VectorSubtract (dest, self->s.origin, dir);
VectorNormalize (dir);
vectoangles2(dir, self->s.angles);
VectorScale (dir, 500, self->velocity);
VectorCopy(dest, self->monsterinfo.saved_goal);
}
else if (VectorCompare (self->monsterinfo.saved_goal, vec3_origin))
{
VectorSubtract(self->enemy->s.origin, self->s.origin, dir);
vectoangles2(dir, self->s.angles);
// if lurking, hunter sphere uses lurking sound
self->s.sound = gi.soundindex ("spheres/h_lurk.wav");
VectorClear (self->velocity);
}
else
{
VectorSubtract(self->monsterinfo.saved_goal, self->s.origin, dir);
dist = VectorNormalize(dir);
if(dist > 1)
{
vectoangles2(dir, self->s.angles);
if(dist > 500)
VectorScale(dir, 500, self->velocity);
else if (dist < 20)
VectorScale(dir, (dist / FRAMETIME), self->velocity);
else
VectorScale(dir, dist, self->velocity);
// if moving, hunter sphere uses active sound
if(!stupidChase)
self->s.sound = gi.soundindex ("spheres/h_active.wav");
}
else
{
VectorSubtract(self->enemy->s.origin, self->s.origin, dir);
vectoangles2(dir, self->s.angles);
// if not moving, hunter sphere uses lurk sound
if(!stupidChase)
self->s.sound = gi.soundindex ("spheres/h_lurk.wav");
VectorClear(self->velocity);
}
}
}
qboolean R_LoadMD5(model_t *mod, void *buffer, int bufferSize, const char *modName)
{
int i, j, k;
md5Model_t *md5;
md5Bone_t *bone;
md5Surface_t *surf;
srfTriangle_t *tri;
md5Vertex_t *v;
md5Weight_t *weight;
int version;
shader_t *sh;
char *buf_p;
char *token;
vec3_t boneOrigin;
quat_t boneQuat;
matrix_t boneMat;
int numRemaining;
growList_t sortedTriangles;
growList_t vboTriangles;
growList_t vboSurfaces;
int numBoneReferences;
int boneReferences[MAX_BONES];
buf_p = ( char * ) buffer;
// skip MD5Version indent string
COM_ParseExt2(&buf_p, qfalse);
// check version
token = COM_ParseExt2(&buf_p, qfalse);
version = atoi(token);
if (version != MD5_VERSION)
{
ri.Printf(PRINT_WARNING, "R_LoadMD5: %s has wrong version (%i should be %i)\n", modName, version, MD5_VERSION);
return qfalse;
}
mod->type = MOD_MD5;
mod->dataSize += sizeof(md5Model_t);
md5 = mod->md5 = ri.Hunk_Alloc(sizeof(md5Model_t), h_low);
// skip commandline <arguments string>
token = COM_ParseExt2(&buf_p, qtrue);
token = COM_ParseExt2(&buf_p, qtrue);
// ri.Printf(PRINT_ALL, "%s\n", token);
// parse numJoints <number>
token = COM_ParseExt2(&buf_p, qtrue);
if (Q_stricmp(token, "numJoints"))
{
ri.Printf(PRINT_WARNING, "R_LoadMD5: expected 'numJoints' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
token = COM_ParseExt2(&buf_p, qfalse);
md5->numBones = atoi(token);
// parse numMeshes <number>
token = COM_ParseExt2(&buf_p, qtrue);
if (Q_stricmp(token, "numMeshes"))
{
ri.Printf(PRINT_WARNING, "R_LoadMD5: expected 'numMeshes' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
token = COM_ParseExt2(&buf_p, qfalse);
md5->numSurfaces = atoi(token);
//ri.Printf(PRINT_ALL, "R_LoadMD5: '%s' has %i surfaces\n", modName, md5->numSurfaces);
if (md5->numBones < 1)
{
ri.Printf(PRINT_WARNING, "R_LoadMD5: '%s' has no bones\n", modName);
return qfalse;
}
if (md5->numBones > MAX_BONES)
{
ri.Printf(PRINT_WARNING, "R_LoadMD5: '%s' has more than %i bones (%i)\n", modName, MAX_BONES, md5->numBones);
return qfalse;
}
//ri.Printf(PRINT_ALL, "R_LoadMD5: '%s' has %i bones\n", modName, md5->numBones);
// parse all the bones
md5->bones = ri.Hunk_Alloc(sizeof(*bone) * md5->numBones, h_low);
// parse joints {
token = COM_ParseExt2(&buf_p, qtrue);
if (Q_stricmp(token, "joints"))
{
ri.Printf(PRINT_WARNING, "R_LoadMD5: expected 'joints' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
token = COM_ParseExt2(&buf_p, qfalse);
if (Q_stricmp(token, "{"))
{
ri.Printf(PRINT_WARNING, "R_LoadMD5: expected '{' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
for (i = 0, bone = md5->bones; i < md5->numBones; i++, bone++)
{
token = COM_ParseExt2(&buf_p, qtrue);
Q_strncpyz(bone->name, token, sizeof(bone->name));
//ri.Printf(PRINT_ALL, "R_LoadMD5: '%s' has bone '%s'\n", modName, bone->name);
token = COM_ParseExt2(&buf_p, qfalse);
bone->parentIndex = atoi(token);
//ri.Printf(PRINT_ALL, "R_LoadMD5: '%s' has bone '%s' with parent index %i\n", modName, bone->name, bone->parentIndex);
if (bone->parentIndex >= md5->numBones)
{
ri.Error(ERR_DROP, "R_LoadMD5: '%s' has bone '%s' with bad parent index %i while numBones is %i", modName,
bone->name, bone->parentIndex, md5->numBones);
}
// skip (
token = COM_ParseExt2(&buf_p, qfalse);
if (Q_stricmp(token, "("))
{
ri.Printf(PRINT_WARNING, "R_LoadMD5: expected '(' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
for (j = 0; j < 3; j++)
{
token = COM_ParseExt2(&buf_p, qfalse);
boneOrigin[j] = atof(token);
}
// skip )
token = COM_ParseExt2(&buf_p, qfalse);
if (Q_stricmp(token, ")"))
{
ri.Printf(PRINT_WARNING, "R_LoadMD5: expected ')' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
// skip (
token = COM_ParseExt2(&buf_p, qfalse);
if (Q_stricmp(token, "("))
{
ri.Printf(PRINT_WARNING, "R_LoadMD5: expected '(' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
for (j = 0; j < 3; j++)
{
token = COM_ParseExt2(&buf_p, qfalse);
boneQuat[j] = atof(token);
}
QuatCalcW(boneQuat);
MatrixFromQuat(boneMat, boneQuat);
VectorCopy(boneOrigin, bone->origin);
QuatCopy(boneQuat, bone->rotation);
MatrixSetupTransformFromQuat(bone->inverseTransform, boneQuat, boneOrigin);
MatrixInverse(bone->inverseTransform);
// skip )
token = COM_ParseExt2(&buf_p, qfalse);
if (Q_stricmp(token, ")"))
{
ri.Printf(PRINT_WARNING, "R_LoadMD5: expected '(' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
}
// parse }
token = COM_ParseExt2(&buf_p, qtrue);
if (Q_stricmp(token, "}"))
{
ri.Printf(PRINT_WARNING, "R_LoadMD5: expected '}' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
// parse all the surfaces
if (md5->numSurfaces < 1)
{
ri.Printf(PRINT_WARNING, "R_LoadMD5: '%s' has no surfaces\n", modName);
return qfalse;
}
//ri.Printf(PRINT_ALL, "R_LoadMD5: '%s' has %i surfaces\n", modName, md5->numSurfaces);
md5->surfaces = ri.Hunk_Alloc(sizeof(*surf) * md5->numSurfaces, h_low);
for (i = 0, surf = md5->surfaces; i < md5->numSurfaces; i++, surf++)
{
// parse mesh {
token = COM_ParseExt2(&buf_p, qtrue);
if (Q_stricmp(token, "mesh"))
{
ri.Printf(PRINT_WARNING, "R_LoadMD5: expected 'mesh' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
token = COM_ParseExt2(&buf_p, qfalse);
if (Q_stricmp(token, "{"))
{
ri.Printf(PRINT_WARNING, "R_LoadMD5: expected '{' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
// change to surface identifier
surf->surfaceType = SF_MD5;
// give pointer to model for Tess_SurfaceMD5
surf->model = md5;
// parse shader <name>
token = COM_ParseExt2(&buf_p, qtrue);
if (Q_stricmp(token, "shader"))
{
ri.Printf(PRINT_WARNING, "R_LoadMD5: expected 'shader' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
token = COM_ParseExt2(&buf_p, qfalse);
Q_strncpyz(surf->shader, token, sizeof(surf->shader));
//ri.Printf(PRINT_ALL, "R_LoadMD5: '%s' uses shader '%s'\n", modName, surf->shader);
// FIXME .md5mesh meshes don't have surface names
// lowercase the surface name so skin compares are faster
//Q_strlwr(surf->name);
//ri.Printf(PRINT_ALL, "R_LoadMD5: '%s' has surface '%s'\n", modName, surf->name);
// register the shaders
sh = R_FindShader(surf->shader, SHADER_3D_DYNAMIC, qtrue);
if (sh->defaultShader)
{
surf->shaderIndex = 0;
}
else
{
surf->shaderIndex = sh->index;
}
// parse numVerts <number>
token = COM_ParseExt2(&buf_p, qtrue);
if (Q_stricmp(token, "numVerts"))
{
ri.Printf(PRINT_WARNING, "R_LoadMD5: expected 'numVerts' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
token = COM_ParseExt2(&buf_p, qfalse);
surf->numVerts = atoi(token);
if (surf->numVerts > SHADER_MAX_VERTEXES)
{
ri.Error(ERR_DROP, "R_LoadMD5: '%s' has more than %i verts on a surface (%i)",
modName, SHADER_MAX_VERTEXES, surf->numVerts);
}
surf->verts = ri.Hunk_Alloc(sizeof(*v) * surf->numVerts, h_low);
for (j = 0, v = surf->verts; j < surf->numVerts; j++, v++)
{
// skip vert <number>
token = COM_ParseExt2(&buf_p, qtrue);
if (Q_stricmp(token, "vert"))
{
ri.Printf(PRINT_WARNING, "R_LoadMD5: expected 'vert' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
COM_ParseExt2(&buf_p, qfalse);
// skip (
token = COM_ParseExt2(&buf_p, qfalse);
if (Q_stricmp(token, "("))
{
ri.Printf(PRINT_WARNING, "R_LoadMD5: expected '(' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
for (k = 0; k < 2; k++)
{
token = COM_ParseExt2(&buf_p, qfalse);
v->texCoords[k] = atof(token);
}
// skip )
token = COM_ParseExt2(&buf_p, qfalse);
if (Q_stricmp(token, ")"))
{
ri.Printf(PRINT_WARNING, "R_LoadMD5: expected ')' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
token = COM_ParseExt2(&buf_p, qfalse);
v->firstWeight = atoi(token);
token = COM_ParseExt2(&buf_p, qfalse);
v->numWeights = atoi(token);
if (v->numWeights > MAX_WEIGHTS)
{
ri.Error(ERR_DROP, "R_LoadMD5: vertex %i requires more than %i weights on surface (%i) in model '%s'",
j, MAX_WEIGHTS, i, modName);
}
}
// parse numTris <number>
token = COM_ParseExt2(&buf_p, qtrue);
if (Q_stricmp(token, "numTris"))
{
ri.Printf(PRINT_WARNING, "R_LoadMD5: expected 'numTris' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
token = COM_ParseExt2(&buf_p, qfalse);
surf->numTriangles = atoi(token);
if (surf->numTriangles > SHADER_MAX_TRIANGLES)
{
ri.Error(ERR_DROP, "R_LoadMD5: '%s' has more than %i triangles on a surface (%i)",
modName, SHADER_MAX_TRIANGLES, surf->numTriangles);
}
surf->triangles = ri.Hunk_Alloc(sizeof(*tri) * surf->numTriangles, h_low);
for (j = 0, tri = surf->triangles; j < surf->numTriangles; j++, tri++)
{
// skip tri <number>
token = COM_ParseExt2(&buf_p, qtrue);
if (Q_stricmp(token, "tri"))
{
ri.Printf(PRINT_WARNING, "R_LoadMD5: expected 'tri' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
COM_ParseExt2(&buf_p, qfalse);
for (k = 0; k < 3; k++)
{
token = COM_ParseExt2(&buf_p, qfalse);
tri->indexes[k] = atoi(token);
}
}
// parse numWeights <number>
token = COM_ParseExt2(&buf_p, qtrue);
if (Q_stricmp(token, "numWeights"))
{
ri.Printf(PRINT_WARNING, "R_LoadMD5: expected 'numWeights' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
token = COM_ParseExt2(&buf_p, qfalse);
surf->numWeights = atoi(token);
surf->weights = ri.Hunk_Alloc(sizeof(*weight) * surf->numWeights, h_low);
for (j = 0, weight = surf->weights; j < surf->numWeights; j++, weight++)
{
// skip weight <number>
token = COM_ParseExt2(&buf_p, qtrue);
if (Q_stricmp(token, "weight"))
{
ri.Printf(PRINT_WARNING, "R_LoadMD5: expected 'weight' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
COM_ParseExt2(&buf_p, qfalse);
token = COM_ParseExt2(&buf_p, qfalse);
weight->boneIndex = atoi(token);
token = COM_ParseExt2(&buf_p, qfalse);
weight->boneWeight = atof(token);
// skip (
token = COM_ParseExt2(&buf_p, qfalse);
if (Q_stricmp(token, "("))
{
ri.Printf(PRINT_WARNING, "R_LoadMD5: expected '(' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
for (k = 0; k < 3; k++)
{
token = COM_ParseExt2(&buf_p, qfalse);
weight->offset[k] = atof(token);
}
// skip )
token = COM_ParseExt2(&buf_p, qfalse);
if (Q_stricmp(token, ")"))
{
ri.Printf(PRINT_WARNING, "R_LoadMD5: expected ')' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
}
// parse }
token = COM_ParseExt2(&buf_p, qtrue);
if (Q_stricmp(token, "}"))
{
ri.Printf(PRINT_WARNING, "R_LoadMD5: expected '}' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
// loop trough all vertices and set up the vertex weights
for (j = 0, v = surf->verts; j < surf->numVerts; j++, v++)
{
v->weights = ri.Hunk_Alloc(sizeof(*v->weights) * v->numWeights, h_low);
for (k = 0; k < v->numWeights; k++)
{
v->weights[k] = surf->weights + (v->firstWeight + k);
}
}
}
// loading is done now calculate the bounding box and tangent spaces
ClearBounds(md5->bounds[0], md5->bounds[1]);
for (i = 0, surf = md5->surfaces; i < md5->numSurfaces; i++, surf++)
{
for (j = 0, v = surf->verts; j < surf->numVerts; j++, v++)
{
vec3_t tmpVert;
md5Weight_t *w;
VectorClear(tmpVert);
for (k = 0, w = v->weights[0]; k < v->numWeights; k++, w++)
{
vec3_t offsetVec;
bone = &md5->bones[w->boneIndex];
QuatTransformVector(bone->rotation, w->offset, offsetVec);
VectorAdd(bone->origin, offsetVec, offsetVec);
VectorMA(tmpVert, w->boneWeight, offsetVec, tmpVert);
}
VectorCopy(tmpVert, v->position);
AddPointToBounds(tmpVert, md5->bounds[0], md5->bounds[1]);
}
// calc tangent spaces
#if 1
{
const float *v0, *v1, *v2;
const float *t0, *t1, *t2;
vec3_t tangent;
vec3_t binormal;
vec3_t normal;
for (j = 0, v = surf->verts; j < surf->numVerts; j++, v++)
{
VectorClear(v->tangent);
VectorClear(v->binormal);
VectorClear(v->normal);
}
for (j = 0, tri = surf->triangles; j < surf->numTriangles; j++, tri++)
{
v0 = surf->verts[tri->indexes[0]].position;
v1 = surf->verts[tri->indexes[1]].position;
v2 = surf->verts[tri->indexes[2]].position;
t0 = surf->verts[tri->indexes[0]].texCoords;
t1 = surf->verts[tri->indexes[1]].texCoords;
t2 = surf->verts[tri->indexes[2]].texCoords;
#if 1
R_CalcTangentSpace(tangent, binormal, normal, v0, v1, v2, t0, t1, t2);
#else
R_CalcNormalForTriangle(normal, v0, v1, v2);
R_CalcTangentsForTriangle(tangent, binormal, v0, v1, v2, t0, t1, t2);
#endif
for (k = 0; k < 3; k++)
{
float *v;
v = surf->verts[tri->indexes[k]].tangent;
VectorAdd(v, tangent, v);
v = surf->verts[tri->indexes[k]].binormal;
VectorAdd(v, binormal, v);
v = surf->verts[tri->indexes[k]].normal;
VectorAdd(v, normal, v);
}
}
for (j = 0, v = surf->verts; j < surf->numVerts; j++, v++)
{
VectorNormalize(v->tangent);
VectorNormalize(v->binormal);
VectorNormalize(v->normal);
}
}
#else
{
int k;
float bb, s, t;
vec3_t bary;
vec3_t faceNormal;
md5Vertex_t *dv[3];
for (j = 0, tri = surf->triangles; j < surf->numTriangles; j++, tri++)
{
dv[0] = &surf->verts[tri->indexes[0]];
dv[1] = &surf->verts[tri->indexes[1]];
dv[2] = &surf->verts[tri->indexes[2]];
R_CalcNormalForTriangle(faceNormal, dv[0]->position, dv[1]->position, dv[2]->position);
// calculate barycentric basis for the triangle
bb = (dv[1]->texCoords[0] - dv[0]->texCoords[0]) * (dv[2]->texCoords[1] - dv[0]->texCoords[1]) - (dv[2]->texCoords[0] - dv[0]->texCoords[0]) * (dv[1]->texCoords[1] -
dv[0]->texCoords[1]);
if (fabs(bb) < 0.00000001f)
{
continue;
}
// do each vertex
for (k = 0; k < 3; k++)
{
// calculate s tangent vector
s = dv[k]->texCoords[0] + 10.0f;
t = dv[k]->texCoords[1];
bary[0] = ((dv[1]->texCoords[0] - s) * (dv[2]->texCoords[1] - t) - (dv[2]->texCoords[0] - s) * (dv[1]->texCoords[1] - t)) / bb;
bary[1] = ((dv[2]->texCoords[0] - s) * (dv[0]->texCoords[1] - t) - (dv[0]->texCoords[0] - s) * (dv[2]->texCoords[1] - t)) / bb;
bary[2] = ((dv[0]->texCoords[0] - s) * (dv[1]->texCoords[1] - t) - (dv[1]->texCoords[0] - s) * (dv[0]->texCoords[1] - t)) / bb;
dv[k]->tangent[0] = bary[0] * dv[0]->position[0] + bary[1] * dv[1]->position[0] + bary[2] * dv[2]->position[0];
dv[k]->tangent[1] = bary[0] * dv[0]->position[1] + bary[1] * dv[1]->position[1] + bary[2] * dv[2]->position[1];
dv[k]->tangent[2] = bary[0] * dv[0]->position[2] + bary[1] * dv[1]->position[2] + bary[2] * dv[2]->position[2];
VectorSubtract(dv[k]->tangent, dv[k]->position, dv[k]->tangent);
VectorNormalize(dv[k]->tangent);
// calculate t tangent vector (binormal)
s = dv[k]->texCoords[0];
t = dv[k]->texCoords[1] + 10.0f;
bary[0] = ((dv[1]->texCoords[0] - s) * (dv[2]->texCoords[1] - t) - (dv[2]->texCoords[0] - s) * (dv[1]->texCoords[1] - t)) / bb;
bary[1] = ((dv[2]->texCoords[0] - s) * (dv[0]->texCoords[1] - t) - (dv[0]->texCoords[0] - s) * (dv[2]->texCoords[1] - t)) / bb;
bary[2] = ((dv[0]->texCoords[0] - s) * (dv[1]->texCoords[1] - t) - (dv[1]->texCoords[0] - s) * (dv[0]->texCoords[1] - t)) / bb;
dv[k]->binormal[0] = bary[0] * dv[0]->position[0] + bary[1] * dv[1]->position[0] + bary[2] * dv[2]->position[0];
dv[k]->binormal[1] = bary[0] * dv[0]->position[1] + bary[1] * dv[1]->position[1] + bary[2] * dv[2]->position[1];
dv[k]->binormal[2] = bary[0] * dv[0]->position[2] + bary[1] * dv[1]->position[2] + bary[2] * dv[2]->position[2];
VectorSubtract(dv[k]->binormal, dv[k]->position, dv[k]->binormal);
VectorNormalize(dv[k]->binormal);
// calculate the normal as cross product N=TxB
#if 0
CrossProduct(dv[k]->tangent, dv[k]->binormal, dv[k]->normal);
VectorNormalize(dv[k]->normal);
// Gram-Schmidt orthogonalization process for B
// compute the cross product B=NxT to obtain
// an orthogonal basis
CrossProduct(dv[k]->normal, dv[k]->tangent, dv[k]->binormal);
if (DotProduct(dv[k]->normal, faceNormal) < 0)
{
VectorInverse(dv[k]->normal);
//VectorInverse(dv[k]->tangent);
//VectorInverse(dv[k]->binormal);
}
#else
VectorAdd(dv[k]->normal, faceNormal, dv[k]->normal);
#endif
}
}
#if 1
for (j = 0, v = surf->verts; j < surf->numVerts; j++, v++)
{
//VectorNormalize(v->tangent);
//VectorNormalize(v->binormal);
VectorNormalize(v->normal);
}
#endif
}
#endif
#if 0
// do another extra smoothing for normals to avoid flat shading
for (j = 0; j < surf->numVerts; j++)
{
for (k = 0; k < surf->numVerts; k++)
{
if (j == k)
{
continue;
}
if (VectorCompare(surf->verts[j].position, surf->verts[k].position))
{
VectorAdd(surf->verts[j].normal, surf->verts[k].normal, surf->verts[j].normal);
}
}
VectorNormalize(surf->verts[j].normal);
}
#endif
}
// split the surfaces into VBO surfaces by the maximum number of GPU vertex skinning bones
Com_InitGrowList(&vboSurfaces, 10);
for (i = 0, surf = md5->surfaces; i < md5->numSurfaces; i++, surf++)
{
// sort triangles
Com_InitGrowList(&sortedTriangles, 1000);
for (j = 0, tri = surf->triangles; j < surf->numTriangles; j++, tri++)
{
skelTriangle_t *sortTri = Com_Allocate(sizeof(*sortTri));
for (k = 0; k < 3; k++)
{
sortTri->indexes[k] = tri->indexes[k];
sortTri->vertexes[k] = &surf->verts[tri->indexes[k]];
}
sortTri->referenced = qfalse;
Com_AddToGrowList(&sortedTriangles, sortTri);
}
//qsort(sortedTriangles.elements, sortedTriangles.currentElements, sizeof(void *), CompareTrianglesByBoneReferences);
#if 0
for (j = 0; j < sortedTriangles.currentElements; j++)
{
int b[MAX_WEIGHTS * 3];
skelTriangle_t *sortTri = Com_GrowListElement(&sortedTriangles, j);
for (k = 0; k < 3; k++)
{
v = sortTri->vertexes[k];
for (l = 0; l < MAX_WEIGHTS; l++)
{
b[k * 3 + l] = (l < v->numWeights) ? v->weights[l]->boneIndex : 9999;
}
qsort(b, MAX_WEIGHTS * 3, sizeof(int), CompareBoneIndices);
//ri.Printf(PRINT_ALL, "bone indices: %i %i %i %i\n", b[k * 3 + 0], b[k * 3 + 1], b[k * 3 + 2], b[k * 3 + 3]);
}
}
#endif
numRemaining = sortedTriangles.currentElements;
while (numRemaining)
{
numBoneReferences = 0;
Com_Memset(boneReferences, 0, sizeof(boneReferences));
Com_InitGrowList(&vboTriangles, 1000);
for (j = 0; j < sortedTriangles.currentElements; j++)
{
skelTriangle_t *sortTri = Com_GrowListElement(&sortedTriangles, j);
if (sortTri->referenced)
{
continue;
}
if (AddTriangleToVBOTriangleList(&vboTriangles, sortTri, &numBoneReferences, boneReferences))
{
sortTri->referenced = qtrue;
}
}
if (!vboTriangles.currentElements)
{
ri.Printf(PRINT_WARNING, "R_LoadMD5: could not add triangles to a remaining VBO surfaces for model '%s'\n", modName);
Com_DestroyGrowList(&vboTriangles);
break;
}
AddSurfaceToVBOSurfacesList(&vboSurfaces, &vboTriangles, md5, surf, i, numBoneReferences, boneReferences);
numRemaining -= vboTriangles.currentElements;
Com_DestroyGrowList(&vboTriangles);
}
for (j = 0; j < sortedTriangles.currentElements; j++)
{
skelTriangle_t *sortTri = Com_GrowListElement(&sortedTriangles, j);
Com_Dealloc(sortTri);
}
Com_DestroyGrowList(&sortedTriangles);
}
// move VBO surfaces list to hunk
md5->numVBOSurfaces = vboSurfaces.currentElements;
md5->vboSurfaces = ri.Hunk_Alloc(md5->numVBOSurfaces * sizeof(*md5->vboSurfaces), h_low);
for (i = 0; i < md5->numVBOSurfaces; i++)
{
md5->vboSurfaces[i] = ( srfVBOMD5Mesh_t * ) Com_GrowListElement(&vboSurfaces, i);
}
Com_DestroyGrowList(&vboSurfaces);
return qtrue;
}
/*
================
R_DrawMirrors
Draw all viewpasess from mirror position
Mirror textures will be drawn in normal pass
================
*/
void R_DrawMirrors( void )
{
ref_instance_t oldRI;
mplane_t plane;
msurface_t *surf, *surf2;
int i, oldframecount;
mextrasurf_t *es, *tmp, *mirrorchain;
vec3_t forward, right, up;
vec3_t origin, angles;
matrix4x4 mirrormatrix;
cl_entity_t *e;
model_t *m;
float d;
if( !tr.num_mirror_entities ) return; // mo mirrors for this frame
oldRI = RI; // make refinst backup
oldframecount = tr.framecount;
for( i = 0; i < tr.num_mirror_entities; i++ )
{
mirrorchain = tr.mirror_entities[i].chain;
for( es = mirrorchain; es != NULL; es = es->mirrorchain )
{
RI.currententity = e = tr.mirror_entities[i].ent;
RI.currentmodel = m = RI.currententity->model;
surf = INFO_SURF( es, m );
ASSERT( RI.currententity != NULL );
ASSERT( RI.currentmodel != NULL );
// NOTE: copy mirrortexture and mirrormatrix from another surfaces
// from this entity\world that has same planes and reduce number of viewpasses
// make sure what we have one pass at least
if( es != mirrorchain )
{
for( tmp = mirrorchain; tmp != es; tmp = tmp->mirrorchain )
{
surf2 = INFO_SURF( tmp, m );
if( !tmp->mirrortexturenum )
continue; // not filled?
if( surf->plane->dist != surf2->plane->dist )
continue;
if( !VectorCompare( surf->plane->normal, surf2->plane->normal ))
continue;
// found surface with same plane!
break;
}
if( tmp != es && tmp && tmp->mirrortexturenum )
{
// just copy reflection texture from surface with same plane
Matrix4x4_Copy( es->mirrormatrix, tmp->mirrormatrix );
es->mirrortexturenum = tmp->mirrortexturenum;
continue; // pass skiped
}
}
R_PlaneForMirror( surf, &plane, mirrormatrix );
d = -2.0f * ( DotProduct( RI.vieworg, plane.normal ) - plane.dist );
VectorMA( RI.vieworg, d, plane.normal, origin );
d = -2.0f * DotProduct( RI.vforward, plane.normal );
VectorMA( RI.vforward, d, plane.normal, forward );
VectorNormalize( forward );
d = -2.0f * DotProduct( RI.vright, plane.normal );
VectorMA( RI.vright, d, plane.normal, right );
VectorNormalize( right );
d = -2.0f * DotProduct( RI.vup, plane.normal );
VectorMA( RI.vup, d, plane.normal, up );
VectorNormalize( up );
VectorsAngles( forward, right, up, angles );
angles[ROLL] = -angles[ROLL];
RI.params = RP_MIRRORVIEW|RP_CLIPPLANE|RP_OLDVIEWLEAF;
RI.clipPlane = plane;
RI.clipFlags |= ( 1<<5 );
RI.frustum[5] = plane;
RI.frustum[5].signbits = SignbitsForPlane( RI.frustum[5].normal );
RI.frustum[5].type = PLANE_NONAXIAL;
RI.refdef.viewangles[0] = anglemod( angles[0] );
RI.refdef.viewangles[1] = anglemod( angles[1] );
RI.refdef.viewangles[2] = anglemod( angles[2] );
VectorCopy( origin, RI.refdef.vieworg );
VectorCopy( origin, RI.cullorigin );
// put pvsorigin before the mirror plane to avoid get full visibility on world mirrors
if( RI.currententity == clgame.entities )
{
VectorMA( es->origin, 1.0f, plane.normal, origin );
}
else
{
Matrix4x4_VectorTransform( mirrormatrix, es->origin, origin );
VectorMA( origin, 1.0f, plane.normal, origin );
}
VectorCopy( origin, RI.pvsorigin );
// combine two leafs from client and mirror views
r_viewleaf = Mod_PointInLeaf( oldRI.pvsorigin, cl.worldmodel->nodes );
r_viewleaf2 = Mod_PointInLeaf( RI.pvsorigin, cl.worldmodel->nodes );
if( GL_Support( GL_ARB_TEXTURE_NPOT_EXT ))
{
// allow screen size
RI.viewport[2] = bound( 96, RI.viewport[2], 1024 );
RI.viewport[3] = bound( 72, RI.viewport[3], 768 );
}
else
{
RI.viewport[2] = NearestPOW( RI.viewport[2], true );
RI.viewport[3] = NearestPOW( RI.viewport[3], true );
RI.viewport[2] = bound( 128, RI.viewport[2], 1024 );
RI.viewport[3] = bound( 64, RI.viewport[3], 512 );
}
tr.framecount++;
R_RenderScene( &RI.refdef );
r_stats.c_mirror_passes++;
es->mirrortexturenum = R_AllocateMirrorTexture();
// create personal projection matrix for mirror
if( VectorIsNull( e->origin ) && VectorIsNull( e->angles ))
{
Matrix4x4_Copy( es->mirrormatrix, RI.worldviewProjectionMatrix );
}
else
{
Matrix4x4_ConcatTransforms( RI.modelviewMatrix, RI.worldviewMatrix, mirrormatrix );
Matrix4x4_Concat( es->mirrormatrix, RI.projectionMatrix, RI.modelviewMatrix );
}
RI = oldRI; // restore ref instance
}
// clear chain for this entity
for( es = mirrorchain; es != NULL; )
{
tmp = es->mirrorchain;
es->mirrorchain = NULL;
es = tmp;
}
tr.mirror_entities[i].chain = NULL; // done
tr.mirror_entities[i].ent = NULL;
}
r_oldviewleaf = r_viewleaf = NULL; // force markleafs next frame
tr.framecount = oldframecount; // restore real framecount
tr.num_mirror_entities = 0;
tr.num_mirrors_used = 0;
}
//[/KnockdownSys]
gentity_t *G_KickTrace( gentity_t *ent, vec3_t kickDir, float kickDist, vec3_t kickEnd, int kickDamage, float kickPush )
{
vec3_t traceOrg, traceEnd, kickMins, kickMaxs;
trace_t trace;
gentity_t *hitEnt = NULL;
VectorSet(kickMins, -2.0f, -2.0f, -2.0f);
VectorSet(kickMaxs, 2.0f, 2.0f, 2.0f);
//FIXME: variable kick height?
if ( kickEnd && !VectorCompare( kickEnd, vec3_origin ) )
{//they passed us the end point of the trace, just use that
//this makes the trace flat
VectorSet( traceOrg, ent->r.currentOrigin[0], ent->r.currentOrigin[1], kickEnd[2] );
VectorCopy( kickEnd, traceEnd );
}
else
{//extrude
VectorSet( traceOrg, ent->r.currentOrigin[0], ent->r.currentOrigin[1], ent->r.currentOrigin[2]+ent->r.maxs[2]*0.5f );
VectorMA( traceOrg, kickDist, kickDir, traceEnd );
}
if (d_saberKickTweak.integer)
{
trap_G2Trace( &trace, traceOrg, kickMins, kickMaxs, traceEnd, ent->s.number, MASK_SHOT, G2TRFLAG_DOGHOULTRACE|G2TRFLAG_GETSURFINDEX|G2TRFLAG_THICK|G2TRFLAG_HITCORPSES, g_g2TraceLod.integer );
}
else
{
trap_Trace( &trace, traceOrg, kickMins, kickMaxs, traceEnd, ent->s.number, MASK_SHOT );
}
//G_TestLine(traceOrg, traceEnd, 0x0000ff, 5000);
if ( trace.fraction < 1.0f && !trace.startsolid && !trace.allsolid )
{
if (ent->client->jediKickTime > level.time)
{
if (trace.entityNum == ent->client->jediKickIndex)
{ //we are hitting the same ent we last hit in this same anim, don't hit it again
return NULL;
}
}
ent->client->jediKickIndex = trace.entityNum;
ent->client->jediKickTime = level.time + ent->client->ps.legsTimer;
hitEnt = &g_entities[trace.entityNum];
//FIXME: regardless of what we hit, do kick hit sound and impact effect
//G_PlayEffect( "misc/kickHit", trace.endpos, trace.plane.normal );
if ( ent->client->ps.torsoAnim == BOTH_A7_HILT )
{
G_Sound( ent, CHAN_AUTO, G_SoundIndex( "sound/movers/objects/saber_slam" ) );
}
else
{
G_Sound( ent, CHAN_AUTO, G_SoundIndex( va( "sound/weapons/melee/punch%d", Q_irand( 1, 4 ) ) ) );
}
if ( hitEnt->inuse )
{//we hit an entity
//FIXME: don't hit same ent more than once per kick
if ( hitEnt->takedamage )
{//hurt it
if (hitEnt->client)
{
hitEnt->client->ps.otherKiller = ent->s.number;
hitEnt->client->ps.otherKillerDebounceTime = level.time + 10000;
hitEnt->client->ps.otherKillerTime = level.time + 10000;
}
if (d_saberKickTweak.integer)
{
G_Damage( hitEnt, ent, ent, kickDir, trace.endpos, kickDamage*0.2f, DAMAGE_NO_KNOCKBACK, MOD_MELEE );
}
else
{
G_Damage( hitEnt, ent, ent, kickDir, trace.endpos, kickDamage, DAMAGE_NO_KNOCKBACK, MOD_MELEE );
}
}
if ( hitEnt->client
&& !(hitEnt->client->ps.pm_flags&PMF_TIME_KNOCKBACK) //not already flying through air? Intended to stop multiple hits, but...
&& G_CanBeEnemy(ent, hitEnt) )
{//FIXME: this should not always work
if ( hitEnt->health <= 0 )
{//we kicked a dead guy
//throw harder - FIXME: no matter how hard I push them, they don't go anywhere... corpses use less physics???
// G_Throw( hitEnt, kickDir, kickPush*4 );
//see if we should play a better looking death on them
// G_ThrownDeathAnimForDeathAnim( hitEnt, trace.endpos );
//[KnockdownSys]
//reenabled SP code since the knockdown code now based on the SP code again.
G_Throw( hitEnt, kickDir, kickPush*4 );
//see if we should play a better looking death on them
G_ThrownDeathAnimForDeathAnim( hitEnt, trace.endpos );
//G_TossTheMofo(hitEnt, kickDir, kickPush*4.0f);
//[/KnockdownSys]
}
else
{
G_Throw( hitEnt, kickDir, kickPush );
if ( kickPush >= 75.0f && !Q_irand( 0, 2 ) )
{
G_Knockdown( hitEnt, ent, kickDir, 300, qtrue );
}
else
{
G_Knockdown( hitEnt, ent, kickDir, kickPush, qtrue );
}
}
}
}
}
return (hitEnt);
}
int SV_FlyMove (edict_t *ent, float time, int mask)
{
edict_t *hit;
int bumpcount, numbumps;
vec3_t dir;
float d;
int numplanes;
vec3_t planes[MAX_CLIP_PLANES];
vec3_t primal_velocity, original_velocity, new_velocity;
int i, j;
trace_t trace;
vec3_t end;
float time_left;
int blocked;
if (!ent)
{
return 0;
}
numbumps = 4;
blocked = 0;
VectorCopy(ent->velocity, original_velocity);
VectorCopy(ent->velocity, primal_velocity);
numplanes = 0;
time_left = time;
ent->groundentity = NULL;
for (bumpcount = 0; bumpcount < numbumps; bumpcount++)
{
for (i = 0; i < 3; i++)
{
end[i] = ent->s.origin[i] + time_left * ent->velocity[i];
}
trace = gi.trace(ent->s.origin, ent->mins, ent->maxs, end, ent, mask);
if (trace.allsolid)
{
/* entity is trapped in another solid */
VectorCopy(vec3_origin, ent->velocity);
return 3;
}
if (trace.fraction > 0)
{
/* actually covered some distance */
VectorCopy(trace.endpos, ent->s.origin);
VectorCopy(ent->velocity, original_velocity);
numplanes = 0;
}
if (trace.fraction == 1)
{
break; /* moved the entire distance */
}
hit = trace.ent;
if (trace.plane.normal[2] > 0.7)
{
blocked |= 1; /* floor */
if (hit->solid == SOLID_BSP)
{
ent->groundentity = hit;
ent->groundentity_linkcount = hit->linkcount;
}
}
if (!trace.plane.normal[2])
{
blocked |= 2; /* step */
}
/* run the impact function */
SV_Impact(ent, &trace);
if (!ent->inuse)
{
break; /* removed by the impact function */
}
time_left -= time_left * trace.fraction;
/* cliped to another plane */
if (numplanes >= MAX_CLIP_PLANES)
{
/* this shouldn't really happen */
VectorCopy(vec3_origin, ent->velocity);
return 3;
}
VectorCopy(trace.plane.normal, planes[numplanes]);
numplanes++;
/* modify original_velocity so it
parallels all of the clip planes */
for (i = 0; i < numplanes; i++)
{
ClipVelocity(original_velocity, planes[i], new_velocity, 1);
for (j = 0; j < numplanes; j++)
{
if ((j != i) && !VectorCompare(planes[i], planes[j]))
{
if (DotProduct(new_velocity, planes[j]) < 0)
{
break; /* not ok */
}
}
}
if (j == numplanes)
{
break;
}
}
if (i != numplanes)
{
/* go along this plane */
VectorCopy(new_velocity, ent->velocity);
}
else
{
/* go along the crease */
if (numplanes != 2)
{
VectorCopy(vec3_origin, ent->velocity);
return 7;
}
CrossProduct(planes[0], planes[1], dir);
d = DotProduct(dir, ent->velocity);
VectorScale(dir, d, ent->velocity);
}
/* If original velocity is against the original
velocity, stop dead to avoid tiny occilations
in sloping corners */
if (DotProduct(ent->velocity, primal_velocity) <= 0)
{
VectorCopy(vec3_origin, ent->velocity);
return blocked;
}
}
return blocked;
}
qboolean PM_SlideMove( qboolean gravity ) {
int bumpcount, numbumps;
vec3_t dir;
float d;
int numplanes;
vec3_t normal, planes[MAX_CLIP_PLANES];
vec3_t primal_velocity;
vec3_t clipVelocity;
int i, j, k;
trace_t trace;
vec3_t end;
float time_left;
float into;
vec3_t endVelocity;
vec3_t endClipVelocity;
numbumps = 4;
VectorCopy (pm->ps->velocity, primal_velocity);
if ( gravity ) {
VectorCopy( pm->ps->velocity, endVelocity );
endVelocity[2] -= pm->ps->gravity * pml.frametime;
pm->ps->velocity[2] = ( pm->ps->velocity[2] + endVelocity[2] ) * 0.5;
primal_velocity[2] = endVelocity[2];
if ( pml.groundPlane ) {
if ( PM_GroundSlideOkay( pml.groundTrace.plane.normal[2] ) )
{// slide along the ground plane
PM_ClipVelocity (pm->ps->velocity, pml.groundTrace.plane.normal,
pm->ps->velocity, OVERCLIP );
}
}
}
time_left = pml.frametime;
// never turn against the ground plane
if ( pml.groundPlane ) {
numplanes = 1;
VectorCopy( pml.groundTrace.plane.normal, planes[0] );
if ( !PM_GroundSlideOkay( planes[0][2] ) )
{
planes[0][2] = 0;
VectorNormalize( planes[0] );
}
} else {
numplanes = 0;
}
// never turn against original velocity
VectorNormalize2( pm->ps->velocity, planes[numplanes] );
numplanes++;
for ( bumpcount=0 ; bumpcount < numbumps ; bumpcount++ ) {
// calculate position we are trying to move to
VectorMA( pm->ps->origin, time_left, pm->ps->velocity, end );
// see if we can make it there
pm->trace( &trace, pm->ps->origin, pm->mins, pm->maxs, end, pm->ps->clientNum, pm->tracemask);
if (trace.allsolid) {
// entity is completely trapped in another solid
pm->ps->velocity[2] = 0; // don't build up falling damage, but allow sideways acceleration
return qtrue;
}
if (trace.fraction > 0) {
// actually covered some distance
VectorCopy (trace.endpos, pm->ps->origin);
}
if (trace.fraction == 1) {
break; // moved the entire distance
}
// save entity for contact
PM_AddTouchEnt( trace.entityNum );
if (pm->debugLevel){
Com_Printf("PM_SlideMove entity %i touches entity %i\n",pm->ps->clientNum,trace.entityNum);
Com_Printf("PM_SlideMove trace called with parameters %i,(%.3f,%.3f,%.3f),(%.3f,%.3f,%.3f),(%.3f,%.3f,%.3f),(%.3f,%.3f,%.3f),%i,%i\n",
&trace,
pm->ps->origin[0],pm->ps->origin[1], pm->ps->origin[2],
pm->mins[0],pm->mins[1], pm->mins[2],
pm->maxs[0],pm->maxs[1], pm->maxs[2],
end[0],end[1], end[2],
pm->ps->clientNum, pm->tracemask);
}
if (pm->ps->clientNum >= MAX_CLIENTS)
{
bgEntity_t *pEnt = pm_entSelf;
if (pEnt && pEnt->s.eType == ET_NPC && pEnt->s.NPC_class == CLASS_VEHICLE &&
pEnt->m_pVehicle)
{ //do vehicle impact stuff then
PM_VehicleImpact(pEnt, &trace);
}
}
#ifdef QAGAME
else
{
if ( PM_ClientImpact( &trace ) )
{
continue;
}
}
#endif
time_left -= time_left * trace.fraction;
if (numplanes >= MAX_CLIP_PLANES) {
// this shouldn't really happen
VectorClear( pm->ps->velocity );
return qtrue;
}
VectorCopy( trace.plane.normal, normal );
if ( !PM_GroundSlideOkay( normal[2] ) )
{//wall-running
//never push up off a sloped wall
normal[2] = 0;
VectorNormalize( normal );
}
//
// if this is the same plane we hit before, nudge velocity
// out along it, which fixes some epsilon issues with
// non-axial planes
//
if ( !(pm->ps->pm_flags&PMF_STUCK_TO_WALL) )
{//no sliding if stuck to wall!
for ( i = 0 ; i < numplanes ; i++ ) {
if ( VectorCompare( normal, planes[i] ) ) {//DotProduct( normal, planes[i] ) > 0.99 ) {
VectorAdd( normal, pm->ps->velocity, pm->ps->velocity );
break;
}
}
if ( i < numplanes ) {
continue;
}
}
VectorCopy (normal, planes[numplanes]);
numplanes++;
//
// modify velocity so it parallels all of the clip planes
//
// find a plane that it enters
for ( i = 0 ; i < numplanes ; i++ ) {
into = DotProduct( pm->ps->velocity, planes[i] );
if ( into >= 0.1 ) {
continue; // move doesn't interact with the plane
}
// see how hard we are hitting things
if ( -into > pml.impactSpeed ) {
pml.impactSpeed = -into;
}
// slide along the plane
PM_ClipVelocity (pm->ps->velocity, planes[i], clipVelocity, OVERCLIP );
// slide along the plane
PM_ClipVelocity (endVelocity, planes[i], endClipVelocity, OVERCLIP );
// see if there is a second plane that the new move enters
for ( j = 0 ; j < numplanes ; j++ ) {
if ( j == i ) {
continue;
}
if ( DotProduct( clipVelocity, planes[j] ) >= 0.1 ) {
continue; // move doesn't interact with the plane
}
// try clipping the move to the plane
PM_ClipVelocity( clipVelocity, planes[j], clipVelocity, OVERCLIP );
PM_ClipVelocity( endClipVelocity, planes[j], endClipVelocity, OVERCLIP );
// see if it goes back into the first clip plane
if ( DotProduct( clipVelocity, planes[i] ) >= 0 ) {
continue;
}
// slide the original velocity along the crease
CrossProduct (planes[i], planes[j], dir);
VectorNormalize( dir );
d = DotProduct( dir, pm->ps->velocity );
VectorScale( dir, d, clipVelocity );
CrossProduct (planes[i], planes[j], dir);
VectorNormalize( dir );
d = DotProduct( dir, endVelocity );
VectorScale( dir, d, endClipVelocity );
// see if there is a third plane the the new move enters
for ( k = 0 ; k < numplanes ; k++ ) {
if ( k == i || k == j ) {
continue;
}
if ( DotProduct( clipVelocity, planes[k] ) >= 0.1 ) {
continue; // move doesn't interact with the plane
}
// stop dead at a triple plane interaction
VectorClear( pm->ps->velocity );
return qtrue;
}
}
// if we have fixed all interactions, try another move
VectorCopy( clipVelocity, pm->ps->velocity );
VectorCopy( endClipVelocity, endVelocity );
break;
}
}
if ( gravity ) {
VectorCopy( endVelocity, pm->ps->velocity );
}
// don't change velocity if in a timer (FIXME: is this correct?)
if ( pm->ps->pm_time ) {
VectorCopy( primal_velocity, pm->ps->velocity );
}
return ( bumpcount != 0 );
}
/*
@@@@@@@@@@@@@@@@@@@@@
RE_RenderScene
Draw a 3D view into a part of the window, then return
to 2D drawing.
Rendering a scene may require multiple views to be rendered
to handle mirrors,
@@@@@@@@@@@@@@@@@@@@@
*/
void RE_RenderScene(const refdef_t *fd) {
viewParms_t parms;
int startTime;
if (!tr.registered) {
return;
}
GLimp_LogComment("====== RE_RenderScene =====\n");
if (r_norefresh->integer) {
return;
}
startTime = ri.Milliseconds();
if (!tr.world && !(fd->rdflags & RDF_NOWORLDMODEL)) {
ri.Error (ERR_DROP, "R_RenderScene: NULL worldmodel");
}
RE_BeginScene(fd);
// SmileTheory: playing with shadow mapping
if (!(fd->rdflags & RDF_NOWORLDMODEL) && tr.refdef.num_dlights && r_dlightMode->integer >= 2)
{
R_RenderDlightCubemaps(fd);
}
/* playing with more shadows */
if(glRefConfig.framebufferObject && !(fd->rdflags & RDF_NOWORLDMODEL) && r_shadows->integer == 4)
{
R_RenderPshadowMaps(fd);
}
// playing with even more shadows
if(glRefConfig.framebufferObject && r_sunlightMode->integer && !(fd->rdflags & RDF_NOWORLDMODEL) && (r_forceSun->integer || tr.sunShadows))
{
if (r_shadowCascadeZFar != 0)
{
R_RenderSunShadowMaps(fd, 0);
R_RenderSunShadowMaps(fd, 1);
R_RenderSunShadowMaps(fd, 2);
}
else
{
Mat4Zero(tr.refdef.sunShadowMvp[0]);
Mat4Zero(tr.refdef.sunShadowMvp[1]);
Mat4Zero(tr.refdef.sunShadowMvp[2]);
}
// only rerender last cascade if sun has changed position
if (r_forceSun->integer == 2 || !VectorCompare(tr.refdef.sunDir, tr.lastCascadeSunDirection))
{
VectorCopy(tr.refdef.sunDir, tr.lastCascadeSunDirection);
R_RenderSunShadowMaps(fd, 3);
Mat4Copy(tr.refdef.sunShadowMvp[3], tr.lastCascadeSunMvp);
}
else
{
Mat4Copy(tr.lastCascadeSunMvp, tr.refdef.sunShadowMvp[3]);
}
}
// playing with cube maps
// this is where dynamic cubemaps would be rendered
if (0) //(glRefConfig.framebufferObject && !(fd->rdflags & RDF_NOWORLDMODEL))
{
int i, j;
for (i = 0; i < tr.numCubemaps; i++)
{
for (j = 0; j < 6; j++)
{
R_RenderCubemapSide(i, j, qtrue);
}
}
}
// setup view parms for the initial view
//
// set up viewport
// The refdef takes 0-at-the-top y coordinates, so
// convert to GL's 0-at-the-bottom space
//
memset(&parms, 0, sizeof(parms));
parms.viewportX = tr.refdef.x;
parms.viewportY = glConfig.vidHeight - (tr.refdef.y + tr.refdef.height);
parms.viewportWidth = tr.refdef.width;
parms.viewportHeight = tr.refdef.height;
parms.isPortal = qfalse;
parms.fovX = tr.refdef.fov_x;
parms.fovY = tr.refdef.fov_y;
parms.stereoFrame = tr.refdef.stereoFrame;
VectorCopy(fd->vieworg, parms.or.origin);
VectorCopy(fd->viewaxis[0], parms.or.axis[0]);
VectorCopy(fd->viewaxis[1], parms.or.axis[1]);
VectorCopy(fd->viewaxis[2], parms.or.axis[2]);
VectorCopy(fd->vieworg, parms.pvsOrigin);
if(!(fd->rdflags & RDF_NOWORLDMODEL) && r_depthPrepass->value && ((r_forceSun->integer) || tr.sunShadows))
{
parms.flags = VPF_USESUNLIGHT;
}
R_RenderView(&parms);
if(!(fd->rdflags & RDF_NOWORLDMODEL))
R_AddPostProcessCmd();
RE_EndScene();
tr.frontEndMsec += ri.Milliseconds() - startTime;
}
/*
=================
Cmd_Base
=================
*/
void Cmd_Base (void)
{
triangle_t *ptri;
int i, j, k;
int time1;
char file1[1024];
GetToken (false);
if (g_skipmodel || g_release || g_archive)
return;
printf ("---------------------\n");
sprintf (file1, "%s/%s.%s", cdarchive, token, trifileext);
printf ("%s\n", file1);
ExpandPathAndArchive (file1);
sprintf (file1, "%s/%s.%s", cddir, token, trifileext);
time1 = FileTime (file1);
if (time1 == -1)
Error ("%s doesn't exist", file1);
//
// load the base triangles
//
if (do3ds)
Load3DSTriangleList (file1, &ptri, &model.num_tris);
else
LoadTriangleList (file1, &ptri, &model.num_tris);
//
// get the ST values
//
BuildST (ptri, model.num_tris);
//
// run through all the base triangles, storing each unique vertex in the
// base vertex list and setting the indirect triangles to point to the base
// vertices
//
for (i=0 ; i<model.num_tris ; i++)
{
for (j=0 ; j<3 ; j++)
{
// get the xyz index
for (k=0 ; k<model.num_xyz ; k++)
if (VectorCompare (ptri[i].verts[j], base_xyz[k]))
break; // this vertex is already in the base vertex list
if (k == model.num_xyz)
{ // new index
VectorCopy (ptri[i].verts[j], base_xyz[model.num_xyz]);
model.num_xyz++;
}
triangles[i].index_xyz[j] = k;
// get the st index
for (k=0 ; k<model.num_st ; k++)
if (triangle_st[i][j][0] == base_st[k].s
&& triangle_st[i][j][1] == base_st[k].t)
break; // this vertex is already in the base vertex list
if (k == model.num_st)
{ // new index
base_st[model.num_st].s = triangle_st[i][j][0];
base_st[model.num_st].t = triangle_st[i][j][1];
model.num_st++;
}
triangles[i].index_st[j] = k;
}
}
// build triangle strips / fans
BuildGlCmds ();
}
void Weapon_Sandbag_Fire (edict_t *ent)
{
edict_t *sandbag;
ent->client->ps.gunframe++;
if (ent->client->resp.team_on->index == 0)
{
if (allied_sandbags >= sandbaglimit->value)
{
safe_centerprintf(ent, "Your team is at the sandbag limit!\n");
return;
}
}
else if (ent->client->resp.team_on->index == 1)
{
if (axis_sandbags >= sandbaglimit->value)
{
safe_centerprintf(ent, "Your team is at the sandbag limit!\n");
return;
}
}
if (VectorCompare (ent->client->sandbag_pos , vec3_origin))
{
safe_centerprintf(ent, "There's no space for sandbags there!\n");
return;
}
ent->client->pers.inventory[ITEM_INDEX(FindItem("Sandbags"))]--;
sandbag = G_Spawn();
VectorCopy (ent->client->sandbag_preview->mins, sandbag->mins);
VectorCopy (ent->client->sandbag_preview->maxs, sandbag->maxs);
VectorCopy (ent->client->sandbag_preview->s.angles, sandbag->s.angles);
sandbag->classnameb = SANDBAGS;
sandbag->movetype = MOVETYPE_TOSS;
sandbag->solid = SOLID_BBOX;
sandbag->s.modelindex = gi.modelindex ("models/objects/sandbag/tris.md2");
sandbag->think = sandbag_think;
sandbag->nextthink = level.time +.1;
// ent->s.frame = rand() % 16;
// ent->s.frame = 1;
sandbag->mass = 300;
sandbag->touch = sandbag_touch;
sandbag->health = 2000;
sandbag->takedamage = DAMAGE_YES;
sandbag->die = sandbag_die;
sandbag->s.skinnum = 0;
sandbag->s.frame = 0;
// VectorSet (sandbag->mins, -19, -9, -10);
// VectorSet (sandbag->maxs, 19, 9, 8);
VectorCopy (ent->client->sandbag_pos, sandbag->s.origin);
sandbag->clipmask = MASK_SHOT;
sandbag->spawnflags = 1;
if (ent->client->resp.team_on)
sandbag->obj_owner = ent->client->resp.team_on->index;
if (ent->client->resp.team_on->index == 0)
allied_sandbags++;
else if (ent->client->resp.team_on->index == 1)
axis_sandbags++;
sandbag->obj_time = level.time;
gi.linkentity (sandbag);
if (ent->client->pers.inventory[ITEM_INDEX(FindItem("Sandbags"))] ==0)
{
ent->client->weaponstate=WEAPON_LOWER;
ent->client->ps.gunframe = 20;
Use_Weapon (ent, FindItem("fists"));
return;
}
G_FreeEdict (ent->client->sandbag_preview);
ent->client->sandbag_preview = NULL;
}
/*
=================
ParseBrush
=================
*/
void ParseBrush (void)
{
mbrush_t *b;
mface_t *f, *f2;
vec3_t planepts[3];
vec3_t t1, t2, t3, VAxis[2];
int i, j, Faces;
texinfo_t tx;
vec_t d;
vec_t shift[2], rotate, scale[2];
qboolean ok, Valve220;
ExtendArray(mapbrushes, nummapbrushes);
b = &mapbrushes[nummapbrushes];
b->Line = scriptline;
ok = GetToken (true);
while (ok)
{
txcommand = 0;
if (!strcmp (token, "}") )
{
if (!options.onlyents)
{
if (InvalidBrush(b, &Faces))
{
// Too few faces in brush or not closed; drop it
DropBrush (b);
nummapfaces -= Faces;
// Note: texinfo array is not corrected here
return;
}
}
if (options.SortFace)
SortFaces(b);
break;
}
// read the three point plane definition
for (i=0 ; i<3 ; i++)
{
if (i != 0)
GetToken (true);
if (strcmp (token, "(") )
Message (MSGERR, "Invalid brush plane format on line %d", scriptline);
for (j=0 ; j<3 ; j++)
{
GetToken (false);
planepts[i][j] = atof(token); // AR: atof
}
GetToken (false);
if (strcmp (token, ")") )
Message (MSGERR, "Invalid brush plane format on line %d", scriptline);
}
// read the texturedef
memset (&tx, 0, sizeof(tx));
GetToken (false);
if (options.Q2Map)
Q2ToQ1Tex (token);
// Check texture name length
if (strlen(token) > sizeof(char16) - 1)
Message (MSGERR, "Texture name \"%s\" too long on line %d", token, scriptline);
if (options.SolidMap && num_entities == 1 && token[0] == '*' ||
options.noents && num_entities > 1)
{
// No liquid worldbrushes or only worldbrushes allowed; drop brush
DropBrush (b);
while (GetToken(true) && strcmp(token, "}"))
;
return;
}
Valve220 = false;
tx.miptex = FindMiptex (token);
GetToken (false);
if (!strcmp (token, "["))
{
// Valve 220 map import
Valve220 = true;
GetValveTex (VAxis[0]);
}
shift[0] = atoi(token);
GetToken (false);
if (Valve220)
{
// Skip ]
GetToken (false);
GetValveTex (VAxis[1]);
}
shift[1] = atoi(token);
GetToken (false);
if (Valve220)
GetToken (false); // Skip ]
rotate = atoi(token);
GetToken (false);
scale[0] = atof(token);
GetToken (false);
scale[1] = atof(token);
if (options.Q2Map)
{
// Skip extra Q2 style face info
GetToken (false);
GetToken (false);
GetToken (false);
}
ok = GetToken (true); // Note : scriptline normally gets advanced here
// if the three points are all on a previous plane, it is a
// duplicate plane
for (f2 = b->faces ; f2 ; f2=f2->next)
{
for (i=0 ; i<3 ; i++)
{
d = DotProduct(planepts[i],f2->plane.normal) - f2->plane.dist;
if (d < -ON_EPSILON || d > ON_EPSILON)
break;
}
if (i==3)
break;
}
if (f2)
{
Message (MSGWARN, "Brush with duplicate plane on line %d", scriptline - 1);
continue;
}
f = AllocOther(sizeof(mface_t));
// convert to a vector / dist plane
for (j=0 ; j<3 ; j++)
{
t1[j] = planepts[0][j] - planepts[1][j];
t2[j] = planepts[2][j] - planepts[1][j];
t3[j] = planepts[1][j];
}
CrossProduct(t1,t2, f->plane.normal);
if (VectorCompare (f->plane.normal, vec3_origin))
{
Message (MSGWARN, "Brush plane with no normal on line %d", scriptline - 1);
FreeOther (f);
continue;
}
VectorNormalize (f->plane.normal);
f->plane.dist = DotProduct (t3, f->plane.normal);
f->next = b->faces;
b->faces = f;
if (txcommand=='1' || txcommand=='2')
{ // from QuArK, the texture vectors are given directly from the three points
vec3_t TexPt[2];
int k;
vec_t dot22, dot23, dot33, mdet, aa, bb, dd;
k = txcommand-'0';
for (j=0; j<3; j++)
TexPt[1][j] = (planepts[k][j] - planepts[0][j]) * ScaleCorrection;
k = 3-k;
for (j=0; j<3; j++)
TexPt[0][j] = (planepts[k][j] - planepts[0][j]) * ScaleCorrection;
dot22 = DotProduct (TexPt[0], TexPt[0]);
dot23 = DotProduct (TexPt[0], TexPt[1]);
dot33 = DotProduct (TexPt[1], TexPt[1]);
mdet = dot22*dot33-dot23*dot23;
if (mdet<1E-6 && mdet>-1E-6)
{
aa = bb = dd = 0;
Message (MSGWARN, "Degenerate QuArK-style brush texture on line %d", scriptline - 1);
}
else
{
mdet = 1.0/mdet;
aa = dot33*mdet;
bb = -dot23*mdet;
//cc = -dot23*mdet; // cc = bb
dd = dot22*mdet;
}
for (j=0; j<3; j++)
{
tx.vecs[0][j] = aa * TexPt[0][j] + bb * TexPt[1][j];
tx.vecs[1][j] = -(/*cc*/ bb * TexPt[0][j] + dd * TexPt[1][j]);
}
tx.vecs[0][3] = -DotProduct(tx.vecs[0], planepts[0]);
tx.vecs[1][3] = -DotProduct(tx.vecs[1], planepts[0]);
}
else if (Valve220)
{
// Valve 220 texturedef
vec3_t vec;
vec_t tscale;
// Prevent division by zero
if (!scale[0])
scale[0] = 1;
if (!scale[1])
scale[1] = 1;
// FIXME: If origin brushes are in use, this is where to fix their tex alignment!!!
for (i = 0; i < 2; ++i)
{
tscale = 1 / scale[i];
VectorScale(VAxis[i], tscale, vec);
for (j = 0; j < 3; ++j)
tx.vecs[i][j] = (float)vec[j];
tx.vecs[i][3] = (float)shift[i] + DotProduct(vec3_origin, vec);
}
}
else
//
// fake proper texture vectors from QuakeEd style
//
{
vec3_t vecs[2];
int sv, tv;
vec_t ang, sinv, cosv;
vec_t ns, nt;
TextureAxisFromPlane(&f->plane, vecs[0], vecs[1]);
if (!scale[0])
scale[0] = 1;
if (!scale[1])
scale[1] = 1;
// rotate axis
if (rotate == 0)
{ sinv = 0 ; cosv = 1; }
else if (rotate == 90)
{ sinv = 1 ; cosv = 0; }
else if (rotate == 180)
{ sinv = 0 ; cosv = -1; }
else if (rotate == 270)
{ sinv = -1 ; cosv = 0; }
else
{
ang = rotate / 180 * Q_PI;
sinv = sin(ang);
cosv = cos(ang);
}
if (vecs[0][0])
sv = 0;
else if (vecs[0][1])
sv = 1;
else
sv = 2;
if (vecs[1][0])
tv = 0;
else if (vecs[1][1])
tv = 1;
else
tv = 2;
for (i=0 ; i<2 ; i++)
{
ns = cosv * vecs[i][sv] - sinv * vecs[i][tv];
nt = sinv * vecs[i][sv] + cosv * vecs[i][tv];
vecs[i][sv] = ns;
vecs[i][tv] = nt;
}
for (i=0 ; i<2 ; i++)
for (j=0 ; j<3 ; j++)
tx.vecs[i][j] = vecs[i][j] / scale[i];
tx.vecs[0][3] = shift[0];
tx.vecs[1][3] = shift[1];
}
// unique the texinfo
f->texinfo = FindTexinfo (&tx);
nummapfaces++;
};
nummapbrushes++;
b->next = mapent->brushes;
mapent->brushes = b;
}
static qboolean NPC_Howler_Move( int randomJumpChance = 0 )
{
if ( !TIMER_Done( NPC, "standing" ) )
{//standing around
return qfalse;
}
if ( NPC->client->ps.groundEntityNum == ENTITYNUM_NONE )
{//in air, don't do anything
return qfalse;
}
if ( (!NPC->enemy&&TIMER_Done( NPC, "running" )) || !TIMER_Done( NPC, "walking" ) )
{
ucmd.buttons |= BUTTON_WALKING;
}
if ( (!randomJumpChance||Q_irand( 0, randomJumpChance ))
&& NPC_MoveToGoal( qtrue ) )
{
if ( VectorCompare( NPC->client->ps.moveDir, vec3_origin )
|| !NPC->client->ps.speed )
{//uh.... wtf? Got there?
if ( NPCInfo->goalEntity )
{
NPC_FaceEntity( NPCInfo->goalEntity, qfalse );
}
else
{
NPC_UpdateAngles( qfalse, qtrue );
}
return qtrue;
}
//TEMP: don't want to strafe
VectorClear( NPC->client->ps.moveDir );
ucmd.rightmove = 0.0f;
// Com_Printf( "Howler moving %d\n",ucmd.forwardmove );
//if backing up, go slow...
if ( ucmd.forwardmove < 0.0f )
{
ucmd.buttons |= BUTTON_WALKING;
//if ( NPC->client->ps.speed > NPCInfo->stats.walkSpeed )
{//don't walk faster than I'm allowed to
NPC->client->ps.speed = NPCInfo->stats.walkSpeed;
}
}
else
{
if ( (ucmd.buttons&BUTTON_WALKING) )
{
NPC->client->ps.speed = NPCInfo->stats.walkSpeed;
}
else
{
NPC->client->ps.speed = NPCInfo->stats.runSpeed;
}
}
NPCInfo->lockedDesiredYaw = NPCInfo->desiredYaw = NPCInfo->lastPathAngles[YAW];
NPC_UpdateAngles( qfalse, qtrue );
}
else if ( NPCInfo->goalEntity )
{//couldn't get where we wanted to go, try to jump there
NPC_FaceEntity( NPCInfo->goalEntity, qfalse );
NPC_TryJump( NPCInfo->goalEntity, 400.0f, -256.0f );
}
return qtrue;
}
void target_laser_think (edict_t *self)
{
edict_t *ignore;
vec3_t start;
vec3_t end;
trace_t tr;
vec3_t point;
vec3_t last_movedir;
int count;
if (self->spawnflags & 0x80000000)
count = 8;
else
count = 4;
if (self->enemy)
{
VectorCopy (self->movedir, last_movedir);
VectorMA (self->enemy->absmin, 0.5, self->enemy->size, point);
VectorSubtract (point, self->s.origin, self->movedir);
VectorNormalize (self->movedir);
if (!VectorCompare(self->movedir, last_movedir))
self->spawnflags |= 0x80000000;
}
ignore = self;
VectorCopy (self->s.origin, start);
VectorMA (start, 2048, self->movedir, end);
while(1)
{
tr = gi.trace (start, NULL, NULL, end, ignore, CONTENTS_SOLID|CONTENTS_MONSTER|CONTENTS_DEADMONSTER);
if (!tr.ent)
break;
// hurt it if we can
if ((tr.ent->takedamage) && !(tr.ent->flags & FL_IMMUNE_LASER))
T_Damage (tr.ent, self, self->activator, self->movedir, tr.endpos, vec3_origin, self->dmg, 1, DAMAGE_ENERGY, MOD_TARGET_LASER);
// if we hit something that's not a monster or player or is immune to lasers, we're done
if (!(tr.ent->svflags & SVF_MONSTER) && (!tr.ent->client))
{
if (self->spawnflags & 0x80000000)
{
self->spawnflags &= ~0x80000000;
gi.WriteByte (svc_temp_entity);
gi.WriteByte (TE_LASER_SPARKS);
gi.WriteByte (count);
gi.WritePosition (tr.endpos);
gi.WriteDir (tr.plane.normal);
gi.WriteByte (self->s.skinnum);
gi.multicast (tr.endpos, MULTICAST_PVS);
}
break;
}
ignore = tr.ent;
VectorCopy (tr.endpos, start);
}
VectorCopy (tr.endpos, self->s.old_origin);
self->nextthink = level.time + FRAMETIME;
}
/*
====================
StudioCalcBoneQuaterion
====================
*/
static void Mod_StudioCalcBoneQuaterion( int frame, float s, mstudiobone_t *pbone, mstudioanim_t *panim, float *adj, float *q )
{
int j, k;
vec4_t q1, q2;
vec3_t angle1, angle2;
mstudioanimvalue_t *panimvalue;
for( j = 0; j < 3; j++ )
{
if( panim->offset[j+3] == 0 )
{
angle2[j] = angle1[j] = pbone->value[j+3]; // default;
}
else
{
panimvalue = (mstudioanimvalue_t *)((byte *)panim + panim->offset[j+3]);
k = frame;
// debug
if( panimvalue->num.total < panimvalue->num.valid )
k = 0;
while( panimvalue->num.total <= k )
{
k -= panimvalue->num.total;
panimvalue += panimvalue->num.valid + 1;
// DEBUG
if( panimvalue->num.total < panimvalue->num.valid )
k = 0;
}
// Bah, missing blend!
if( panimvalue->num.valid > k )
{
angle1[j] = panimvalue[k+1].value;
if( panimvalue->num.valid > k + 1 )
{
angle2[j] = panimvalue[k+2].value;
}
else
{
if( panimvalue->num.total > k + 1 )
angle2[j] = angle1[j];
else angle2[j] = panimvalue[panimvalue->num.valid+2].value;
}
}
else
{
angle1[j] = panimvalue[panimvalue->num.valid].value;
if( panimvalue->num.total > k + 1 )
{
angle2[j] = angle1[j];
}
else
{
angle2[j] = panimvalue[panimvalue->num.valid + 2].value;
}
}
angle1[j] = pbone->value[j+3] + angle1[j] * pbone->scale[j+3];
angle2[j] = pbone->value[j+3] + angle2[j] * pbone->scale[j+3];
}
if( pbone->bonecontroller[j+3] != -1 )
{
angle1[j] += adj[pbone->bonecontroller[j+3]];
angle2[j] += adj[pbone->bonecontroller[j+3]];
}
}
if( !VectorCompare( angle1, angle2 ))
{
AngleQuaternion( angle1, q1 );
AngleQuaternion( angle2, q2 );
QuaternionSlerp( q1, q2, s, q );
}
else
{
AngleQuaternion( angle1, q );
}
}
void NPC_BSGM_Attack( void )
{
//Don't do anything if we're hurt
if ( NPC->painDebounceTime > level.time )
{
NPC_UpdateAngles( qtrue, qtrue );
return;
}
#if 0
//FIXME: if killed enemy, use victory anim
if ( NPC->enemy && NPC->enemy->health <= 0
&& !NPC->enemy->s.number )
{//my enemy is dead
if ( NPC->client->ps.torsoAnim == BOTH_STAND2TO1 )
{
if ( NPC->client->ps.torsoTimer <= 500 )
{
G_AddVoiceEvent( NPC, Q_irand( EV_VICTORY1, EV_VICTORY3 ), 3000 );
NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_TRIUMPHANT1START, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
NPC->client->ps.legsTimer += 500;
NPC->client->ps.torsoTimer += 500;
}
}
else if ( NPC->client->ps.torsoAnim == BOTH_TRIUMPHANT1START )
{
if ( NPC->client->ps.torsoTimer <= 500 )
{
NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_TRIUMPHANT1STARTGESTURE, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
NPC->client->ps.legsTimer += 500;
NPC->client->ps.torsoTimer += 500;
}
}
else if ( NPC->client->ps.torsoAnim == BOTH_TRIUMPHANT1STARTGESTURE )
{
if ( NPC->client->ps.torsoTimer <= 500 )
{
NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_TRIUMPHANT1STOP, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
NPC->client->ps.legsTimer += 500;
NPC->client->ps.torsoTimer += 500;
}
}
else if ( NPC->client->ps.torsoAnim == BOTH_TRIUMPHANT1STOP )
{
if ( NPC->client->ps.torsoTimer <= 500 )
{
NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_STAND1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
NPC->client->ps.legsTimer = -1;
NPC->client->ps.torsoTimer = -1;
}
}
else if ( NPC->wait )
{
if ( TIMER_Done( NPC, "gloatTime" ) )
{
GM_StartGloat();
}
else if ( DistanceHorizontalSquared( NPC->client->renderInfo.eyePoint, NPC->enemy->r.currentOrigin ) > 4096 && (NPCInfo->scriptFlags&SCF_CHASE_ENEMIES) )//64 squared
{
NPCInfo->goalEntity = NPC->enemy;
GM_Move();
}
else
{//got there
GM_StartGloat();
}
}
NPC_FaceEnemy( qtrue );
NPC_UpdateAngles( qtrue, qtrue );
return;
}
#endif
//If we don't have an enemy, just idle
if ( NPC_CheckEnemyExt(qfalse) == qfalse || !NPC->enemy )
{
NPC->enemy = NULL;
NPC_BSGM_Patrol();
return;
}
enemyLOS4 = enemyCS4 = qfalse;
move4 = qtrue;
faceEnemy4 = qfalse;
shoot4 = qfalse;
hitAlly4 = qfalse;
VectorClear( impactPos4 );
enemyDist4 = DistanceSquared( NPC->r.currentOrigin, NPC->enemy->r.currentOrigin );
//if ( NPC->client->ps.torsoAnim == BOTH_ATTACK4 ||
// NPC->client->ps.torsoAnim == BOTH_ATTACK5 )
if (0)
{
shoot4 = qfalse;
if ( TIMER_Done( NPC, "smackTime" ) && !NPCInfo->blockedDebounceTime )
{//time to smack
//recheck enemyDist4 and InFront
if ( enemyDist4 < MELEE_DIST_SQUARED && InFront( NPC->enemy->r.currentOrigin, NPC->r.currentOrigin, NPC->client->ps.viewangles, 0.3f ) )
{
vec3_t smackDir;
VectorSubtract( NPC->enemy->r.currentOrigin, NPC->r.currentOrigin, smackDir );
smackDir[2] += 30;
VectorNormalize( smackDir );
//hurt them
G_Sound( NPC->enemy, CHAN_AUTO, G_SoundIndex( "sound/weapons/galak/skewerhit.wav" ) );
G_Damage( NPC->enemy, NPC, NPC, smackDir, NPC->r.currentOrigin, (g_spskill.integer+1)*Q_irand( 5, 10), DAMAGE_NO_ARMOR|DAMAGE_NO_KNOCKBACK, MOD_CRUSH );
if ( NPC->client->ps.torsoAnim == BOTH_ATTACK4 )
{//smackdown
int knockAnim = BOTH_KNOCKDOWN1;
if ( BG_CrouchAnim( NPC->enemy->client->ps.legsAnim ) )
{//knockdown from crouch
knockAnim = BOTH_KNOCKDOWN4;
}
//throw them
smackDir[2] = 1;
VectorNormalize( smackDir );
G_Throw( NPC->enemy, smackDir, 50 );
NPC_SetAnim( NPC->enemy, SETANIM_BOTH, knockAnim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
}
else
{//uppercut
//throw them
G_Throw( NPC->enemy, smackDir, 100 );
//make them backflip
NPC_SetAnim( NPC->enemy, SETANIM_BOTH, BOTH_KNOCKDOWN5, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
}
//done with the damage
NPCInfo->blockedDebounceTime = 1;
}
}
}
else if ( NPC->lockCount ) //already shooting laser
{//sometimes use the laser beam attack, but only after he's taken down our generator
shoot4 = qfalse;
if ( NPC->lockCount == 1 )
{//charging up
if ( TIMER_Done( NPC, "beamDelay" ) )
{//time to start the beam
int laserAnim;
//if ( Q_irand( 0, 1 ) )
if (1)
{
laserAnim = BOTH_ATTACK2;
}
/*
else
{
laserAnim = BOTH_ATTACK7;
}
*/
NPC_SetAnim( NPC, SETANIM_BOTH, laserAnim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
TIMER_Set( NPC, "attackDelay", NPC->client->ps.torsoTimer + Q_irand( 1000, 3000 ) );
//turn on beam effect
NPC->lockCount = 2;
G_PlayEffectID( G_EffectIndex("galak/trace_beam"), NPC->r.currentOrigin, vec3_origin );
NPC->s.loopSound = G_SoundIndex( "sound/weapons/galak/lasercutting.wav" );
if ( !NPCInfo->coverTarg )
{//for moving looping sound at end of trace
NPCInfo->coverTarg = G_Spawn();
if ( NPCInfo->coverTarg )
{
G_SetOrigin( NPCInfo->coverTarg, NPC->client->renderInfo.muzzlePoint );
NPCInfo->coverTarg->r.svFlags |= SVF_BROADCAST;
NPCInfo->coverTarg->s.loopSound = G_SoundIndex( "sound/weapons/galak/lasercutting.wav" );
}
}
}
}
else
{//in the actual attack now
if ( NPC->client->ps.torsoTimer <= 0 )
{//attack done!
NPC->lockCount = 0;
G_FreeEntity( NPCInfo->coverTarg );
NPC->s.loopSound = 0;
#if 0
NPC_SetAnim( NPC, SETANIM_TORSO, TORSO_DROPWEAP2, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
#endif
TIMER_Set( NPC, "attackDelay", NPC->client->ps.torsoTimer );
}
else
{//attack still going
//do the trace and damage
trace_t trace;
vec3_t end, mins={-3,-3,-3}, maxs={3,3,3};
VectorMA( NPC->client->renderInfo.muzzlePoint, 1024, NPC->client->renderInfo.muzzleDir, end );
trap_Trace( &trace, NPC->client->renderInfo.muzzlePoint, mins, maxs, end, NPC->s.number, MASK_SHOT );
if ( trace.allsolid || trace.startsolid )
{//oops, in a wall
if ( NPCInfo->coverTarg )
{
G_SetOrigin( NPCInfo->coverTarg, NPC->client->renderInfo.muzzlePoint );
}
}
else
{//clear
if ( trace.fraction < 1.0f )
{//hit something
gentity_t *traceEnt = &g_entities[trace.entityNum];
if ( traceEnt && traceEnt->takedamage )
{//damage it
G_SoundAtLoc( trace.endpos, CHAN_AUTO, G_SoundIndex( "sound/weapons/galak/laserdamage.wav" ) );
G_Damage( traceEnt, NPC, NPC, NPC->client->renderInfo.muzzleDir, trace.endpos, 10, 0, MOD_UNKNOWN );
}
}
if ( NPCInfo->coverTarg )
{
G_SetOrigin( NPCInfo->coverTarg, trace.endpos );
}
if ( !Q_irand( 0, 5 ) )
{
G_SoundAtLoc( trace.endpos, CHAN_AUTO, G_SoundIndex( "sound/weapons/galak/laserdamage.wav" ) );
}
}
}
}
}
else
{//Okay, we're not in a special attack, see if we should switch weapons or start a special attack
/*
if ( NPC->s.weapon == WP_REPEATER
&& !(NPCInfo->scriptFlags & SCF_ALT_FIRE)//using rapid-fire
&& NPC->enemy->s.weapon == WP_SABER //enemy using saber
&& NPC->client && (NPC->client->ps.saberEventFlags&SEF_DEFLECTED)
&& !Q_irand( 0, 50 ) )
{//he's deflecting my shots, switch to the laser or the lob fire for a while
TIMER_Set( NPC, "noRapid", Q_irand( 2000, 6000 ) );
NPCInfo->scriptFlags |= SCF_ALT_FIRE;
NPC->alt_fire = qtrue;
if ( NPC->locationDamage[HL_GENERIC1] > GENERATOR_HEALTH && (Q_irand( 0, 1 )||enemyDist4 < MAX_LOB_DIST_SQUARED) )
{//shield down, use laser
NPC_GM_StartLaser();
}
}
else*/
if (// !NPC->client->ps.powerups[PW_GALAK_SHIELD]
1 //rwwFIXMEFIXME: just act like the shield is down til the effects and stuff are done
&& enemyDist4 < MELEE_DIST_SQUARED
&& InFront( NPC->enemy->r.currentOrigin, NPC->r.currentOrigin, NPC->client->ps.viewangles, 0.3f )
&& NPC->enemy->localAnimIndex <= 1 )//within 80 and in front
{//our shield is down, and enemy within 80, if very close, use melee attack to slap away
if ( TIMER_Done( NPC, "attackDelay" ) )
{
//animate me
int swingAnim = BOTH_ATTACK1;
#if 0
if ( NPC->locationDamage[HL_GENERIC1] > GENERATOR_HEALTH )
{//generator down, use random melee
swingAnim = Q_irand( BOTH_ATTACK4, BOTH_ATTACK5 );//smackdown or uppercut
}
else
{//always knock-away
swingAnim = BOTH_ATTACK5;//uppercut
}
#endif
//FIXME: swing sound
NPC_SetAnim( NPC, SETANIM_BOTH, swingAnim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
TIMER_Set( NPC, "attackDelay", NPC->client->ps.torsoTimer + Q_irand( 1000, 3000 ) );
//delay the hurt until the proper point in the anim
TIMER_Set( NPC, "smackTime", 600 );
NPCInfo->blockedDebounceTime = 0;
//FIXME: say something?
}
}
else if ( !NPC->lockCount && NPC->locationDamage[HL_GENERIC1] > GENERATOR_HEALTH
&& TIMER_Done( NPC, "attackDelay" )
&& InFront( NPC->enemy->r.currentOrigin, NPC->r.currentOrigin, NPC->client->ps.viewangles, 0.3f )
&& ((!Q_irand( 0, 10*(2-g_spskill.integer))&& enemyDist4 > MIN_LOB_DIST_SQUARED&& enemyDist4 < MAX_LOB_DIST_SQUARED)
||(!TIMER_Done( NPC, "noLob" )&&!TIMER_Done( NPC, "noRapid" )))
&& NPC->enemy->s.weapon != WP_TURRET )
{//sometimes use the laser beam attack, but only after he's taken down our generator
shoot4 = qfalse;
NPC_GM_StartLaser();
}
else if ( enemyDist4 < MIN_LOB_DIST_SQUARED
&& (NPC->enemy->s.weapon != WP_TURRET || Q_stricmp( "PAS", NPC->enemy->classname ))
&& TIMER_Done( NPC, "noRapid" ) )//256
{//enemy within 256
if ( (NPC->client->ps.weapon == WP_REPEATER) && (NPCInfo->scriptFlags & SCF_ALT_FIRE) )
{//shooting an explosive, but enemy too close, switch to primary fire
NPCInfo->scriptFlags &= ~SCF_ALT_FIRE;
NPC->alt_fire = qfalse;
//FIXME: use weap raise & lower anims
NPC_ChangeWeapon( WP_REPEATER );
}
}
else if ( (enemyDist4 > MAX_LOB_DIST_SQUARED || (NPC->enemy->s.weapon == WP_TURRET && !Q_stricmp( "PAS", NPC->enemy->classname )))
&& TIMER_Done( NPC, "noLob" ) )//448
{//enemy more than 448 away and we are ready to try lob fire again
if ( (NPC->client->ps.weapon == WP_REPEATER) && !(NPCInfo->scriptFlags & SCF_ALT_FIRE) )
{//enemy far enough away to use lobby explosives
NPCInfo->scriptFlags |= SCF_ALT_FIRE;
NPC->alt_fire = qtrue;
//FIXME: use weap raise & lower anims
NPC_ChangeWeapon( WP_REPEATER );
}
}
}
//can we see our target?
if ( NPC_ClearLOS4( NPC->enemy ) )
{
NPCInfo->enemyLastSeenTime = level.time;//used here for aim debouncing, not always a clear LOS
enemyLOS4 = qtrue;
if ( NPC->client->ps.weapon == WP_NONE )
{
enemyCS4 = qfalse;//not true, but should stop us from firing
NPC_AimAdjust( -1 );//adjust aim worse longer we have no weapon
}
else
{//can we shoot our target?
if ( ((NPC->client->ps.weapon == WP_REPEATER && (NPCInfo->scriptFlags&SCF_ALT_FIRE))) && enemyDist4 < MIN_LOB_DIST_SQUARED )//256
{
enemyCS4 = qfalse;//not true, but should stop us from firing
hitAlly4 = qtrue;//us!
//FIXME: if too close, run away!
}
else
{
int hit = NPC_ShotEntity( NPC->enemy, impactPos4 );
gentity_t *hitEnt = &g_entities[hit];
if ( hit == NPC->enemy->s.number
|| ( hitEnt && hitEnt->client && hitEnt->client->playerTeam == NPC->client->enemyTeam )
|| ( hitEnt && hitEnt->takedamage ) )
{//can hit enemy or will hit glass or other breakable, so shoot anyway
enemyCS4 = qtrue;
NPC_AimAdjust( 2 );//adjust aim better longer we have clear shot at enemy
VectorCopy( NPC->enemy->r.currentOrigin, NPCInfo->enemyLastSeenLocation );
}
else
{//Hmm, have to get around this bastard
NPC_AimAdjust( 1 );//adjust aim better longer we can see enemy
if ( hitEnt && hitEnt->client && hitEnt->client->playerTeam == NPC->client->playerTeam )
{//would hit an ally, don't fire!!!
hitAlly4 = qtrue;
}
else
{//Check and see where our shot *would* hit... if it's not close to the enemy (within 256?), then don't fire
}
}
}
}
}
else if ( trap_InPVS( NPC->enemy->r.currentOrigin, NPC->r.currentOrigin ) )
{
int hit;
gentity_t *hitEnt;
if ( TIMER_Done( NPC, "talkDebounce" ) && !Q_irand( 0, 10 ) )
{
if ( NPCInfo->enemyCheckDebounceTime < 8 )
{
int speech = -1;
switch( NPCInfo->enemyCheckDebounceTime )
{
case 0:
case 1:
case 2:
speech = EV_CHASE1 + NPCInfo->enemyCheckDebounceTime;
break;
case 3:
case 4:
case 5:
speech = EV_COVER1 + NPCInfo->enemyCheckDebounceTime-3;
break;
case 6:
case 7:
speech = EV_ESCAPING1 + NPCInfo->enemyCheckDebounceTime-6;
break;
}
NPCInfo->enemyCheckDebounceTime++;
if ( speech != -1 )
{
G_AddVoiceEvent( NPC, speech, Q_irand( 3000, 5000 ) );
TIMER_Set( NPC, "talkDebounce", Q_irand( 5000, 7000 ) );
}
}
}
NPCInfo->enemyLastSeenTime = level.time;
hit = NPC_ShotEntity( NPC->enemy, impactPos4 );
hitEnt = &g_entities[hit];
if ( hit == NPC->enemy->s.number
|| ( hitEnt && hitEnt->client && hitEnt->client->playerTeam == NPC->client->enemyTeam )
|| ( hitEnt && hitEnt->takedamage ) )
{//can hit enemy or will hit glass or other breakable, so shoot anyway
enemyCS4 = qtrue;
}
else
{
faceEnemy4 = qtrue;
NPC_AimAdjust( -1 );//adjust aim worse longer we cannot see enemy
}
}
if ( enemyLOS4 )
{
faceEnemy4 = qtrue;
}
else
{
if ( !NPCInfo->goalEntity )
{
NPCInfo->goalEntity = NPC->enemy;
}
if ( NPCInfo->goalEntity == NPC->enemy )
{//for now, always chase the enemy
move4 = qtrue;
}
}
if ( enemyCS4 )
{
shoot4 = qtrue;
//NPCInfo->enemyCheckDebounceTime = level.time;//actually used here as a last actual LOS
}
else
{
if ( !NPCInfo->goalEntity )
{
NPCInfo->goalEntity = NPC->enemy;
}
if ( NPCInfo->goalEntity == NPC->enemy )
{//for now, always chase the enemy
move4 = qtrue;
}
}
//Check for movement to take care of
GM_CheckMoveState();
//See if we should override shooting decision with any special considerations
GM_CheckFireState();
if ( NPC->client->ps.weapon == WP_REPEATER && (NPCInfo->scriptFlags&SCF_ALT_FIRE) && shoot4 && TIMER_Done( NPC, "attackDelay" ) )
{
vec3_t muzzle;
vec3_t angles;
vec3_t target;
vec3_t velocity = {0,0,0};
vec3_t mins = {-REPEATER_ALT_SIZE,-REPEATER_ALT_SIZE,-REPEATER_ALT_SIZE}, maxs = {REPEATER_ALT_SIZE,REPEATER_ALT_SIZE,REPEATER_ALT_SIZE};
qboolean clearshot;
CalcEntitySpot( NPC, SPOT_WEAPON, muzzle );
VectorCopy( NPC->enemy->r.currentOrigin, target );
target[0] += flrand( -5, 5 )+(crandom()*(6-NPCInfo->currentAim)*2);
target[1] += flrand( -5, 5 )+(crandom()*(6-NPCInfo->currentAim)*2);
target[2] += flrand( -5, 5 )+(crandom()*(6-NPCInfo->currentAim)*2);
//Find the desired angles
clearshot = WP_LobFire( NPC, muzzle, target, mins, maxs, MASK_SHOT|CONTENTS_LIGHTSABER,
velocity, qtrue, NPC->s.number, NPC->enemy->s.number,
300, 1100, 1500, qtrue );
if ( VectorCompare( vec3_origin, velocity ) || (!clearshot&&enemyLOS4&&enemyCS4) )
{//no clear lob shot and no lob shot that will hit something breakable
if ( enemyLOS4 && enemyCS4 && TIMER_Done( NPC, "noRapid" ) )
{//have a clear straight shot, so switch to primary
NPCInfo->scriptFlags &= ~SCF_ALT_FIRE;
NPC->alt_fire = qfalse;
NPC_ChangeWeapon( WP_REPEATER );
//keep this weap for a bit
TIMER_Set( NPC, "noLob", Q_irand( 500, 1000 ) );
}
else
{
shoot4 = qfalse;
}
}
else
{
vectoangles( velocity, angles );
NPCInfo->desiredYaw = AngleNormalize360( angles[YAW] );
NPCInfo->desiredPitch = AngleNormalize360( angles[PITCH] );
VectorCopy( velocity, NPC->client->hiddenDir );
NPC->client->hiddenDist = VectorNormalize ( NPC->client->hiddenDir );
}
}
else if ( faceEnemy4 )
{//face the enemy
NPC_FaceEnemy( qtrue );
}
if ( !TIMER_Done( NPC, "standTime" ) )
{
move4 = qfalse;
}
if ( !(NPCInfo->scriptFlags&SCF_CHASE_ENEMIES) )
{//not supposed to chase my enemies
if ( NPCInfo->goalEntity == NPC->enemy )
{//goal is my entity, so don't move
move4 = qfalse;
}
}
if ( move4 && !NPC->lockCount )
{//move toward goal
if ( NPCInfo->goalEntity
/*&& NPC->client->ps.legsAnim != BOTH_ALERT1
&& NPC->client->ps.legsAnim != BOTH_ATTACK2
&& NPC->client->ps.legsAnim != BOTH_ATTACK4
&& NPC->client->ps.legsAnim != BOTH_ATTACK5
&& NPC->client->ps.legsAnim != BOTH_ATTACK7*/ )
{
move4 = GM_Move();
}
else
{
move4 = qfalse;
}
}
if ( !TIMER_Done( NPC, "flee" ) )
{//running away
faceEnemy4 = qfalse;
}
//FIXME: check scf_face_move_dir here?
if ( !faceEnemy4 )
{//we want to face in the dir we're running
if ( !move4 )
{//if we haven't moved, we should look in the direction we last looked?
VectorCopy( NPC->client->ps.viewangles, NPCInfo->lastPathAngles );
}
if ( move4 )
{//don't run away and shoot
NPCInfo->desiredYaw = NPCInfo->lastPathAngles[YAW];
NPCInfo->desiredPitch = 0;
shoot4 = qfalse;
}
}
NPC_UpdateAngles( qtrue, qtrue );
if ( NPCInfo->scriptFlags & SCF_DONT_FIRE )
{
shoot4 = qfalse;
}
if ( NPC->enemy && NPC->enemy->enemy )
{
if ( NPC->enemy->s.weapon == WP_SABER && NPC->enemy->enemy->s.weapon == WP_SABER )
{//don't shoot at an enemy jedi who is fighting another jedi, for fear of injuring one or causing rogue blaster deflections (a la Obi Wan/Vader duel at end of ANH)
shoot4 = qfalse;
}
}
//FIXME: don't shoot right away!
if ( shoot4 )
{//try to shoot if it's time
if ( TIMER_Done( NPC, "attackDelay" ) )
{
if( !(NPCInfo->scriptFlags & SCF_FIRE_WEAPON) ) // we've already fired, no need to do it again here
{
WeaponThink( qtrue );
}
}
}
//also:
if ( NPC->enemy->s.weapon == WP_TURRET && !Q_stricmp( "PAS", NPC->enemy->classname ) )
{//crush turrets
if ( G_BoundsOverlap( NPC->r.absmin, NPC->r.absmax, NPC->enemy->r.absmin, NPC->enemy->r.absmax ) )
{//have to do this test because placed turrets are not solid to NPCs (so they don't obstruct navigation)
//if ( NPC->client->ps.powerups[PW_GALAK_SHIELD] > 0 )
if (0)
{
NPC->client->ps.powerups[PW_BATTLESUIT] = level.time + ARMOR_EFFECT_TIME;
G_Damage( NPC->enemy, NPC, NPC, NULL, NPC->r.currentOrigin, 100, DAMAGE_NO_KNOCKBACK, MOD_UNKNOWN );
}
else
{
G_Damage( NPC->enemy, NPC, NPC, NULL, NPC->r.currentOrigin, 100, DAMAGE_NO_KNOCKBACK, MOD_CRUSH );
}
}
}
else if ( NPCInfo->touchedByPlayer != NULL && NPCInfo->touchedByPlayer == NPC->enemy )
{//touched enemy
//if ( NPC->client->ps.powerups[PW_GALAK_SHIELD] > 0 )
if (0)
{//zap him!
vec3_t smackDir;
//animate me
#if 0
NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_ATTACK6, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
#endif
TIMER_Set( NPC, "attackDelay", NPC->client->ps.torsoTimer );
TIMER_Set( NPC, "standTime", NPC->client->ps.legsTimer );
//FIXME: debounce this?
NPCInfo->touchedByPlayer = NULL;
//FIXME: some shield effect?
NPC->client->ps.powerups[PW_BATTLESUIT] = level.time + ARMOR_EFFECT_TIME;
VectorSubtract( NPC->enemy->r.currentOrigin, NPC->r.currentOrigin, smackDir );
smackDir[2] += 30;
VectorNormalize( smackDir );
G_Damage( NPC->enemy, NPC, NPC, smackDir, NPC->r.currentOrigin, (g_spskill.integer+1)*Q_irand( 5, 10), DAMAGE_NO_KNOCKBACK, MOD_UNKNOWN );
//throw them
G_Throw( NPC->enemy, smackDir, 100 );
//NPC->enemy->s.powerups |= ( 1 << PW_SHOCKED );
if ( NPC->enemy->client )
{
// NPC->enemy->client->ps.powerups[PW_SHOCKED] = level.time + 1000;
NPC->enemy->client->ps.electrifyTime = level.time + 1000;
}
//stop any attacks
ucmd.buttons = 0;
}
}
if ( NPCInfo->movementSpeech < 3 && NPCInfo->blockedSpeechDebounceTime <= level.time )
{
if ( NPC->enemy && NPC->enemy->health > 0 && NPC->enemy->painDebounceTime > level.time )
{
if ( NPC->enemy->health < 50 && NPCInfo->movementSpeech == 2 )
{
G_AddVoiceEvent( NPC, EV_ANGER2, Q_irand( 2000, 4000 ) );
NPCInfo->movementSpeech = 3;
}
else if ( NPC->enemy->health < 75 && NPCInfo->movementSpeech == 1 )
{
G_AddVoiceEvent( NPC, EV_ANGER1, Q_irand( 2000, 4000 ) );
NPCInfo->movementSpeech = 2;
}
else if ( NPC->enemy->health < 100 && NPCInfo->movementSpeech == 0 )
{
G_AddVoiceEvent( NPC, EV_ANGER3, Q_irand( 2000, 4000 ) );
NPCInfo->movementSpeech = 1;
}
}
}
}
/*
* R_DrawPortalSurface
*
* Renders the portal view and captures the results from framebuffer if
* we need to do a $portalmap stage. Note that for $portalmaps we must
* use a different viewport.
*/
static void R_DrawPortalSurface( portalSurface_t *portalSurface ) {
unsigned int i;
int x, y, w, h;
float dist, d, best_d;
vec3_t viewerOrigin;
vec3_t origin;
mat3_t axis;
entity_t *ent, *best;
cplane_t *portal_plane = &portalSurface->plane, *untransformed_plane = &portalSurface->untransformed_plane;
const shader_t *shader = portalSurface->shader;
vec_t *portal_centre = portalSurface->centre;
bool mirror, refraction = false;
image_t *captureTexture;
int captureTextureId = -1;
int prevRenderFlags = 0;
bool prevFlipped;
bool doReflection, doRefraction;
image_t *portalTexures[2] = { NULL, NULL };
doReflection = doRefraction = true;
if( shader->flags & SHADER_PORTAL_CAPTURE ) {
shaderpass_t *pass;
captureTexture = NULL;
captureTextureId = 0;
for( i = 0, pass = shader->passes; i < shader->numpasses; i++, pass++ ) {
if( pass->program_type == GLSL_PROGRAM_TYPE_DISTORTION ) {
if( ( pass->alphagen.type == ALPHA_GEN_CONST && pass->alphagen.args[0] == 1 ) ) {
doRefraction = false;
} else if( ( pass->alphagen.type == ALPHA_GEN_CONST && pass->alphagen.args[0] == 0 ) ) {
doReflection = false;
}
break;
}
}
} else {
captureTexture = NULL;
captureTextureId = -1;
}
x = y = 0;
w = rn.refdef.width;
h = rn.refdef.height;
dist = PlaneDiff( rn.viewOrigin, portal_plane );
if( dist <= BACKFACE_EPSILON || !doReflection ) {
if( !( shader->flags & SHADER_PORTAL_CAPTURE2 ) || !doRefraction ) {
return;
}
// even if we're behind the portal, we still need to capture
// the second portal image for refraction
refraction = true;
captureTexture = NULL;
captureTextureId = 1;
if( dist < 0 ) {
VectorInverse( portal_plane->normal );
portal_plane->dist = -portal_plane->dist;
}
}
mirror = true; // default to mirror view
// it is stupid IMO that mirrors require a RT_PORTALSURFACE entity
best = NULL;
best_d = 100000000;
for( i = 0; i < rn.numEntities; i++ ) {
ent = R_NUM2ENT( rn.entities[i] );
if( ent->rtype != RT_PORTALSURFACE ) {
continue;
}
d = PlaneDiff( ent->origin, untransformed_plane );
if( ( d >= -64 ) && ( d <= 64 ) ) {
d = Distance( ent->origin, portal_centre );
if( d < best_d ) {
best = ent;
best_d = d;
}
}
}
if( best == NULL ) {
if( captureTextureId < 0 ) {
// still do a push&pop because to ensure the clean state
if( R_PushRefInst() ) {
R_PopRefInst();
}
return;
}
} else {
if( !VectorCompare( best->origin, best->origin2 ) ) { // portal
mirror = false;
}
best->rtype = NUM_RTYPES;
}
prevRenderFlags = rn.renderFlags;
prevFlipped = ( rn.refdef.rdflags & RDF_FLIPPED ) != 0;
if( !R_PushRefInst() ) {
return;
}
VectorCopy( rn.viewOrigin, viewerOrigin );
if( prevFlipped ) {
VectorInverse( &rn.viewAxis[AXIS_RIGHT] );
}
setup_and_render:
if( refraction ) {
VectorInverse( portal_plane->normal );
portal_plane->dist = -portal_plane->dist;
CategorizePlane( portal_plane );
VectorCopy( rn.viewOrigin, origin );
Matrix3_Copy( rn.refdef.viewaxis, axis );
VectorCopy( viewerOrigin, rn.pvsOrigin );
rn.renderFlags |= RF_PORTALVIEW;
if( prevFlipped ) {
rn.renderFlags |= RF_FLIPFRONTFACE;
}
} else if( mirror ) {
VectorReflect( rn.viewOrigin, portal_plane->normal, portal_plane->dist, origin );
VectorReflect( &rn.viewAxis[AXIS_FORWARD], portal_plane->normal, 0, &axis[AXIS_FORWARD] );
VectorReflect( &rn.viewAxis[AXIS_RIGHT], portal_plane->normal, 0, &axis[AXIS_RIGHT] );
VectorReflect( &rn.viewAxis[AXIS_UP], portal_plane->normal, 0, &axis[AXIS_UP] );
Matrix3_Normalize( axis );
VectorCopy( viewerOrigin, rn.pvsOrigin );
rn.renderFlags = ( prevRenderFlags ^ RF_FLIPFRONTFACE ) | RF_MIRRORVIEW;
} else {
vec3_t tvec;
mat3_t A, B, C, rot;
// build world-to-portal rotation matrix
VectorNegate( portal_plane->normal, tvec );
NormalVectorToAxis( tvec, A );
// build portal_dest-to-world rotation matrix
ByteToDir( best->frame, tvec );
NormalVectorToAxis( tvec, B );
Matrix3_Transpose( B, C );
// multiply to get world-to-world rotation matrix
Matrix3_Multiply( C, A, rot );
// translate view origin
VectorSubtract( rn.viewOrigin, best->origin, tvec );
Matrix3_TransformVector( rot, tvec, origin );
VectorAdd( origin, best->origin2, origin );
Matrix3_Transpose( A, B );
Matrix3_Multiply( rn.viewAxis, B, rot );
Matrix3_Multiply( best->axis, rot, B );
Matrix3_Transpose( C, A );
Matrix3_Multiply( B, A, axis );
// set up portal_plane
VectorCopy( &axis[AXIS_FORWARD], portal_plane->normal );
portal_plane->dist = DotProduct( best->origin2, portal_plane->normal );
CategorizePlane( portal_plane );
// for portals, vis data is taken from portal origin, not
// view origin, because the view point moves around and
// might fly into (or behind) a wall
VectorCopy( best->origin2, rn.pvsOrigin );
VectorCopy( best->origin2, rn.lodOrigin );
rn.renderFlags |= RF_PORTALVIEW;
// ignore entities, if asked politely
if( best->renderfx & RF_NOPORTALENTS ) {
rn.renderFlags |= RF_ENVVIEW;
}
if( prevFlipped ) {
rn.renderFlags |= RF_FLIPFRONTFACE;
}
}
rn.refdef.rdflags &= ~( RDF_UNDERWATER | RDF_CROSSINGWATER | RDF_FLIPPED );
rn.meshlist = &r_portallist;
rn.portalmasklist = NULL;
rn.renderFlags |= RF_CLIPPLANE;
rn.renderFlags &= ~RF_SOFT_PARTICLES;
rn.clipPlane = *portal_plane;
rn.nearClip = Z_NEAR;
rn.farClip = R_DefaultFarClip();
rn.polygonFactor = POLYOFFSET_FACTOR;
rn.polygonUnits = POLYOFFSET_UNITS;
rn.clipFlags |= 16;
rn.frustum[4] = *portal_plane; // nearclip
CategorizePlane( &rn.frustum[4] );
// if we want to render to a texture, initialize texture
// but do not try to render to it more than once
if( captureTextureId >= 0 ) {
int texFlags = shader->flags & SHADER_NO_TEX_FILTERING ? IT_NOFILTERING : 0;
captureTexture = R_GetPortalTexture( rsc.refdef.width, rsc.refdef.height, texFlags,
rsc.frameCount );
portalTexures[captureTextureId] = captureTexture;
if( !captureTexture ) {
// couldn't register a slot for this plane
goto done;
}
x = y = 0;
w = captureTexture->upload_width;
h = captureTexture->upload_height;
rn.refdef.width = w;
rn.refdef.height = h;
rn.refdef.x = 0;
rn.refdef.y = 0;
rn.renderTarget = captureTexture->fbo;
rn.renderFlags |= RF_PORTAL_CAPTURE;
Vector4Set( rn.viewport, rn.refdef.x + x, rn.refdef.y + y, w, h );
Vector4Set( rn.scissor, rn.refdef.x + x, rn.refdef.y + y, w, h );
} else {
rn.renderFlags &= ~RF_PORTAL_CAPTURE;
}
VectorCopy( origin, rn.refdef.vieworg );
Matrix3_Copy( axis, rn.refdef.viewaxis );
R_SetupViewMatrices( &rn.refdef );
R_SetupFrustum( &rn.refdef, rn.nearClip, rn.farClip, rn.frustum, rn.frustumCorners );
R_SetupPVS( &rn.refdef );
R_RenderView( &rn.refdef );
if( doRefraction && !refraction && ( shader->flags & SHADER_PORTAL_CAPTURE2 ) ) {
rn.renderFlags = prevRenderFlags;
refraction = true;
captureTexture = NULL;
captureTextureId = 1;
goto setup_and_render;
}
done:
portalSurface->texures[0] = portalTexures[0];
portalSurface->texures[1] = portalTexures[1];
R_PopRefInst();
}