/*
=============
R_CheckCvars
See if some cvars that we watch have changed
=============
*/
static void R_CheckCvars() {
// gamma stuff
if ( r_gamma.IsModified() || r_brightness.IsModified() ) {
r_gamma.ClearModified();
r_brightness.ClearModified();
R_SetColorMappings();
}
// filtering
if ( r_maxAnisotropicFiltering.IsModified() || r_useTrilinearFiltering.IsModified() || r_lodBias.IsModified() ) {
idLib::Printf( "Updating texture filter parameters.\n" );
r_maxAnisotropicFiltering.ClearModified();
r_useTrilinearFiltering.ClearModified();
r_lodBias.ClearModified();
for ( int i = 0 ; i < globalImages->images.Num() ; i++ ) {
if ( globalImages->images[i] ) {
globalImages->images[i]->Bind();
globalImages->images[i]->SetTexParameters();
}
}
}
extern idCVar r_useSeamlessCubeMap;
if ( r_useSeamlessCubeMap.IsModified() ) {
r_useSeamlessCubeMap.ClearModified();
if ( glConfig.seamlessCubeMapAvailable ) {
if ( r_useSeamlessCubeMap.GetBool() ) {
qglEnable( GL_TEXTURE_CUBE_MAP_SEAMLESS );
} else {
qglDisable( GL_TEXTURE_CUBE_MAP_SEAMLESS );
}
}
}
extern idCVar r_useSRGB;
if ( r_useSRGB.IsModified() ) {
r_useSRGB.ClearModified();
if ( glConfig.sRGBFramebufferAvailable ) {
if ( r_useSRGB.GetBool() ) {
qglEnable( GL_FRAMEBUFFER_SRGB );
} else {
qglDisable( GL_FRAMEBUFFER_SRGB );
}
}
}
if ( r_multiSamples.IsModified() ) {
if ( r_multiSamples.GetInteger() > 0 ) {
qglEnable( GL_MULTISAMPLE_ARB );
} else {
qglDisable( GL_MULTISAMPLE_ARB );
}
}
// check for changes to logging state
GLimp_EnableLogging( r_logFile.GetInteger() != 0 );
}
/*
===============
Sys_GetConsoleKey
===============
*/
unsigned char Sys_GetConsoleKey(bool shifted) {
static unsigned char keys[2] = { '`', '~' };
if (in_kbd.IsModified()) {
idStr lang = in_kbd.GetString();
if (lang.Length()) {
if (!lang.Icmp("french")) {
keys[0] = '<';
keys[1] = '>';
} else if (!lang.Icmp("german")) {
keys[0] = '^';
keys[1] = 176; // °
} else if (!lang.Icmp("italian")) {
keys[0] = '\\';
keys[1] = '|';
} else if (!lang.Icmp("spanish")) {
keys[0] = 186; // º
keys[1] = 170; // ª
} else if (!lang.Icmp("turkish")) {
keys[0] = '"';
keys[1] = 233; // é
}
}
in_kbd.ClearModified();
}
return shifted ? keys[1] : keys[0];
}
/*
========================
idParallelJobManagerLocal::Submit
========================
*/
void idParallelJobManagerLocal::Submit( idParallelJobList_Threads* jobList, int parallelism )
{
if( jobs_numThreads.IsModified() )
{
maxThreads = idMath::ClampInt( 0, MAX_JOB_THREADS, jobs_numThreads.GetInteger() );
jobs_numThreads.ClearModified();
}
// determine the number of threads to use
int numThreads = maxThreads;
if( parallelism == JOBLIST_PARALLELISM_DEFAULT )
{
numThreads = maxThreads;
}
else if( parallelism == JOBLIST_PARALLELISM_MAX_CORES )
{
numThreads = numLogicalCpuCores;
}
else if( parallelism == JOBLIST_PARALLELISM_MAX_THREADS )
{
numThreads = MAX_JOB_THREADS;
}
else if( parallelism > MAX_JOB_THREADS )
{
numThreads = MAX_JOB_THREADS;
}
else
{
numThreads = parallelism;
}
if( numThreads <= 0 )
{
threadJobListState_t state( jobList->GetVersion() );
jobList->RunJobs( 0, state, false );
return;
}
for( int i = 0; i < numThreads; i++ )
{
threads[i].AddJobList( jobList );
threads[i].SignalWork();
}
}
/*
================
idCollisionModelManagerLocal::DrawModel
================
*/
void idCollisionModelManagerLocal::DrawModel( cmHandle_t handle, const idVec3& modelOrigin, const idMat3& modelAxis,
const idVec3& viewOrigin, const float radius )
{
cm_model_t* model;
idVec3 viewPos;
if( handle < 0 && handle >= numModels )
{
return;
}
if( cm_drawColor.IsModified() )
{
sscanf( cm_drawColor.GetString(), "%f %f %f %f", &cm_color.x, &cm_color.y, &cm_color.z, &cm_color.w );
cm_drawColor.ClearModified();
}
model = models[ handle ];
viewPos = ( viewOrigin - modelOrigin ) * modelAxis.Transpose();
checkCount++;
DrawNodePolygons( model, model->node, modelOrigin, modelAxis, viewPos, radius );
}
/*
=================
idCommonLocal::Frame
=================
*/
void idCommonLocal::Frame() {
try {
SCOPED_PROFILE_EVENT( "Common::Frame" );
// This is the only place this is incremented
idLib::frameNumber++;
// allow changing SIMD usage on the fly
if ( com_forceGenericSIMD.IsModified() ) {
idSIMD::InitProcessor( "doom", com_forceGenericSIMD.GetBool() );
com_forceGenericSIMD.ClearModified();
}
// Do the actual switch between Doom 3 and the classics here so
// that things don't get confused in the middle of the frame.
PerformGameSwitch();
// pump all the events
Sys_GenerateEvents();
// write config file if anything changed
WriteConfiguration();
eventLoop->RunEventLoop();
// Activate the shell if it's been requested
if ( showShellRequested && game ) {
game->Shell_Show( true );
showShellRequested = false;
}
// if the console or another gui is down, we don't need to hold the mouse cursor
bool chatting = false;
if ( console->Active() || Dialog().IsDialogActive() || session->IsSystemUIShowing() || ( game && game->InhibitControls() && !IsPlayingDoomClassic() ) ) {
Sys_GrabMouseCursor( false );
usercmdGen->InhibitUsercmd( INHIBIT_SESSION, true );
chatting = true;
} else {
Sys_GrabMouseCursor( true );
usercmdGen->InhibitUsercmd( INHIBIT_SESSION, false );
}
const bool pauseGame = ( !mapSpawned || ( !IsMultiplayer() && ( Dialog().IsDialogPausing() || session->IsSystemUIShowing() || ( game && game->Shell_IsActive() ) ) ) ) && !IsPlayingDoomClassic();
// save the screenshot and audio from the last draw if needed
if ( aviCaptureMode ) {
idStr name = va("demos/%s/%s_%05i.tga", aviDemoShortName.c_str(), aviDemoShortName.c_str(), aviDemoFrameCount++ );
renderSystem->TakeScreenshot( com_aviDemoWidth.GetInteger(), com_aviDemoHeight.GetInteger(), name, com_aviDemoSamples.GetInteger(), NULL );
// remove any printed lines at the top before taking the screenshot
console->ClearNotifyLines();
// this will call Draw, possibly multiple times if com_aviDemoSamples is > 1
renderSystem->TakeScreenshot( com_aviDemoWidth.GetInteger(), com_aviDemoHeight.GetInteger(), name, com_aviDemoSamples.GetInteger(), NULL );
}
//--------------------------------------------
// wait for the GPU to finish drawing
//
// It is imporant to minimize the time spent between this
// section and the call to renderSystem->RenderCommandBuffers(),
// because the GPU is completely idle.
//--------------------------------------------
// this should exit right after vsync, with the GPU idle and ready to draw
// This may block if the GPU isn't finished renderng the previous frame.
frameTiming.startSyncTime = Sys_Microseconds();
const emptyCommand_t * renderCommands = NULL;
if ( com_smp.GetBool() ) {
renderCommands = renderSystem->SwapCommandBuffers( &time_frontend, &time_backend, &time_shadows, &time_gpu );
} else {
// the GPU will stay idle through command generation for minimal
// input latency
renderSystem->SwapCommandBuffers_FinishRendering( &time_frontend, &time_backend, &time_shadows, &time_gpu );
}
frameTiming.finishSyncTime = Sys_Microseconds();
//--------------------------------------------
// Determine how many game tics we are going to run,
// now that the previous frame is completely finished.
//
// It is important that any waiting on the GPU be done
// before this, or there will be a bad stuttering when
// dropping frames for performance management.
//--------------------------------------------
// input:
// thisFrameTime
// com_noSleep
// com_engineHz
// com_fixedTic
// com_deltaTimeClamp
// IsMultiplayer
//
// in/out state:
// gameFrame
// gameTimeResidual
// lastFrameTime
// syncNextFrame
//
// Output:
// numGameFrames
// How many game frames to run
int numGameFrames = 0;
for(;;) {
const int thisFrameTime = Sys_Milliseconds();
static int lastFrameTime = thisFrameTime; // initialized only the first time
const int deltaMilliseconds = thisFrameTime - lastFrameTime;
lastFrameTime = thisFrameTime;
// if there was a large gap in time since the last frame, or the frame
// rate is very very low, limit the number of frames we will run
const int clampedDeltaMilliseconds = Min( deltaMilliseconds, com_deltaTimeClamp.GetInteger() );
gameTimeResidual += clampedDeltaMilliseconds * timescale.GetFloat();
// don't run any frames when paused
if ( pauseGame ) {
gameFrame++;
gameTimeResidual = 0;
break;
}
// debug cvar to force multiple game tics
if ( com_fixedTic.GetInteger() > 0 ) {
numGameFrames = com_fixedTic.GetInteger();
gameFrame += numGameFrames;
gameTimeResidual = 0;
break;
}
if ( syncNextGameFrame ) {
// don't sleep at all
syncNextGameFrame = false;
gameFrame++;
numGameFrames++;
gameTimeResidual = 0;
break;
}
for ( ;; ) {
// How much time to wait before running the next frame,
// based on com_engineHz
const int frameDelay = FRAME_TO_MSEC( gameFrame + 1 ) - FRAME_TO_MSEC( gameFrame );
if ( gameTimeResidual < frameDelay ) {
break;
}
gameTimeResidual -= frameDelay;
gameFrame++;
numGameFrames++;
// if there is enough residual left, we may run additional frames
}
if ( numGameFrames > 0 ) {
// ready to actually run them
break;
}
// if we are vsyncing, we always want to run at least one game
// frame and never sleep, which might happen due to scheduling issues
// if we were just looking at real time.
if ( com_noSleep.GetBool() ) {
numGameFrames = 1;
gameFrame += numGameFrames;
gameTimeResidual = 0;
break;
}
// not enough time has passed to run a frame, as might happen if
// we don't have vsync on, or the monitor is running at 120hz while
// com_engineHz is 60, so sleep a bit and check again
Sys_Sleep( 0 );
}
//--------------------------------------------
// It would be better to push as much of this as possible
// either before or after the renderSystem->SwapCommandBuffers(),
// because the GPU is completely idle.
//--------------------------------------------
// Update session and syncronize to the new session state after sleeping
session->UpdateSignInManager();
session->Pump();
session->ProcessSnapAckQueue();
if ( session->GetState() == idSession::LOADING ) {
// If the session reports we should be loading a map, load it!
ExecuteMapChange();
mapSpawnData.savegameFile = NULL;
mapSpawnData.persistentPlayerInfo.Clear();
return;
} else if ( session->GetState() != idSession::INGAME && mapSpawned ) {
// If the game is running, but the session reports we are not in a game, disconnect
// This happens when a server disconnects us or we sign out
LeaveGame();
return;
}
if ( mapSpawned && !pauseGame ) {
if ( IsClient() ) {
RunNetworkSnapshotFrame();
}
}
ExecuteReliableMessages();
// send frame and mouse events to active guis
GuiFrameEvents();
//--------------------------------------------
// Prepare usercmds and kick off the game processing
// in a background thread
//--------------------------------------------
// get the previous usercmd for bypassed head tracking transform
const usercmd_t previousCmd = usercmdGen->GetCurrentUsercmd();
// build a new usercmd
int deviceNum = session->GetSignInManager().GetMasterInputDevice();
usercmdGen->BuildCurrentUsercmd( deviceNum );
if ( deviceNum == -1 ) {
for ( int i = 0; i < MAX_INPUT_DEVICES; i++ ) {
Sys_PollJoystickInputEvents( i );
Sys_EndJoystickInputEvents();
}
}
if ( pauseGame ) {
usercmdGen->Clear();
}
usercmd_t newCmd = usercmdGen->GetCurrentUsercmd();
// Store server game time - don't let time go past last SS time in case we are extrapolating
if ( IsClient() ) {
newCmd.serverGameMilliseconds = std::min( Game()->GetServerGameTimeMs(), Game()->GetSSEndTime() );
} else {
newCmd.serverGameMilliseconds = Game()->GetServerGameTimeMs();
}
userCmdMgr.MakeReadPtrCurrentForPlayer( Game()->GetLocalClientNum() );
// Stuff a copy of this userCmd for each game frame we are going to run.
// Ideally, the usercmds would be built in another thread so you could
// still get 60hz control accuracy when the game is running slower.
for ( int i = 0 ; i < numGameFrames ; i++ ) {
newCmd.clientGameMilliseconds = FRAME_TO_MSEC( gameFrame-numGameFrames+i+1 );
userCmdMgr.PutUserCmdForPlayer( game->GetLocalClientNum(), newCmd );
}
// If we're in Doom or Doom 2, run tics and upload the new texture.
if ( ( GetCurrentGame() == DOOM_CLASSIC || GetCurrentGame() == DOOM2_CLASSIC ) && !( Dialog().IsDialogPausing() || session->IsSystemUIShowing() ) ) {
RunDoomClassicFrame();
}
// start the game / draw command generation thread going in the background
gameReturn_t ret = gameThread.RunGameAndDraw( numGameFrames, userCmdMgr, IsClient(), gameFrame - numGameFrames );
if ( !com_smp.GetBool() ) {
// in non-smp mode, run the commands we just generated, instead of
// frame-delayed ones from a background thread
renderCommands = renderSystem->SwapCommandBuffers_FinishCommandBuffers();
}
//----------------------------------------
// Run the render back end, getting the GPU busy with new commands
// ASAP to minimize the pipeline bubble.
//----------------------------------------
frameTiming.startRenderTime = Sys_Microseconds();
renderSystem->RenderCommandBuffers( renderCommands );
if ( com_sleepRender.GetInteger() > 0 ) {
// debug tool to test frame adaption
Sys_Sleep( com_sleepRender.GetInteger() );
}
frameTiming.finishRenderTime = Sys_Microseconds();
// make sure the game / draw thread has completed
// This may block if the game is taking longer than the render back end
gameThread.WaitForThread();
// Send local usermds to the server.
// This happens after the game frame has run so that prediction data is up to date.
SendUsercmds( Game()->GetLocalClientNum() );
// Now that we have an updated game frame, we can send out new snapshots to our clients
session->Pump(); // Pump to get updated usercmds to relay
SendSnapshots();
// Render the sound system using the latest commands from the game thread
if ( pauseGame ) {
soundWorld->Pause();
soundSystem->SetPlayingSoundWorld( menuSoundWorld );
} else {
soundWorld->UnPause();
soundSystem->SetPlayingSoundWorld( soundWorld );
}
soundSystem->Render();
// process the game return for map changes, etc
ProcessGameReturn( ret );
idLobbyBase & lobby = session->GetActivePlatformLobbyBase();
if ( lobby.HasActivePeers() ) {
if ( net_drawDebugHud.GetInteger() == 1 ) {
lobby.DrawDebugNetworkHUD();
}
if ( net_drawDebugHud.GetInteger() == 2 ) {
lobby.DrawDebugNetworkHUD2();
}
lobby.DrawDebugNetworkHUD_ServerSnapshotMetrics( net_drawDebugHud.GetInteger() == 3 );
}
// report timing information
if ( com_speeds.GetBool() ) {
static int lastTime = Sys_Milliseconds();
int nowTime = Sys_Milliseconds();
int com_frameMsec = nowTime - lastTime;
lastTime = nowTime;
Printf( "frame:%d all:%3d gfr:%3d rf:%3lld bk:%3lld\n", idLib::frameNumber, com_frameMsec, time_gameFrame, time_frontend / 1000, time_backend / 1000 );
time_gameFrame = 0;
time_gameDraw = 0;
}
// the FPU stack better be empty at this point or some bad code or compiler bug left values on the stack
if ( !Sys_FPU_StackIsEmpty() ) {
Printf( Sys_FPU_GetState() );
FatalError( "idCommon::Frame: the FPU stack is not empty at the end of the frame\n" );
}
mainFrameTiming = frameTiming;
session->GetSaveGameManager().Pump();
} catch( idException & ) {
return; // an ERP_DROP was thrown
}
}
