void SpawnAllEntities( int nEntities, HierarchicalSpawn_t *pSpawnList, bool bActivateEntities )
{
int nEntity;
for (nEntity = 0; nEntity < nEntities; nEntity++)
{
VPROF( "MapEntity_ParseAllEntities_Spawn");
CBaseEntity *pEntity = pSpawnList[nEntity].m_pEntity;
if ( pSpawnList[nEntity].m_pDeferredParent )
{
// UNDONE: Promote this up to the root of this function?
MDLCACHE_CRITICAL_SECTION();
CBaseEntity *pParent = pSpawnList[nEntity].m_pDeferredParent;
int iAttachment = -1;
CBaseAnimating *pAnim = pParent->GetBaseAnimating();
if ( pAnim )
{
iAttachment = pAnim->LookupAttachment(pSpawnList[nEntity].m_pDeferredParentAttachment);
}
pEntity->SetParent( pParent, iAttachment );
}
if ( pEntity )
{
if (DispatchSpawn(pEntity) < 0)
{
for ( int i = nEntity+1; i < nEntities; i++ )
{
// this is a child object that will be deleted now
if ( pSpawnList[i].m_pEntity && pSpawnList[i].m_pEntity->IsMarkedForDeletion() )
{
pSpawnList[i].m_pEntity = NULL;
}
}
// Spawn failed.
gEntList.CleanupDeleteList();
// Remove the entity from the spawn list
pSpawnList[nEntity].m_pEntity = NULL;
}
}
}
if ( bActivateEntities )
{
VPROF( "MapEntity_ParseAllEntities_Activate");
bool bAsyncAnims = mdlcache->SetAsyncLoad( MDLCACHE_ANIMBLOCK, false );
for (nEntity = 0; nEntity < nEntities; nEntity++)
{
CBaseEntity *pEntity = pSpawnList[nEntity].m_pEntity;
if ( pEntity )
{
MDLCACHE_CRITICAL_SECTION();
pEntity->Activate();
}
}
mdlcache->SetAsyncLoad( MDLCACHE_ANIMBLOCK, bAsyncAnims );
}
}
void CMeshOES2::RenderPass(void)
{
Assert(m_Type != MATERIAL_HETEROGENOUS);
VPROF("CMeshOES2::RenderPass");
int i;
const CPrimList *pPrim = s_pPrims;
bool applied = false;
if (m_Type == MATERIAL_POINTS)
{
for (i = 0; i < s_nPrims; ++i, ++pPrim)
{
if (!(pPrim->m_NumIndices))
continue;
if (!applied)
{
applied = true;
MeshMgr()->ApplyStreamState();
}
glDrawArrays(GL_POINTS, 0, pPrim->m_NumIndices);
}
}
else
{
MeshMgr()->BindOESBuffer(OES_BUFFER_TARGET_INDEX, m_pIndexBuffer->GetOESBuffer());
for (i = 0; i < s_nPrims; ++i, ++pPrim)
{
if (!(pPrim->m_NumIndices))
continue;
#ifdef VPROF_ENABLED
int numPrimitives;
switch (m_Type)
{
case MATERIAL_LINES:
numPrimitives = pPrim->m_NumIndices >> 1;
break;
case MATERIAL_TRIANGLES:
numPrimitives = pPrim->m_NumIndices / 3;
break;
case MATERIAL_TRIANGLE_STRIP:
numPrimitives = pPrim->m_NumIndices - 2;
break;
NO_DEFAULT
}
VPROF("glDrawElements");
VPROF_INCREMENT_COUNTER("DrawElements", 1);
VPROF_INCREMENT_COUNTER("numPrimitives", numPrimitives);
#endif
if (!applied)
{
applied = true;
MeshMgr()->ApplyStreamState();
}
glDrawElements(m_Mode, pPrim->m_NumIndices, GL_UNSIGNED_SHORT, (void *)(pPrim->m_FirstIndex << 1));
}
}
}
int SelectWeightedSequence( CStudioHdr *pstudiohdr, int activity, int curSequence )
{
VPROF( "SelectWeightedSequence" );
#ifdef CLIENT_DLL
VPROF_INCREMENT_COUNTER( "Client SelectWeightedSequence", 1 );
#else // ifdef GAME_DLL
VPROF_INCREMENT_COUNTER( "Server SelectWeightedSequence", 1 );
#endif
if (! pstudiohdr)
return 0;
if (!pstudiohdr->SequencesAvailable())
return 0;
VerifySequenceIndex( pstudiohdr );
int numSeq = pstudiohdr->GetNumSeq();
if ( numSeq == 1 )
{
return ( GetSequenceActivity( pstudiohdr, 0, NULL ) == activity ) ? 0 : ACTIVITY_NOT_AVAILABLE;
}
return pstudiohdr->SelectWeightedSequence( activity, curSequence );
}
/**
* Cache the sequence numbers for the first ACT_HOP activities, since the CS player doesn't have multiple
* sequences per activity.
*/
int CCSPlayerAnimState::SelectWeightedSequence( Activity activity )
{
VPROF( "CCSPlayerAnimState::ComputeMainSequence" );
if ( activity > ACT_CROUCHIDLE || activity < 1 )
{
return GetOuter()->SelectWeightedSequence( activity );
}
CheckCachedSequenceValidity();
int sequence = m_sequenceCache[ activity - 1 ];
if ( sequence < 0 )
{
// just in case, look up the sequence if we didn't precache it above
sequence = m_sequenceCache[ activity - 1 ] = GetOuter()->SelectWeightedSequence( activity );
}
#if defined(CLIENT_DLL) && defined(_DEBUG)
int realSequence = GetOuter()->SelectWeightedSequence( activity );
Assert( realSequence == sequence );
#endif
return sequence;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : bool -
//-----------------------------------------------------------------------------
void C_TEMetalSparks::PostDataUpdate( DataUpdateType_t updateType )
{
VPROF( "C_TEMetalSparks::PostDataUpdate" );
g_pEffects->MetalSparks( m_vecPos, m_vecDir );
RecordMetalSparks( m_vecPos, m_vecDir );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CHL2WarsGameMovement::PlayerMove()
{
// Other movetype than strategic? use base class
if( player->GetMoveType() != MOVETYPE_STRATEGIC )
{
CGameMovement::PlayerMove();
return;
}
VPROF( "CHL2WarsGameMovement::PlayerMove" );
CheckParameters();
// clear output applied velocity
mv->m_outWishVel.Init();
mv->m_outJumpVel.Init();
MoveHelper( )->ResetTouchList(); // Assume we don't touch anything
ReduceTimers();
AngleVectors (mv->m_vecViewAngles, &m_vecForward, &m_vecRight, &m_vecUp ); // Determine movement angles
SetGroundEntity( NULL );
// Store off the starting water level
m_nOldWaterLevel = player->GetWaterLevel();
m_nOnLadder = 0;
StrategicPlayerMove();
}
void IGameSystem::FrameUpdatePostEntityThinkAllSystems()
{
VPROF("FrameUpdatePostEntityThinkAllSystems");
SafeRemoveIfDesiredAllSystems();
InvokePerFrameMethod( &IGameSystemPerFrame::FrameUpdatePostEntityThink );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : bool -
//-----------------------------------------------------------------------------
void C_TEDynamicLight::PostDataUpdate( DataUpdateType_t updateType )
{
VPROF( "C_TEDynamicLight::PostDataUpdate" );
CBroadcastRecipientFilter filter;
TE_DynamicLight( filter, 0.0f, &m_vecOrigin, r, g, b, exponent, m_fRadius, m_fTime, m_fDecay, LIGHT_INDEX_TE_DYNAMIC );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void C_TEWorldDecal::PostDataUpdate( DataUpdateType_t updateType )
{
VPROF( "C_TEWorldDecal::PostDataUpdate" );
if ( r_decals.GetInt() )
{
C_BaseEntity *ent = cl_entitylist->GetEnt( 0 );
if ( ent )
{
bool bNoBlood = UTIL_IsLowViolence();
bool bIsBlood = false;
if ( bNoBlood )
{
const char *pchDecalName = decalsystem->GetDecalNameForIndex( m_nIndex );
if ( pchDecalName && V_stristr( pchDecalName, "blood" ) )
{
bIsBlood = true;
}
}
if ( !( bNoBlood && bIsBlood ) )
{
effects->DecalShoot( m_nIndex, 0, ent->GetModel(), ent->GetAbsOrigin(), ent->GetAbsAngles(), m_vecOrigin, 0, 0 );
}
}
}
RecordWorldDecal( &m_vecOrigin, m_nIndex );
}
void CPortalGameMovement::TracePlayerBBox( const Vector& start, const Vector& end, unsigned int fMask, int collisionGroup, trace_t& pm )
{
VPROF( "CGameMovement::TracePlayerBBox" );
CPortal_Player *pPortalPlayer = (CPortal_Player *)((CBaseEntity *)mv->m_nPlayerHandle.Get());
Ray_t ray;
ray.Init( start, end, GetPlayerMins(), GetPlayerMaxs() );
#ifdef CLIENT_DLL
CTraceFilterSimple traceFilter( mv->m_nPlayerHandle.Get(), collisionGroup );
#else
CTraceFilterSimple baseFilter( mv->m_nPlayerHandle.Get(), collisionGroup );
CTraceFilterTranslateClones traceFilter( &baseFilter );
#endif
UTIL_Portal_TraceRay_With( pPortalPlayer->m_hPortalEnvironment, ray, fMask, &traceFilter, &pm );
// If we're moving through a portal and failed to hit anything with the above ray trace
// Use UTIL_Portal_TraceEntity to test this movement through a portal and override the trace with the result
if ( pm.fraction == 1.0f && UTIL_DidTraceTouchPortals( ray, pm ) && sv_player_trace_through_portals.GetBool() )
{
trace_t tempTrace;
UTIL_Portal_TraceEntity( pPortalPlayer, start, end, fMask, &traceFilter, &tempTrace );
if ( tempTrace.DidHit() && tempTrace.fraction < pm.fraction && !tempTrace.startsolid && !tempTrace.allsolid )
{
pm = tempTrace;
}
}
}
//-----------------------------------------------------------------------------
// Inherited from IParticleSystemQuery
//-----------------------------------------------------------------------------
void CParticleSystemQuery::GetLightingAtPoint( const Vector& vecOrigin, Color &cTint )
{
VPROF("CParticleSystemQuery::GetLightingAtPoint");
#ifdef GAME_DLL
// FIXME: Go through to the engine from the server to get these values
cTint.SetColor( 255, 255, 255, 255 );
#else
if ( engine->IsInGame() )
{
s_LightMutex.Lock();
// Compute our lighting at our position
Vector totalColor = engine->GetLightForPoint( vecOrigin, true );
s_LightMutex.Unlock();
// Get our lighting information
cTint.SetColor( totalColor.x*255, totalColor.y*255, totalColor.z*255, 0 );
}
else
{
// FIXME: Go through to the engine from the server to get these values
cTint.SetColor( 255, 255, 255, 255 );
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void C_TETFParticleEffect::PostDataUpdate( DataUpdateType_t updateType )
{
VPROF( "C_TETFParticleEffect::PostDataUpdate" );
CEffectData data;
data.m_nHitBox = m_iParticleSystemIndex;
data.m_vOrigin = m_vecOrigin;
data.m_vStart = m_vecStart;
data.m_vAngles = m_vecAngles;
if ( m_hEntity != INVALID_EHANDLE_INDEX )
{
data.m_hEntity = m_hEntity;
data.m_fFlags |= PARTICLE_DISPATCH_FROM_ENTITY;
}
else
{
data.m_hEntity = NULL;
}
data.m_nDamageType = m_iAttachType;
data.m_nAttachmentIndex = m_iAttachmentPointIndex;
if ( m_bResetParticles )
{
data.m_fFlags |= PARTICLE_DISPATCH_RESET_PARTICLES;
}
DispatchEffect( "ParticleEffect", data );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void C_TEPhysicsProp::PostDataUpdate( DataUpdateType_t updateType )
{
VPROF( "C_TEPhysicsProp::PostDataUpdate" );
tempents->PhysicsProp( m_nModelIndex, m_nSkin, m_vecOrigin, m_angRotation, m_vecVelocity, m_nFlags, m_nEffects );
RecordPhysicsProp( m_vecOrigin, m_angRotation, m_vecVelocity, m_nModelIndex, m_nFlags, m_nSkin, m_nEffects );
}
void GameStartFrame( void )
{
VPROF( "GameStartFrame" );
if ( g_pGameRules )
g_pGameRules->Think();
}
//-----------------------------------------------------------------------------
// Purpose: Looks up a sequence by sequence name first, then by activity name.
// Input : label - The sequence name or activity name to look up.
// Output : Returns the sequence index of the matching sequence, or ACT_INVALID.
//-----------------------------------------------------------------------------
int LookupSequence( CStudioHdr *pstudiohdr, const char *label )
{
VPROF( "LookupSequence" );
if (! pstudiohdr)
return 0;
if (!pstudiohdr->SequencesAvailable())
return 0;
//
// Look up by sequence name.
//
for (int i = 0; i < pstudiohdr->GetNumSeq(); i++)
{
mstudioseqdesc_t &seqdesc = pstudiohdr->pSeqdesc( i );
if (stricmp( seqdesc.pszLabel(), label ) == 0)
return i;
}
//
// Not found, look up by activity name.
//
int nActivity = LookupActivity( pstudiohdr, label );
if (nActivity != ACT_INVALID )
{
return SelectWeightedSequence( pstudiohdr, nActivity );
}
return ACT_INVALID;
}
void CBaseShader::DrawElements( IMaterialVar **ppParams, int nModulationFlags,
IShaderShadow* pShaderShadow, IShaderDynamicAPI* pShaderAPI )
{
VPROF("CBaseShader::DrawElements");
// Re-entrancy check
Assert( !s_ppParams );
s_ppParams = ppParams;
s_pShaderAPI = pShaderAPI;
s_pShaderShadow = pShaderShadow;
s_nModulationFlags = nModulationFlags;
s_pMeshBuilder = IsXbox() ? NULL : (pShaderAPI ? pShaderAPI->GetVertexModifyBuilder() : NULL);
if ( IsSnapshotting() )
{
// Set up the shadow state
SetInitialShadowState( );
}
OnDrawElements( ppParams, pShaderShadow, pShaderAPI );
s_nModulationFlags = 0;
s_ppParams = NULL;
s_pShaderAPI = NULL;
s_pShaderShadow = NULL;
s_pMeshBuilder = NULL;
}
void CEntityTouchManager::FrameUpdatePostEntityThink()
{
VPROF( "CEntityTouchManager::FrameUpdatePostEntityThink" );
// Loop through all entities again, checking their untouch if flagged to do so
int count = m_updateList.Count();
if ( count )
{
// copy off the list
CBaseEntity **ents = (CBaseEntity **)stackalloc( sizeof(CBaseEntity *) * count );
memcpy( ents, m_updateList.Base(), sizeof(CBaseEntity *) * count );
// clear it
m_updateList.RemoveAll();
// now update those ents
for ( int i = 0; i < count; i++ )
{
//Assert( ents[i]->GetCheckUntouch() );
if ( ents[i]->GetCheckUntouch() )
{
ents[i]->PhysicsCheckForEntityUntouch();
}
}
stackfree( ents );
}
}
void CGlowOverlay::DrawOverlays( bool bCacheFullSceneState )
{
VPROF("CGlowOverlay::DrawOverlays()");
CMatRenderContextPtr pRenderContext( materials );
bool bClippingEnabled = pRenderContext->EnableClipping( true );
unsigned short iNext;
for( unsigned short i=g_GlowOverlaySystem.m_GlowOverlays.Head(); i != g_GlowOverlaySystem.m_GlowOverlays.InvalidIndex(); i = iNext )
{
iNext = g_GlowOverlaySystem.m_GlowOverlays.Next( i );
CGlowOverlay *pOverlay = g_GlowOverlaySystem.m_GlowOverlays[i];
if( !pOverlay->m_bActivated )
continue;
if( pOverlay->Update() )
{
pRenderContext->EnableClipping( ((pOverlay->m_bInSky) ? (false):(bClippingEnabled)) ); //disable clipping in skybox, restore clipping to pre-existing state when not in skybox (it may be off as well)
pOverlay->Draw( bCacheFullSceneState );
}
else
{
delete pOverlay;
}
}
pRenderContext->EnableClipping( bClippingEnabled ); //restore clipping to original state
}
//-----------------------------------------------------------------------------
// Purpose: Checks if the player is standing on a moving entity and adjusts velocity and
// basevelocity appropriately
// Input : *player -
// frametime -
//-----------------------------------------------------------------------------
void CPlayerMove::CheckMovingGround( CBasePlayer *player, double frametime )
{
VPROF( "CPlayerMove::CheckMovingGround()" );
CBaseEntity *groundentity;
if ( player->GetFlags() & FL_ONGROUND )
{
groundentity = player->GetGroundEntity();
if ( groundentity && ( groundentity->GetFlags() & FL_CONVEYOR) )
{
Vector vecNewVelocity;
groundentity->GetGroundVelocityToApply( vecNewVelocity );
if ( player->GetFlags() & FL_BASEVELOCITY )
{
vecNewVelocity += player->GetBaseVelocity();
}
player->SetBaseVelocity( vecNewVelocity );
player->AddFlag( FL_BASEVELOCITY );
}
}
if ( !( player->GetFlags() & FL_BASEVELOCITY ) )
{
// Apply momentum (add in half of the previous frame of velocity first)
player->ApplyAbsVelocityImpulse( (1.0 + ( frametime * 0.5 )) * player->GetBaseVelocity() );
player->SetBaseVelocity( vec3_origin );
}
player->RemoveFlag( FL_BASEVELOCITY );
}
//-----------------------------------------------------------------------------
// Purpose: Called after player movement
// Input : *player -
// thinktime -
// frametime -
//-----------------------------------------------------------------------------
void CPlayerMove::RunPostThink( CBasePlayer *player )
{
VPROF( "CPlayerMove::RunPostThink" );
// Run post-think
player->PostThink();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void C_TEDecal::PostDataUpdate( DataUpdateType_t updateType )
{
VPROF( "C_TEDecal::PostDataUpdate" );
CBroadcastRecipientFilter filter;
TE_Decal( filter, 0.0f, &m_vecOrigin, &m_vecStart, m_nEntity, m_nHitbox, m_nIndex );
}
//-----------------------------------------------------------------------------
// Purpose: We're about to run this usercmd for the specified player. We can set up groupinfo and masking here, etc.
// This is the time to examine the usercmd for anything extra. This call happens even if think does not.
// Input : *player -
// *cmd -
//-----------------------------------------------------------------------------
void CPlayerMove::StartCommand( CBasePlayer *player, CUserCmd *cmd )
{
VPROF( "CPlayerMove::StartCommand" );
#if !defined( NO_ENTITY_PREDICTION )
CPredictableId::ResetInstanceCounters();
#endif
player->m_pCurrentCommand = cmd;
CBaseEntity::SetPredictionRandomSeed( cmd );
CBaseEntity::SetPredictionPlayer( player );
#if defined (HL2_DLL)
// pull out backchannel data and move this out
int i;
for (i = 0; i < cmd->entitygroundcontact.Count(); i++)
{
int entindex = cmd->entitygroundcontact[i].entindex;
CBaseEntity *pEntity = CBaseEntity::Instance( engine->PEntityOfEntIndex( entindex) );
if (pEntity)
{
CBaseAnimating *pAnimating = pEntity->GetBaseAnimating();
if (pAnimating)
{
pAnimating->SetIKGroundContactInfo( cmd->entitygroundcontact[i].minheight, cmd->entitygroundcontact[i].maxheight );
}
}
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose: Finishes running movement
// Input : *player -
// *move -
// *ucmd -
// time -
//-----------------------------------------------------------------------------
void CPlayerMove::FinishMove( CBasePlayer *player, CUserCmd *ucmd, CMoveData *move )
{
VPROF( "CPlayerMove::FinishMove" );
// NOTE: Don't copy this. the movement code modifies its local copy but is not expecting to be authoritative
//player->m_flMaxspeed = move->m_flClientMaxSpeed;
player->SetAbsOrigin( move->GetAbsOrigin() );
player->SetAbsVelocity( move->m_vecVelocity );
player->SetPreviouslyPredictedOrigin( move->GetAbsOrigin() );
player->m_Local.m_nOldButtons = move->m_nButtons;
// Convert final pitch to body pitch
float pitch = move->m_vecAngles[ PITCH ];
if ( pitch > 180.0f )
{
pitch -= 360.0f;
}
pitch = clamp( pitch, -90.f, 90.f );
move->m_vecAngles[ PITCH ] = pitch;
player->SetBodyPitch( pitch );
player->SetLocalAngles( move->m_vecAngles );
// The class had better not have changed during the move!!
if ( player->m_hConstraintEntity )
Assert( move->m_vecConstraintCenter == player->m_hConstraintEntity.Get()->GetAbsOrigin() );
else
Assert( move->m_vecConstraintCenter == player->m_vecConstraintCenter );
Assert( move->m_flConstraintRadius == player->m_flConstraintRadius );
Assert( move->m_flConstraintWidth == player->m_flConstraintWidth );
Assert( move->m_flConstraintSpeedFactor == player->m_flConstraintSpeedFactor );
}
//-----------------------------------------------------------------------------
// Purpose: Prepares for running movement
// Input : *player -
// *ucmd -
// *pHelper -
// *move -
// time -
//-----------------------------------------------------------------------------
void CPlayerMove::SetupMove( CBasePlayer *player, CUserCmd *ucmd, IMoveHelper *pHelper, CMoveData *move )
{
VPROF( "CPlayerMove::SetupMove" );
// Allow sound, etc. to be created by movement code
move->m_bFirstRunOfFunctions = true;
// Prepare the usercmd fields
move->m_nImpulseCommand = ucmd->impulse;
move->m_vecViewAngles = ucmd->viewangles;
CBaseEntity *pMoveParent = player->GetMoveParent();
if (!pMoveParent)
{
move->m_vecAbsViewAngles = move->m_vecViewAngles;
}
else
{
matrix3x4_t viewToParent, viewToWorld;
AngleMatrix( move->m_vecViewAngles, viewToParent );
ConcatTransforms( pMoveParent->EntityToWorldTransform(), viewToParent, viewToWorld );
MatrixAngles( viewToWorld, move->m_vecAbsViewAngles );
}
move->m_nButtons = ucmd->buttons;
// Ingore buttons for movement if at controls
if ( player->GetFlags() & FL_ATCONTROLS )
{
move->m_flForwardMove = 0;
move->m_flSideMove = 0;
move->m_flUpMove = 0;
}
else
{
move->m_flForwardMove = ucmd->forwardmove;
move->m_flSideMove = ucmd->sidemove;
move->m_flUpMove = ucmd->upmove;
}
// Prepare remaining fields
move->m_flClientMaxSpeed = player->m_flMaxspeed;
move->m_nOldButtons = player->m_Local.m_nOldButtons;
move->m_vecAngles = player->pl.v_angle;
move->m_vecVelocity = player->GetAbsVelocity();
move->m_nPlayerHandle = player;
move->m_vecAbsOrigin = player->GetAbsOrigin();
// Copy constraint information
if ( player->m_hConstraintEntity.Get() )
move->m_vecConstraintCenter = player->m_hConstraintEntity.Get()->GetAbsOrigin();
else
move->m_vecConstraintCenter = player->m_vecConstraintCenter;
move->m_flConstraintRadius = player->m_flConstraintRadius;
move->m_flConstraintWidth = player->m_flConstraintWidth;
move->m_flConstraintSpeedFactor = player->m_flConstraintSpeedFactor;
}
void DispInfo_BuildPrimLists(
IDispInfo *pHead,
CDispInfo *visibleDisps[MAX_MAP_DISPINFO],
int &nVisibleDisps )
{
VPROF("DispInfo_BuildPrimLists");
nVisibleDisps = 0;
for( IDispInfo *pCur=pHead; pCur; pCur = pCur->GetNextInRenderChain() )
{
CDispInfo *pDisp = static_cast<CDispInfo*>( pCur );
if( pDisp->Render( pDisp->m_pMesh ) )
{
// Add it to the list of visible displacements.
if( nVisibleDisps < MAX_MAP_DISPINFO )
{
visibleDisps[nVisibleDisps++] = pDisp;
}
#ifndef SWDS
int nSurfID = pDisp->GetParent();
OverlayMgr()->AddFragmentListToRenderList( MSurf_OverlayFragmentList( nSurfID ) );
#endif
}
// g_EngineStats.IncrementCountedStat( ENGINE_STATS_NUM_DISP_TRIANGLES, 1 );
}
}
void CBasePlayerAnimState::ComputeMainSequence()
{
VPROF( "CBasePlayerAnimState::ComputeMainSequence" );
CBaseAnimatingOverlay *pPlayer = GetOuter();
// Have our class or the mod-specific class determine what the current activity is.
Activity idealActivity = CalcMainActivity();
#ifdef CLIENT_DLL
Activity oldActivity = m_eCurrentMainSequenceActivity;
#endif
// Store our current activity so the aim and fire layers know what to do.
m_eCurrentMainSequenceActivity = idealActivity;
// Export to our outer class..
int animDesired = SelectWeightedSequence( TranslateActivity(idealActivity) );
if ( !ShouldResetMainSequence( pPlayer->GetSequence(), animDesired ) )
return;
if ( animDesired < 0 )
animDesired = 0;
pPlayer->ResetSequence( animDesired );
#ifdef CLIENT_DLL
if ( ShouldResetGroundSpeed( oldActivity, idealActivity ) )
{
ResetGroundSpeed();
}
#endif
}
void CBaseShader::DrawElements( IMaterialVar **ppParams, int nModulationFlags,
IShaderShadow* pShaderShadow, IShaderDynamicAPI* pShaderAPI, VertexCompressionType_t vertexCompression, CBasePerMaterialContextData **pContextDataPtr, CBasePerInstanceContextData** pInstanceDataPtr )
{
VPROF("CBaseShader::DrawElements");
// Re-entrancy check
Assert( !s_ppParams );
s_ppParams = ppParams;
s_pShaderAPI = pShaderAPI;
s_pShaderShadow = pShaderShadow;
s_nModulationFlags = nModulationFlags;
s_pInstanceDataPtr = (CPerInstanceContextData**)( pInstanceDataPtr );
s_nPassCount = 0;
if ( IsSnapshotting() )
{
// Set up the shadow state
SetInitialShadowState( );
}
OnDrawElements( ppParams, pShaderShadow, pShaderAPI, vertexCompression, pContextDataPtr );
s_pInstanceDataPtr = NULL;
s_nPassCount = 0;
s_nModulationFlags = 0;
s_ppParams = NULL;
s_pShaderAPI = NULL;
s_pShaderShadow = NULL;
}
//-----------------------------------------------------------------------------
// Purpose: We've finished running a user's command
// Input : *player -
//-----------------------------------------------------------------------------
void CPlayerMove::FinishCommand( CBasePlayer *player )
{
VPROF( "CPlayerMove::FinishCommand" );
player->m_pCurrentCommand = NULL;
CBaseEntity::SetPredictionRandomSeed( NULL );
CBaseEntity::SetPredictionPlayer( NULL );
}
void CBasePlayerAnimState::UpdateInterpolators()
{
VPROF( "CBasePlayerAnimState::UpdateInterpolators" );
// First, figure out their current MAX speed based on their current activity.
float flCurMaxSpeed = GetCurrentMaxGroundSpeed();
m_flMaxGroundSpeed = flCurMaxSpeed;
}
void GameStartFrame( void )
{
VPROF("GameStartFrame()");
if ( g_fGameOver )
return;
gpGlobals->teamplay = (teamplay.GetInt() != 0);
}
