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); }