Batman

project/src/Timer.cpp

@@ -0,0 +1,144 @@
+#include "Timer.h"
+
+#include <iostream>
+#include <numeric>
+
+#include <iostream>
+#include <fstream>
+#include <float.h>
+
+#include "SDL.h"
+using namespace dae;
+
+Timer::Timer()
+{
+	const uint64_t countsPerSecond = SDL_GetPerformanceFrequency();
+	m_SecondsPerCount = 1.0f / static_cast<float>(countsPerSecond);
+}
+
+void Timer::Reset()
+{
+	const uint64_t currentTime = SDL_GetPerformanceCounter();
+
+	m_BaseTime = currentTime;
+	m_PreviousTime = currentTime;
+	m_StopTime = 0;
+	m_FPSTimer = 0.0f;
+	m_FPSCount = 0;
+	m_IsStopped = false;
+}
+
+void Timer::Start()
+{
+	const uint64_t startTime = SDL_GetPerformanceCounter();
+
+	if (m_IsStopped)
+	{
+		m_PausedTime += (startTime - m_StopTime);
+
+		m_PreviousTime = startTime;
+		m_StopTime = 0;
+		m_IsStopped = false;
+	}
+}
+
+void Timer::StartBenchmark(int numFrames)
+{
+	if (m_BenchmarkActive)
+	{
+		std::cout << "(Benchmark already running)";
+		return;
+	}
+
+	m_BenchmarkActive = true;
+
+	m_BenchmarkAvg = 0.f;
+	m_BenchmarkHigh = FLT_MIN;
+	m_BenchmarkLow = FLT_MAX;
+
+	m_BenchmarkFrames = numFrames;
+	m_BenchmarkCurrFrame = 0;
+
+	m_Benchmarks.clear();
+	m_Benchmarks.resize(m_BenchmarkFrames);
+
+	std::cout << "**BENCHMARK STARTED**\n";
+}
+
+void Timer::Update()
+{
+	if (m_IsStopped)
+	{
+		m_FPS = 0;
+		m_ElapsedTime = 0.0f;
+		m_TotalTime = (float)(((m_StopTime - m_PausedTime) - m_BaseTime) * m_BaseTime);
+		return;
+	}
+
+	const uint64_t currentTime = SDL_GetPerformanceCounter();
+	m_CurrentTime = currentTime;
+
+	m_ElapsedTime = (float)((m_CurrentTime - m_PreviousTime) * m_SecondsPerCount);
+	m_PreviousTime = m_CurrentTime;
+
+	if (m_ElapsedTime < 0.0f)
+		m_ElapsedTime = 0.0f;
+
+	if (m_ForceElapsedUpperBound && m_ElapsedTime > m_ElapsedUpperBound)
+	{
+		m_ElapsedTime = m_ElapsedUpperBound;
+	}
+
+	m_TotalTime = (float)(((m_CurrentTime - m_PausedTime) - m_BaseTime) * m_SecondsPerCount);
+
+	//FPS LOGIC
+	m_FPSTimer += m_ElapsedTime;
+	++m_FPSCount;
+	if (m_FPSTimer >= 1.0f)
+	{
+		m_dFPS = m_FPSCount / m_FPSTimer;
+		m_FPS = m_FPSCount;
+		m_FPSCount = 0;
+		m_FPSTimer = 0.0f;
+
+		if (m_BenchmarkActive)
+		{
+			m_Benchmarks[m_BenchmarkCurrFrame] = m_dFPS;
+
+			m_BenchmarkLow = std::min(m_BenchmarkLow, m_dFPS);
+			m_BenchmarkHigh = std::max(m_BenchmarkHigh, m_dFPS);
+
+			++m_BenchmarkCurrFrame;
+			if (m_BenchmarkCurrFrame >= m_BenchmarkFrames)
+			{
+				m_BenchmarkActive = false;
+				m_BenchmarkAvg = std::accumulate(m_Benchmarks.begin(), m_Benchmarks.end(), 0.f) / float(m_BenchmarkFrames);
+
+				//print
+				std::cout << "**BENCHMARK FINISHED**\n";
+				std::cout << ">> HIGH = " << m_BenchmarkHigh << std::endl;
+				std::cout << ">> LOW = " << m_BenchmarkLow << std::endl;
+				std::cout << ">> AVG = " << m_BenchmarkAvg << std::endl;
+
+				//file save
+				std::ofstream fileStream("benchmark.txt");
+				fileStream << "FRAMES = " << m_BenchmarkCurrFrame << std::endl;
+				fileStream << "HIGH = " << m_BenchmarkHigh << std::endl;
+				fileStream << "LOW = " << m_BenchmarkLow << std::endl;
+				fileStream << "AVG = " << m_BenchmarkAvg << std::endl;
+				fileStream.close();
+			}
+		}
+	}
+}
+
+void Timer::Stop()
+{
+	if (!m_IsStopped)
+	{
+		const uint64_t currentTime = SDL_GetPerformanceCounter();
+
+		m_StopTime = currentTime;
+		m_IsStopped = true;
+	}
+}