codemp/cgame/cg_ents.c File Reference

#include "cg_local.h"
#include "..\game\q_shared.h"
#include "..\ghoul2\g2.h"
#include "../namespace_begin.h"
#include "../namespace_end.h"

Go to the source code of this file.

Functions
qboolean	CG_InFighter (void)
void	CG_PositionEntityOnTag (refEntity_t *entity, const refEntity_t *parent, qhandle_t parentModel, char *tagName)
void	CG_PositionRotatedEntityOnTag (refEntity_t *entity, const refEntity_t *parent, qhandle_t parentModel, char *tagName)
void	CG_SetEntitySoundPosition (centity_t *cent)
void	CG_S_AddLoopingSound (int entityNum, const vec3_t origin, const vec3_t velocity, sfxHandle_t sfx)
void	CG_S_AddRealLoopingSound (int entityNum, const vec3_t origin, const vec3_t velocity, sfxHandle_t sfx)
void	CG_S_StopLoopingSound (int entityNum, sfxHandle_t sfx)
void	CG_S_UpdateLoopingSounds (int entityNum)
localEntity_t *	FX_AddOrientedLine (vec3_t start, vec3_t end, vec3_t normal, float stScale, float scale, float dscale, float startalpha, float endalpha, float killTime, qhandle_t shader)
void	FX_DrawPortableShield (centity_t *cent)
void	CG_Special (centity_t *cent)
void	CG_SetGhoul2Info (refEntity_t *ent, centity_t *cent)
void	CG_CreateBBRefEnts (entityState_t *s1, vec3_t origin)
void	G2_BoltToGhoul2Model (centity_t *cent, refEntity_t *ent)
void	ScaleModelAxis (refEntity_t *ent)
void	CG_Disintegration (centity_t *cent, refEntity_t *ent)
void	CG_AddRadarEnt (centity_t *cent)
void	CG_AddBracketedEnt (centity_t *cent)
void	CG_G2ServerBoneAngles (centity_t *cent)
qboolean	BG_GetRootSurfNameWithVariant (void *ghoul2, const char *rootSurfName, char *returnSurfName, int returnSize)
qboolean	CG_GreyItem (int type, int tag, int plSide)
void	CG_CreateDistortionTrailPart (centity_t *cent, float scale, vec3_t pos)
void	CG_PlayDoorLoopSound (centity_t *cent)
void	CG_PlayDoorSound (centity_t *cent, int type)
void	CG_Beam (centity_t *cent)
void	CG_AdjustPositionForMover (const vec3_t in, int moverNum, int fromTime, int toTime, vec3_t out)
void	CG_CalcEntityLerpPositions (centity_t *cent)
void	CG_G2Animated (centity_t *cent)
void	CG_ManualEntityRender (centity_t *cent)
void	CG_AddPacketEntities (qboolean isPortal)
void	CG_ROFF_NotetrackCallback (centity_t *cent, const char *notetrack)
void	CG_Cube (vec3_t mins, vec3_t maxs, vec3_t color, float alpha)
Variables
char *	forceHolocronModels []
int	cgSiegeEntityRender
int	CG_BMS_START = 0
int	CG_BMS_MID = 1
int	CG_BMS_END = 2

---

Function Documentation

qboolean BG_GetRootSurfNameWithVariant (  void *  ghoul2, const char *  rootSurfName, char *  returnSurfName, int  returnSize )

