better time class, switched floats to doubles, removed vsync, added f…

…ramerate cap

engine/core/module.h

@@ -8,11 +8,11 @@ namespace ce {
 	class Module {
 	 private:
 	 public:
-		virtual void tick(float deltaTime) = 0;
+		virtual void tick(double deltaTime) = 0;
 	};
 	typedef Module* init_module_t();
 	typedef void delete_module_t(Module*);
 }
-#define CE_MODULE(X)                                      \
-	extern "C" ce::Module* init_module() { return new X; } \
-	extern "C" void delete_module(ce::Module* m) { delete m; }
+#define CE_MODULE(CLASS)                                      \
+	extern "C" ce::Module* init_module() { return new CLASS; } \
+	extern "C" void delete_module(ce::Module* m) { delete m; }

engine/core/time.cpp

@@ -1,18 +1,29 @@
 #include "time.h"
 
-#include <ce_rendering.h>
+#include <SDL.h>
 
-float ce::Time::getTime() {
-	return SDL_GetTicks() / 1000.0f;
-}
 ce::Time::Time()
-	: m_last(getTime()), m_now(0), m_dt(0), m_fps(0) {}
+	: m_dt(0), m_fps(0) {
+	update(false, false);
+}
 
 ce::Time::~Time() {}
 
-void ce::Time::update() {
-	m_now = getTime();
-	m_dt = m_now - m_last;
-	m_fps = 1 / m_dt;
+void ce::Time::recalculate(bool dt, bool fps) {
+	m_now = SDL_GetPerformanceCounter();
+	if (dt)
+		m_dt = (m_now - m_last) / (double)SDL_GetPerformanceFrequency();
+	if (fps)
+		m_fps = (double)SDL_GetPerformanceFrequency() / (m_now - m_last);
+}
+
+void ce::Time::update(bool dt, bool fps) {
+	recalculate(dt, fps);
 	m_last = m_now;
+}
+
+void ce::Time::waitUntilDelta(double dt) {
+	do
+		recalculate(true, false);
+	while (m_dt < dt);
 }

engine/core/time.h

@@ -3,17 +3,18 @@
 namespace ce {
 	class Time {
 	 private:
-		float m_now, m_last, m_dt, m_fps;
-
-		float getTime();
+		unsigned long m_now, m_last;
+		double m_dt, m_fps;
 
 	 public:
 		Time();
 		~Time();
 
-		void update();
+		void recalculate(bool dt = true, bool fps = true);
+		void update(bool dt = true, bool fps = true);
+		void waitUntilDelta(double dt);
 
-		float getDeltaTime() { return m_dt; }
-		float getFPS() { return m_fps; };
+		double getDeltaTime() { return m_dt; }
+		double getFPS() { return m_fps; };
 	};
 }

engine/main.cpp

@@ -94,6 +94,7 @@ int main(int argc, char* argv[]) {
 	ce::Time* time = new ce::Time();
 
 	ce::Window* window = new ce::Window("Cinnabar");
+	SDL_GL_SetSwapInterval(0); // disable vsync
 
 	ce::RenderEngine* renderEngine = new ce::RenderEngine();
 	renderEngine->setFOV(75.0f);
@@ -117,7 +118,8 @@ int main(int argc, char* argv[]) {
 	ce::Transform* blenderPos = new ce::Transform();
 	ce::Material* blenderMaterial = new ce::Material("vertColor");
 
-	float mouseSens = 0.25f;
+	double mouseSens = 0.05;
+	double deltaTimeMin = 1.0 / 1000.0; // framerate cap
 	ce::Camera* camera = new ce::Camera();
 	// TODO: Seperate so i can put in a player class later
 	glm::vec3 cameraVelocity(0.0f);
@@ -128,9 +130,10 @@ int main(int argc, char* argv[]) {
 	 * Game Loop
 	 */
 	SDL_Event event;
-	int running = 1;
+	bool running = true;
 	while (running) {
 		time->update();
+		std::cout << time->getFPS() << std::endl;
 
 		while (SDL_PollEvent(&event)) {
 			switch (event.type) {
@@ -149,37 +152,29 @@ int main(int argc, char* argv[]) {
 					break;
 				}
 				case SDL_KEYDOWN: {
-					float cameraSpeed = 2.5f * time->getDeltaTime();
-					if (event.key.keysym.sym == SDLK_w)
-						cameraVelocity.z = cameraSpeed;
-					else if (event.key.keysym.sym == SDLK_s)
-						cameraVelocity.z = -cameraSpeed;
-					if (event.key.keysym.sym == SDLK_a)
-						cameraVelocity.x = -cameraSpeed;
-					else if (event.key.keysym.sym == SDLK_d)
-						cameraVelocity.x = cameraSpeed;
-					if (event.key.keysym.sym == SDLK_SPACE)
-						cameraVelocity.y = cameraSpeed;
-					else if (event.key.keysym.sym == SDLK_LSHIFT)
-						cameraVelocity.y = -cameraSpeed;
-					if (event.key.keysym.sym == SDLK_ESCAPE)
-						window->setMouseVisibility(true);
+					double cameraSpeed = 2.5 * time->getDeltaTime();
+					switch (event.key.keysym.sym) {
+						case SDLK_w: cameraVelocity.z = cameraSpeed; break;
+						case SDLK_s: cameraVelocity.z = -cameraSpeed; break;
+						case SDLK_d: cameraVelocity.x = cameraSpeed; break;
+						case SDLK_a: cameraVelocity.x = -cameraSpeed; break;
+						case SDLK_SPACE: cameraVelocity.y = cameraSpeed; break;
+						case SDLK_LSHIFT: cameraVelocity.y = -cameraSpeed; break;
+
+						case SDLK_ESCAPE: window->setMouseVisibility(true); break;
+					}
 					break;
 				}
 				case SDL_KEYUP: {
-					if ((event.key.keysym.sym == SDLK_w && cameraVelocity.z > 0) ||
-						 (event.key.keysym.sym == SDLK_s && cameraVelocity.z < 0))
-						cameraVelocity.z = 0;
-					if ((event.key.keysym.sym == SDLK_a && cameraVelocity.x < 0) ||
-						 (event.key.keysym.sym == SDLK_d && cameraVelocity.x > 0))
-						cameraVelocity.x = 0;
-					if ((event.key.keysym.sym == SDLK_SPACE && cameraVelocity.y > 0) ||
-						 (event.key.keysym.sym == SDLK_LSHIFT && cameraVelocity.y < 0))
-						cameraVelocity.y = 0;
+					switch (event.key.keysym.sym) { // note that this movement is terrible and should absolutely not be used in a proper engine
+						case SDLK_w: case SDLK_s: cameraVelocity.z = 0; break;
+						case SDLK_d: case SDLK_a: cameraVelocity.x = 0; break;
+						case SDLK_SPACE: case SDLK_LSHIFT: cameraVelocity.y = 0; break;
+					}
 					break;
 				}
 				case SDL_QUIT: {
-					running = 0;
+					running = false;
 					break;
 				}
 				case SDL_WINDOWEVENT: {
@@ -192,9 +187,9 @@ int main(int argc, char* argv[]) {
 		moduleManager->tickModules(time->getDeltaTime());
 
 		// Rotate cube
-		cubePos->roll(25.0f * time->getDeltaTime());
-		cubePos->yaw(50.0f * time->getDeltaTime());
-		cubePos->pitch(100.0f * time->getDeltaTime());
+		cubePos->roll(25.0 * time->getDeltaTime());
+		cubePos->yaw(50.0 * time->getDeltaTime());
+		cubePos->pitch(100.0 * time->getDeltaTime());
 
 		// Move camera
 		glm::vec3
@@ -213,6 +208,9 @@ int main(int argc, char* argv[]) {
 		renderEngine->render();
 
 		window->swapBuffers();
+
+		// framerate cap
+		time->waitUntilDelta(deltaTimeMin);
 	}
 	delete cubeMesh;
 	delete cubeMaterial;

engine/managers/module_manager.cpp

@@ -18,7 +18,7 @@ void ce::ModuleManger::loadModules() {
 			LOG_ERROR(dlerror());
 			continue;
 		}
-		//reset Errors
+		// reset errors
 		dlerror();
 		const char* error;
 		LOG_INFO("Loading Symbols for: " + path);
@@ -57,7 +57,7 @@ ce::ModuleManger::~ModuleManger() {
 	}
 }
 
-void ce::ModuleManger::tickModules(float deltaTime) {
+void ce::ModuleManger::tickModules(double deltaTime) {
 	for (int i = 0; i < m_modules.size(); i++)
 		m_modules[i].module->tick(deltaTime);
-}
+}

engine/managers/module_manager.h

@@ -25,6 +25,6 @@ namespace ce {
 		ModuleManger();
 		~ModuleManger();
 
-		void tickModules(float deltaTime);
+		void tickModules(double deltaTime);
 	};
 }

engine/math/transform.h

@@ -10,7 +10,6 @@ namespace ce {
 		 * Pitch:X
 		 * Yaw:Y
 		 * Roll: Z
-		 *
 		 */
 		glm::vec3 m_pos, m_rot, m_scale;
 

engine/rendering/camera.h

@@ -7,9 +7,8 @@ namespace ce {
 	class Camera {
 	 private:
 		ce::Transform* m_transform;
-		float
-			speed,
-			fov;
+		double speed;
+		float fov;
 
 	 public:
 		Camera();

engine/rendering/render_engine.h

@@ -17,7 +17,7 @@ namespace ce {
 
 	class RenderEngine {
 	 private:
-		float m_aspectRatio, m_fov, m_near, m_far;
+		double m_aspectRatio, m_fov, m_near, m_far;
 
 		Camera* m_camera;