add glfw

CMakeLists.txt

@@ -14,5 +14,13 @@ FetchContent_Declare(
 	FIND_PACKAGE_ARGS
 )
 
+set(GLFW_LIBRARY_TYPE "SHARED" CACHE INTERNAL "")
+FetchContent_Declare(
+	glfw3
+	GIT_REPOSITORY https://github.com/glfw/glfw
+	GIT_TAG 21fea01161e0d6b70c0c5c1f52dc8e7a7df14a50
+	FIND_PACKAGE_ARGS
+)
+
 add_subdirectory(quark)
 add_subdirectory(sandbox)

quark/CMakeLists.txt

@@ -1,6 +1,7 @@
 project(quark CXX)
 
 FetchContent_MakeAvailable(spdlog)
+FetchContent_MakeAvailable(glfw3)
 
 add_library(quark SHARED)
 
@@ -10,16 +11,23 @@ target_sources(quark
 	src/quark/Application.cpp
 	src/quark/Logger.cpp
 
+	src/platform/linux/LinuxWindow.cpp
+
 	PUBLIC FILE_SET HEADERS
 	BASE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/src FILES
 	src/quark.hpp
+
+	src/quark/Core.hpp
 	src/quark/Application.hpp
 	src/quark/Logger.hpp
+	src/quark/Window.hpp
 
 	src/quark/events/Event.hpp
 	src/quark/events/ApplicationEvent.hpp
 	src/quark/events/KeyEvent.hpp
 	src/quark/events/MouseEvent.hpp
+
+	src/platform/linux/LinuxWindow.hpp
 )
 
 target_include_directories(quark INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/src)
