bugfix(fps): Fix crashes and ww3d updates in tools (#1688)

Author: xezon

Core/GameEngine/Include/Common/FramePacer.h

@@ -20,6 +20,9 @@
 #include "Common/FrameRateLimit.h"
 
 
+// TheSuperHackers @todo Use unsigned integers for fps values
+// TheSuperHackers @todo Consolidate the GlobalData::m_useFpsLimit and FramePacer::m_enableFpsLimit
+// TheSuperHackers @todo Implement new fast forward in here
 class FramePacer
 {
 public:
@@ -36,8 +39,13 @@ class FramePacer
 
 	void update(); ///< Signal that the app/render update is done and wait for the fps limit if applicable.
 
-	void setFramesPerSecondLimit( Int fps ); ///< Set the max update fps.
-	Int getFramesPerSecondLimit() const; ///< Get the max update fps.
+	void setFramesPerSecondLimit( Int fps ); ///< Set the update fps limit.
+	Int  getFramesPerSecondLimit() const; ///< Get the update fps limit.
+	void enableFramesPerSecondLimit( Bool enable ); ///< Enable or disable the update fps limit.
+	Bool isFramesPerSecondLimitEnabled() const; ///< Returns whether the fps limit is enabled here.
+	Bool isActualFramesPerSecondLimitEnabled() const; ///< Returns whether the fps limit is actually enabled when considering all game settings and setups.
+	Int  getActualFramesPerSecondLimit() const; // Get the actual update fps limit.
+
 	Real getUpdateTime() const; ///< Get the last update delta time in seconds.
 	Real getUpdateFps() const; ///< Get the last update fps.
 
@@ -47,8 +55,8 @@ class FramePacer
 	Bool isGameHalted() const;
 
 	void setLogicTimeScaleFps( Int fps ); ///< Set the logic time scale fps and therefore scale the simulation time. Is capped by the max render fps and does not apply to network matches.
-	Int getLogicTimeScaleFps() const; ///< Get the raw logic time scale fps value.
-	void enableLogicTimeScale( Bool enable ); ///< Enable the logic time scale setup. If disabled, the simulation time scale is bound to the render frame time or network update time.
+	Int  getLogicTimeScaleFps() const; ///< Get the raw logic time scale fps value.
+	void enableLogicTimeScale( Bool enable ); ///< Enable or disable the logic time scale setup. If disabled, the simulation time scale is bound to the render frame time or network update time.
 	Bool isLogicTimeScaleEnabled() const; ///< Check whether the logic time scale setup is enabled.
 	Int  getActualLogicTimeScaleFps(LogicTimeQueryFlags flags = 0) const; ///< Get the real logic time scale fps, depending on the max render fps, network state and enabled state.
 	Real getActualLogicTimeScaleRatio(LogicTimeQueryFlags flags = 0) const; ///< Get the real logic time scale ratio, depending on the max render fps, network state and enabled state.
@@ -65,6 +73,7 @@ class FramePacer
 
 	Real m_updateTime; ///< Last update delta time in seconds
 
+	Bool m_enableFpsLimit;
 	Bool m_enableLogicTimeScale;
 	Bool m_isTimeFrozen;
 	Bool m_isGameHalted;

Core/GameEngine/Include/Common/FrameRateLimit.h

@@ -29,8 +29,8 @@ class FrameRateLimit
 	Real wait(UnsignedInt maxFps);
 
 private:
-	LARGE_INTEGER m_freq;
-	LARGE_INTEGER m_start;
+	Int64 m_freq;
+	Int64 m_start;
 };
 
 

Core/GameEngine/Source/Common/FramePacer.cpp

@@ -37,7 +37,8 @@ FramePacer::FramePacer()
 
 	m_maxFPS = BaseFps;
 	m_logicTimeScaleFPS = LOGICFRAMES_PER_SECOND;
-	m_updateTime = 1.0f / BaseFps; // initialized to something to avoid division by zero on first use
+	m_updateTime = 1.0f / (Real)BaseFps; // initialized to something to avoid division by zero on first use
+	m_enableFpsLimit = FALSE;
 	m_enableLogicTimeScale = FALSE;
 	m_isTimeFrozen = FALSE;
 	m_isGameHalted = FALSE;
@@ -51,25 +52,9 @@ FramePacer::~FramePacer()
 
 void FramePacer::update()
 {
-	Bool allowFpsLimit = TheTacticalView->getTimeMultiplier()<=1 && !TheScriptEngine->isTimeFast();
-
-	// I'm disabling this in debug because many people need alt-tab capability.  If you happen to be
-	// doing performance tuning, please just change this on your local system. -MDC
-#if defined(RTS_DEBUG)
-	if (allowFpsLimit)
-		::Sleep(1); // give everyone else a tiny time slice.
-#endif
-
-#if defined(_ALLOW_DEBUG_CHEATS_IN_RELEASE)
-	allowFpsLimit &= !(!TheGameLogic->isGamePaused() && TheGlobalData->m_TiVOFastMode);
-#else	//always allow this cheat key if we're in a replay game.
-	allowFpsLimit &= !(!TheGameLogic->isGamePaused() && TheGlobalData->m_TiVOFastMode && TheGameLogic->isInReplayGame());
-#endif
-
 	// TheSuperHackers @bugfix xezon 05/08/2025 Re-implements the frame rate limiter
 	// with higher resolution counters to cap the frame rate more accurately to the desired limit.
-	allowFpsLimit &= TheGlobalData->m_useFpsLimit;
-	const UnsignedInt maxFps = allowFpsLimit ? getFramesPerSecondLimit() : RenderFpsPreset::UncappedFpsValue;
+	const UnsignedInt maxFps = getActualFramesPerSecondLimit();// allowFpsLimit ? getFramesPerSecondLimit() : RenderFpsPreset::UncappedFpsValue;
 	m_updateTime = m_frameRateLimit.wait(maxFps);
 }
 
@@ -84,6 +69,45 @@ Int FramePacer::getFramesPerSecondLimit()  const
 	return m_maxFPS;
 }
 
+void FramePacer::enableFramesPerSecondLimit( Bool enable )
+{
+	m_enableFpsLimit = enable;
+}
+
+Bool FramePacer::isFramesPerSecondLimitEnabled() const
+{
+	return m_enableFpsLimit;
+}
+
+Bool FramePacer::isActualFramesPerSecondLimitEnabled() const
+{
+	Bool allowFpsLimit = true;
+
+	if (TheTacticalView != NULL)
+	{
+		allowFpsLimit &= TheTacticalView->getTimeMultiplier()<=1 && !TheScriptEngine->isTimeFast();
+	}
+
+	if (TheGameLogic != NULL)
+	{
+#if defined(_ALLOW_DEBUG_CHEATS_IN_RELEASE)
+		allowFpsLimit &= !(!TheGameLogic->isGamePaused() && TheGlobalData->m_TiVOFastMode);
+#else	//always allow this cheat key if we're in a replay game.
+		allowFpsLimit &= !(!TheGameLogic->isGamePaused() && TheGlobalData->m_TiVOFastMode && TheGameLogic->isInReplayGame());
+#endif
+	}
+
+	allowFpsLimit &= TheGlobalData->m_useFpsLimit;
+	allowFpsLimit &= isFramesPerSecondLimitEnabled();
+
+	return allowFpsLimit;
+}
+
+Int FramePacer::getActualFramesPerSecondLimit() const
+{
+	return isActualFramesPerSecondLimitEnabled() ? getFramesPerSecondLimit() : RenderFpsPreset::UncappedFpsValue;
+}
+
 Real FramePacer::getUpdateTime()  const
 {
 	return m_updateTime;
@@ -153,10 +177,11 @@ Int FramePacer::getActualLogicTimeScaleFps(LogicTimeQueryFlags flags) const
 
 	if (isLogicTimeScaleEnabled())
 	{
-		return min(getLogicTimeScaleFps(), getFramesPerSecondLimit());
+		return getLogicTimeScaleFps();
 	}
 
-	return getFramesPerSecondLimit();
+	// Returns uncapped value to align with the render update as per the original game behavior.
+	return RenderFpsPreset::UncappedFpsValue;
 }
 
 Real FramePacer::getActualLogicTimeScaleRatio(LogicTimeQueryFlags flags) const

Core/GameEngine/Source/Common/FrameRateLimit.cpp

@@ -22,15 +22,19 @@
 
 FrameRateLimit::FrameRateLimit()
 {
-	QueryPerformanceFrequency(&m_freq);
-	QueryPerformanceCounter(&m_start);
+	LARGE_INTEGER freq;
+	LARGE_INTEGER start;
+	QueryPerformanceFrequency(&freq);
+	QueryPerformanceCounter(&start);
+	m_freq = freq.QuadPart;
+	m_start = start.QuadPart;
 }
 
 Real FrameRateLimit::wait(UnsignedInt maxFps)
 {
 	LARGE_INTEGER tick;
 	QueryPerformanceCounter(&tick);
-	double elapsedSeconds = static_cast<double>(tick.QuadPart - m_start.QuadPart) / m_freq.QuadPart;
+	double elapsedSeconds = static_cast<double>(tick.QuadPart - m_start) / m_freq;
 	const double targetSeconds = 1.0 / maxFps;
 	const double sleepSeconds = targetSeconds - elapsedSeconds - 0.002; // leave ~2ms for spin wait
 
@@ -45,11 +49,11 @@ Real FrameRateLimit::wait(UnsignedInt maxFps)
 	do
 	{
 		QueryPerformanceCounter(&tick);
-		elapsedSeconds = static_cast<double>(tick.QuadPart - m_start.QuadPart) / m_freq.QuadPart;
+		elapsedSeconds = static_cast<double>(tick.QuadPart - m_start) / m_freq;
 	}
 	while (elapsedSeconds < targetSeconds);
 
-	m_start = tick;
+	m_start = tick.QuadPart;
 	return (Real)elapsedSeconds;
 }
 

Core/Libraries/Source/WWVegas/WWLib/WWCommon.h

@@ -31,7 +31,8 @@ enum
 {
 	// TheSuperHackers @info The original WWSync was 33 ms, ~30 fps, integer.
 	// Changing this will require tweaking all Drawable code that concerns the ww3d time step, including locomotion physics.
-	WWSyncPerSecond = 30
+	WWSyncPerSecond = 30,
+	WWSyncMilliseconds = 1000 / WWSyncPerSecond,
 };
 
 #if defined(_MSC_VER) && _MSC_VER < 1300

Core/Tools/W3DView/GraphicView.cpp

@@ -436,7 +436,8 @@ CGraphicView::RepaintView
 	//	Simple check to avoid re-entrance
 	//
 	static bool _already_painting = false;
-	if (_already_painting) return;
+	if (_already_painting)
+		return;
 	_already_painting = true;
 
 	 //
@@ -452,10 +453,15 @@ CGraphicView::RepaintView
 		m_dwLastFrameUpdate = cur_ticks;
 
 		// Update the W3D frame times according to our elapsed tick count
