Move game loop into engine lib

CMakeLists.txt

@@ -38,6 +38,8 @@ add_library(${PROJECT_NAME} STATIC
 
 	"include/engine.hpp"
 
+	"include/util.hpp"
+
 	"include/log.hpp"
 
 	"include/window.hpp"
@@ -67,7 +69,6 @@ add_library(${PROJECT_NAME} STATIC
 
 	"include/gfx.hpp"
 	"include/gfx_device.hpp"
-
 )
 
 # compiling options:

include/engine.hpp

@@ -1,13 +1,27 @@
 #pragma once
 
+#include <memory>
+
 namespace engine {
 
-	struct AppInfo {
+	class Window;
-		const char* name;
+	class GFXDevice;
-		const char* version;
+
+	class Application {
+
+	public:
+		Application(const char* appName, const char* appVersion);
+
+		Application(const Application&) = delete;
+		Application& operator=(const Application&) = delete;
+
+		~Application();
+
+		void gameLoop();
+
+	private:
+		std::unique_ptr<Window> m_win;
+		std::unique_ptr<GFXDevice> m_gfx;
 	};
 
-
-	bool versionFromCharArray(const char* version, int* major, int* minor, int* patch);
-
 }

include/engine_api.h

@@ -1,5 +1,6 @@
 #pragma once
 
+/*
 #ifndef ENGINE_API
 # ifdef _MSC_VER
 #  ifdef ENGINE_EXPORTS
@@ -11,5 +12,6 @@
 #  define ENGINE_API
 # endif
 #endif
+*/
 
 #define ENGINE_API

include/gfx_device.hpp

@@ -2,8 +2,6 @@
 
 #include "engine_api.h"
 
-#include "engine.hpp"
-
 #include <memory>
 
 struct SDL_Window;
@@ -13,7 +11,7 @@ namespace engine {
 	class ENGINE_API GFXDevice {
 
 	public:
-		GFXDevice(AppInfo appInfo, SDL_Window* window);
+		GFXDevice(const char* appName, const char* appVersion, SDL_Window* window);
 
 		GFXDevice(const GFXDevice&) = delete;
 		GFXDevice& operator=(const GFXDevice&) = delete;

include/util.hpp

@@ -0,0 +1,18 @@
+#pragma once
+
+#include <cstdio>
+
+namespace engine {
+
+	inline bool versionFromCharArray(const char* version, int* major, int* minor, int* patch)
+	{
+		if (sscanf(version, "%d.%d.%d", major, minor, patch) != 3) {
+			*major = 0;
+			*minor = 0;
+			*patch = 0;
+			return false;
+		}
+		return true;
+	}
+
+}

src/engine.cpp

@@ -1,18 +1,57 @@
 #include "engine.hpp"
 
-#include <cstdio>
+#include "window.hpp"
+#include "gfx_device.hpp"
 
 namespace engine {
 
-bool versionFromCharArray(const char* version, int* major, int* minor, int* patch)
+	Application::Application(const char* appName, const char* appVersion)
 	{
-	if (sscanf(version, "%d.%d.%d", major, minor, patch) != 3) {
+		m_win = std::make_unique<Window>(appName);
-		*major = 0;
+		m_gfx = std::make_unique<GFXDevice>(appName, appVersion, m_win->m_handle);
-		*minor = 0;
+	}
-		*patch = 0;
+
-		return false;
+	Application::~Application()
+	{
+
+	}
+
+	void Application::gameLoop()
+	{
+		uint64_t lastTick = m_win->getNanos();
+		constexpr int TICKFREQ = 20; // in hz
+
+		// single-threaded game loop
+		while (m_win->isRunning()) {
+
+			/* logic */
+
+			if (m_win->getLastFrameStamp() >= lastTick + (BILLION / TICKFREQ)) {
+				lastTick = m_win->getLastFrameStamp();
+
+				// do tick stuff here
+
+			}
+
+			if (m_win->getKeyPress(inputs::Key::F11)) {
+				if (m_win->isFullscreen()) {
+					m_win->setFullscreen(false);
+				}
+				else {
+					m_win->setFullscreen(true, false); // borderless window
+				}
+			}
+			if (m_win->getKeyPress(inputs::Key::ESCAPE)) {
+				m_win->setCloseFlag();
+			}
+
+			/* draw */
+			m_gfx->draw();
+
+			/* poll events */
+			m_win->getInputAndEvents();
+
 		}
-	return true;
 	}
 
 }

src/gfx_device_vulkan.cpp

@@ -4,6 +4,8 @@
 
 #include "gfx_device.hpp"
 
+#include "util.hpp"
+
 #include "config.h"
 #include "log.hpp"
 
@@ -49,7 +51,7 @@ namespace engine {
 	class GFXDevice::Impl {
 
 	public:
-		Impl(AppInfo appInfo, SDL_Window* window)
+		Impl(const char* appName, const char* appVersion, SDL_Window* window)
 		{
 #ifdef NDEBUG
 			// release mode: don't use validation layer
@@ -58,7 +60,7 @@ namespace engine {
 			// debug mode: use validation layer
 			LayerInfo layerInfo(true);
 #endif
-			auto instance = std::make_shared<Instance>(appInfo, layerInfo, getRequiredVulkanExtensions(window));
+			auto instance = std::make_shared<Instance>(appName, appVersion, layerInfo, getRequiredVulkanExtensions(window));
 
 			volkLoadInstanceOnly(instance->getHandle());
 
@@ -110,19 +112,19 @@ namespace engine {
 		class Instance {
 
 		public:
-			Instance(AppInfo appInfo, const LayerInfo& layerInfo, const std::vector<const char*>& windowExtensions)
+			Instance(const char* appName, const char* appVersion, const LayerInfo& layerInfo, const std::vector<const char*>& windowExtensions)
 			{
 				VkResult res;
 
 				int appVersionMajor = 0, appVersionMinor = 0, appVersionPatch = 0;
-				assert(versionFromCharArray(appInfo.version, &appVersionMajor, &appVersionMinor, &appVersionPatch));
+				assert(versionFromCharArray(appVersion, &appVersionMajor, &appVersionMinor, &appVersionPatch));
 				int engineVersionMajor = 0, engineVersionMinor = 0, engineVersionPatch = 0;
 				assert(versionFromCharArray(ENGINE_VERSION, &engineVersionMajor, &engineVersionMinor, &engineVersionPatch));
 
 				VkApplicationInfo applicationInfo{
 					.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO,
 					.pNext = nullptr,
-					.pApplicationName = appInfo.name,
+					.pApplicationName = appName,
 					.applicationVersion = VK_MAKE_VERSION(appVersionMajor, appVersionMinor, appVersionPatch),
 					.pEngineName = "engine",
 					.engineVersion = VK_MAKE_VERSION(engineVersionMajor, engineVersionMinor, engineVersionPatch),
@@ -797,7 +799,7 @@ namespace engine {
 
 	};
 
-	GFXDevice::GFXDevice(AppInfo appInfo, SDL_Window* window)
+	GFXDevice::GFXDevice(const char* appName, const char* appVersion, SDL_Window* window)
 	{
 		VkResult res;
 		res = volkInitialize();
@@ -811,7 +813,7 @@ namespace engine {
 			throw std::runtime_error("The loaded Vulkan version must be at least 1.3");
 		}
 
-		m_pimpl = std::make_unique<Impl>(appInfo, window);
+		m_pimpl = std::make_unique<Impl>(appName, appVersion, window);
 
 	}