diff options
| author | Paweł Redman <pawel.redman@gmail.com> | 2017-03-22 17:56:34 +0100 |
|---|---|---|
| committer | Paweł Redman <pawel.redman@gmail.com> | 2017-03-22 17:56:34 +0100 |
| commit | 6a777afc079c2a8d3af3ecd2145fe8dd50567a39 (patch) | |
| tree | 520f4489cebf8564ef6cb27064ceea45cbc005b3 /src/cgame/cg_ents.c | |
Diffstat (limited to 'src/cgame/cg_ents.c')
| -rw-r--r-- | src/cgame/cg_ents.c | 1256 |
1 files changed, 1256 insertions, 0 deletions
diff --git a/src/cgame/cg_ents.c b/src/cgame/cg_ents.c new file mode 100644 index 0000000..feb777a --- /dev/null +++ b/src/cgame/cg_ents.c @@ -0,0 +1,1256 @@ +/*
+===========================================================================
+Copyright (C) 1999-2005 Id Software, Inc.
+Copyright (C) 2000-2006 Tim Angus
+
+This file is part of Tremulous.
+
+Tremulous 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.
+
+Tremulous 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 Tremulous; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+===========================================================================
+*/
+
+// cg_ents.c -- present snapshot entities, happens every single frame
+
+
+#include "cg_local.h"
+
+/*
+======================
+CG_DrawBoxFace
+
+Draws a bounding box face
+======================
+*/
+static void CG_DrawBoxFace( vec3_t a, vec3_t b, vec3_t c, vec3_t d )
+{
+ polyVert_t verts[ 4 ];
+ vec4_t color = { 255.0f, 0.0f, 0.0f, 128.0f };
+
+ VectorCopy( d, verts[ 0 ].xyz );
+ verts[ 0 ].st[ 0 ] = 1;
+ verts[ 0 ].st[ 1 ] = 1;
+ Vector4Copy( color, verts[ 0 ].modulate );
+
+ VectorCopy( c, verts[ 1 ].xyz );
+ verts[ 1 ].st[ 0 ] = 1;
+ verts[ 1 ].st[ 1 ] = 0;
+ Vector4Copy( color, verts[ 1 ].modulate );
+
+ VectorCopy( b, verts[ 2 ].xyz );
+ verts[ 2 ].st[ 0 ] = 0;
+ verts[ 2 ].st[ 1 ] = 0;
+ Vector4Copy( color, verts[ 2 ].modulate );
+
+ VectorCopy( a, verts[ 3 ].xyz );
+ verts[ 3 ].st[ 0 ] = 0;
+ verts[ 3 ].st[ 1 ] = 1;
+ Vector4Copy( color, verts[ 3 ].modulate );
+
+ trap_R_AddPolyToScene( cgs.media.outlineShader, 4, verts );
+}
+
+/*
+======================
+CG_DrawBoundingBox
+
+Draws a bounding box
+======================
+*/
+void CG_DrawBoundingBox( vec3_t origin, vec3_t mins, vec3_t maxs )
+{
+ vec3_t ppp, mpp, mmp, pmp;
+ vec3_t mmm, pmm, ppm, mpm;
+
+ ppp[ 0 ] = origin[ 0 ] + maxs[ 0 ];
+ ppp[ 1 ] = origin[ 1 ] + maxs[ 1 ];
+ ppp[ 2 ] = origin[ 2 ] + maxs[ 2 ];
+
+ mpp[ 0 ] = origin[ 0 ] + mins[ 0 ];
+ mpp[ 1 ] = origin[ 1 ] + maxs[ 1 ];
+ mpp[ 2 ] = origin[ 2 ] + maxs[ 2 ];
+
+ mmp[ 0 ] = origin[ 0 ] + mins[ 0 ];
+ mmp[ 1 ] = origin[ 1 ] + mins[ 1 ];
+ mmp[ 2 ] = origin[ 2 ] + maxs[ 2 ];
+
+ pmp[ 0 ] = origin[ 0 ] + maxs[ 0 ];
+ pmp[ 1 ] = origin[ 1 ] + mins[ 1 ];
+ pmp[ 2 ] = origin[ 2 ] + maxs[ 2 ];
+
+ ppm[ 0 ] = origin[ 0 ] + maxs[ 0 ];
+ ppm[ 1 ] = origin[ 1 ] + maxs[ 1 ];
+ ppm[ 2 ] = origin[ 2 ] + mins[ 2 ];
+
+ mpm[ 0 ] = origin[ 0 ] + mins[ 0 ];
+ mpm[ 1 ] = origin[ 1 ] + maxs[ 1 ];
+ mpm[ 2 ] = origin[ 2 ] + mins[ 2 ];
+
+ mmm[ 0 ] = origin[ 0 ] + mins[ 0 ];
+ mmm[ 1 ] = origin[ 1 ] + mins[ 1 ];
+ mmm[ 2 ] = origin[ 2 ] + mins[ 2 ];
+
+ pmm[ 0 ] = origin[ 0 ] + maxs[ 0 ];
+ pmm[ 1 ] = origin[ 1 ] + mins[ 1 ];
+ pmm[ 2 ] = origin[ 2 ] + mins[ 2 ];
+
+ //phew!
+
+ CG_DrawBoxFace( ppp, mpp, mmp, pmp );
+ CG_DrawBoxFace( ppp, pmp, pmm, ppm );
+ CG_DrawBoxFace( mpp, ppp, ppm, mpm );
+ CG_DrawBoxFace( mmp, mpp, mpm, mmm );
+ CG_DrawBoxFace( pmp, mmp, mmm, pmm );
+ CG_DrawBoxFace( mmm, mpm, ppm, pmm );
+}
+
+
+/*
+======================
+CG_PositionEntityOnTag
+
+Modifies the entities position and axis by the given
+tag location
+======================
+*/
+void CG_PositionEntityOnTag( refEntity_t *entity, const refEntity_t *parent,
+ qhandle_t parentModel, char *tagName )
+{
+ int i;
+ orientation_t lerped;
+
+ // lerp the tag
+ trap_R_LerpTag( &lerped, parentModel, parent->oldframe, parent->frame,
+ 1.0 - parent->backlerp, tagName );
+
+ // FIXME: allow origin offsets along tag?
+ VectorCopy( parent->origin, entity->origin );
+ for( i = 0; i < 3; i++ )
+ VectorMA( entity->origin, lerped.origin[ i ], parent->axis[ i ], entity->origin );
+
+ // had to cast away the const to avoid compiler problems...
+ MatrixMultiply( lerped.axis, ( (refEntity_t *)parent )->axis, entity->axis );
+ entity->backlerp = parent->backlerp;
+}
+
+
+/*
+======================
+CG_PositionRotatedEntityOnTag
+
+Modifies the entities position and axis by the given
+tag location
+======================
+*/
+void CG_PositionRotatedEntityOnTag( refEntity_t *entity, const refEntity_t *parent,
+ qhandle_t parentModel, char *tagName )
+{
+ int i;
+ orientation_t lerped;
+ vec3_t tempAxis[ 3 ];
+
+//AxisClear( entity->axis );
+ // lerp the tag
+ trap_R_LerpTag( &lerped, parentModel, parent->oldframe, parent->frame,
+ 1.0 - parent->backlerp, tagName );
+
+ // FIXME: allow origin offsets along tag?
+ VectorCopy( parent->origin, entity->origin );
+ for( i = 0; i < 3; i++ )
+ VectorMA( entity->origin, lerped.origin[ i ], parent->axis[ i ], entity->origin );
+
+ // had to cast away the const to avoid compiler problems...
+ MatrixMultiply( entity->axis, lerped.axis, tempAxis );
+ MatrixMultiply( tempAxis, ( (refEntity_t *)parent )->axis, entity->axis );
+}
+
+
+
+/*
+==========================================================================
+
+FUNCTIONS CALLED EACH FRAME
+
+==========================================================================
+*/
+
+/*
+======================
+CG_SetEntitySoundPosition
+
+Also called by event processing code
+======================
+*/
+void CG_SetEntitySoundPosition( centity_t *cent )
+{
+ if( cent->currentState.solid == SOLID_BMODEL )
+ {
+ vec3_t origin;
+ float *v;
+
+ v = cgs.inlineModelMidpoints[ cent->currentState.modelindex ];
+ VectorAdd( cent->lerpOrigin, v, origin );
+ trap_S_UpdateEntityPosition( cent->currentState.number, origin );
+ }
+ else
+ trap_S_UpdateEntityPosition( cent->currentState.number, cent->lerpOrigin );
+}
+
+/*
+==================
+CG_EntityEffects
+
+Add continuous entity effects, like local entity emission and lighting
+==================
+*/
+static void CG_EntityEffects( centity_t *cent )
+{
+ // update sound origins
+ CG_SetEntitySoundPosition( cent );
+
+ // add loop sound
+ if( cent->currentState.loopSound )
+ {
+ if( cent->currentState.eType != ET_SPEAKER )
+ {
+ trap_S_AddLoopingSound( cent->currentState.number, cent->lerpOrigin, vec3_origin,
+ cgs.gameSounds[ cent->currentState.loopSound ] );
+ }
+ else
+ {
+ trap_S_AddRealLoopingSound( cent->currentState.number, cent->lerpOrigin, vec3_origin,
+ cgs.gameSounds[ cent->currentState.loopSound ] );
+ }
+ }
+
+
+ // constant light glow
+ if ( cent->currentState.constantLight )
+ {
+ int cl;
+ int i, r, g, b;
+
+ cl = cent->currentState.constantLight;
+ r = cl & 255;
+ g = ( cl >> 8 ) & 255;
+ b = ( cl >> 16 ) & 255;
+ i = ( ( cl >> 24 ) & 255 ) * 4;
+ trap_R_AddLightToScene( cent->lerpOrigin, i, r, g, b );
+ }
+
+ if( CG_IsTrailSystemValid( ¢->muzzleTS ) )
+ {
+ //FIXME hack to prevent tesla trails reaching too far
+ if( cent->currentState.eType == ET_BUILDABLE )
+ {
+ vec3_t front, back;
+
+ CG_AttachmentPoint( ¢->muzzleTS->frontAttachment, front );
+ CG_AttachmentPoint( ¢->muzzleTS->backAttachment, back );
+
+ if( Distance( front, back ) > ( TESLAGEN_RANGE * M_ROOT3 ) )
+ CG_DestroyTrailSystem( ¢->muzzleTS );
+ }
+
+ if( cg.time > cent->muzzleTSDeathTime && CG_IsTrailSystemValid( ¢->muzzleTS ) )
+ CG_DestroyTrailSystem( ¢->muzzleTS );
+ }
+}
+
+
+/*
+==================
+CG_General
+==================
+*/
+static void CG_General( centity_t *cent )
+{
+ refEntity_t ent;
+ entityState_t *s1;
+
+ s1 = ¢->currentState;
+
+ // if set to invisible, skip
+ if( !s1->modelindex )
+ return;
+
+ memset( &ent, 0, sizeof( ent ) );
+
+ // set frame
+
+ ent.frame = s1->frame;
+ ent.oldframe = ent.frame;
+ ent.backlerp = 0;
+
+ VectorCopy( cent->lerpOrigin, ent.origin);
+ VectorCopy( cent->lerpOrigin, ent.oldorigin);
+
+ ent.hModel = cgs.gameModels[ s1->modelindex ];
+
+ // player model
+ if( s1->number == cg.snap->ps.clientNum )
+ ent.renderfx |= RF_THIRD_PERSON; // only draw from mirrors
+
+ // convert angles to axis
+ AnglesToAxis( cent->lerpAngles, ent.axis );
+
+ // add to refresh list
+ trap_R_AddRefEntityToScene( &ent );
+}
+
+/*
+==================
+CG_Speaker
+
+Speaker entities can automatically play sounds
+==================
+*/
+static void CG_Speaker( centity_t *cent )
+{
+ if( ! cent->currentState.clientNum )
+ { // FIXME: use something other than clientNum...
+ return; // not auto triggering
+ }
+
+ if( cg.time < cent->miscTime )
+ return;
+
+ trap_S_StartSound( NULL, cent->currentState.number, CHAN_ITEM, cgs.gameSounds[ cent->currentState.eventParm ] );
+
+ // ent->s.frame = ent->wait * 10;
+ // ent->s.clientNum = ent->random * 10;
+ cent->miscTime = cg.time + cent->currentState.frame * 100 + cent->currentState.clientNum * 100 * crandom( );
+}
+
+
+//============================================================================
+
+/*
+===============
+CG_LaunchMissile
+===============
+*/
+static void CG_LaunchMissile( centity_t *cent )
+{
+ entityState_t *es;
+ const weaponInfo_t *wi;
+ particleSystem_t *ps;
+ trailSystem_t *ts;
+ weapon_t weapon;
+ weaponMode_t weaponMode;
+
+ es = ¢->currentState;
+
+ weapon = es->weapon;
+ if( weapon > WP_NUM_WEAPONS )
+ weapon = WP_NONE;
+
+ wi = &cg_weapons[ weapon ];
+ weaponMode = es->generic1;
+
+ if( wi->wim[ weaponMode ].missileParticleSystem )
+ {
+ ps = CG_SpawnNewParticleSystem( wi->wim[ weaponMode ].missileParticleSystem );
+
+ if( CG_IsParticleSystemValid( &ps ) )
+ {
+ CG_SetAttachmentCent( &ps->attachment, cent );
+ CG_AttachToCent( &ps->attachment );
+ }
+ }
+
+ if( wi->wim[ weaponMode ].missileTrailSystem )
+ {
+ ts = CG_SpawnNewTrailSystem( wi->wim[ weaponMode ].missileTrailSystem );
+
+ if( CG_IsTrailSystemValid( &ts ) )
+ {
+ CG_SetAttachmentCent( &ts->frontAttachment, cent );
+ CG_AttachToCent( &ts->frontAttachment );
+ }
+ }
+}
+
+/*
+===============
+CG_Missile
+===============
+*/
+static void CG_Missile( centity_t *cent )
+{
+ refEntity_t ent;
+ entityState_t *es;
+ const weaponInfo_t *wi;
+ weapon_t weapon;
+ weaponMode_t weaponMode;
+ const weaponInfoMode_t *wim;
+
+ es = ¢->currentState;
+
+ weapon = es->weapon;
+ if( weapon > WP_NUM_WEAPONS )
+ weapon = WP_NONE;
+
+ wi = &cg_weapons[ weapon ];
+ weaponMode = es->generic1;
+
+ wim = &wi->wim[ weaponMode ];
+
+ // calculate the axis
+ VectorCopy( es->angles, cent->lerpAngles );
+
+ // add dynamic light
+ if( wim->missileDlight )
+ {
+ trap_R_AddLightToScene( cent->lerpOrigin, wim->missileDlight,
+ wim->missileDlightColor[ 0 ],
+ wim->missileDlightColor[ 1 ],
+ wim->missileDlightColor[ 2 ] );
+ }
+
+ // add missile sound
+ if( wim->missileSound )
+ {
+ vec3_t velocity;
+
+ BG_EvaluateTrajectoryDelta( ¢->currentState.pos, cg.time, velocity );
+
+ trap_S_AddLoopingSound( cent->currentState.number, cent->lerpOrigin, velocity, wim->missileSound );
+ }
+
+ // create the render entity
+ memset( &ent, 0, sizeof( ent ) );
+ VectorCopy( cent->lerpOrigin, ent.origin );
+ VectorCopy( cent->lerpOrigin, ent.oldorigin );
+
+ if( wim->usesSpriteMissle )
+ {
+ ent.reType = RT_SPRITE;
+ ent.radius = wim->missileSpriteSize;
+ ent.rotation = 0;
+ ent.customShader = wim->missileSprite;
+ ent.shaderRGBA[ 0 ] = 0xFF;
+ ent.shaderRGBA[ 1 ] = 0xFF;
+ ent.shaderRGBA[ 2 ] = 0xFF;
+ ent.shaderRGBA[ 3 ] = 0xFF;
+ }
+ else
+ {
+ ent.hModel = wim->missileModel;
+ ent.renderfx = wim->missileRenderfx | RF_NOSHADOW;
+
+ // convert direction of travel into axis
+ if( VectorNormalize2( es->pos.trDelta, ent.axis[ 0 ] ) == 0 )
+ ent.axis[ 0 ][ 2 ] = 1;
+
+ // spin as it moves
+ if( es->pos.trType != TR_STATIONARY && wim->missileRotates )
+ RotateAroundDirection( ent.axis, cg.time / 4 );
+ else
+ RotateAroundDirection( ent.axis, es->time );
+
+ if( wim->missileAnimates )
+ {
+ int timeSinceStart = cg.time - es->time;
+
+ if( wim->missileAnimLooping )
+ {
+ ent.frame = wim->missileAnimStartFrame +
+ (int)( ( timeSinceStart / 1000.0f ) * wim->missileAnimFrameRate ) %
+ wim->missileAnimNumFrames;
+ }
+ else
+ {
+ ent.frame = wim->missileAnimStartFrame +
+ (int)( ( timeSinceStart / 1000.0f ) * wim->missileAnimFrameRate );
+
+ if( ent.frame > ( wim->missileAnimStartFrame + wim->missileAnimNumFrames ) )
+ ent.frame = wim->missileAnimStartFrame + wim->missileAnimNumFrames;
+ }
+ }
+ }
+
+ //only refresh if there is something to display
+ if( wim->missileSprite || wim->missileModel )
+ trap_R_AddRefEntityToScene( &ent );
+}
+
+/*
+===============
+CG_Mover
+===============
+*/
+static void CG_Mover( centity_t *cent )
+{
+ refEntity_t ent;
+ entityState_t *s1;
+
+ s1 = ¢->currentState;
+
+ // create the render entity
+ memset( &ent, 0, sizeof( ent ) );
+ VectorCopy( cent->lerpOrigin, ent.origin );
+ VectorCopy( cent->lerpOrigin, ent.oldorigin );
+ AnglesToAxis( cent->lerpAngles, ent.axis );
+
+ ent.renderfx = RF_NOSHADOW;
+
+ // flicker between two skins (FIXME?)
+ ent.skinNum = ( cg.time >> 6 ) & 1;
+
+ // get the model, either as a bmodel or a modelindex
+ if( s1->solid == SOLID_BMODEL )
+ ent.hModel = cgs.inlineDrawModel[ s1->modelindex ];
+ else
+ ent.hModel = cgs.gameModels[ s1->modelindex ];
+
+ // add to refresh list
+ trap_R_AddRefEntityToScene( &ent );
+
+ // add the secondary model
+ if( s1->modelindex2 )
+ {
+ ent.skinNum = 0;
+ ent.hModel = cgs.gameModels[ s1->modelindex2 ];
+ trap_R_AddRefEntityToScene( &ent );
+ }
+
+}
+
+/*
+===============
+CG_Beam
+
+Also called as an event
+===============
+*/
+void CG_Beam( centity_t *cent )
+{
+ refEntity_t ent;
+ entityState_t *s1;
+
+ s1 = ¢->currentState;
+
+ // create the render entity
+ memset( &ent, 0, sizeof( ent ) );
+ VectorCopy( s1->pos.trBase, ent.origin );
+ VectorCopy( s1->origin2, ent.oldorigin );
+ AxisClear( ent.axis );
+ ent.reType = RT_BEAM;
+
+ ent.renderfx = RF_NOSHADOW;
+
+ // add to refresh list
+ trap_R_AddRefEntityToScene( &ent );
+}
+
+
+/*
+===============
+CG_Portal
+===============
+*/
+static void CG_Portal( centity_t *cent )
+{
+ refEntity_t ent;
+ entityState_t *s1;
+
+ s1 = ¢->currentState;
+
+ // create the render entity
+ memset( &ent, 0, sizeof( ent ) );
+ VectorCopy( cent->lerpOrigin, ent.origin );
+ VectorCopy( s1->origin2, ent.oldorigin );
+ ByteToDir( s1->eventParm, ent.axis[ 0 ] );
+ PerpendicularVector( ent.axis[ 1 ], ent.axis[ 0 ] );
+
+ // negating this tends to get the directions like they want
+ // we really should have a camera roll value
+ VectorSubtract( vec3_origin, ent.axis[ 1 ], ent.axis[ 1 ] );
+
+ CrossProduct( ent.axis[ 0 ], ent.axis[ 1 ], ent.axis[ 2 ] );
+ ent.reType = RT_PORTALSURFACE;
+ ent.oldframe = s1->powerups;
+ ent.frame = s1->frame; // rotation speed
+ ent.skinNum = s1->clientNum / 256.0 * 360; // roll offset
+
+ // add to refresh list
+ trap_R_AddRefEntityToScene( &ent );
+}
+
+//============================================================================
+
+#define SETBOUNDS(v1,v2,r) ((v1)[0]=(-r/2),(v1)[1]=(-r/2),(v1)[2]=(-r/2),\
+ (v2)[0]=(r/2),(v2)[1]=(r/2),(v2)[2]=(r/2))
+#define RADIUSSTEP 0.5f
+
+#define FLARE_OFF 0
+#define FLARE_NOFADE 1
+#define FLARE_TIMEFADE 2
+#define FLARE_REALFADE 3
+
+/*
+=========================
+CG_LightFlare
+=========================
+*/
+static void CG_LightFlare( centity_t *cent )
+{
+ refEntity_t flare;
+ entityState_t *es;
+ vec3_t forward, delta;
+ float len;
+ trace_t tr;
+ float maxAngle;
+ vec3_t mins, maxs, start, end;
+ float srcRadius, srLocal, ratio = 1.0f;
+ int entityNum;
+
+ es = ¢->currentState;
+
+ if( cg.renderingThirdPerson )
+ entityNum = MAGIC_TRACE_HACK;
+ else
+ entityNum = cg.predictedPlayerState.clientNum;
+
+ //don't draw light flares
+ if( cg_lightFlare.integer == FLARE_OFF )
+ return;
+
+ //flare is "off"
+ if( es->eFlags & EF_NODRAW )
+ return;
+
+ CG_Trace( &tr, cg.refdef.vieworg, NULL, NULL, es->angles2,
+ entityNum, MASK_SHOT );
+
+ //if there is no los between the view and the flare source
+ //it definately cannot be seen
+ if( tr.fraction < 1.0f || tr.allsolid )
+ return;
+
+ memset( &flare, 0, sizeof( flare ) );
+
+ flare.reType = RT_SPRITE;
+ flare.customShader = cgs.gameShaders[ es->modelindex ];
+ flare.shaderRGBA[ 0 ] = 0xFF;
+ flare.shaderRGBA[ 1 ] = 0xFF;
+ flare.shaderRGBA[ 2 ] = 0xFF;
+ flare.shaderRGBA[ 3 ] = 0xFF;
+
+ //flares always drawn before the rest of the scene
+ flare.renderfx |= RF_DEPTHHACK;
+
+ //bunch of geometry
+ AngleVectors( es->angles, forward, NULL, NULL );
+ VectorCopy( cent->lerpOrigin, flare.origin );
+ VectorSubtract( flare.origin, cg.refdef.vieworg, delta );
+ len = VectorLength( delta );
+ VectorNormalize( delta );
+
+ //flare is too close to camera to be drawn
+ if( len < es->generic1 )
+ return;
+
+ //don't bother for flares behind the view plane
+ if( DotProduct( delta, cg.refdef.viewaxis[ 0 ] ) < 0.0 )
+ return;
+
+ //only recalculate radius and ratio every three frames
+ if( !( cg.clientFrame % 2 ) )
+ {
+ //can only see the flare when in front of it
+ flare.radius = len / es->origin2[ 0 ];
+
+ if( es->origin2[ 2 ] == 0 )
+ srcRadius = srLocal = flare.radius / 2.0f;
+ else
+ srcRadius = srLocal = len / es->origin2[ 2 ];
+
+ maxAngle = es->origin2[ 1 ];
+
+ if( maxAngle > 0.0f )
+ {
+ float radiusMod = 1.0f - ( 180.0f - RAD2DEG(
+ acos( DotProduct( delta, forward ) ) ) ) / maxAngle;
+
+ if( radiusMod < 0.0f )
+ radiusMod = 0.0f;
+
+ flare.radius *= radiusMod;
+ }
+
+ if( flare.radius < 0.0f )
+ flare.radius = 0.0f;
+
+ VectorMA( flare.origin, -flare.radius, delta, end );
+ VectorMA( cg.refdef.vieworg, flare.radius, delta, start );
+
+ if( cg_lightFlare.integer == FLARE_REALFADE )
+ {
+ //"correct" flares
+ CG_BiSphereTrace( &tr, cg.refdef.vieworg, end,
+ 1.0f, srcRadius, entityNum, MASK_SHOT );
+
+ if( tr.fraction < 1.0f )
+ ratio = tr.lateralFraction;
+ else
+ ratio = 1.0f;
+ }
+ else if( cg_lightFlare.integer == FLARE_TIMEFADE )
+ {
+ //draw timed flares
+ SETBOUNDS( mins, maxs, srcRadius );
+ CG_Trace( &tr, start, mins, maxs, end,
+ entityNum, MASK_SHOT );
+
+ if( ( tr.fraction < 1.0f || tr.startsolid ) && cent->lfs.status )
+ {
+ cent->lfs.status = qfalse;
+ cent->lfs.lastTime = cg.time;
+ }
+ else if( ( tr.fraction == 1.0f && !tr.startsolid ) && !cent->lfs.status )
+ {
+ cent->lfs.status = qtrue;
+ cent->lfs.lastTime = cg.time;
+ }
+
+ //fade flare up
+ if( cent->lfs.status )
+ {
+ if( cent->lfs.lastTime + es->time > cg.time )
+ ratio = (float)( cg.time - cent->lfs.lastTime ) / es->time;
+ }
+
+ //fade flare down
+ if( !cent->lfs.status )
+ {
+ if( cent->lfs.lastTime + es->time > cg.time )
+ {
+ ratio = (float)( cg.time - cent->lfs.lastTime ) / es->time;
+ ratio = 1.0f - ratio;
+ }
+ else
+ ratio = 0.0f;
+ }
+ }
+ else if( cg_lightFlare.integer == FLARE_NOFADE )
+ {
+ //draw nofade flares
+ SETBOUNDS( mins, maxs, srcRadius );
+ CG_Trace( &tr, start, mins, maxs, end,
+ entityNum, MASK_SHOT );
+
+ //flare source occluded
+ if( ( tr.fraction < 1.0f || tr.startsolid ) )
+ ratio = 0.0f;
+ }
+ }
+ else
+ {
+ ratio = cent->lfs.lastRatio;
+ flare.radius = cent->lfs.lastRadius;
+ }
+
+ cent->lfs.lastRatio = ratio;
+ cent->lfs.lastRadius = flare.radius;
+
+ if( ratio < 1.0f )
+ {
+ flare.radius *= ratio;
+ flare.shaderRGBA[ 3 ] = (byte)( (float)flare.shaderRGBA[ 3 ] * ratio );
+ }
+
+ if( flare.radius <= 0.0f )
+ return;
+
+ trap_R_AddRefEntityToScene( &flare );
+}
+
+/*
+=========================
+CG_Lev2ZapChain
+=========================
+*/
+static void CG_Lev2ZapChain( centity_t *cent )
+{
+ int i;
+ entityState_t *es;
+ centity_t *source = NULL, *target = NULL;
+
+ es = ¢->currentState;
+
+ for( i = 0; i <= 2; i++ )
+ {
+ switch( i )
+ {
+ case 0:
+ if( es->time <= 0 )
+ continue;
+
+ source = &cg_entities[ es->powerups ];
+ target = &cg_entities[ es->time ];
+ break;
+
+ case 1:
+ if( es->time2 <= 0 )
+ continue;
+
+ source = &cg_entities[ es->time ];
+ target = &cg_entities[ es->time2 ];
+ break;
+
+ case 2:
+ if( es->constantLight <= 0 )
+ continue;
+
+ source = &cg_entities[ es->time2 ];
+ target = &cg_entities[ es->constantLight ];
+ break;
+ }
+
+ if( !CG_IsTrailSystemValid( ¢->level2ZapTS[ i ] ) )
+ cent->level2ZapTS[ i ] = CG_SpawnNewTrailSystem( cgs.media.level2ZapTS );
+
+ if( CG_IsTrailSystemValid( ¢->level2ZapTS[ i ] ) )
+ {
+ CG_SetAttachmentCent( ¢->level2ZapTS[ i ]->frontAttachment, source );
+ CG_SetAttachmentCent( ¢->level2ZapTS[ i ]->backAttachment, target );
+ CG_AttachToCent( ¢->level2ZapTS[ i ]->frontAttachment );
+ CG_AttachToCent( ¢->level2ZapTS[ i ]->backAttachment );
+ }
+ }
+}
+
+/*
+=========================
+CG_AdjustPositionForMover
+
+Also called by client movement prediction code
+=========================
+*/
+void CG_AdjustPositionForMover( const vec3_t in, int moverNum, int fromTime, int toTime, vec3_t out )
+{
+ centity_t *cent;
+ vec3_t oldOrigin, origin, deltaOrigin;
+ vec3_t oldAngles, angles, deltaAngles;
+
+ if( moverNum <= 0 || moverNum >= ENTITYNUM_MAX_NORMAL )
+ {
+ VectorCopy( in, out );
+ return;
+ }
+
+ cent = &cg_entities[ moverNum ];
+
+ if( cent->currentState.eType != ET_MOVER )
+ {
+ VectorCopy( in, out );
+ return;
+ }
+
+ BG_EvaluateTrajectory( ¢->currentState.pos, fromTime, oldOrigin );
+ BG_EvaluateTrajectory( ¢->currentState.apos, fromTime, oldAngles );
+
+ BG_EvaluateTrajectory( ¢->currentState.pos, toTime, origin );
+ BG_EvaluateTrajectory( ¢->currentState.apos, toTime, angles );
+
+ VectorSubtract( origin, oldOrigin, deltaOrigin );
+ VectorSubtract( angles, oldAngles, deltaAngles );
+
+ VectorAdd( in, deltaOrigin, out );
+
+ // FIXME: origin change when on a rotating object
+}
+
+
+/*
+=============================
+CG_InterpolateEntityPosition
+=============================
+*/
+static void CG_InterpolateEntityPosition( centity_t *cent )
+{
+ vec3_t current, next;
+ float f;
+
+ // it would be an internal error to find an entity that interpolates without
+ // a snapshot ahead of the current one
+ if( cg.nextSnap == NULL )
+ CG_Error( "CG_InterpoateEntityPosition: cg.nextSnap == NULL" );
+
+ f = cg.frameInterpolation;
+
+ // this will linearize a sine or parabolic curve, but it is important
+ // to not extrapolate player positions if more recent data is available
+ BG_EvaluateTrajectory( ¢->currentState.pos, cg.snap->serverTime, current );
+ BG_EvaluateTrajectory( ¢->nextState.pos, cg.nextSnap->serverTime, next );
+
+ cent->lerpOrigin[ 0 ] = current[ 0 ] + f * ( next[ 0 ] - current[ 0 ] );
+ cent->lerpOrigin[ 1 ] = current[ 1 ] + f * ( next[ 1 ] - current[ 1 ] );
+ cent->lerpOrigin[ 2 ] = current[ 2 ] + f * ( next[ 2 ] - current[ 2 ] );
+
+ BG_EvaluateTrajectory( ¢->currentState.apos, cg.snap->serverTime, current );
+ BG_EvaluateTrajectory( ¢->nextState.apos, cg.nextSnap->serverTime, next );
+
+ cent->lerpAngles[ 0 ] = LerpAngle( current[ 0 ], next[ 0 ], f );
+ cent->lerpAngles[ 1 ] = LerpAngle( current[ 1 ], next[ 1 ], f );
+ cent->lerpAngles[ 2 ] = LerpAngle( current[ 2 ], next[ 2 ], f );
+
+}
+
+/*
+===============
+CG_CalcEntityLerpPositions
+
+===============
+*/
+static void CG_CalcEntityLerpPositions( centity_t *cent )
+{
+ // this will be set to how far forward projectiles will be extrapolated
+ int timeshift = 0;
+
+ // if this player does not want to see extrapolated players
+ if( !cg_smoothClients.integer )
+ {
+ // make sure the clients use TR_INTERPOLATE
+ if( cent->currentState.number < MAX_CLIENTS )
+ {
+ cent->currentState.pos.trType = TR_INTERPOLATE;
+ cent->nextState.pos.trType = TR_INTERPOLATE;
+ }
+ }
+
+ if( cent->interpolate && cent->currentState.pos.trType == TR_INTERPOLATE )
+ {
+ CG_InterpolateEntityPosition( cent );
+ return;
+ }
+
+ // first see if we can interpolate between two snaps for
+ // linear extrapolated clients
+ if( cent->interpolate && cent->currentState.pos.trType == TR_LINEAR_STOP &&
+ cent->currentState.number < MAX_CLIENTS )
+ {
+ CG_InterpolateEntityPosition( cent );
+ return;
+ }
+
+ if( cg_projectileNudge.integer > 0 &&
+ cent->currentState.eType == ET_MISSILE &&
+ !( cg.snap->ps.pm_flags & PMF_FOLLOW ) )
+ {
+ timeshift = cg.ping;
+ }
+
+ // just use the current frame and evaluate as best we can
+ BG_EvaluateTrajectory( ¢->currentState.pos,
+ ( cg.time + timeshift ), cent->lerpOrigin );
+ BG_EvaluateTrajectory( ¢->currentState.apos,
+ ( cg.time + timeshift ), cent->lerpAngles );
+
+ if( timeshift )
+ {
+ trace_t tr;
+ vec3_t lastOrigin;
+
+ BG_EvaluateTrajectory( ¢->currentState.pos, cg.time, lastOrigin );
+
+ CG_Trace( &tr, lastOrigin, vec3_origin, vec3_origin, cent->lerpOrigin,
+ cent->currentState.number, MASK_SHOT );
+
+ // don't let the projectile go through the floor
+ if( tr.fraction < 1.0f )
+ VectorLerp( tr.fraction, lastOrigin, cent->lerpOrigin, cent->lerpOrigin );
+ }
+
+ // adjust for riding a mover if it wasn't rolled into the predicted
+ // player state
+ if( cent != &cg.predictedPlayerEntity )
+ {
+ CG_AdjustPositionForMover( cent->lerpOrigin, cent->currentState.groundEntityNum,
+ cg.snap->serverTime, cg.time, cent->lerpOrigin );
+ }
+}
+
+
+/*
+===============
+CG_CEntityPVSEnter
+
+===============
+*/
+static void CG_CEntityPVSEnter( centity_t *cent )
+{
+ entityState_t *es = ¢->currentState;
+
+ if( cg_debugPVS.integer )
+ CG_Printf( "Entity %d entered PVS\n", cent->currentState.number );
+
+ switch( es->eType )
+ {
+ case ET_MISSILE:
+ CG_LaunchMissile( cent );
+ break;
+ }
+
+ //clear any particle systems from previous uses of this centity_t
+ cent->muzzlePS = NULL;
+ cent->muzzlePsTrigger = qfalse;
+ cent->jetPackPS = NULL;
+ cent->jetPackState = JPS_OFF;
+ cent->buildablePS = NULL;
+ cent->entityPS = NULL;
+ cent->entityPSMissing = qfalse;
+
+ //make sure that the buildable animations are in a consistent state
+ //when a buildable enters the PVS
+ cent->buildableAnim = cent->lerpFrame.animationNumber = BANIM_NONE;
+ cent->oldBuildableAnim = es->legsAnim;
+}
+
+
+/*
+===============
+CG_CEntityPVSLeave
+
+===============
+*/
+static void CG_CEntityPVSLeave( centity_t *cent )
+{
+ int i;
+ entityState_t *es = ¢->currentState;
+
+ if( cg_debugPVS.integer )
+ CG_Printf( "Entity %d left PVS\n", cent->currentState.number );
+
+ switch( es->eType )
+ {
+ case ET_LEV2_ZAP_CHAIN:
+ for( i = 0; i <= 2; i++ )
+ {
+ if( CG_IsTrailSystemValid( ¢->level2ZapTS[ i ] ) )
+ CG_DestroyTrailSystem( ¢->level2ZapTS[ i ] );
+ }
+ break;
+ }
+}
+
+
+/*
+===============
+CG_AddCEntity
+
+===============
+*/
+static void CG_AddCEntity( centity_t *cent )
+{
+ // event-only entities will have been dealt with already
+ if( cent->currentState.eType >= ET_EVENTS )
+ return;
+
+ // calculate the current origin
+ CG_CalcEntityLerpPositions( cent );
+
+ // add automatic effects
+ CG_EntityEffects( cent );
+
+ switch( cent->currentState.eType )
+ {
+ default:
+ CG_Error( "Bad entity type: %i\n", cent->currentState.eType );
+ break;
+
+ case ET_INVISIBLE:
+ case ET_PUSH_TRIGGER:
+ case ET_TELEPORT_TRIGGER:
+ break;
+
+ case ET_GENERAL:
+ CG_General( cent );
+ break;
+
+ case ET_CORPSE:
+ CG_Corpse( cent );
+ break;
+
+ case ET_PLAYER:
+ CG_Player( cent );
+ break;
+
+ case ET_BUILDABLE:
+ CG_Buildable( cent );
+ break;
+
+ case ET_MISSILE:
+ CG_Missile( cent );
+ break;
+
+ case ET_MOVER:
+ CG_Mover( cent );
+ break;
+
+ case ET_BEAM:
+ CG_Beam( cent );
+ break;
+
+ case ET_PORTAL:
+ CG_Portal( cent );
+ break;
+
+ case ET_SPEAKER:
+ CG_Speaker( cent );
+ break;
+
+ case ET_PARTICLE_SYSTEM:
+ CG_ParticleSystemEntity( cent );
+ break;
+
+ case ET_ANIMMAPOBJ:
+ CG_AnimMapObj( cent );
+ break;
+
+ case ET_MODELDOOR:
+ CG_ModelDoor( cent );
+ break;
+
+ case ET_LIGHTFLARE:
+ CG_LightFlare( cent );
+ break;
+
+ case ET_LEV2_ZAP_CHAIN:
+ CG_Lev2ZapChain( cent );
+ break;
+ }
+}
+
+/*
+===============
+CG_AddPacketEntities
+
+===============
+*/
+void CG_AddPacketEntities( void )
+{
+ int num;
+ centity_t *cent;
+ playerState_t *ps;
+
+ // set cg.frameInterpolation
+ if( cg.nextSnap )
+ {
+ int delta;
+
+ delta = ( cg.nextSnap->serverTime - cg.snap->serverTime );
+
+ if( delta == 0 )
+ cg.frameInterpolation = 0;
+ else
+ cg.frameInterpolation = (float)( cg.time - cg.snap->serverTime ) / delta;
+ }
+ else
+ {
+ cg.frameInterpolation = 0; // actually, it should never be used, because
+ // no entities should be marked as interpolating
+ }
+
+ // the auto-rotating items will all have the same axis
+ cg.autoAngles[ 0 ] = 0;
+ cg.autoAngles[ 1 ] = ( cg.time & 2047 ) * 360 / 2048.0;
+ cg.autoAngles[ 2 ] = 0;
+
+ cg.autoAnglesFast[ 0 ] = 0;
+ cg.autoAnglesFast[ 1 ] = ( cg.time & 1023 ) * 360 / 1024.0f;
+ cg.autoAnglesFast[ 2 ] = 0;
+
+ AnglesToAxis( cg.autoAngles, cg.autoAxis );
+ AnglesToAxis( cg.autoAnglesFast, cg.autoAxisFast );
+
+ // generate and add the entity from the playerstate
+ ps = &cg.predictedPlayerState;
+ BG_PlayerStateToEntityState( ps, &cg.predictedPlayerEntity.currentState, qfalse );
+ cg.predictedPlayerEntity.valid = qtrue;
+ CG_AddCEntity( &cg.predictedPlayerEntity );
+
+ // lerp the non-predicted value for lightning gun origins
+ CG_CalcEntityLerpPositions( &cg_entities[ cg.snap->ps.clientNum ] );
+
+ // scanner
+ CG_UpdateEntityPositions( );
+
+ for( num = 0; num < MAX_GENTITIES; num++ )
+ cg_entities[ num ].valid = qfalse;
+
+ // add each entity sent over by the server
+ for( num = 0; num < cg.snap->numEntities; num++ )
+ {
+ cent = &cg_entities[ cg.snap->entities[ num ].number ];
+ cent->valid = qtrue;
+ }
+
+ for( num = 0; num < MAX_GENTITIES; num++ )
+ {
+ cent = &cg_entities[ num ];
+
+ if( cent->valid && !cent->oldValid )
+ CG_CEntityPVSEnter( cent );
+ else if( !cent->valid && cent->oldValid )
+ CG_CEntityPVSLeave( cent );
+
+ cent->oldValid = cent->valid;
+ }
+
+ // add each entity sent over by the server
+ for( num = 0; num < cg.snap->numEntities; num++ )
+ {
+ cent = &cg_entities[ cg.snap->entities[ num ].number ];
+ CG_AddCEntity( cent );
+ }
+
+ //make an attempt at drawing bounding boxes of selected entity types
+ if( cg_drawBBOX.integer )
+ {
+ for( num = 0; num < cg.snap->numEntities; num++ )
+ {
+ float x, zd, zu;
+ vec3_t mins, maxs;
+ entityState_t *es;
+
+ cent = &cg_entities[ cg.snap->entities[ num ].number ];
+ es = ¢->currentState;
+
+ switch( es->eType )
+ {
+ case ET_BUILDABLE:
+ case ET_MISSILE:
+ case ET_CORPSE:
+ x = ( es->solid & 255 );
+ zd = ( ( es->solid >> 8 ) & 255 );
+ zu = ( ( es->solid >> 16 ) & 255 ) - 32;
+
+ mins[ 0 ] = mins[ 1 ] = -x;
+ maxs[ 0 ] = maxs[ 1 ] = x;
+ mins[ 2 ] = -zd;
+ maxs[ 2 ] = zu;
+
+ CG_DrawBoundingBox( cent->lerpOrigin, mins, maxs );
+ break;
+
+ default:
+ break;
+ }
+ }
+ }
+}
+
|