Improvements to make sim timing info more accurate, and allowing proper fast-motion

Author: Causeless

Managers/PerformanceMan.cpp

@@ -130,7 +130,7 @@ namespace RTE {
 			std::snprintf(str, sizeof(str), "Frame: %.1fms | Update: %.1fms | Draw: %.1fms", m_MSPFAverage, m_MSPUAverage, m_MSPDAverage);
 			guiFont->DrawAligned(&drawBitmap, c_StatsOffsetX, c_StatsHeight + 10, str, GUIFont::Left);
 
-			std::snprintf(str, sizeof(str), "Time Scale: x%.2f ([1]-, [2]+, [Ctrl+1]Rst)", g_TimerMan.IsOneSimUpdatePerFrame() ? g_TimerMan.GetSimSpeed() : g_TimerMan.GetTimeScale());
+			std::snprintf(str, sizeof(str), "Time Scale: x%.2f ([1]-, [2]+, [Ctrl+1]Rst)", g_TimerMan.GetSimSpeed());
 			guiFont->DrawAligned(&drawBitmap, c_StatsOffsetX, c_StatsHeight + 20, str, GUIFont::Left);
 
 			std::snprintf(str, sizeof(str), "Real to Sim Cap: %.2f ms ([3]-, [4]+, [Ctrl+3]Rst)", g_TimerMan.GetRealToSimCap() * 1000.0F);

Managers/PerformanceMan.h

@@ -92,6 +92,12 @@ namespace RTE {
 		/// <param name="showGraphs">Whether to show the performance graphs or not.</param>
 		void ShowAdvancedPerformanceStats(bool showGraphs = true) { m_AdvancedPerfStats = showGraphs; }
 
+		/// <summary>
+		/// Gets the average of the MSPU reading buffer, calculated each update.
+		/// </summary>
+		/// <returns>The average value of the MSPU reading buffer.</returns>
+		float GetMSPSUAverage() const { return m_MSPSUAverage; }
+
 		/// <summary>
 		/// Gets the average of the MSPF reading buffer, calculated each frame.
 		/// </summary>

Managers/TimerMan.cpp

@@ -30,7 +30,6 @@ namespace RTE {
 		m_TimeScale = 1.0F;
 		m_SimPaused = false;
 		m_OneSimUpdatePerFrame = true;
-		m_SimSpeedLimited = true;
 	}
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -89,35 +88,32 @@ namespace RTE {
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
+#pragma optimize("", off)
 	void TimerMan::Update() {
 		long long prevTime = m_RealTimeTicks;
 		m_RealTimeTicks = std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::steady_clock::now() - m_StartTime).count();
-		unsigned long long timeIncrease = m_RealTimeTicks - prevTime;
-		// Cap it if too long (as when the app went out of focus).
-		if (timeIncrease > m_RealToSimCap) { timeIncrease = m_RealToSimCap; }
+
+		// Cap timeIncrease if too long (as when the app went out of focus), to m_RealToSimCap.
+		long long timeIncrease = std::min(m_RealTimeTicks - prevTime, m_RealToSimCap);
 
 		RTEAssert(timeIncrease > 0, "It seems your CPU is giving bad timing data to the game, this is known to happen on some multi-core processors. This may be fixed by downloading the latest CPU drivers from AMD or Intel.");
 
 		// If not paused, add the new time difference to the sim accumulator, scaling by the TimeScale.
-		if (!m_SimPaused) { m_SimAccumulator += static_cast<long long>(static_cast<float>(timeIncrease) * m_TimeScale); }
+		if (!m_SimPaused) { 
+			m_SimAccumulator += static_cast<long long>(static_cast<float>(timeIncrease) * m_TimeScale); 
+		}
+
+		// Make sure we don't get runaway behind schedule
+		m_SimAccumulator = std::min(m_SimAccumulator, m_DeltaTime * 2);
 
 		RTEAssert(m_SimAccumulator >= 0, "Negative sim time accumulator?!");
 
 		// Reset the counter since the last drawn update. Set it negative since we're counting full pure sim updates and this will be incremented to 0 on next SimUpdate.
-		if (m_DrawnSimUpdate) { m_SimUpdatesSinceDrawn = -1; }
-
-		// Override the accumulator and just put one delta time in there so sim updates only once per frame.
-		if (m_OneSimUpdatePerFrame) {
-			// Make sure we don't get runaway behind
-			if (m_SimSpeedLimited && m_SimAccumulator > m_DeltaTime * 2.0f) { m_SimAccumulator = m_DeltaTime; }
-
-			// Reset the counter of sim updates since the last drawn. it will always be 0 since every update results in a drawn frame.
-			m_SimUpdatesSinceDrawn = -1;
-
-			m_SimSpeed = GetDeltaTimeMS() / g_PerformanceMan.GetMSPFAverage();
-			if (IsSimSpeedLimited() && m_SimSpeed > 1.0F) { m_SimSpeed = 1.0F; }
-		} else {
-			m_SimSpeed = 1.0F;
+		if (m_DrawnSimUpdate || m_OneSimUpdatePerFrame) {
+			m_SimUpdatesSinceDrawn = -1; 
 		}
+
+		m_SimSpeed = std::min(GetDeltaTimeMS() / g_PerformanceMan.GetMSPSUAverage(), GetTimeScale());
 	}
+#pragma optimize("", on)
 }

Managers/TimerMan.h

@@ -109,18 +109,6 @@ namespace RTE {
 		/// <param name="oneUpdate">Whether the sim should be set to only update once per graphics frame or not.</param>
 		void SetOneSimUpdatePerFrame(bool oneUpdate = true) { m_OneSimUpdatePerFrame = oneUpdate; }
 
-		/// <summary>
-		/// Shows whether the sim speed is limited to not exceed 1.0x.
-		/// </summary>
-		/// <returns>Whether the sim is limited to not exceed 1.0x of real time.</returns>
-		bool IsSimSpeedLimited() const { return m_OneSimUpdatePerFrame && m_SimSpeedLimited; }
-
-		/// <summary>
-		/// Sets whether to limit the sim speed to not exceed real time.
-		/// </summary>
-		/// <param name="simLimited">Whether the sim speed should be limited to not exceed 1.0.</param>
-		void SetSimSpeedLimited(bool simLimited = true) { m_SimSpeedLimited = simLimited; }
-
 		/// <summary>
 		/// Gets the number of ticks per second (the resolution of the timer).
 		/// </summary>
@@ -241,7 +229,6 @@ namespace RTE {
 
 		bool m_SimPaused; //!< Simulation paused; no real time ticks will go to the sim accumulator.
 		bool m_OneSimUpdatePerFrame; //!< Whether to force this to artificially make time for only one single sim update for the graphics frame. Useful for debugging or profiling.
-		bool m_SimSpeedLimited; //!< Whether the simulation is limited to going at 1.0x and not faster.
 
 	private: