The Quake III Arena sources as originally released under the GPL license on August 20, 2005.
This commit is contained in:
Travis Bradshaw
commit
dbe4ddb103
1409 changed files with 806066 additions and 0 deletions
886
code/cgame/cg_localents.c
Normal file
886
code/cgame/cg_localents.c
Normal file
|
|
@ -0,0 +1,886 @@
|
|||
/*
|
||||
===========================================================================
|
||||
Copyright (C) 1999-2005 Id Software, Inc.
|
||||
|
||||
This file is part of Quake III Arena source code.
|
||||
|
||||
Quake III Arena source code is free software; you can redistribute it
|
||||
and/or modify it under the terms of the GNU General Public License as
|
||||
published by the Free Software Foundation; either version 2 of the License,
|
||||
or (at your option) any later version.
|
||||
|
||||
Quake III Arena source code is distributed in the hope that it will be
|
||||
useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with Foobar; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
===========================================================================
|
||||
*/
|
||||
//
|
||||
|
||||
// cg_localents.c -- every frame, generate renderer commands for locally
|
||||
// processed entities, like smoke puffs, gibs, shells, etc.
|
||||
|
||||
#include "cg_local.h"
|
||||
|
||||
#define MAX_LOCAL_ENTITIES 512
|
||||
localEntity_t cg_localEntities[MAX_LOCAL_ENTITIES];
|
||||
localEntity_t cg_activeLocalEntities; // double linked list
|
||||
localEntity_t *cg_freeLocalEntities; // single linked list
|
||||
|
||||
/*
|
||||
===================
|
||||
CG_InitLocalEntities
|
||||
|
||||
This is called at startup and for tournement restarts
|
||||
===================
|
||||
*/
|
||||
void CG_InitLocalEntities( void ) {
|
||||
int i;
|
||||
|
||||
memset( cg_localEntities, 0, sizeof( cg_localEntities ) );
|
||||
cg_activeLocalEntities.next = &cg_activeLocalEntities;
|
||||
cg_activeLocalEntities.prev = &cg_activeLocalEntities;
|
||||
cg_freeLocalEntities = cg_localEntities;
|
||||
for ( i = 0 ; i < MAX_LOCAL_ENTITIES - 1 ; i++ ) {
|
||||
cg_localEntities[i].next = &cg_localEntities[i+1];
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
==================
|
||||
CG_FreeLocalEntity
|
||||
==================
|
||||
*/
|
||||
void CG_FreeLocalEntity( localEntity_t *le ) {
|
||||
if ( !le->prev ) {
|
||||
CG_Error( "CG_FreeLocalEntity: not active" );
|
||||
}
|
||||
|
||||
// remove from the doubly linked active list
|
||||
le->prev->next = le->next;
|
||||
le->next->prev = le->prev;
|
||||
|
||||
// the free list is only singly linked
|
||||
le->next = cg_freeLocalEntities;
|
||||
cg_freeLocalEntities = le;
|
||||
}
|
||||
|
||||
/*
|
||||
===================
|
||||
CG_AllocLocalEntity
|
||||
|
||||
Will allways succeed, even if it requires freeing an old active entity
|
||||
===================
|
||||
*/
|
||||
localEntity_t *CG_AllocLocalEntity( void ) {
|
||||
localEntity_t *le;
|
||||
|
||||
if ( !cg_freeLocalEntities ) {
|
||||
// no free entities, so free the one at the end of the chain
|
||||
// remove the oldest active entity
|
||||
CG_FreeLocalEntity( cg_activeLocalEntities.prev );
|
||||
}
|
||||
|
||||
le = cg_freeLocalEntities;
|
||||
cg_freeLocalEntities = cg_freeLocalEntities->next;
|
||||
|
||||
memset( le, 0, sizeof( *le ) );
|
||||
|
||||
// link into the active list
|
||||
le->next = cg_activeLocalEntities.next;
|
||||
le->prev = &cg_activeLocalEntities;
|
||||
cg_activeLocalEntities.next->prev = le;
|
||||
cg_activeLocalEntities.next = le;
|
||||
return le;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
====================================================================================
|
||||
|
||||
FRAGMENT PROCESSING
|
||||
|
||||
A fragment localentity interacts with the environment in some way (hitting walls),
|
||||
or generates more localentities along a trail.
|
||||
|
||||
====================================================================================
|
||||
*/
|
||||
|
||||
/*
|
||||
================
|
||||
CG_BloodTrail
|
||||
|
||||
Leave expanding blood puffs behind gibs
|
||||
================
|
||||
*/
|
||||
void CG_BloodTrail( localEntity_t *le ) {
|
||||
int t;
|
||||
int t2;
|
||||
int step;
|
||||
vec3_t newOrigin;
|
||||
localEntity_t *blood;
|
||||
|
||||
step = 150;
|
||||
t = step * ( (cg.time - cg.frametime + step ) / step );
|
||||
t2 = step * ( cg.time / step );
|
||||
|
||||
for ( ; t <= t2; t += step ) {
|
||||
BG_EvaluateTrajectory( &le->pos, t, newOrigin );
|
||||
|
||||
blood = CG_SmokePuff( newOrigin, vec3_origin,
|
||||
20, // radius
|
||||
1, 1, 1, 1, // color
|
||||
2000, // trailTime
|
||||
t, // startTime
|
||||
0, // fadeInTime
|
||||
0, // flags
|
||||
cgs.media.bloodTrailShader );
|
||||
// use the optimized version
|
||||
blood->leType = LE_FALL_SCALE_FADE;
|
||||
// drop a total of 40 units over its lifetime
|
||||
blood->pos.trDelta[2] = 40;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
================
|
||||
CG_FragmentBounceMark
|
||||
================
|
||||
*/
|
||||
void CG_FragmentBounceMark( localEntity_t *le, trace_t *trace ) {
|
||||
int radius;
|
||||
|
||||
if ( le->leMarkType == LEMT_BLOOD ) {
|
||||
|
||||
radius = 16 + (rand()&31);
|
||||
CG_ImpactMark( cgs.media.bloodMarkShader, trace->endpos, trace->plane.normal, random()*360,
|
||||
1,1,1,1, qtrue, radius, qfalse );
|
||||
} else if ( le->leMarkType == LEMT_BURN ) {
|
||||
|
||||
radius = 8 + (rand()&15);
|
||||
CG_ImpactMark( cgs.media.burnMarkShader, trace->endpos, trace->plane.normal, random()*360,
|
||||
1,1,1,1, qtrue, radius, qfalse );
|
||||
}
|
||||
|
||||
|
||||
// don't allow a fragment to make multiple marks, or they
|
||||
// pile up while settling
|
||||
le->leMarkType = LEMT_NONE;
|
||||
}
|
||||
|
||||
/*
|
||||
================
|
||||
CG_FragmentBounceSound
|
||||
================
|
||||
*/
|
||||
void CG_FragmentBounceSound( localEntity_t *le, trace_t *trace ) {
|
||||
if ( le->leBounceSoundType == LEBS_BLOOD ) {
|
||||
// half the gibs will make splat sounds
|
||||
if ( rand() & 1 ) {
|
||||
int r = rand()&3;
|
||||
sfxHandle_t s;
|
||||
|
||||
if ( r == 0 ) {
|
||||
s = cgs.media.gibBounce1Sound;
|
||||
} else if ( r == 1 ) {
|
||||
s = cgs.media.gibBounce2Sound;
|
||||
} else {
|
||||
s = cgs.media.gibBounce3Sound;
|
||||
}
|
||||
trap_S_StartSound( trace->endpos, ENTITYNUM_WORLD, CHAN_AUTO, s );
|
||||
}
|
||||
} else if ( le->leBounceSoundType == LEBS_BRASS ) {
|
||||
|
||||
}
|
||||
|
||||
// don't allow a fragment to make multiple bounce sounds,
|
||||
// or it gets too noisy as they settle
|
||||
le->leBounceSoundType = LEBS_NONE;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
================
|
||||
CG_ReflectVelocity
|
||||
================
|
||||
*/
|
||||
void CG_ReflectVelocity( localEntity_t *le, trace_t *trace ) {
|
||||
vec3_t velocity;
|
||||
float dot;
|
||||
int hitTime;
|
||||
|
||||
// reflect the velocity on the trace plane
|
||||
hitTime = cg.time - cg.frametime + cg.frametime * trace->fraction;
|
||||
BG_EvaluateTrajectoryDelta( &le->pos, hitTime, velocity );
|
||||
dot = DotProduct( velocity, trace->plane.normal );
|
||||
VectorMA( velocity, -2*dot, trace->plane.normal, le->pos.trDelta );
|
||||
|
||||
VectorScale( le->pos.trDelta, le->bounceFactor, le->pos.trDelta );
|
||||
|
||||
VectorCopy( trace->endpos, le->pos.trBase );
|
||||
le->pos.trTime = cg.time;
|
||||
|
||||
|
||||
// check for stop, making sure that even on low FPS systems it doesn't bobble
|
||||
if ( trace->allsolid ||
|
||||
( trace->plane.normal[2] > 0 &&
|
||||
( le->pos.trDelta[2] < 40 || le->pos.trDelta[2] < -cg.frametime * le->pos.trDelta[2] ) ) ) {
|
||||
le->pos.trType = TR_STATIONARY;
|
||||
} else {
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
================
|
||||
CG_AddFragment
|
||||
================
|
||||
*/
|
||||
void CG_AddFragment( localEntity_t *le ) {
|
||||
vec3_t newOrigin;
|
||||
trace_t trace;
|
||||
|
||||
if ( le->pos.trType == TR_STATIONARY ) {
|
||||
// sink into the ground if near the removal time
|
||||
int t;
|
||||
float oldZ;
|
||||
|
||||
t = le->endTime - cg.time;
|
||||
if ( t < SINK_TIME ) {
|
||||
// we must use an explicit lighting origin, otherwise the
|
||||
// lighting would be lost as soon as the origin went
|
||||
// into the ground
|
||||
VectorCopy( le->refEntity.origin, le->refEntity.lightingOrigin );
|
||||
le->refEntity.renderfx |= RF_LIGHTING_ORIGIN;
|
||||
oldZ = le->refEntity.origin[2];
|
||||
le->refEntity.origin[2] -= 16 * ( 1.0 - (float)t / SINK_TIME );
|
||||
trap_R_AddRefEntityToScene( &le->refEntity );
|
||||
le->refEntity.origin[2] = oldZ;
|
||||
} else {
|
||||
trap_R_AddRefEntityToScene( &le->refEntity );
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
// calculate new position
|
||||
BG_EvaluateTrajectory( &le->pos, cg.time, newOrigin );
|
||||
|
||||
// trace a line from previous position to new position
|
||||
CG_Trace( &trace, le->refEntity.origin, NULL, NULL, newOrigin, -1, CONTENTS_SOLID );
|
||||
if ( trace.fraction == 1.0 ) {
|
||||
// still in free fall
|
||||
VectorCopy( newOrigin, le->refEntity.origin );
|
||||
|
||||
if ( le->leFlags & LEF_TUMBLE ) {
|
||||
vec3_t angles;
|
||||
|
||||
BG_EvaluateTrajectory( &le->angles, cg.time, angles );
|
||||
AnglesToAxis( angles, le->refEntity.axis );
|
||||
}
|
||||
|
||||
trap_R_AddRefEntityToScene( &le->refEntity );
|
||||
|
||||
// add a blood trail
|
||||
if ( le->leBounceSoundType == LEBS_BLOOD ) {
|
||||
CG_BloodTrail( le );
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
// if it is in a nodrop zone, remove it
|
||||
// this keeps gibs from waiting at the bottom of pits of death
|
||||
// and floating levels
|
||||
if ( trap_CM_PointContents( trace.endpos, 0 ) & CONTENTS_NODROP ) {
|
||||
CG_FreeLocalEntity( le );
|
||||
return;
|
||||
}
|
||||
|
||||
// leave a mark
|
||||
CG_FragmentBounceMark( le, &trace );
|
||||
|
||||
// do a bouncy sound
|
||||
CG_FragmentBounceSound( le, &trace );
|
||||
|
||||
// reflect the velocity on the trace plane
|
||||
CG_ReflectVelocity( le, &trace );
|
||||
|
||||
trap_R_AddRefEntityToScene( &le->refEntity );
|
||||
}
|
||||
|
||||
/*
|
||||
=====================================================================
|
||||
|
||||
TRIVIAL LOCAL ENTITIES
|
||||
|
||||
These only do simple scaling or modulation before passing to the renderer
|
||||
=====================================================================
|
||||
*/
|
||||
|
||||
/*
|
||||
====================
|
||||
CG_AddFadeRGB
|
||||
====================
|
||||
*/
|
||||
void CG_AddFadeRGB( localEntity_t *le ) {
|
||||
refEntity_t *re;
|
||||
float c;
|
||||
|
||||
re = &le->refEntity;
|
||||
|
||||
c = ( le->endTime - cg.time ) * le->lifeRate;
|
||||
c *= 0xff;
|
||||
|
||||
re->shaderRGBA[0] = le->color[0] * c;
|
||||
re->shaderRGBA[1] = le->color[1] * c;
|
||||
re->shaderRGBA[2] = le->color[2] * c;
|
||||
re->shaderRGBA[3] = le->color[3] * c;
|
||||
|
||||
trap_R_AddRefEntityToScene( re );
|
||||
}
|
||||
|
||||
/*
|
||||
==================
|
||||
CG_AddMoveScaleFade
|
||||
==================
|
||||
*/
|
||||
static void CG_AddMoveScaleFade( localEntity_t *le ) {
|
||||
refEntity_t *re;
|
||||
float c;
|
||||
vec3_t delta;
|
||||
float len;
|
||||
|
||||
re = &le->refEntity;
|
||||
|
||||
if ( le->fadeInTime > le->startTime && cg.time < le->fadeInTime ) {
|
||||
// fade / grow time
|
||||
c = 1.0 - (float) ( le->fadeInTime - cg.time ) / ( le->fadeInTime - le->startTime );
|
||||
}
|
||||
else {
|
||||
// fade / grow time
|
||||
c = ( le->endTime - cg.time ) * le->lifeRate;
|
||||
}
|
||||
|
||||
re->shaderRGBA[3] = 0xff * c * le->color[3];
|
||||
|
||||
if ( !( le->leFlags & LEF_PUFF_DONT_SCALE ) ) {
|
||||
re->radius = le->radius * ( 1.0 - c ) + 8;
|
||||
}
|
||||
|
||||
BG_EvaluateTrajectory( &le->pos, cg.time, re->origin );
|
||||
|
||||
// if the view would be "inside" the sprite, kill the sprite
|
||||
// so it doesn't add too much overdraw
|
||||
VectorSubtract( re->origin, cg.refdef.vieworg, delta );
|
||||
len = VectorLength( delta );
|
||||
if ( len < le->radius ) {
|
||||
CG_FreeLocalEntity( le );
|
||||
return;
|
||||
}
|
||||
|
||||
trap_R_AddRefEntityToScene( re );
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
===================
|
||||
CG_AddScaleFade
|
||||
|
||||
For rocket smokes that hang in place, fade out, and are
|
||||
removed if the view passes through them.
|
||||
There are often many of these, so it needs to be simple.
|
||||
===================
|
||||
*/
|
||||
static void CG_AddScaleFade( localEntity_t *le ) {
|
||||
refEntity_t *re;
|
||||
float c;
|
||||
vec3_t delta;
|
||||
float len;
|
||||
|
||||
re = &le->refEntity;
|
||||
|
||||
// fade / grow time
|
||||
c = ( le->endTime - cg.time ) * le->lifeRate;
|
||||
|
||||
re->shaderRGBA[3] = 0xff * c * le->color[3];
|
||||
re->radius = le->radius * ( 1.0 - c ) + 8;
|
||||
|
||||
// if the view would be "inside" the sprite, kill the sprite
|
||||
// so it doesn't add too much overdraw
|
||||
VectorSubtract( re->origin, cg.refdef.vieworg, delta );
|
||||
len = VectorLength( delta );
|
||||
if ( len < le->radius ) {
|
||||
CG_FreeLocalEntity( le );
|
||||
return;
|
||||
}
|
||||
|
||||
trap_R_AddRefEntityToScene( re );
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
=================
|
||||
CG_AddFallScaleFade
|
||||
|
||||
This is just an optimized CG_AddMoveScaleFade
|
||||
For blood mists that drift down, fade out, and are
|
||||
removed if the view passes through them.
|
||||
There are often 100+ of these, so it needs to be simple.
|
||||
=================
|
||||
*/
|
||||
static void CG_AddFallScaleFade( localEntity_t *le ) {
|
||||
refEntity_t *re;
|
||||
float c;
|
||||
vec3_t delta;
|
||||
float len;
|
||||
|
||||
re = &le->refEntity;
|
||||
|
||||
// fade time
|
||||
c = ( le->endTime - cg.time ) * le->lifeRate;
|
||||
|
||||
re->shaderRGBA[3] = 0xff * c * le->color[3];
|
||||
|
||||
re->origin[2] = le->pos.trBase[2] - ( 1.0 - c ) * le->pos.trDelta[2];
|
||||
|
||||
re->radius = le->radius * ( 1.0 - c ) + 16;
|
||||
|
||||
// if the view would be "inside" the sprite, kill the sprite
|
||||
// so it doesn't add too much overdraw
|
||||
VectorSubtract( re->origin, cg.refdef.vieworg, delta );
|
||||
len = VectorLength( delta );
|
||||
if ( len < le->radius ) {
|
||||
CG_FreeLocalEntity( le );
|
||||
return;
|
||||
}
|
||||
|
||||
trap_R_AddRefEntityToScene( re );
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*
|
||||
================
|
||||
CG_AddExplosion
|
||||
================
|
||||
*/
|
||||
static void CG_AddExplosion( localEntity_t *ex ) {
|
||||
refEntity_t *ent;
|
||||
|
||||
ent = &ex->refEntity;
|
||||
|
||||
// add the entity
|
||||
trap_R_AddRefEntityToScene(ent);
|
||||
|
||||
// add the dlight
|
||||
if ( ex->light ) {
|
||||
float light;
|
||||
|
||||
light = (float)( cg.time - ex->startTime ) / ( ex->endTime - ex->startTime );
|
||||
if ( light < 0.5 ) {
|
||||
light = 1.0;
|
||||
} else {
|
||||
light = 1.0 - ( light - 0.5 ) * 2;
|
||||
}
|
||||
light = ex->light * light;
|
||||
trap_R_AddLightToScene(ent->origin, light, ex->lightColor[0], ex->lightColor[1], ex->lightColor[2] );
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
================
|
||||
CG_AddSpriteExplosion
|
||||
================
|
||||
*/
|
||||
static void CG_AddSpriteExplosion( localEntity_t *le ) {
|
||||
refEntity_t re;
|
||||
float c;
|
||||
|
||||
re = le->refEntity;
|
||||
|
||||
c = ( le->endTime - cg.time ) / ( float ) ( le->endTime - le->startTime );
|
||||
if ( c > 1 ) {
|
||||
c = 1.0; // can happen during connection problems
|
||||
}
|
||||
|
||||
re.shaderRGBA[0] = 0xff;
|
||||
re.shaderRGBA[1] = 0xff;
|
||||
re.shaderRGBA[2] = 0xff;
|
||||
re.shaderRGBA[3] = 0xff * c * 0.33;
|
||||
|
||||
re.reType = RT_SPRITE;
|
||||
re.radius = 42 * ( 1.0 - c ) + 30;
|
||||
|
||||
trap_R_AddRefEntityToScene( &re );
|
||||
|
||||
// add the dlight
|
||||
if ( le->light ) {
|
||||
float light;
|
||||
|
||||
light = (float)( cg.time - le->startTime ) / ( le->endTime - le->startTime );
|
||||
if ( light < 0.5 ) {
|
||||
light = 1.0;
|
||||
} else {
|
||||
light = 1.0 - ( light - 0.5 ) * 2;
|
||||
}
|
||||
light = le->light * light;
|
||||
trap_R_AddLightToScene(re.origin, light, le->lightColor[0], le->lightColor[1], le->lightColor[2] );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
#ifdef MISSIONPACK
|
||||
/*
|
||||
====================
|
||||
CG_AddKamikaze
|
||||
====================
|
||||
*/
|
||||
void CG_AddKamikaze( localEntity_t *le ) {
|
||||
refEntity_t *re;
|
||||
refEntity_t shockwave;
|
||||
float c;
|
||||
vec3_t test, axis[3];
|
||||
int t;
|
||||
|
||||
re = &le->refEntity;
|
||||
|
||||
t = cg.time - le->startTime;
|
||||
VectorClear( test );
|
||||
AnglesToAxis( test, axis );
|
||||
|
||||
if (t > KAMI_SHOCKWAVE_STARTTIME && t < KAMI_SHOCKWAVE_ENDTIME) {
|
||||
|
||||
if (!(le->leFlags & LEF_SOUND1)) {
|
||||
// trap_S_StartSound (re->origin, ENTITYNUM_WORLD, CHAN_AUTO, cgs.media.kamikazeExplodeSound );
|
||||
trap_S_StartLocalSound(cgs.media.kamikazeExplodeSound, CHAN_AUTO);
|
||||
le->leFlags |= LEF_SOUND1;
|
||||
}
|
||||
// 1st kamikaze shockwave
|
||||
memset(&shockwave, 0, sizeof(shockwave));
|
||||
shockwave.hModel = cgs.media.kamikazeShockWave;
|
||||
shockwave.reType = RT_MODEL;
|
||||
shockwave.shaderTime = re->shaderTime;
|
||||
VectorCopy(re->origin, shockwave.origin);
|
||||
|
||||
c = (float)(t - KAMI_SHOCKWAVE_STARTTIME) / (float)(KAMI_SHOCKWAVE_ENDTIME - KAMI_SHOCKWAVE_STARTTIME);
|
||||
VectorScale( axis[0], c * KAMI_SHOCKWAVE_MAXRADIUS / KAMI_SHOCKWAVEMODEL_RADIUS, shockwave.axis[0] );
|
||||
VectorScale( axis[1], c * KAMI_SHOCKWAVE_MAXRADIUS / KAMI_SHOCKWAVEMODEL_RADIUS, shockwave.axis[1] );
|
||||
VectorScale( axis[2], c * KAMI_SHOCKWAVE_MAXRADIUS / KAMI_SHOCKWAVEMODEL_RADIUS, shockwave.axis[2] );
|
||||
shockwave.nonNormalizedAxes = qtrue;
|
||||
|
||||
if (t > KAMI_SHOCKWAVEFADE_STARTTIME) {
|
||||
c = (float)(t - KAMI_SHOCKWAVEFADE_STARTTIME) / (float)(KAMI_SHOCKWAVE_ENDTIME - KAMI_SHOCKWAVEFADE_STARTTIME);
|
||||
}
|
||||
else {
|
||||
c = 0;
|
||||
}
|
||||
c *= 0xff;
|
||||
shockwave.shaderRGBA[0] = 0xff - c;
|
||||
shockwave.shaderRGBA[1] = 0xff - c;
|
||||
shockwave.shaderRGBA[2] = 0xff - c;
|
||||
shockwave.shaderRGBA[3] = 0xff - c;
|
||||
|
||||
trap_R_AddRefEntityToScene( &shockwave );
|
||||
}
|
||||
|
||||
if (t > KAMI_EXPLODE_STARTTIME && t < KAMI_IMPLODE_ENDTIME) {
|
||||
// explosion and implosion
|
||||
c = ( le->endTime - cg.time ) * le->lifeRate;
|
||||
c *= 0xff;
|
||||
re->shaderRGBA[0] = le->color[0] * c;
|
||||
re->shaderRGBA[1] = le->color[1] * c;
|
||||
re->shaderRGBA[2] = le->color[2] * c;
|
||||
re->shaderRGBA[3] = le->color[3] * c;
|
||||
|
||||
if( t < KAMI_IMPLODE_STARTTIME ) {
|
||||
c = (float)(t - KAMI_EXPLODE_STARTTIME) / (float)(KAMI_IMPLODE_STARTTIME - KAMI_EXPLODE_STARTTIME);
|
||||
}
|
||||
else {
|
||||
if (!(le->leFlags & LEF_SOUND2)) {
|
||||
// trap_S_StartSound (re->origin, ENTITYNUM_WORLD, CHAN_AUTO, cgs.media.kamikazeImplodeSound );
|
||||
trap_S_StartLocalSound(cgs.media.kamikazeImplodeSound, CHAN_AUTO);
|
||||
le->leFlags |= LEF_SOUND2;
|
||||
}
|
||||
c = (float)(KAMI_IMPLODE_ENDTIME - t) / (float) (KAMI_IMPLODE_ENDTIME - KAMI_IMPLODE_STARTTIME);
|
||||
}
|
||||
VectorScale( axis[0], c * KAMI_BOOMSPHERE_MAXRADIUS / KAMI_BOOMSPHEREMODEL_RADIUS, re->axis[0] );
|
||||
VectorScale( axis[1], c * KAMI_BOOMSPHERE_MAXRADIUS / KAMI_BOOMSPHEREMODEL_RADIUS, re->axis[1] );
|
||||
VectorScale( axis[2], c * KAMI_BOOMSPHERE_MAXRADIUS / KAMI_BOOMSPHEREMODEL_RADIUS, re->axis[2] );
|
||||
re->nonNormalizedAxes = qtrue;
|
||||
|
||||
trap_R_AddRefEntityToScene( re );
|
||||
// add the dlight
|
||||
trap_R_AddLightToScene( re->origin, c * 1000.0, 1.0, 1.0, c );
|
||||
}
|
||||
|
||||
if (t > KAMI_SHOCKWAVE2_STARTTIME && t < KAMI_SHOCKWAVE2_ENDTIME) {
|
||||
// 2nd kamikaze shockwave
|
||||
if (le->angles.trBase[0] == 0 &&
|
||||
le->angles.trBase[1] == 0 &&
|
||||
le->angles.trBase[2] == 0) {
|
||||
le->angles.trBase[0] = random() * 360;
|
||||
le->angles.trBase[1] = random() * 360;
|
||||
le->angles.trBase[2] = random() * 360;
|
||||
}
|
||||
else {
|
||||
c = 0;
|
||||
}
|
||||
memset(&shockwave, 0, sizeof(shockwave));
|
||||
shockwave.hModel = cgs.media.kamikazeShockWave;
|
||||
shockwave.reType = RT_MODEL;
|
||||
shockwave.shaderTime = re->shaderTime;
|
||||
VectorCopy(re->origin, shockwave.origin);
|
||||
|
||||
test[0] = le->angles.trBase[0];
|
||||
test[1] = le->angles.trBase[1];
|
||||
test[2] = le->angles.trBase[2];
|
||||
AnglesToAxis( test, axis );
|
||||
|
||||
c = (float)(t - KAMI_SHOCKWAVE2_STARTTIME) / (float)(KAMI_SHOCKWAVE2_ENDTIME - KAMI_SHOCKWAVE2_STARTTIME);
|
||||
VectorScale( axis[0], c * KAMI_SHOCKWAVE2_MAXRADIUS / KAMI_SHOCKWAVEMODEL_RADIUS, shockwave.axis[0] );
|
||||
VectorScale( axis[1], c * KAMI_SHOCKWAVE2_MAXRADIUS / KAMI_SHOCKWAVEMODEL_RADIUS, shockwave.axis[1] );
|
||||
VectorScale( axis[2], c * KAMI_SHOCKWAVE2_MAXRADIUS / KAMI_SHOCKWAVEMODEL_RADIUS, shockwave.axis[2] );
|
||||
shockwave.nonNormalizedAxes = qtrue;
|
||||
|
||||
if (t > KAMI_SHOCKWAVE2FADE_STARTTIME) {
|
||||
c = (float)(t - KAMI_SHOCKWAVE2FADE_STARTTIME) / (float)(KAMI_SHOCKWAVE2_ENDTIME - KAMI_SHOCKWAVE2FADE_STARTTIME);
|
||||
}
|
||||
else {
|
||||
c = 0;
|
||||
}
|
||||
c *= 0xff;
|
||||
shockwave.shaderRGBA[0] = 0xff - c;
|
||||
shockwave.shaderRGBA[1] = 0xff - c;
|
||||
shockwave.shaderRGBA[2] = 0xff - c;
|
||||
shockwave.shaderRGBA[3] = 0xff - c;
|
||||
|
||||
trap_R_AddRefEntityToScene( &shockwave );
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
===================
|
||||
CG_AddInvulnerabilityImpact
|
||||
===================
|
||||
*/
|
||||
void CG_AddInvulnerabilityImpact( localEntity_t *le ) {
|
||||
trap_R_AddRefEntityToScene( &le->refEntity );
|
||||
}
|
||||
|
||||
/*
|
||||
===================
|
||||
CG_AddInvulnerabilityJuiced
|
||||
===================
|
||||
*/
|
||||
void CG_AddInvulnerabilityJuiced( localEntity_t *le ) {
|
||||
int t;
|
||||
|
||||
t = cg.time - le->startTime;
|
||||
if ( t > 3000 ) {
|
||||
le->refEntity.axis[0][0] = (float) 1.0 + 0.3 * (t - 3000) / 2000;
|
||||
le->refEntity.axis[1][1] = (float) 1.0 + 0.3 * (t - 3000) / 2000;
|
||||
le->refEntity.axis[2][2] = (float) 0.7 + 0.3 * (2000 - (t - 3000)) / 2000;
|
||||
}
|
||||
if ( t > 5000 ) {
|
||||
le->endTime = 0;
|
||||
CG_GibPlayer( le->refEntity.origin );
|
||||
}
|
||||
else {
|
||||
trap_R_AddRefEntityToScene( &le->refEntity );
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
===================
|
||||
CG_AddRefEntity
|
||||
===================
|
||||
*/
|
||||
void CG_AddRefEntity( localEntity_t *le ) {
|
||||
if (le->endTime < cg.time) {
|
||||
CG_FreeLocalEntity( le );
|
||||
return;
|
||||
}
|
||||
trap_R_AddRefEntityToScene( &le->refEntity );
|
||||
}
|
||||
|
||||
#endif
|
||||
/*
|
||||
===================
|
||||
CG_AddScorePlum
|
||||
===================
|
||||
*/
|
||||
#define NUMBER_SIZE 8
|
||||
|
||||
void CG_AddScorePlum( localEntity_t *le ) {
|
||||
refEntity_t *re;
|
||||
vec3_t origin, delta, dir, vec, up = {0, 0, 1};
|
||||
float c, len;
|
||||
int i, score, digits[10], numdigits, negative;
|
||||
|
||||
re = &le->refEntity;
|
||||
|
||||
c = ( le->endTime - cg.time ) * le->lifeRate;
|
||||
|
||||
score = le->radius;
|
||||
if (score < 0) {
|
||||
re->shaderRGBA[0] = 0xff;
|
||||
re->shaderRGBA[1] = 0x11;
|
||||
re->shaderRGBA[2] = 0x11;
|
||||
}
|
||||
else {
|
||||
re->shaderRGBA[0] = 0xff;
|
||||
re->shaderRGBA[1] = 0xff;
|
||||
re->shaderRGBA[2] = 0xff;
|
||||
if (score >= 50) {
|
||||
re->shaderRGBA[1] = 0;
|
||||
} else if (score >= 20) {
|
||||
re->shaderRGBA[0] = re->shaderRGBA[1] = 0;
|
||||
} else if (score >= 10) {
|
||||
re->shaderRGBA[2] = 0;
|
||||
} else if (score >= 2) {
|
||||
re->shaderRGBA[0] = re->shaderRGBA[2] = 0;
|
||||
}
|
||||
|
||||
}
|
||||
if (c < 0.25)
|
||||
re->shaderRGBA[3] = 0xff * 4 * c;
|
||||
else
|
||||
re->shaderRGBA[3] = 0xff;
|
||||
|
||||
re->radius = NUMBER_SIZE / 2;
|
||||
|
||||
VectorCopy(le->pos.trBase, origin);
|
||||
origin[2] += 110 - c * 100;
|
||||
|
||||
VectorSubtract(cg.refdef.vieworg, origin, dir);
|
||||
CrossProduct(dir, up, vec);
|
||||
VectorNormalize(vec);
|
||||
|
||||
VectorMA(origin, -10 + 20 * sin(c * 2 * M_PI), vec, origin);
|
||||
|
||||
// if the view would be "inside" the sprite, kill the sprite
|
||||
// so it doesn't add too much overdraw
|
||||
VectorSubtract( origin, cg.refdef.vieworg, delta );
|
||||
len = VectorLength( delta );
|
||||
if ( len < 20 ) {
|
||||
CG_FreeLocalEntity( le );
|
||||
return;
|
||||
}
|
||||
|
||||
negative = qfalse;
|
||||
if (score < 0) {
|
||||
negative = qtrue;
|
||||
score = -score;
|
||||
}
|
||||
|
||||
for (numdigits = 0; !(numdigits && !score); numdigits++) {
|
||||
digits[numdigits] = score % 10;
|
||||
score = score / 10;
|
||||
}
|
||||
|
||||
if (negative) {
|
||||
digits[numdigits] = 10;
|
||||
numdigits++;
|
||||
}
|
||||
|
||||
for (i = 0; i < numdigits; i++) {
|
||||
VectorMA(origin, (float) (((float) numdigits / 2) - i) * NUMBER_SIZE, vec, re->origin);
|
||||
re->customShader = cgs.media.numberShaders[digits[numdigits-1-i]];
|
||||
trap_R_AddRefEntityToScene( re );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
//==============================================================================
|
||||
|
||||
/*
|
||||
===================
|
||||
CG_AddLocalEntities
|
||||
|
||||
===================
|
||||
*/
|
||||
void CG_AddLocalEntities( void ) {
|
||||
localEntity_t *le, *next;
|
||||
|
||||
// walk the list backwards, so any new local entities generated
|
||||
// (trails, marks, etc) will be present this frame
|
||||
le = cg_activeLocalEntities.prev;
|
||||
for ( ; le != &cg_activeLocalEntities ; le = next ) {
|
||||
// grab next now, so if the local entity is freed we
|
||||
// still have it
|
||||
next = le->prev;
|
||||
|
||||
if ( cg.time >= le->endTime ) {
|
||||
CG_FreeLocalEntity( le );
|
||||
continue;
|
||||
}
|
||||
switch ( le->leType ) {
|
||||
default:
|
||||
CG_Error( "Bad leType: %i", le->leType );
|
||||
break;
|
||||
|
||||
case LE_MARK:
|
||||
break;
|
||||
|
||||
case LE_SPRITE_EXPLOSION:
|
||||
CG_AddSpriteExplosion( le );
|
||||
break;
|
||||
|
||||
case LE_EXPLOSION:
|
||||
CG_AddExplosion( le );
|
||||
break;
|
||||
|
||||
case LE_FRAGMENT: // gibs and brass
|
||||
CG_AddFragment( le );
|
||||
break;
|
||||
|
||||
case LE_MOVE_SCALE_FADE: // water bubbles
|
||||
CG_AddMoveScaleFade( le );
|
||||
break;
|
||||
|
||||
case LE_FADE_RGB: // teleporters, railtrails
|
||||
CG_AddFadeRGB( le );
|
||||
break;
|
||||
|
||||
case LE_FALL_SCALE_FADE: // gib blood trails
|
||||
CG_AddFallScaleFade( le );
|
||||
break;
|
||||
|
||||
case LE_SCALE_FADE: // rocket trails
|
||||
CG_AddScaleFade( le );
|
||||
break;
|
||||
|
||||
case LE_SCOREPLUM:
|
||||
CG_AddScorePlum( le );
|
||||
break;
|
||||
|
||||
#ifdef MISSIONPACK
|
||||
case LE_KAMIKAZE:
|
||||
CG_AddKamikaze( le );
|
||||
break;
|
||||
case LE_INVULIMPACT:
|
||||
CG_AddInvulnerabilityImpact( le );
|
||||
break;
|
||||
case LE_INVULJUICED:
|
||||
CG_AddInvulnerabilityJuiced( le );
|
||||
break;
|
||||
case LE_SHOWREFENTITY:
|
||||
CG_AddRefEntity( le );
|
||||
break;
|
||||
#endif
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
Loading…
Add table
Add a link
Reference in a new issue