@@ -31,6 +39,7 @@ target_precompile_headers(quark
 
 target_link_libraries(quark
 	spdlog::spdlog
+	glfw
 )
 
 include(GNUInstallDirs)

quark/src/platform/linux/LinuxWindow.cpp

@@ -0,0 +1,68 @@
+#include "LinuxWindow.hpp"
+#include "quark/Core.hpp"
+#include "quark.hpp"
+#include <GLFW/glfw3.h>
+
+namespace qk {
+	static bool GLFWInitialized = false;
+
+	std::unique_ptr<Window> Window::Create(const WindowConfig& config) {
+		return std::make_unique<LinuxWindow>(config);
+	}
+
+	LinuxWindow::LinuxWindow(const WindowConfig& config) {
+		Init(config);
+	}
+
+	LinuxWindow::~LinuxWindow() {
+		Destroy();
+	}
+
+	void LinuxWindow::Init(const WindowConfig& config) {
+		data.title = config.title;
+		data.width = config.width;
+		data.height = config.height;
+
+		QK_CORE_INFO("Creating window {0} ({1}x{2})", data.title, data.width, data.height);
+
+		if (!GLFWInitialized) {
+			int success = glfwInit();
+			QK_CORE_ASSERT(success, "Could not initialize GLFW");
+
+			GLFWInitialized = true;
+		}
+		
+		glfwWindowHintString(GLFW_X11_CLASS_NAME, "testclass");
+
+		window = glfwCreateWindow((int)config.width, (int)config.height, config.title.c_str(), nullptr, nullptr);
+		glfwMakeContextCurrent(window);
+		glfwSetWindowUserPointer(window, &data);
+
+
+		SetVSync(true);
+	}
+
+	void LinuxWindow::Destroy() {
+		glfwDestroyWindow(window);
+		window = nullptr;
+	}
+
+	void LinuxWindow::OnUpdate() {
+		glfwPollEvents();
+		glfwSwapBuffers(window);
+	}
+
+	constexpr void LinuxWindow::SetVSync(bool enabled) {
+		if (enabled) {
+			glfwSwapInterval(1);
+		} else {
+			glfwSwapInterval(0);
+		}
+
+		data.vsync = enabled;
+	}
+
+	bool LinuxWindow::HasVSync() const {
+		return data.vsync;
+	}
+}

quark/src/platform/linux/LinuxWindow.hpp

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <GLFW/glfw3.h>
+
+#include "quark/Window.hpp"
+
+namespace qk {
+	class LinuxWindow :
+		public Window
+	{
+	public:
+		LinuxWindow(const WindowConfig& config);
+		virtual ~LinuxWindow();
+
+		void OnUpdate() override;
+
+		inline unsigned int GetWidth() const override { return data.width; }
+		inline unsigned int GetHeight() const override { return data.height; }
+
+		inline void SetEventCallback(const EventCallbackFn& callback) override { data.eventCallback = callback; }
+		constexpr void SetVSync(bool enable) override;
+		bool HasVSync() const override;
+
+	private:
+		virtual void Init(const WindowConfig& config);
+		virtual void Destroy();
+
+	private:
+		GLFWwindow* window;
+
+		struct WindowData {
+			std::string title;
+			unsigned int width, height;
+			bool vsync;
+
+			EventCallbackFn eventCallback;
+		} data;
+	};
+}

quark/src/qkpch.hpp

@@ -7,6 +7,7 @@
 #include <functional>
 
 #include <string>
+#include <string_view>
 #include <sstream>
 #include <vector>
 #include <unordered_map>

quark/src/quark.hpp

@@ -1,7 +1,9 @@
 #pragma once
 
 // IWYU pragma: begin_exports
+#include "qkpch.hpp"
 #include "quark/Application.hpp"
 
 #include "quark/Logger.hpp"
+
 // IWYU pragma: end_exports

quark/src/quark/Application.cpp

@@ -1,16 +1,15 @@
 #include "Application.hpp"
-#include "quark/Logger.hpp"
-#include "quark/events/ApplicationEvent.hpp"
 #include <spdlog/spdlog.h>
 
 namespace qk {
 
+	Application::Application() {
+		window = Window::Create();
+	}
+
 	void Application::Run() const {
-		WindowResizeEvent e(1200, 720);
+		while(isRunning) {
-		QK_TRACE(e);
+			window->OnUpdate();
-
-		for(;;) {
-
 		}
 	}
 

quark/src/quark/Application.hpp

@@ -1,13 +1,20 @@
 #pragma once
 // IWYU pragma: private, include <quark.hpp>
 
+#include "Window.hpp"
+
 namespace qk {
 
 	class Application {
 	public:
+		Application();
 		virtual ~Application() {}
 
 		void Run() const;
+
+	private:
+		std::unique_ptr<Window> window;
+		bool isRunning = true;
 	};
 
 	std::unique_ptr<qk::Application> CreateApplication();

quark/src/quark/Core.hpp

@@ -0,0 +1,13 @@
+#pragma once
+
+
+#ifndef NDEBUG
+#	include <signal.h>
+#	define _LINE_TO_STR(x) #x
+#	define LINE_TO_STR(x) _LINE_TO_STR(x)
+#	define QK_ASSERT(x, ...) { if (!(x)) { QK_CRITICAL(__FILE__ ":" LINE_TO_STR(__LINE__) ": Assertion failed: {0}", __VA_ARGS__); raise(SIGTRAP); } }
+#	define QK_CORE_ASSERT(x, ...) { if (!(x)) { QK_CORE_CRITICAL(__FILE__ ":" LINE_TO_STR(__LINE__) ": Assertion failed: {0}", __VA_ARGS__); raise(SIGTRAP); } }
+#else
+#	define QK_ASSERT
+#	define QK_CORE_ASSERT
+#endif

quark/src/quark/Window.hpp

@@ -0,0 +1,31 @@
+#pragma once
+
+#include "quark/events/Event.hpp"
+namespace qk {
+	struct WindowConfig {
+		std::string title;
+		unsigned int width, height;
+
+		WindowConfig(const std::string& title = "quark Engine", unsigned int width = 1280, unsigned int height = 720) :
+			title(title), width(width), height(height)
+		{ }
+	};
+
+	class Window {
+	public:
+		using EventCallbackFn = std::function<void(Event&)>;
+
+		virtual ~Window() {}
+
+		virtual void OnUpdate() = 0;
+
+		virtual unsigned int GetWidth() const = 0;
+		virtual unsigned int GetHeight() const = 0;
+
+		virtual void SetEventCallback(const EventCallbackFn& callback) = 0;
+		virtual void SetVSync(bool enabled) = 0;
+		virtual bool HasVSync() const = 0;
+
+		static std::unique_ptr<Window> Create(const WindowConfig& config = WindowConfig());
+	};
+}