Readds all the std::chrono calls back into the game loop. (#85)

Move from QueryPerformanceCounter to std::chrono::steady_clock for multiplatforming

Author: uvcat7

src/Core/Core.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <cstdint>
+#include <chrono>
 
 namespace Vortex {
 
@@ -51,7 +52,7 @@ struct TimingData;
 typedef const String& StringRef;
 typedef uint64_t TextureHandle;
 
-extern float deltaTime;
+extern std::chrono::duration<double> deltaTime;
 
 extern void HudNote(const char* fmt, ...);
 extern void HudInfo(const char* fmt, ...);

src/Core/TextDraw.cpp

@@ -321,8 +321,6 @@ void Text::draw(vec2i textPos)
 		}
 		batch.flush();
 	}
-
-	VortexCheckGlError();
 }
 
 };

src/Editor/Editor.cpp

@@ -894,13 +894,13 @@ void tick()
 	gTextOverlay->handleInputs(events);
 
 	GuiMain::setViewSize(r.w, r.h);
-	GuiMain::frameStart(deltaTime, events);
+	GuiMain::frameStart(deltaTime.count(), events);
 
 	vec2i view = gSystem->getWindowSize();
 
 	handleDialogs();
 
-	gui_->tick({ 0, 0, view.x, view.y }, deltaTime, events);
+	gui_->tick({ 0, 0, view.x, view.y }, deltaTime.count(), events);
 
 	if (!GuiMain::isCapturingText())
 	{

src/Editor/Music.cpp

@@ -3,6 +3,7 @@
 #include <limits.h>
 #include <stdint.h>
 #include <math.h>
+#include <chrono>
 
 #include <Core/Vector.h>
 #include <Core/Reference.h>
@@ -48,7 +49,7 @@ struct MusicImpl : public Music, public MixSource {
 
 Mixer* myMixer;
 Sound mySamples;
-double myPlayTimer;
+std::chrono::steady_clock::time_point myPlayTimer;
 TickData myBeatTick, myNoteTick;
 String myTitle, myArtist;
 int myMusicSpeed;

src/Editor/Sound.cpp

@@ -10,6 +10,7 @@
 
 #include <stdint.h>
 #include <limits.h>
+#include <chrono>
 
 namespace Vortex {
 
@@ -93,7 +94,7 @@ class Sound::Thread : public BackgroundThread
 	int myCurrentFrame;
 	int myReservedFrames;
 	uchar myProgress;
-	double myStartTime;
+	std::chrono::steady_clock::time_point myStartTime;
 };
 
 Sound::Thread::~Thread()

src/Editor/TextOverlay.cpp

@@ -411,7 +411,7 @@ void tickHud()
 		{
 			fade += 0.5f;
 		}
-		float delta = clamp(deltaTime * fade, 0.0f, 1.0f);
+		float delta = clamp(deltaTime.count() * fade, 0.0, 1.0);
 
 		hudEntries_[i].timeLeft -= delta;
 		if(hudEntries_[i].timeLeft <= -0.5f) hudEntries_.erase(i);
@@ -625,7 +625,7 @@ void drawAbout()
 
 	DrawTitleText("ABOUT", "[ESC] close", nullptr);
 
-	auto fps = Str::fmt("%1 FPS").arg(1.0f / max(deltaTime, 0.0001f), 0, 0);
+	auto fps = Str::fmt("%1 FPS").arg(1.0f / max(deltaTime.count(), 0.0001), 0, 0);
 	Text::arrange(Text::TR, fps);
 	Text::draw(vec2i{size.x - 4, 4});
 }

src/System/Debug.cpp

@@ -5,7 +5,7 @@
 #include <io.h>
 #include <fcntl.h>
 #include <stdio.h>
-#include <time.h>
+#include <chrono>
 
 #define WIN32_LEAN_AND_MEAN
 #include <windows.h>
@@ -17,22 +17,18 @@ namespace Debug {
 
 // ================================================================================================
 // Debug :: timing functions.
+using namespace std::chrono;
 
-double getElapsedTime()
+steady_clock::time_point getElapsedTime()
 {
-	static const double timer = []() {
-		LARGE_INTEGER freq;
-		return QueryPerformanceFrequency(&freq) ? 1.0 / static_cast<double>(freq.QuadPart) : 1.0;
-	}();
-
-	LARGE_INTEGER counter;
-	QueryPerformanceCounter(&counter);
-	return static_cast<double>(counter.QuadPart) * timer;
+	return std::chrono::steady_clock::now();
 }
 
-double getElapsedTime(double startTime)
+double getElapsedTime(steady_clock::time_point startTime)
 {
-	return getElapsedTime() - startTime;
+	auto currentTime = steady_clock::now();
+	const duration<double> deltaTime = currentTime - startTime;
+	return deltaTime.count();
 }
 
 // ================================================================================================

src/System/Debug.h

@@ -2,6 +2,7 @@
 
 #include <Core/Core.h>
 #include <assert.h>
+#include <chrono>
 
 #ifndef _DEBUG
 #define VORTEX_DISABLE_ASSERTS
@@ -15,10 +16,10 @@ namespace Debug
 	enum Type { INFO, WARNING, ERROR };
 
 	/// Returns a timestamp of the current time.
-	double getElapsedTime();
+	std::chrono::steady_clock::time_point getElapsedTime();
 
 	/// Returns the number of seconds elapsed since the start time.
-	double getElapsedTime(double startTime);
+	double getElapsedTime(std::chrono::steady_clock::time_point startTime);
 
 	/// Creates a blank log file.
 	void openLogFile();

src/System/System.cpp

@@ -28,6 +28,7 @@
 #include <gl/gl.h>
 #undef ERROR
 
+#include <chrono>
 #include <thread>
 #include <numeric>
 #include <stdio.h>
@@ -45,7 +46,7 @@ processorArchitecture='*' publicKeyToken='6595b64144ccf1df' language='*'\"")
 
 namespace Vortex {
 
-float deltaTime; // Defined in <Core/Core.h>
+std::chrono::duration<double> deltaTime; // Defined in <Core/Core.h>
 
 namespace {
 
@@ -222,7 +223,7 @@ struct SystemImpl : public System {
 
 wchar_t* myClassName;
 HINSTANCE myInstance;
-double myApplicationStartTime;
+std::chrono::steady_clock::time_point myApplicationStartTime;
 Cursor::Icon myCursor;
 Key::Code myKeyMap[256];
 InputEvents myEvents;
@@ -398,22 +399,28 @@ void createMenu()
 
 void CALLBACK messageLoop()
 {
+	using namespace std::chrono;
+
 	if(!myInitSuccesful) return;
 
 #ifdef DEBUG
 	long long frames = 0;
 	auto lowcounts = 0;
-	std::list<double> fpsList, sleepList, frameList, inputList, waitList; 
+	std::list<double> fpsList, sleepList, frameList, inputList, waitList;
+	// Adjust frameGuess to your VSync target if you are testing with VSync enabled
 	auto frameGuess = 960;
 #endif
 
 	Editor::create();
 	forwardArgs();
 	createMenu();
 
+	// Non-vsync FPS max target
+	auto frameTarget = duration<double>(1.0 / 960.0);
+
 	// Enter the message loop.
 	MSG message;
-	double prevTime = Debug::getElapsedTime();
+	auto prevTime = Debug::getElapsedTime();
 	while(!myIsTerminated)
 	{
 
@@ -446,15 +453,88 @@ void CALLBACK messageLoop()
 		// Reset the mouse cursor.
 		myCursor = Cursor::ARROW;
 
-		// Tick function.
-		double curTime = Debug::getElapsedTime();
-		deltaTime = (float)min(max(0.00025, curTime - prevTime), 0.25);
-		prevTime = curTime;
+#ifdef DEBUG
+		auto inputTime = Debug::getElapsedTime();
+#endif
+
+		VortexCheckGlError();
 
 		gEditor->tick();
 
 		// Display.
 		SwapBuffers(myHDC);
+
+#ifdef DEBUG
+		auto renderTime = Debug::getElapsedTime();
+#endif
+		// Tick function.
+		duration<double> frameTime = Debug::getElapsedTime() - prevTime;
+		auto waitTime = frameTarget.count() - frameTime.count();
+
+		if (wglSwapInterval)
+		{
+			while (Debug::getElapsedTime() - prevTime < frameTarget)
+			{
+				std::this_thread::yield();
+			}
+		}
+
+		// End of frame
+		auto curTime = Debug::getElapsedTime();
+		deltaTime = duration<double>((float)min(max(0, duration<double>(curTime - prevTime).count()), 0.25));
+		prevTime = curTime;
+
+#ifdef DEBUG
+		// Do frame statistics
+		// Note that these will be wrong with VSync enabled.
+		fpsList.push_front(deltaTime.count());
+		waitList.push_front(duration<double>(curTime - renderTime).count());
+		frameList.push_front(duration<double>(renderTime - inputTime).count());
+		inputList.push_front(duration<double>(inputTime - startTime).count());
+
+		if (abs(deltaTime.count() - 1.0 / (double)frameGuess) / (1.0 / (double)frameGuess) > 0.01)
+		{
+			lowcounts++;
+		}
+		if (fpsList.size() >= frameGuess * 2)
+		{
+			fpsList.pop_back();
+			frameList.pop_back();
+			inputList.pop_back();
+			waitList.pop_back();
+		}
+		auto min = *std::min_element(fpsList.begin(), fpsList.end());
+		auto max = *std::max_element(fpsList.begin(), fpsList.end());
+		auto maxIndex = std::distance(fpsList.begin(), std::max_element(fpsList.begin(), fpsList.end()));
+		auto siz = fpsList.size();
+		auto avg = std::accumulate(fpsList.begin(), fpsList.end(), 0.0) / siz;
+		auto varianceFunc = [&avg, &siz](double accumulator, double val) {
+			return accumulator + (val - avg) * (val - avg);
+			};
+		auto std = sqrt(std::accumulate(fpsList.begin(), fpsList.end(), 0.0, varianceFunc) / siz);
+		auto frameAvg = std::accumulate(frameList.begin(), frameList.end(), 0.0) / frameList.size();
+		auto frameMax = frameList.begin();
+		std::advance(frameMax, maxIndex);
+		auto inputMax = inputList.begin();
+		std::advance(inputMax, maxIndex);
+		auto waitMax = waitList.begin();
+		std::advance(waitMax, maxIndex);
+		if (frames % (frameGuess * 2) == 0)
+		{
+			Debug::log("frame total average: %f, frame render average %f, std dev %f, lowest FPS %f, highest FPS %f, highest FPS render time %f, highest FPS input time %f, highest FPS wait time %f, lag frames %d\n",
+				avg,
+				frameAvg,
+				std,
+				1.0 / max,
+				1.0 / min,
+				*frameMax,
+				*inputMax,
+				*waitMax,
+				lowcounts);
+			lowcounts = 0;
+		}
+		frames++;
+#endif
 	}
 	Editor::destroy();
 }