-		if (ticks_to_use == 0) {
-			WW3D::Sync (WW3D::Get_Sync_Time() + (ticks_elapsed * m_animationSpeed));
-		} else {
-			WW3D::Sync (WW3D::Get_Sync_Time() + ticks_to_use);
+		if (ticks_to_use == 0)
+		{
+			WW3D::Update_Logic_Frame_Time(ticks_elapsed * m_animationSpeed);
+			WW3D::Sync(WW3D::Get_Fractional_Sync_Milliseconds() >= WWSyncMilliseconds);
+		}
+		else
+		{
+			WW3D::Update_Logic_Frame_Time(ticks_to_use);
+			WW3D::Sync(true);
 		}
 
 		// Do we need to update the current animation?

Generals/Code/GameEngine/Source/Common/GameMain.cpp

@@ -41,6 +41,7 @@ Int GameMain()
 	int exitcode = 0;
 	// initialize the game engine using factory function
 	TheFramePacer = new FramePacer();
+	TheFramePacer->enableFramesPerSecondLimit(TRUE);
 	TheGameEngine = CreateGameEngine();
 	TheGameEngine->init();
 

Generals/Code/Libraries/Source/WWVegas/WW3D2/ww3d.h

@@ -173,6 +173,7 @@ class WW3D
 	static void						Sync(bool step);
 	static unsigned int		Get_Sync_Time(void) { return SyncTime; }
 	static unsigned int		Get_Sync_Frame_Time(void) { return SyncTime - PreviousSyncTime; }
+	static unsigned int		Get_Fractional_Sync_Milliseconds() { return FractionalSyncMs; }
 	static float					Get_Logic_Frame_Time_Milliseconds() { return LogicFrameTimeMs; }
 	static float					Get_Logic_Frame_Time_Seconds() { return LogicFrameTimeMs * 0.001f; }
 	static unsigned int		Get_Frame_Count(void) { return FrameCount; }

Generals/Code/Tools/GUIEdit/Source/EditWindow.cpp

@@ -49,6 +49,7 @@
 
 // USER INCLUDES //////////////////////////////////////////////////////////////
 #include "Common/Debug.h"
+#include "Common/FramePacer.h"
 #include "GameClient/Display.h"
 #include "GameClient/GameWindowManager.h"
 #include "W3DDevice/GameClient/W3DFileSystem.h"
@@ -1456,13 +1457,9 @@ void EditWindow::drawGrid( void )
 //=============================================================================
 void EditWindow::draw( void )
 {
-	static UnsignedInt syncTime = 0;
-
 	// allow W3D to update its internals
-	WW3D::Sync( syncTime );
-
-	// for now, use constant time steps to avoid animations running independent of framerate
-	syncTime += 50;
+	WW3D::Update_Logic_Frame_Time(TheFramePacer->getLogicTimeStepMilliseconds());
+	WW3D::Sync(WW3D::Get_Fractional_Sync_Milliseconds() >= WWSyncMilliseconds);
 
 	// start render block
 	WW3D::Begin_Render( true, true, Vector3( m_backgroundColor.red,
@@ -1479,6 +1476,7 @@ void EditWindow::draw( void )
 	// render is all done!
 	WW3D::End_Render();
 
+	TheFramePacer->update();
 }
 
 // EditWindow::setSize ========================================================

Generals/Code/Tools/GUIEdit/Source/WinMain.cpp

@@ -50,8 +50,8 @@
 
 // USER INCLUDES //////////////////////////////////////////////////////////////
 #include "Common/Debug.h"
+#include "Common/FramePacer.h"
 #include "Common/GameMemory.h"
-#include "Common/GameEngine.h"
 #include "GameClient/GameWindowManager.h"
 #include "Win32Device/GameClient/Win32Mouse.h"
 #include "resource.h"
@@ -224,6 +224,8 @@ Int APIENTRY WinMain(HINSTANCE hInstance,
 		return FALSE;
 	TheEditor->init();
 
+	TheFramePacer = new FramePacer();
+
 	//
 	// see if we have any messages to process, a NULL window handle tells the
 	// OS to look at the main window associated with the calling thread, us!
@@ -262,7 +264,7 @@ Int APIENTRY WinMain(HINSTANCE hInstance,
 		else
 		{
 
-			// udpate our universe
+			// update our universe
 			TheEditor->update();
 			Sleep(1);
 
@@ -271,6 +273,9 @@ Int APIENTRY WinMain(HINSTANCE hInstance,
 	}
 
 	// shutdown GUIEdit data
+	delete TheFramePacer;
+	TheFramePacer = NULL;
+
 	delete TheEditor;
 	TheEditor = NULL;