Definition at line 101 of file bg_g2_utils.c. { if ( !ghoul2 || !trap_G2API_GetSurfaceRenderStatus( ghoul2, 0, rootSurfName ) ) {//see if the basic name without variants is on Q_strncpyz( returnSurfName, rootSurfName, returnSize ); return qtrue; } else {//check variants int i; for ( i = 0; i < MAX_VARIANTS; i++ ) { Com_sprintf( returnSurfName, returnSize, "%s%c", rootSurfName, 'a'+i ); if ( !trap_G2API_GetSurfaceRenderStatus( ghoul2, 0, returnSurfName ) ) { return qtrue; } } } Q_strncpyz( returnSurfName, rootSurfName, returnSize ); return qfalse; }

void CG_AddBracketedEnt (  centity_t *  cent  )

Definition at line 811 of file cg_ents.c. References cg_t::bracketedEntities, cg_t::bracketedEntityCount, centity_t, cg, Com_Printf(), centity_s::currentState, entityState_s::number, and cg_t::radarEntities. Referenced by CG_Player(). { if (cg.bracketedEntityCount == sizeof(cg.bracketedEntities)/sizeof(cg.bracketedEntities[0])) { #ifdef _DEBUG Com_Printf("^3Warning: CG_AddBracketedEnt full. (%d max)\n", sizeof(cg.radarEntities)/sizeof(cg.bracketedEntities[0])); #endif return; } cg.bracketedEntities[cg.bracketedEntityCount++] = cent->currentState.number; }

void CG_AddPacketEntities (  qboolean  isPortal  )

Definition at line 3412 of file cg_ents.c. References AnglesToAxis(), cg_t::autoAngles, cg_t::autoAnglesFast, cg_t::autoAxis, cg_t::autoAxisFast, BG_PlayerStateToEntityState(), centity_s::bodyHeight, cg_t::bracketedEntityCount, centity_t, cg, CG_CheckPlayerG2Weapons(), cg_entities, cg_numpermanents, cg_permanents, playerState_s::clientNum, centity_s::currentState, centity_s::currentValid, snapshot_t::entities, ET_NPC, ET_PLAYER, entityState_s::eType, cg_t::frameInterpolation, entityState_s::isPortalEnt, playerState_s::m_iVehicleNum, entityState_s::m_iVehicleNum, cg_t::nextSnap, entityState_s::number, snapshot_t::numEntities, entityState_s::owner, playerState_t, entityState_s::pos, cg_t::predictedPlayerState, cg_t::predictedVehicleState, snapshot_t::ps, qfalse, cg_t::radarEntityCount, snapshot_t::serverTime, cg_t::snap, cg_t::time, TR_INTERPOLATE, and trajectory_t::trType. Referenced by CG_DrawActiveFrame(), and CG_DrawSkyBoxPortal(). { int num; centity_t *cent; playerState_t *ps; if (isPortal) { for ( num = 0 ; num < cg.snap->numEntities ; num++ ) { cent = &cg_entities[ cg.snap->entities[ num ].number ]; if (cent->currentState.isPortalEnt) { CG_AddCEntity( cent ); } } return; } // 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 ); // Reset radar entities cg.radarEntityCount = 0; cg.bracketedEntityCount = 0; // generate and add the entity from the playerstate ps = &cg.predictedPlayerState; CG_CheckPlayerG2Weapons(ps, &cg_entities[cg.predictedPlayerState.clientNum]); BG_PlayerStateToEntityState( ps, &cg_entities[cg.predictedPlayerState.clientNum].currentState, qfalse ); if (cg.predictedPlayerState.m_iVehicleNum) { //add the vehicle I'm riding first //BG_PlayerStateToEntityState( &cg.predictedVehicleState, &cg_entities[cg.predictedPlayerState.m_iVehicleNum].currentState, qfalse ); //cg_entities[cg.predictedPlayerState.m_iVehicleNum].currentState.eType = ET_NPC; centity_t *veh = &cg_entities[cg.predictedPlayerState.m_iVehicleNum]; if (veh->currentState.owner == cg.predictedPlayerState.clientNum) { BG_PlayerStateToEntityState( &cg.predictedVehicleState, &veh->currentState, qfalse ); veh->currentState.eType = ET_NPC; veh->currentState.pos.trType = TR_INTERPOLATE; } CG_AddCEntity(veh); veh->bodyHeight = cg.time; //indicate we have already been added } CG_AddCEntity( &cg_entities[cg.predictedPlayerState.clientNum] ); /* // lerp the non-predicted value for lightning gun origins CG_CalcEntityLerpPositions( &cg_entities[ cg.snap->ps.clientNum ] ); */ //No longer have to do this. // add each entity sent over by the server for ( num = 0 ; num < cg.snap->numEntities ; num++ ) { // Don't re-add ents that have been predicted. if (cg.snap->entities[ num ].number != cg.snap->ps.clientNum) { cent = &cg_entities[ cg.snap->entities[ num ].number ]; if (cent->currentState.eType == ET_PLAYER && cent->currentState.m_iVehicleNum) { //add his veh first int j = 0; while (j < cg.snap->numEntities) { if (cg.snap->entities[j].number == cent->currentState.m_iVehicleNum) { centity_t *veh = &cg_entities[cg.snap->entities[j].number]; CG_AddCEntity(veh); veh->bodyHeight = cg.time; //indicate we have already been added break; } j++; } } else if (cent->currentState.eType == ET_NPC && cent->currentState.m_iVehicleNum && cent->bodyHeight == cg.time) { //never add a vehicle with a pilot, his pilot entity will get him added first. //if we were to add the vehicle after the pilot, the pilot's bolt would lag a frame behind. continue; } CG_AddCEntity( cent ); } } for(num=0;num<cg_numpermanents;num++) { cent = cg_permanents[num]; if (cent->currentValid) { CG_AddCEntity( cent ); } } }

void CG_AddRadarEnt (  centity_t *  cent  )

Definition at line 799 of file cg_ents.c. References centity_t, cg, Com_Printf(), centity_s::currentState, entityState_s::number, cg_t::radarEntities, and cg_t::radarEntityCount. Referenced by CG_Player(). { if (cg.radarEntityCount == sizeof(cg.radarEntities)/sizeof(cg.radarEntities[0])) { #ifdef _DEBUG Com_Printf("^3Warning: CG_AddRadarEnt full. (%d max)\n", sizeof(cg.radarEntities)/sizeof(cg.radarEntities[0])); #endif return; } cg.radarEntities[cg.radarEntityCount++] = cent->currentState.number; }

void CG_AdjustPositionForMover (  const vec3_t  in, int  moverNum, int  fromTime, int  toTime, vec3_t  out )

Definition at line 2994 of file cg_ents.c. References entityState_s::apos, BG_EvaluateTrajectory(), centity_t, cg_entities, centity_s::currentState, ENTITYNUM_MAX_NORMAL, ET_MOVER, entityState_s::eType, entityState_s::pos, vec3_t, VectorAdd, VectorCopy, and VectorSubtract. Referenced by CG_CalcEntityLerpPositions(), and CG_PredictPlayerState(). { 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( &cent->currentState.pos, fromTime, oldOrigin ); BG_EvaluateTrajectory( &cent->currentState.apos, fromTime, oldAngles ); BG_EvaluateTrajectory( &cent->currentState.pos, toTime, origin ); BG_EvaluateTrajectory( &cent->currentState.apos, toTime, angles ); VectorSubtract( origin, oldOrigin, deltaOrigin ); VectorSubtract( angles, oldAngles, deltaAngles ); VectorAdd( in, deltaOrigin, out ); // FIXME: origin change when on a rotating object }

void CG_Beam (  centity_t *  cent  )

Definition at line 2921 of file cg_ents.c. References refEntity_t::axis, AxisClear(), centity_t, CG_SetGhoul2Info(), centity_s::currentState, entityState_t, memset(), refEntity_t::oldorigin, refEntity_t::origin, entityState_s::origin2, entityState_s::pos, refEntity_t::renderfx, refEntity_t::reType, RF_NOSHADOW, RT_BEAM, trap_R_AddRefEntityToScene(), trajectory_t::trBase, and VectorCopy. Referenced by CG_EntityEvent(). { refEntity_t ent; entityState_t *s1; s1 = &cent->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; /* Ghoul2 Insert Start */ CG_SetGhoul2Info(&ent, cent); /* Ghoul2 Insert End */ // add to refresh list trap_R_AddRefEntityToScene(&ent); }

void CG_CalcEntityLerpPositions (  centity_t *  cent  )

Definition at line 3064 of file cg_ents.c. References trace_t::allsolid, entityState_s::apos, BG_EvaluateTrajectory(), centity_t, cg, CG_AdjustPositionForMover(), cg_entities, cg_smoothClients, CG_Trace(), CLASS_VEHICLE, playerState_s::clientNum, centity_s::currentState, DEFAULT_MAXS_2, DEFAULT_MINS_2, EF_DEAD, EF_RAG, entityState_s::eFlags, ET_NPC, entityState_s::eType, trace_t::fraction, entityState_s::groundEntityNum, vmCvar_t::integer, centity_s::interpolate, centity_s::isRagging, centity_s::lerpAngles, centity_s::lerpOrigin, playerState_s::m_iVehicleNum, MASK_PLAYERSOLID, MAX_CLIENTS, centity_s::nextState, entityState_s::NPC_class, entityState_s::number, entityState_s::owner, playerMaxs, playerMins, entityState_s::pos, cg_t::predictedPlayerState, qboolean, qfalse, qtrue, snapshot_t::serverTime, cg_t::snap, trace_t::startsolid, cg_t::time, TR_INTERPOLATE, TR_LINEAR_STOP, trajectory_t::trType, vec3_t, VectorAdd, VectorClear, VectorCopy, VectorMA, and VectorNormalize(). Referenced by vmMain(). { qboolean goAway = qfalse; // 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 (cg.predictedPlayerState.m_iVehicleNum && cg.predictedPlayerState.m_iVehicleNum == cent->currentState.number && cent->currentState.eType == ET_NPC && cent->currentState.NPC_class == CLASS_VEHICLE) { //special case for vehicle we are riding centity_t *veh = &cg_entities[cg.predictedPlayerState.m_iVehicleNum]; if (veh->currentState.owner == cg.predictedPlayerState.clientNum) { //only do this if the vehicle is pilotted by this client and predicting properly BG_EvaluateTrajectory( &cent->currentState.pos, cg.time, cent->lerpOrigin ); BG_EvaluateTrajectory( &cent->currentState.apos, cg.time, cent->lerpAngles ); return; } } 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 ); goAway = qtrue; } else if (cent->interpolate && cent->currentState.eType == ET_NPC && cent->currentState.NPC_class == CLASS_VEHICLE) { CG_InterpolateEntityPosition( cent ); goAway = qtrue; } else { // just use the current frame and evaluate as best we can BG_EvaluateTrajectory( &cent->currentState.pos, cg.time, cent->lerpOrigin ); BG_EvaluateTrajectory( &cent->currentState.apos, cg.time, cent->lerpAngles ); } #if 0 if (cent->hasRagOffset && cent->ragOffsetTime < cg.time) { //take all of the offsets from last frame and normalize the total direction and add it in vec3_t slideDir; vec3_t preOffset; vec3_t addedOffset; vec3_t playerMins = {-15, -15, DEFAULT_MINS_2}; vec3_t playerMaxs = {15, 15, DEFAULT_MAXS_2}; trace_t tr; //VectorSubtract(cent->lerpOrigin, callData->bonePos, slideDir); VectorCopy(cent->ragOffsets, slideDir); VectorNormalize(slideDir); //Store it in case we want to go back VectorCopy(cent->lerpOriginOffset, preOffset); //just add a little at a time VectorMA(cent->lerpOriginOffset, 0.4f, slideDir, cent->lerpOriginOffset); if (VectorLength(cent->lerpOriginOffset) > 10.0f) { //don't go too far away VectorCopy(preOffset, cent->lerpOriginOffset); } else { //Let's trace there to make sure we can make it VectorAdd(cent->lerpOrigin, cent->lerpOriginOffset, addedOffset); CG_Trace(&tr, cent->lerpOrigin, playerMins, playerMaxs, addedOffset, cent->currentState.number, MASK_PLAYERSOLID); if (tr.startsolid || tr.allsolid || tr.fraction != 1.0f) { //can't get there VectorCopy(preOffset, cent->lerpOriginOffset); } else { /* if (cent->lerpOriginOffset[2] > 4.0f) { //don't go too far off the ground cent->lerpOriginOffset[2] = 4.0f; } */ //I guess I just don't want this happening. cent->lerpOriginOffset[2] = 0.0f; } } //done with this bit cent->hasRagOffset = qfalse; VectorClear(cent->ragOffsets); cent->ragOffsetTime = cg.time + 50; } //See if we should add in the offset for ragdoll if (cent->isRagging && ((cent->currentState.eFlags & EF_DEAD) || (cent->currentState.eFlags & EF_RAG))) { VectorAdd(cent->lerpOrigin, cent->lerpOriginOffset, cent->lerpOrigin); } #endif if (goAway) { return; } // adjust for riding a mover if it wasn't rolled into the predicted // player state if ( cent->currentState.number != cg.predictedPlayerState.clientNum ) { CG_AdjustPositionForMover( cent->lerpOrigin, cent->currentState.groundEntityNum, cg.snap->serverTime, cg.time, cent->lerpOrigin ); } }

void CG_CreateBBRefEnts (  entityState_t *  s1, vec3_t  origin )

Definition at line 502 of file cg_ents.c. References entityState_t, and vec3_t. { /* //g2r #if _DEBUG refEntity_t point[8]; int i; vec3_t angles = {0,0,0}; for (i=0; i<8; i++) { memset (&point[i], 0, sizeof(refEntity_t)); point[i].reType = RT_SPRITE; point[i].radius = 1; point[i].customShader = trap_R_RegisterShader("textures/tests/circle"); point[i].shaderRGBA[0] = 255; point[i].shaderRGBA[1] = 255; point[i].shaderRGBA[2] = 255; point[i].shaderRGBA[3] = 255; AnglesToAxis( angles, point[i].axis ); // now, we need to put the correct origins into each origin from the mins and max's switch(i) { case 0: VectorCopy(s1->mins, point[i].origin); break; case 1: VectorCopy(s1->mins, point[i].origin); point[i].origin[0] = s1->maxs[0]; break; case 2: VectorCopy(s1->mins, point[i].origin); point[i].origin[1] = s1->maxs[1]; break; case 3: VectorCopy(s1->mins, point[i].origin); point[i].origin[0] = s1->maxs[0]; point[i].origin[1] = s1->maxs[1]; break; case 4: VectorCopy(s1->maxs, point[i].origin); break; case 5: VectorCopy(s1->maxs, point[i].origin); point[i].origin[0] = s1->mins[0]; break; case 6: VectorCopy(s1->maxs, point[i].origin); point[i].origin[1] = s1->mins[1]; break; case 7: VectorCopy(s1->maxs, point[i].origin); point[i].origin[0] = s1->mins[0]; point[i].origin[1] = s1->mins[1]; break; } // add the original origin to each point and then stuff them out there VectorAdd(point[i].origin, origin, point[i].origin); trap_R_AddRefEntityToScene (&point[i]); } #endif */ }

void CG_CreateDistortionTrailPart (  centity_t *  cent, float  scale, vec3_t  pos )

Definition at line 2324 of file cg_ents.c. References AnglesToAxis(), refEntity_t::axis, centity_t, cg, cg_renderToTextureFX, cgs, refEntity_t::customShader, refEntity_t::hModel, vmCvar_t::integer, cgMedia_t::itemRespawningRezOut, centity_s::lerpAngles, cgs_t::media, memset(), refEntity_t::modelScale, refEntity_t::origin, PITCH, refEntity_t::radius, cg_t::refdef, refEntity_t::renderfx, RF_DISTORTION, RF_FORCE_ENT_ALPHA, ScaleModelAxis(), refEntity_t::shaderRGBA, trap_R_AddRefEntityToScene(), trap_R_RegisterModel(), vec3_t, VectorCopy, VectorNormalize(), VectorSubtract, and refdef_t::vieworg. { refEntity_t ent; vec3_t ang; float vLen; if (!cg_renderToTextureFX.integer) { return; } memset( &ent, 0, sizeof( ent ) ); VectorCopy( pos, ent.origin ); VectorSubtract(ent.origin, cg.refdef.vieworg, ent.axis[0]); vLen = VectorLength(ent.axis[0]); if (VectorNormalize(ent.axis[0]) <= 0.1f) { // Entity is right on vieworg. quit. return; } VectorCopy(cent->lerpAngles, ang); ang[PITCH] += 90.0f; AnglesToAxis(ang, ent.axis); //radius must be a power of 2, and is the actual captured texture size if (vLen < 512) { ent.radius = 256; } else if (vLen < 1024) { ent.radius = 128; } else if (vLen < 2048) { ent.radius = 64; } else { ent.radius = 32; } ent.modelScale[0] = scale; ent.modelScale[1] = scale; ent.modelScale[2] = scale*16.0f; ScaleModelAxis(&ent); ent.hModel = trap_R_RegisterModel("models/weapons2/merr_sonn/trailmodel.md3"); ent.customShader = cgs.media.itemRespawningRezOut;//cgs.media.cloakedShader;//cgs.media.halfShieldShader; #if 1 ent.renderfx = (RF_DISTORTION|RF_FORCE_ENT_ALPHA); ent.shaderRGBA[0] = 255.0f; ent.shaderRGBA[1] = 255.0f; ent.shaderRGBA[2] = 255.0f; ent.shaderRGBA[3] = 100.0f; #else //no alpha ent.renderfx = RF_DISTORTION; #endif trap_R_AddRefEntityToScene( &ent ); }

void CG_Cube (  vec3_t  mins, vec3_t  maxs, vec3_t  color, float  alpha )

Definition at line 3744 of file cg_ents.c. References addpolyArgStruct_t, addpolyArgStruct_s::alpha1, addpolyArgStruct_s::alpha2, cg, cgs, cg_t::frametime, addpolyArgStruct_s::killTime, cgs_t::media, memset(), addpolyArgStruct_s::numVerts, addpolyArgStruct_s::p, addpolyArgStruct_s::rgb1, addpolyArgStruct_s::rgb2, addpolyArgStruct_s::rotationDelta, addpolyArgStruct_s::shader, cgMedia_t::solidWhite, trap_FX_AddPoly(), vec3_t, and VectorCopy. Referenced by CG_PredictPlayerState(). { vec3_t rot={0,0,0}; int vec[3]; int axis, i; addpolyArgStruct_t apArgs; memset (&apArgs, 0, sizeof(apArgs)); for ( axis = 0, vec[0] = 0, vec[1] = 1, vec[2] = 2; axis < 3; axis++, vec[0]++, vec[1]++, vec[2]++ ) { for ( i = 0; i < 3; i++ ) { if ( vec[i] > 2 ) { vec[i] = 0; } } apArgs.p[0][vec[1]] = mins[vec[1]]; apArgs.p[0][vec[2]] = mins[vec[2]]; apArgs.p[1][vec[1]] = mins[vec[1]]; apArgs.p[1][vec[2]] = maxs[vec[2]]; apArgs.p[2][vec[1]] = maxs[vec[1]]; apArgs.p[2][vec[2]] = maxs[vec[2]]; apArgs.p[3][vec[1]] = maxs[vec[1]]; apArgs.p[3][vec[2]] = mins[vec[2]]; //- face apArgs.p[0][vec[0]] = apArgs.p[1][vec[0]] = apArgs.p[2][vec[0]] = apArgs.p[3][vec[0]] = mins[vec[0]]; apArgs.numVerts = 4; apArgs.alpha1 = apArgs.alpha2 = alpha; VectorCopy( color, apArgs.rgb1 ); VectorCopy( color, apArgs.rgb2 ); VectorCopy( rot, apArgs.rotationDelta ); apArgs.killTime = cg.frametime; apArgs.shader = cgs.media.solidWhite; trap_FX_AddPoly( &apArgs ); //+ face apArgs.p[0][vec[0]] = apArgs.p[1][vec[0]] = apArgs.p[2][vec[0]] = apArgs.p[3][vec[0]] = maxs[vec[0]]; trap_FX_AddPoly( &apArgs ); } }

void CG_Disintegration (  centity_t *  cent, refEntity_t *  ent )

Definition at line 653 of file cg_ents.c. References AngleVectors(), centity_t, cg, cg_timescale, cgs, crandom, centity_s::currentState, refEntity_t::customShader, cgMedia_t::disruptorShader, centity_s::dustTrailTime, cgs_t::effects, refEntity_t::endTime, cgs_t::gameModels, centity_s::ghoul2, centity_s::lerpAngles, centity_s::lerpOrigin, cgEffects_t::mDisruptorDeathSmoke, cgs_t::media, centity_s::modelScale, NULL, refEntity_t::oldorigin, refEntity_t::origin, ORIGIN, entityState_s::origin2, random, cg_t::refdef, refEntity_t::renderfx, RF_DISINTEGRATE1, RF_DISINTEGRATE2, cg_t::time, trap_FX_PlayEffectID(), trap_G2API_AddBolt(), trap_G2API_GetBoltMatrix(), trap_R_AddRefEntityToScene(), vmCvar_t::value, vec3_t, vectoangles(), VectorCopy, VectorMA, VectorNormalize(), VectorScale, VectorSet, VectorSubtract, refdef_t::viewaxis, and YAW. Referenced by CG_Player(). { vec3_t tempAng, hitLoc; float tempLength; VectorCopy(cent->currentState.origin2, hitLoc); VectorSubtract( hitLoc, ent->origin, ent->oldorigin ); tempLength = VectorNormalize( ent->oldorigin ); vectoangles( ent->oldorigin, tempAng ); tempAng[YAW] -= cent->lerpAngles[YAW]; AngleVectors( tempAng, ent->oldorigin, NULL, NULL ); VectorScale( ent->oldorigin, tempLength, ent->oldorigin ); ent->endTime = cent->dustTrailTime; ent->renderfx |= RF_DISINTEGRATE2; ent->customShader = cgs.media.disruptorShader; trap_R_AddRefEntityToScene( ent ); ent->renderfx &= ~(RF_DISINTEGRATE2); ent->renderfx |= (RF_DISINTEGRATE1); ent->customShader = 0; trap_R_AddRefEntityToScene( ent ); if ( cg.time - ent->endTime < 1000 && (cg_timescale.value * cg_timescale.value * random()) > 0.05f ) { vec3_t fxOrg, fxDir; mdxaBone_t boltMatrix; int torsoBolt = trap_G2API_AddBolt(cent->ghoul2, 0, "lower_lumbar"); VectorSet(fxDir, 0, 1, 0); trap_G2API_GetBoltMatrix( cent->ghoul2, 0, torsoBolt, &boltMatrix, cent->lerpAngles, cent->lerpOrigin, cg.time, cgs.gameModels, cent->modelScale); BG_GiveMeVectorFromMatrix( &boltMatrix, ORIGIN, fxOrg ); VectorMA( fxOrg, -18, cg.refdef.viewaxis[0], fxOrg ); fxOrg[2] += crandom() * 20; trap_FX_PlayEffectID( cgs.effects.mDisruptorDeathSmoke, fxOrg, fxDir, -1, -1 ); if ( random() > 0.5f ) { trap_FX_PlayEffectID( cgs.effects.mDisruptorDeathSmoke, fxOrg, fxDir, -1, -1 ); } } }

void CG_G2Animated (  centity_t *  cent  )

Definition at line 7454 of file cg_players.c. References BG_NUM_TOGGLEABLE_SURFACES, bgToggleableSurfaceDebris, bgToggleableSurfaces, centity_t, CG_G2AnimEntModelLoad(), CG_Player(), CG_RagDoll(), CG_ReattachLimb(), cgs, centity_s::currentState, EF_DEAD, EF_RAG, cgs_t::effects, entityState_s::eFlags, centity_s::ghoul2, centity_s::lerpAngles, centity_s::localAnimIndex, cgEffects_t::mShipDestDestroyed, centity_s::npcLocalSurfOff, centity_s::npcLocalSurfOn, qtrue, centity_s::smoothYaw, entityState_s::surfacesOff, entityState_s::surfacesOn, centity_s::torsoBolt, trap_G2API_SetSurfaceOnOff(), TURN_OFF, TURN_ON, vec3_t, VectorClear, and YAW. { #ifdef SMOOTH_G2ANIM_LERPANGLES float angSmoothFactor = 0.7f; #endif if (!cent->ghoul2) { //Initialize this g2 anim ent, then return (will start rendering next frame) CG_G2AnimEntModelLoad(cent); cent->npcLocalSurfOff = 0; cent->npcLocalSurfOn = 0; return; } if (cent->npcLocalSurfOff != cent->currentState.surfacesOff || cent->npcLocalSurfOn != cent->currentState.surfacesOn) { //looks like it's time for an update. int i = 0; while (i < BG_NUM_TOGGLEABLE_SURFACES && bgToggleableSurfaces[i]) { if (!(cent->npcLocalSurfOff & (1 << i)) && (cent->currentState.surfacesOff & (1 << i))) { //it wasn't off before but it's off now, so reflect this change in the g2 instance. if (bgToggleableSurfaceDebris[i] > 0) { //make some local debris of this thing? //FIXME: throw off the proper model effect, too CG_CreateSurfaceDebris(cent, i, cgs.effects.mShipDestDestroyed, qtrue); } trap_G2API_SetSurfaceOnOff(cent->ghoul2, bgToggleableSurfaces[i], TURN_OFF); } if (!(cent->npcLocalSurfOn & (1 << i)) && (cent->currentState.surfacesOn & (1 << i))) { //same as above, but on instead of off. trap_G2API_SetSurfaceOnOff(cent->ghoul2, bgToggleableSurfaces[i], TURN_ON); } i++; } cent->npcLocalSurfOff = cent->currentState.surfacesOff; cent->npcLocalSurfOn = cent->currentState.surfacesOn; } /* if (cent->currentState.weapon && !trap_G2API_HasGhoul2ModelOnIndex(&(cent->ghoul2), 1) && !(cent->currentState.eFlags & EF_DEAD)) { //if the server says we have a weapon and we haven't copied one onto ourselves yet, then do so. trap_G2API_CopySpecificGhoul2Model(g2WeaponInstances[cent->currentState.weapon], 0, cent->ghoul2, 1); if (cent->currentState.weapon == WP_SABER) { trap_S_StartSound(cent->lerpOrigin, cent->currentState.number, CHAN_AUTO, trap_S_RegisterSound( "sound/weapons/saber/saberon.wav" )); } } */ if (cent->torsoBolt && !(cent->currentState.eFlags & EF_DEAD)) { //he's alive and has a limb missing still, reattach it and reset the weapon CG_ReattachLimb(cent); } if (((cent->currentState.eFlags & EF_DEAD) || (cent->currentState.eFlags & EF_RAG)) && !cent->localAnimIndex) { vec3_t forcedAngles; VectorClear(forcedAngles); forcedAngles[YAW] = cent->lerpAngles[YAW]; CG_RagDoll(cent, forcedAngles); } #ifdef SMOOTH_G2ANIM_LERPANGLES if ((cent->lerpAngles[YAW] > 0 && cent->smoothYaw < 0) || (cent->lerpAngles[YAW] < 0 && cent->smoothYaw > 0)) { //keep it from snapping around on the threshold cent->smoothYaw = -cent->smoothYaw; } cent->lerpAngles[YAW] = cent->smoothYaw+(cent->lerpAngles[YAW]-cent->smoothYaw)*angSmoothFactor; cent->smoothYaw = cent->lerpAngles[YAW]; #endif //now just render as a player CG_Player(cent); /* if ( cg_showVehBounds.integer ) {//show vehicle bboxes if ( cent->currentState.clientNum >= MAX_CLIENTS && cent->currentState.NPC_class == CLASS_VEHICLE && cent->m_pVehicle && cent->m_pVehicle->m_pVehicleInfo && cent->currentState.clientNum != cg.predictedVehicleState.clientNum ) {//not the predicted vehicle vec3_t NPCDEBUG_RED = {1.0, 0.0, 0.0}; vec3_t absmin, absmax; vec3_t bmins, bmaxs; float *old = cent->m_pVehicle->m_vOrientation; cent->m_pVehicle->m_vOrientation = &cent->lerpAngles[0]; BG_VehicleAdjustBBoxForOrientation( cent->m_pVehicle, cent->lerpOrigin, bmins, bmaxs, cent->currentState.number, MASK_PLAYERSOLID, NULL ); cent->m_pVehicle->m_vOrientation = old; VectorAdd( cent->lerpOrigin, bmins, absmin ); VectorAdd( cent->lerpOrigin, bmaxs, absmax ); CG_Cube( absmin, absmax, NPCDEBUG_RED, 0.25 ); } } */ }

void CG_G2ServerBoneAngles (  centity_t *  cent  )

Definition at line 3914 of file cg_players.c. References BONE_ANGLES_POSTMULT, entityState_s::boneAngles1, entityState_s::boneAngles2, entityState_s::boneAngles3, entityState_s::boneAngles4, entityState_s::boneIndex1, entityState_s::boneIndex2, entityState_s::boneIndex3, entityState_s::boneIndex4, entityState_s::boneOrient, centity_t, cg, CG_ConfigString(), cgs, CS_G2BONES, centity_s::currentState, cgs_t::gameModels, centity_s::ghoul2, cg_t::time, trap_G2API_SetBoneAngles(), vec3_t, and VectorCopy. { int i = 0; int bone = cent->currentState.boneIndex1; int flags, up, right, forward; vec3_t boneAngles; VectorCopy(cent->currentState.boneAngles1, boneAngles); while (i < 4) { //cycle through the 4 bone index values on the entstate if (bone) { //if it's non-0 then it could have something in it. const char *boneName = CG_ConfigString(CS_G2BONES+bone); if (boneName && boneName[0]) { //got the bone, now set the angles from the corresponding entitystate boneangles value. flags = BONE_ANGLES_POSTMULT; //get the orientation out of our bit field forward = (cent->currentState.boneOrient)&7; //3 bits from bit 0 right = (cent->currentState.boneOrient>>3)&7; //3 bits from bit 3 up = (cent->currentState.boneOrient>>6)&7; //3 bits from bit 6 trap_G2API_SetBoneAngles(cent->ghoul2, 0, boneName, boneAngles, flags, up, right, forward, cgs.gameModels, 100, cg.time); } } switch (i) { case 0: bone = cent->currentState.boneIndex2; VectorCopy(cent->currentState.boneAngles2, boneAngles); break; case 1: bone = cent->currentState.boneIndex3; VectorCopy(cent->currentState.boneAngles3, boneAngles); break; case 2: bone = cent->currentState.boneIndex4; VectorCopy(cent->currentState.boneAngles4, boneAngles); break; default: break; } i++; } }

qboolean CG_GreyItem (  int  type, int  tag, int  plSide )

Definition at line 1849 of file cg_ents.c. References FORCE_DARKSIDE, FORCE_LIGHTSIDE, IT_POWERUP, PW_FORCE_ENLIGHTENED_DARK, PW_FORCE_ENLIGHTENED_LIGHT, qboolean, qfalse, and qtrue. { if (type == IT_POWERUP && (tag == PW_FORCE_ENLIGHTENED_LIGHT || tag == PW_FORCE_ENLIGHTENED_DARK)) { if (plSide == FORCE_LIGHTSIDE) { if (tag == PW_FORCE_ENLIGHTENED_DARK) { return qtrue; } } else if (plSide == FORCE_DARKSIDE) { if (tag == PW_FORCE_ENLIGHTENED_LIGHT) { return qtrue; } } } return qfalse; }

qboolean CG_InFighter (  void   )

Definition at line 5594 of file cg_draw.c. { if ( cg.predictedPlayerState.m_iVehicleNum ) {//I'm in a vehicle centity_t *vehCent = &cg_entities[cg.predictedPlayerState.m_iVehicleNum]; if ( vehCent && vehCent->m_pVehicle && vehCent->m_pVehicle->m_pVehicleInfo && vehCent->m_pVehicle->m_pVehicleInfo->type == VH_FIGHTER ) {//I'm in a fighter return qtrue; } } return qfalse; }

void CG_ManualEntityRender (  centity_t *  cent  )

Definition at line 3401 of file cg_ents.c. References centity_t. Referenced by CG_Player(). { CG_AddCEntity(cent); }

void CG_PlayDoorLoopSound (  centity_t *  cent  )

Definition at line 2739 of file cg_ents.c. References centity_t, CG_BMS_MID, CG_ConfigString(), CG_S_AddRealLoopingSound(), cgs, CS_AMBIENT_SET, centity_s::currentState, ET_MOVER, entityState_s::eType, cgs_t::inlineModelMidpoints, centity_s::lerpOrigin, entityState_s::modelindex, entityState_s::number, sfxHandle_t, entityState_s::soundSetIndex, trap_AS_GetBModelSound(), vec3_origin, vec3_t, VectorAdd, and VectorCopy. Referenced by CG_EntityEvent(). { sfxHandle_t sfx; const char *soundSet; vec3_t origin; float *v; if ( !cent->currentState.soundSetIndex ) { return; } soundSet = CG_ConfigString( CS_AMBIENT_SET + cent->currentState.soundSetIndex ); if (!soundSet || !soundSet[0]) { return; } sfx = trap_AS_GetBModelSound( soundSet, CG_BMS_MID ); if ( sfx == -1 ) { return; } if (cent->currentState.eType == ET_MOVER) //shouldn't be in here otherwise, but just in case. { v = cgs.inlineModelMidpoints[ cent->currentState.modelindex ]; VectorAdd( cent->lerpOrigin, v, origin ); } else { VectorCopy(cent->lerpOrigin, origin); } //ent->s.loopSound = sfx; CG_S_AddRealLoopingSound(cent->currentState.number, origin, vec3_origin, sfx); }

void CG_PlayDoorSound (  centity_t *  cent, int  type )

Definition at line 2785 of file cg_ents.c. References centity_t, CG_ConfigString(), CHAN_AUTO, CS_AMBIENT_SET, centity_s::currentState, NULL, entityState_s::number, sfxHandle_t, entityState_s::soundSetIndex, trap_AS_GetBModelSound(), and trap_S_StartSound(). Referenced by CG_EntityEvent(). { sfxHandle_t sfx; const char *soundSet; if ( !cent->currentState.soundSetIndex ) { return; } soundSet = CG_ConfigString( CS_AMBIENT_SET + cent->currentState.soundSetIndex ); if (!soundSet || !soundSet[0]) { return; } sfx = trap_AS_GetBModelSound( soundSet, type ); if ( sfx == -1 ) { return; } trap_S_StartSound( NULL, cent->currentState.number, CHAN_AUTO, sfx ); }

void CG_PositionEntityOnTag (  refEntity_t *  entity, const refEntity_t *  parent, qhandle_t  parentModel, char *  tagName )

Definition at line 26 of file cg_ents.c. References refEntity_t::axis, orientation_t::axis, refEntity_t::backlerp, refEntity_t::frame, MatrixMultiply(), refEntity_t::oldframe, refEntity_t::origin, orientation_t::origin, qhandle_t, trap_R_LerpTag(), VectorCopy, and VectorMA. Referenced by CG_AddPlayerWeapon(). { 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; }

void CG_PositionRotatedEntityOnTag (  refEntity_t *  entity, const refEntity_t *  parent, qhandle_t  parentModel, char *  tagName )

Definition at line 55 of file cg_ents.c. References refEntity_t::axis, orientation_t::axis, refEntity_t::backlerp, refEntity_t::frame, MatrixMultiply(), refEntity_t::oldframe, refEntity_t::origin, orientation_t::origin, qhandle_t, trap_R_LerpTag(), vec3_t, VectorCopy, and VectorMA. Referenced by CG_AddPlayerWeapon(). { 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 ); }

void CG_ROFF_NotetrackCallback (  centity_t *  cent, const char *  notetrack )

Definition at line 3539 of file cg_ents.c. References AngleVectors(), atof(), centity_t, CHAN_BODY, Com_Printf(), Com_sprintf(), centity_s::currentState, centity_s::lerpAngles, centity_s::lerpOrigin, entityState_s::number, strcmp(), trap_FX_PlayEffectID(), trap_FX_RegisterEffect(), trap_S_RegisterSound(), trap_S_StartSound(), vec3_t, VectorClear, and VectorCopy. Referenced by vmMain(). { int i = 0, r = 0, objectID = 0, anglesGathered = 0, posoffsetGathered = 0; char type[256]; char argument[512]; char addlArg[512]; char errMsg[256]; char t[64]; int addlArgs = 0; vec3_t parsedAngles, parsedOffset, useAngles, useOrigin, forward, right, up; if (!cent || !notetrack) { return; } //notetrack = "effect effects/explosion1.efx 0+0+64 0-0-1"; while (notetrack[i] && notetrack[i] != ' ') { type[i] = notetrack[i]; i++; } type[i] = '\0'; if (notetrack[i] != ' ') { //didn't pass in a valid notetrack type, or forgot the argument for it return; } i++; while (notetrack[i] && notetrack[i] != ' ') { argument[r] = notetrack[i]; r++; i++; } argument[r] = '\0'; if (!r) { return; } if (notetrack[i] == ' ') { //additional arguments... addlArgs = 1; i++; r = 0; while (notetrack[i]) { addlArg[r] = notetrack[i]; r++; i++; } addlArg[r] = '\0'; } if (strcmp(type, "effect") == 0) { if (!addlArgs) { //sprintf(errMsg, "Offset position argument for 'effect' type is invalid."); //goto functionend; VectorClear(parsedOffset); goto defaultoffsetposition; } i = 0; while (posoffsetGathered < 3) { r = 0; while (addlArg[i] && addlArg[i] != '+' && addlArg[i] != ' ') { t[r] = addlArg[i]; r++; i++; } t[r] = '\0'; i++; if (!r) { //failure.. //sprintf(errMsg, "Offset position argument for 'effect' type is invalid."); //goto functionend; VectorClear(parsedOffset); i = 0; goto defaultoffsetposition; } parsedOffset[posoffsetGathered] = atof(t); posoffsetGathered++; } if (posoffsetGathered < 3) { Com_sprintf(errMsg, sizeof(errMsg), "Offset position argument for 'effect' type is invalid."); goto functionend; } i--; if (addlArg[i] != ' ') { addlArgs = 0; } defaultoffsetposition: objectID = trap_FX_RegisterEffect(argument); if (objectID) { if (addlArgs) { //if there is an additional argument for an effect it is expected to be XANGLE-YANGLE-ZANGLE i++; while (anglesGathered < 3) { r = 0; while (addlArg[i] && addlArg[i] != '-') { t[r] = addlArg[i]; r++; i++; } t[r] = '\0'; i++; if (!r) { //failed to get a new part of the vector anglesGathered = 0; break; } parsedAngles[anglesGathered] = atof(t); anglesGathered++; } if (anglesGathered) { VectorCopy(parsedAngles, useAngles); } else { //failed to parse angles from the extra argument provided.. VectorCopy(cent->lerpAngles, useAngles); } } else { //if no constant angles, play in direction entity is facing VectorCopy(cent->lerpAngles, useAngles); } AngleVectors(useAngles, forward, right, up); VectorCopy(cent->lerpOrigin, useOrigin); //forward useOrigin[0] += forward[0]*parsedOffset[0]; useOrigin[1] += forward[1]*parsedOffset[0]; useOrigin[2] += forward[2]*parsedOffset[0]; //right useOrigin[0] += right[0]*parsedOffset[1]; useOrigin[1] += right[1]*parsedOffset[1]; useOrigin[2] += right[2]*parsedOffset[1]; //up useOrigin[0] += up[0]*parsedOffset[2]; useOrigin[1] += up[1]*parsedOffset[2]; useOrigin[2] += up[2]*parsedOffset[2]; trap_FX_PlayEffectID(objectID, useOrigin, useAngles, -1, -1); } } else if (strcmp(type, "sound") == 0) { objectID = trap_S_RegisterSound(argument); trap_S_StartSound(cent->lerpOrigin, cent->currentState.number, CHAN_BODY, objectID); } else if (strcmp(type, "loop") == 0) { //handled server-side return; } //else if ... else { if (type[0]) { Com_Printf("^3Warning: \"%s\" is an invalid ROFF notetrack function\n", type); } else { Com_Printf("^3Warning: Notetrack is missing function and/or arguments\n"); } } return; functionend: Com_Printf("^3Type-specific notetrack error: %s\n", errMsg); return; }

void CG_S_AddLoopingSound (  int  entityNum, const vec3_t  origin, const vec3_t  velocity, sfxHandle_t  sfx )

Definition at line 119 of file cg_ents.c. References centity_t, cg_entities, cgLoopSound_t, Com_Printf(), cgLoopSound_s::entityNum, centity_s::loopingSound, MAX_CG_LOOPSOUNDS, NULL, centity_s::numLoopingSounds, cgLoopSound_s::origin, qboolean, qfalse, qtrue, S_COLOR_YELLOW, cgLoopSound_s::sfx, sfxHandle_t, vec3_t, VectorCopy, and cgLoopSound_s::velocity. Referenced by CG_S_AddRealLoopingSound(). { centity_t *cent = &cg_entities[entityNum]; cgLoopSound_t *cSound = NULL; int i = 0; qboolean alreadyPlaying = qfalse; //first see if we're already looping this sound handle. while (i < cent->numLoopingSounds) { cSound = &cent->loopingSound[i]; if (cSound->sfx == sfx) { alreadyPlaying = qtrue; break; } } if (alreadyPlaying && cSound) { //if this is the case, just update the properties of the looping sound and return. VectorCopy(origin, cSound->origin); VectorCopy(velocity, cSound->velocity); } else if (cent->numLoopingSounds >= MAX_CG_LOOPSOUNDS) { //Just don't add it then I suppose. #ifdef _XBOX // We decreased this number, so I'd like to know if it gets overflowed Com_Printf( S_COLOR_YELLOW "Warning: MAX_CG_LOOPSOUNDS exceeded!!\n" ); #endif return; } //Add a new looping sound. cSound = &cent->loopingSound[cent->numLoopingSounds]; cSound->entityNum = entityNum; VectorCopy(origin, cSound->origin); VectorCopy(velocity, cSound->velocity); cSound->sfx = sfx; cent->numLoopingSounds++; }

void CG_S_AddRealLoopingSound (  int  entityNum, const vec3_t  origin, const vec3_t  velocity, sfxHandle_t  sfx )

Definition at line 169 of file cg_ents.c. References CG_S_AddLoopingSound(), sfxHandle_t, and vec3_t. Referenced by CG_EntityEvent(), and CG_PlayDoorLoopSound(). { CG_S_AddLoopingSound(entityNum, origin, velocity, sfx); }

void CG_S_StopLoopingSound (  int  entityNum, sfxHandle_t  sfx )

Definition at line 181 of file cg_ents.c. References centity_t, cg_entities, cgLoopSound_t, centity_s::loopingSound, memcpy(), centity_s::numLoopingSounds, cgLoopSound_s::sfx, and sfxHandle_t. Referenced by CG_EntityEvent(). { centity_t *cent = &cg_entities[entityNum]; cgLoopSound_t *cSound; if (sfx == -1) { //clear all the looping sounds on the entity cent->numLoopingSounds = 0; } else { //otherwise, clear only the specified looping sound int i = 0; while (i < cent->numLoopingSounds) { cSound = &cent->loopingSound[i]; if (cSound->sfx == sfx) { //remove it then int x = i+1; while (x < cent->numLoopingSounds) { memcpy(&cent->loopingSound[x-1], &cent->loopingSound[x], sizeof(cent->loopingSound[x])); x++; } cent->numLoopingSounds--; } i++; } } //trap_S_StopLoopingSound(entityNum); }

void CG_S_UpdateLoopingSounds (  int  entityNum  )

Definition at line 223 of file cg_ents.c. References centity_t, cg_entities, cgLoopSound_t, cgs, centity_s::currentState, ET_MOVER, entityState_s::eType, cgs_t::inlineModelMidpoints, centity_s::lerpOrigin, centity_s::loopingSound, entityState_s::modelindex, centity_s::numLoopingSounds, cgLoopSound_s::sfx, trap_S_AddLoopingSound(), vec3_t, VectorAdd, VectorCopy, and cgLoopSound_s::velocity. Referenced by CG_UpdateSoundTrackers(). { centity_t *cent = &cg_entities[entityNum]; cgLoopSound_t *cSound; vec3_t lerpOrg; float *v; int i = 0; if (!cent->numLoopingSounds) { return; } if (cent->currentState.eType == ET_MOVER) { v = cgs.inlineModelMidpoints[ cent->currentState.modelindex ]; VectorAdd( cent->lerpOrigin, v, lerpOrg ); } else { VectorCopy(cent->lerpOrigin, lerpOrg); } while (i < cent->numLoopingSounds) { cSound = &cent->loopingSound[i]; //trap_S_AddLoopingSound(entityNum, cSound->origin, cSound->velocity, cSound->sfx); //I guess just keep using lerpOrigin for now, trap_S_AddLoopingSound(entityNum, lerpOrg, cSound->velocity, cSound->sfx); i++; } }

void CG_SetEntitySoundPosition (  centity_t *  cent  )

Definition at line 96 of file cg_ents.c. References centity_t, cgs, centity_s::currentState, cgs_t::inlineModelMidpoints, centity_s::lerpOrigin, entityState_s::modelindex, entityState_s::number, entityState_s::solid, SOLID_BMODEL, trap_S_UpdateEntityPosition(), vec3_t, and VectorAdd. Referenced by CG_CheckEvents(). { 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 ); } }

void CG_SetGhoul2Info (  refEntity_t *  ent, centity_t *  cent )

Definition at line 490 of file cg_ents.c. References refEntity_t::angles, centity_t, refEntity_t::ghoul2, centity_s::ghoul2, centity_s::lerpAngles, centity_s::modelScale, refEntity_t::modelScale, refEntity_t::radius, centity_s::radius, and VectorCopy. Referenced by CG_Beam(), and CG_Player(). { ent->ghoul2 = cent->ghoul2; VectorCopy( cent->modelScale, ent->modelScale); ent->radius = cent->radius; VectorCopy (cent->lerpAngles, ent->angles); }

void CG_Special (  centity_t *  cent  )

Definition at line 463 of file cg_ents.c. References centity_t, centity_s::currentState, entityState_t, FX_DrawPortableShield(), HI_SHIELD, and entityState_s::modelindex. { entityState_t *s1; s1 = &cent->currentState; if (!s1) { return; } // if set to invisible, skip if (!s1->modelindex) { return; } if (s1->modelindex == HI_SHIELD) { // The portable shield should go through a different rendering function. FX_DrawPortableShield(cent); return; } }

localEntity_t* FX_AddOrientedLine (  vec3_t  start, vec3_t  end, vec3_t  normal, float  stScale, float  scale, float  dscale, float  startalpha, float  endalpha, float  killTime, qhandle_t  shader )

Definition at line 329 of file cg_ents.c. References localEntity_s::alpha, refEntity_t::axis, AxisClear(), cg, CG_AllocLocalEntity(), localEntity_s::color, Com_Printf(), refEntity_t::customShader, localEntity_s::dalpha, refEntity_t::data, localEntity_s::data, localEntity_s::endTime, LE_OLINE, localEntity_s::leType, localEntity_s::lifeRate, localEntity_t, refEntity_t::oldorigin, refEntity_t::origin, qhandle_t, localEntity_s::refEntity, RotateAroundDirection(), refEntity_t::shaderRGBA, localEntity_s::startTime, cg_t::time, vec3_t, and VectorCopy. Referenced by FX_DrawPortableShield(). { localEntity_t *le; #ifdef _DEBUG if (!shader) { Com_Printf("FX_AddLine: NULL shader\n"); } #endif le = CG_AllocLocalEntity(); le->leType = LE_OLINE; le->startTime = cg.time; le->endTime = le->startTime + killTime; le->data.line.width = scale; le->data.line.dwidth = dscale; le->alpha = startalpha; le->dalpha = endalpha - startalpha; le->refEntity.data.line.stscale = stScale; le->refEntity.data.line.width = scale; le->refEntity.customShader = shader; // set origin VectorCopy ( start, le->refEntity.origin); VectorCopy ( end, le->refEntity.oldorigin ); AxisClear(le->refEntity.axis); VectorCopy( normal, le->refEntity.axis[0] ); RotateAroundDirection( le->refEntity.axis, 0); // le->refEntity.data.sprite.rotation ); This is roll in quad land le->refEntity.shaderRGBA[0] = 0xff; le->refEntity.shaderRGBA[1] = 0xff; le->refEntity.shaderRGBA[2] = 0xff; le->refEntity.shaderRGBA[3] = 0xff; le->color[0] = 1.0; le->color[1] = 1.0; le->color[2] = 1.0; le->color[3] = 1.0; le->lifeRate = 1.0 / ( le->endTime - le->startTime ); return(le); }

void FX_DrawPortableShield (  centity_t *  cent  )

Definition at line 379 of file cg_ents.c. References atoi(), centity_t, centity_s::currentState, EF_NODRAW, entityState_s::eFlags, FX_AddOrientedLine(), centity_s::lerpOrigin, localEntity_t, entityState_s::otherEntityNum2, qhandle_t, TEAM_RED, entityState_s::time2, trap_Cvar_VariableStringBuffer(), trap_R_RegisterShader(), entityState_s::trickedentindex, vec3_t, VectorClear, and VectorCopy. Referenced by CG_Special(). { //rww - this code differs a bit from the draw code in EF, I don't know why I had to do //it this way yet it worked in EF the other way. int xaxis, height, posWidth, negWidth, team; vec3_t start, end, normal; localEntity_t *le; qhandle_t shader; char buf[1024]; trap_Cvar_VariableStringBuffer("cl_paused", buf, sizeof(buf)); if (atoi(buf)) { //rww - fix to keep from rendering repeatedly while HUD menu is up return; } if (cent->currentState.eFlags & EF_NODRAW) { return; } // decode the data stored in time2 xaxis = ((cent->currentState.time2 >> 24) & 1); height = ((cent->currentState.time2 >> 16) & 255); posWidth = ((cent->currentState.time2 >> 8) & 255); negWidth = (cent->currentState.time2 & 255); team = (cent->currentState.otherEntityNum2); VectorClear(normal); VectorCopy(cent->lerpOrigin, start); VectorCopy(cent->lerpOrigin, end); if (xaxis) // drawing along x-axis { start[0] -= negWidth; end[0] += posWidth; } else { start[1] -= negWidth; end[1] += posWidth; } normal[0] = 1; normal[1] = 1; start[2] += height/2; end[2] += height/2; if (team == TEAM_RED) { if (cent->currentState.trickedentindex) { shader = trap_R_RegisterShader( "gfx/misc/red_dmgshield" ); } else { shader = trap_R_RegisterShader( "gfx/misc/red_portashield" ); } } else { if (cent->currentState.trickedentindex) { shader = trap_R_RegisterShader( "gfx/misc/blue_dmgshield" ); } else { shader = trap_R_RegisterShader( "gfx/misc/blue_portashield" ); } } le = FX_AddOrientedLine(start, end, normal, 1.0f, height, 0.0f, 1.0f, 1.0f, 50.0, shader); }

void G2_BoltToGhoul2Model (  centity_t *  cent, refEntity_t *  ent )

Definition at line 571 of file cg_ents.c. References entityState_s::angles, refEntity_t::axis, BOLT_AND, BOLT_SHIFT, centity_s::boltInfo, centity_t, cg, cg_entities, cgs, centity_s::currentState, ENTITY_AND, ENTITY_SHIFT, cgs_t::gameModels, centity_s::ghoul2, mdxaBone_t::matrix, MODEL_AND, MODEL_SHIFT, centity_s::modelScale, refEntity_t::origin, entityState_s::origin, cg_t::time, and trap_G2API_GetBoltMatrix(). { // extract the wraith ID from the bolt info int modelNum = cent->boltInfo >> MODEL_SHIFT; int boltNum = cent->boltInfo >> BOLT_SHIFT; int entNum = cent->boltInfo >> ENTITY_SHIFT; mdxaBone_t boltMatrix; modelNum &= MODEL_AND; boltNum &= BOLT_AND; entNum &= ENTITY_AND; //NOTENOTE I put this here because the cgs.gamemodels array no longer gets initialized. assert(0); // go away and get me the bolt position for this frame please trap_G2API_GetBoltMatrix(cent->ghoul2, modelNum, boltNum, &boltMatrix, cg_entities[entNum].currentState.angles, cg_entities[entNum].currentState.origin, cg.time, cgs.gameModels, cent->modelScale); // set up the axis and origin we need for the actual effect spawning ent->origin[0] = boltMatrix.matrix[0][3]; ent->origin[1] = boltMatrix.matrix[1][3]; ent->origin[2] = boltMatrix.matrix[2][3]; ent->axis[0][0] = boltMatrix.matrix[0][0]; ent->axis[0][1] = boltMatrix.matrix[1][0]; ent->axis[0][2] = boltMatrix.matrix[2][0]; ent->axis[1][0] = boltMatrix.matrix[0][1]; ent->axis[1][1] = boltMatrix.matrix[1][1]; ent->axis[1][2] = boltMatrix.matrix[2][1]; ent->axis[2][0] = boltMatrix.matrix[0][2]; ent->axis[2][1] = boltMatrix.matrix[1][2]; ent->axis[2][2] = boltMatrix.matrix[2][2]; }

void ScaleModelAxis (  refEntity_t *  ent  )

Definition at line 609 of file cg_ents.c. References refEntity_t::axis, refEntity_t::modelScale, refEntity_t::nonNormalizedAxes, qtrue, and VectorScale. Referenced by CG_AddFragment(), CG_Chunks(), CG_CreateDistortionTrailPart(), CG_CreateModelFromSpawnEnt(), CG_MiscEnt(), and CG_Player(). { // scale the model should we need to if (ent->modelScale[0] && ent->modelScale[0] != 1.0f) { VectorScale( ent->axis[0], ent->modelScale[0] , ent->axis[0] ); ent->nonNormalizedAxes = qtrue; } if (ent->modelScale[1] && ent->modelScale[1] != 1.0f) { VectorScale( ent->axis[1], ent->modelScale[1] , ent->axis[1] ); ent->nonNormalizedAxes = qtrue; } if (ent->modelScale[2] && ent->modelScale[2] != 1.0f) { VectorScale( ent->axis[2], ent->modelScale[2] , ent->axis[2] ); ent->nonNormalizedAxes = qtrue; } }

---

Variable Documentation

int CG_BMS_END = 2

Definition at line 2731 of file cg_ents.c.

int CG_BMS_MID = 1

Definition at line 2730 of file cg_ents.c. Referenced by CG_PlayDoorLoopSound().

int CG_BMS_START = 0

Definition at line 2729 of file cg_ents.c.

int cgSiegeEntityRender

Definition at line 702 of file cg_ents.c.

char* forceHolocronModels[]

Initial value: { "models/map_objects/mp/lt_heal.md3", "models/map_objects/mp/force_jump.md3", "models/map_objects/mp/force_speed.md3", "models/map_objects/mp/force_push.md3", "models/map_objects/mp/force_pull.md3", "models/map_objects/mp/lt_telepathy.md3", "models/map_objects/mp/dk_grip.md3", "models/map_objects/mp/dk_lightning.md3", "models/map_objects/mp/dk_rage.md3", "models/map_objects/mp/lt_protect.md3", "models/map_objects/mp/lt_absorb.md3", "models/map_objects/mp/lt_healother.md3", "models/map_objects/mp/dk_powerother.md3", "models/map_objects/mp/dk_drain.md3", "models/map_objects/mp/force_sight.md3", "models/map_objects/mp/saber_attack.md3", "models/map_objects/mp/saber_defend.md3", "models/map_objects/mp/saber_throw.md3" } Definition at line 632 of file cg_ents.c. Referenced by CG_Player().