Frame Order

==Engine==
The engine has two modes of execution, a threaded path and a non-threaded path. The host_thread_mode cvar determines which path is taken. Dedicated servers will ignore this cvar and always use the non-threaded path. XBox 360 runs in threaded mode by default, while PC runs in non-threaded mode by default. Threaded mode was introduced with the Orange Box version of the Source engine, and does not exist in Episode 1 or previous versions.
Listenservers (ie, singleplayer games, or multiplayer games hosted by one of the players) will run all sections of code, calling both client.dll and server.dll functions from the same thread and in the same engine loop. Clients connected to a remote server will run the italicized sections only, and dedicated servers will run the bold items only. Dedicated server builds (Linux or Windows SrcDs) will run only the underlined sections.
Legend:
* Bold - Server code, occurs on any server engine, server-only or listenserver
* Italics - Client code, occurs on any client engine, client-only or listenserver
* Underline - Code path for a dedicated server (Non underline items do not run on a dedicated server.)
* Green - Function call from the engine into game source
===Non-threaded model===
* Device input
* CHLClient::FrameStageNotify(FRAME_START)
* Console commands
* For each tick:
** Networking
** Input
** Server game code
** Client logic
** Client prediction
* Rendering
* Sound
* Client HUD update
===Threaded model===
* Device input
* CHLClient::FrameStageNotify(FRAME_START)
* Console commands
* For each client tick:
** Networking
** Client logic
* Client prediction
* For each server tick:
** Input
** Networking
* Server game code (in a separate thread)
* Rendering
* Sound
* Client HUD update
==Sections==
Legend:
* Green - Function call from the engine into game source
* Purple - Code that exists inside the game sources available to modders
* Red - Special information
===Device input===
This section reads messages from the operating system and handles keyboard and window events.
Key events are sent by priority first to tools (PET, Actbusy, etc) then to VGUI, then to the client game code, and finally to the engine. If one does not process it, it is then sent to the next.
* If a key is pressed: CHLClient::IN_KeyEvent
===Console commands===
This section evaluates and executes commands input into the game console. If the console command is a ConCommand created by the game code, it will execute a callback into the game code through ConCommand::Dispatch( const CCommand &command ) in convar.cpp.
===Networking===
This section sends and receives network messages. It runs on a localhost server through an internal backdoor loopback device. On server-only or client-only instances it runs over a UDP connection. No game code callbacks are made during this time.
===Input===
This section reads and processes input messages. It runs only on client or localhost engines.
* CHLClient::HudProcessInput()
* Process console commands
* Process player movement commands
** CHLClient::CreateMove()
** Queue movement commands to network to the server
===Server game code===
This section calls Think functions for each entity and processes game logic.
* If this is the last tick in the frame: CServerGameDLL::Think()
* Read network input
* For each plugin: IServerPluginCallbacks::GameFrame()
* CServerGameDLL::GameFrame()
** For each game system: FrameUpdatePreEntityThink()
** GameRules::Think()
** Physics simulations
*** For each player: CBasePlayer::PlayerRunCommand()
** For each game system: FrameUpdatePostEntityThink()
* If this is the last tick in the frame: (This part of the tree occurs in a separate thread if the engine is threaded.)
** CServerGameDLL::PreClientUpdate()
*** For each game system: PreClientUpdate()
** Transmit queued network messages
** For every client:
*** Set up network pack data
**** CServerGameClients::ClientSetupVisibility()
**** CServerGameEnts::CheckTransmit()
**** In a singleplayer game, Client logic is run through the local network backdoor (using memcpy instead of a slower network loopback)
**** Changed entity data tables are packed for network transmission, and snapshots are sent to clients
** CServerGameClients::PostClientMessagesSent()
===Client logic===
This section reads network packets and updates the entities on the client.
* Read packets
** If message is an entity packet:
*** If multiplayer or if there are extra commands:
**** Run prediction
*** CPrediction::PreEntityPacketReceived
*** CHLClient::FrameStageNotify(FRAME_NET_UPDATE_START)
**** Absolute origin/angle queries invalidated
*** Update baseline, update entity data tables
**** Calls to C_BaseEntity::PreDataUpdate as necessary.
*** CHLClient::FrameStageNotify(FRAME_NET_UPDATE_POSTDATAUPDATE_START)
*** For every updated entity: C_BaseEntity::PostDataUpdate()
*** CHLClient::FrameStageNotify(FRAME_NET_UPDATE_POSTDATAUPDATE_END)
**** CPrediction::PostEntityPacketReceived()
*** If an entity has entered or exited the client's PVS: C_BaseEntity::NotifyShouldTransmit()
*** CHLClient::FrameStageNotify(FRAME_NET_UPDATE_END)
**** Absolute origin/angle queries re-validated
*** CPrediction::PostNetworkDataReceived()
** If message is an entity message:
*** CHLClient::DispatchUserMessage()
** If message is a game event:
*** ClientModeShared::FireGameEvent()
===Client prediction===
This section runs prediction code for the local client.
* CPrediction::Update()
** Perform prediction. For every player movement command:
*** CPrediction::RunSimulation()
*** For every predictable entity:
**** If data table has changed: C_BaseEntity::OnPreDataChanged()
**** C_BaseEntity::PhysicsSimulate()
***** CPrediction::RunCommand()
***** If the entity is a player:
****** C_BasePlayer::PreThink()
****** CPrediction::SetupMove()
****** CGameMovement::ProcessMovement()
****** CPrediction::FinishMove()
****** C_BasePlayer::PostThink()
****** CMoveHelperClient::ProcessImpacts()
***** If the entity is not a player:
****** Run physics simulation and C_BaseEntity::Think()
** CPrediction::Untouch()
* Update view angles with input information
** CPrediction::SetLocalViewAngles()
* CHLClient::ExtraMouseSample()
===Rendering===
Rendering code sets up the view, updates all entities, and then renders the scene and user interface.
* CHLClient::FrameStageNotify(FRAME_RENDER_START)
** CInput::CAM_Think()
** CViewRender::OnRenderStart()
*** CViewRender::SetUpView()
**** CBasePlayer::CalcView()
*** For every player: CBasePlayer::UpdateClientSideAnimation()
**** CMultiPlayerAnimState::Update()
*** ProcessOnDataChangedEvents()
**** For every entity with data changed: C_BaseEntity::OnDataChanged()
*** Update entities, tempents, particle systems, simulate physics, call ClientThink() functions
* CHLClient::View_Render()
** Draws world and then UI
* CHLClient::FrameStageNotify(FRAME_RENDER_END)
===Sound===
Sound code processes and plays sounds on the client. It makes no calls into the game code.
===Client HUD update===
This section calls one thing:
* CHLClient::HudUpdate()
** Update HUD and game systems
Category:Programming