Refactor and Magnum integration

CMakeLists.txt

@@ -13,5 +13,7 @@ project (EtrediaEmpires)
 add_subdirectory(sdk/materials)
 add_subdirectory(utils)
 add_subdirectory(p7lib)
-add_subdirectory (ECSAPI)
+add_subdirectory(server)
+add_subdirectory(engine-api)
+add_subdirectory(renderers/magnum-renderer)
 add_subdirectory(engine)

engine-api/CMakeLists.txt

@@ -0,0 +1,31 @@
+if (POLICY CMP0141)
+  cmake_policy(SET CMP0141 NEW)
+  set(CMAKE_MSVC_DEBUG_INFORMATION_FORMAT "$<IF:$<AND:$<C_COMPILER_ID:MSVC>,$<CXX_COMPILER_ID:MSVC>>,$<$<CONFIG:Debug,RelWithDebInfo>:EditAndContinue>,$<$<CONFIG:Debug,RelWithDebInfo>:ProgramDatabase>>")
+endif()
+
+set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON)
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
+
+project(engine-api)
+
+file(GLOB_RECURSE SOURCES CONFIGURE_DEPENDS
+    "src/*.cpp"
+    "src/*.c"
+    "include/*.hpp"
+    "include/*.h"
+)
+
+
+# Find dependencies
+
+find_package(glfw3 CONFIG REQUIRED)
+
+# Link library
+
+add_library(${PROJECT_NAME} ${SOURCES})
+
+target_link_libraries(${PROJECT_NAME} PUBLIC utils)
+target_link_libraries(${PROJECT_NAME} PRIVATE glfw)
+
+target_include_directories(${PROJECT_NAME} PUBLIC include/)

engine-api/include/ee_engine_api/RenderInterface.hpp

@@ -0,0 +1,22 @@
+#pragma once
+#include <GLFW/glfw3.h>
+
+class IRenderer
+{
+public:
+    virtual ~IRenderer();
+
+    void Draw();
+    virtual void ResizeWindow(int width, int height);
+
+protected:
+    int screenWidth, screenHeight;
+
+    GLFWwindow *window;
+
+    explicit IRenderer(GLFWwindow *window);
+
+    virtual void Clear() = 0;
+    virtual void DrawMap() = 0;
+    virtual void DrawUI() = 0;
+};

engine-api/src/RenderInterface.cpp

@@ -0,0 +1,26 @@
+#include <ee_engine_api/RenderInterface.hpp>
+#include <ee_utils/allocator.hpp>
+
+IRenderer::IRenderer(GLFWwindow *window)
+{
+    this->window = window;
+	glfwGetFramebufferSize(window, &screenWidth, &screenHeight);
+}
+
+IRenderer::~IRenderer()
+{
+	
+}
+
+void IRenderer::Draw()
+{
+	Clear();
+	DrawMap();
+	DrawUI();
+}
+
+void IRenderer::ResizeWindow(int width, int height)
+{
+	screenWidth = width;
+	screenHeight = height;
+}

engine/CMakeLists.txt

@@ -31,6 +31,8 @@ find_package(glfw3 CONFIG REQUIRED)
 add_executable(${PROJECT_NAME} ${SOURCES})
 
 target_link_libraries(${PROJECT_NAME} PUBLIC utils)
+target_link_libraries(${PROJECT_NAME} PUBLIC engine-api)
+target_link_libraries(${PROJECT_NAME} PUBLIC magnum-renderer)
 
 target_link_libraries(${PROJECT_NAME} PRIVATE Boost::lockfree)
 target_link_libraries(${PROJECT_NAME} PRIVATE xxHash::xxhash)

engine/include/AssetData.hpp

@@ -14,16 +14,16 @@ struct AssetBinary : AssetData
     ~AssetBinary();
 };
 
-struct AssetShader : AssetData
+struct AssetVulkanShader : AssetData
 {
     uint32_t* content = nullptr;
     size_t size = 0;
 
-    AssetShader(uint8_t* &source, const size_t &sourceSize);
-    ~AssetShader();
+    AssetVulkanShader(uint8_t* &source, const size_t &sourceSize);
+    ~AssetVulkanShader();
 };
 
-struct AssetMaterial : AssetData
+struct AssetVulkanMaterial : AssetData
 {
     uint32_t vertexShaderAssetID;
     uint32_t fragmentShaderAssetID;

engine/include/AssetManager.hpp

@@ -30,8 +30,8 @@ public:
     {
         BINARY,
 
-        SHADER,
-        MATERIAL,
+        VULKAN_SHADER,
+        VULKAN_MATERIAL,
         IMAGE
     } type = BINARY; 
 
@@ -108,8 +108,8 @@ private:
     std::vector<AssetLoadingEntry> loadingEntries;
 
     std::vector<AssetBinary*> binaryStorage;
-    std::vector<AssetShader*> shadersStorage;
-    std::vector<AssetMaterial*> materialsStorage;
+    std::vector<AssetVulkanShader*> shadersStorage;
+    std::vector<AssetVulkanMaterial*> materialsStorage;
 
     void Threading();
     void Request(const AssetStreamCommand &command);

engine/include/Engine.hpp

@@ -1,6 +1,8 @@
 #pragma once
+
+#include <ee_engine_api/RenderInterface.hpp>
+
 #include "AssetManager.hpp"
-#include "RenderInterface.hpp"
 
 class Engine
 {

engine/include/RenderInterface.hpp

@@ -1,53 +0,0 @@
-#pragma once
-#include <thread>
-#include <atomic>
-#include <Boost/lockfree/spsc_queue.hpp>
-#include <GLFW/glfw3.h>
-
-struct RenderCommand
-{
-    enum Type
-    {
-        NONE,
-
-        RESIZE_WINDOW,
-        SHUTDOWN
-    } type = NONE;
-};
-
-class IRenderer
-{
-public:
-    IRenderer(GLFWwindow *window);
-    ~IRenderer();
-    
-    void Start();
-    void Shutdown();
-    
-    bool GetThreadStatus();
-    bool GetDrawStatus();
-
-    void ResizeWindow(int width, int height);
-
-private:
-    std::atomic<bool> isRunning;
-    std::atomic<bool> isDrawing;
-    std::atomic<int> screenWidth, screenHeight;
-
-    std::stop_token *stoken;
-    std::jthread renderThread;
-    boost::lockfree::spsc_queue<RenderCommand, boost::lockfree::capacity<512>> commands;
-
-    GLFWwindow *window;
-
-    virtual void Draw() = 0;
-
-    void Threading();
-    void Request(const RenderCommand &command);
-    void Request(const RenderCommand::Type &type);
-    virtual void Init() = 0;
-    virtual void Dispose() = 0;
-    void Loop();
-    void ProcessCommand(const RenderCommand &command);
-    void Release();
-};

engine/include/compile_config.hpp

@@ -1,5 +1,7 @@
 #pragma once
 
+#define P7_LOGS_PATH L" /P7.Dir=logs/game/"
+
 #ifdef NDEBUG
 	#define P7_SINK L" /P7.Sink=FileTxt"
 #else

engine/src/AssetData.cpp

@@ -1,5 +1,5 @@
 #include "AssetData.hpp"
-#include "allocator.hpp"
+#include <ee_utils/allocator.hpp>
 
 AssetBinary::AssetBinary(uint8_t* &source, const size_t &sourceSize)
 {
@@ -14,14 +14,14 @@ AssetBinary::~AssetBinary()
         DeallocateArray(content);
 }
 
-AssetShader::AssetShader(uint8_t* &source, const size_t &sourceSize)
+AssetVulkanShader::AssetVulkanShader(uint8_t* &source, const size_t &sourceSize)
 {
     content = reinterpret_cast<uint32_t*>(source);
     size = sourceSize;
     source = nullptr;
 }
 
-AssetShader::~AssetShader()
+AssetVulkanShader::~AssetVulkanShader()
 {
     if (content != nullptr)
         DeallocateArray(content);

engine/src/AssetManager.cpp

@@ -1,6 +1,6 @@
 #include "compile_config.hpp"
 #include "AssetManager.hpp"
-#include "allocator.hpp"
+#include <ee_utils/allocator.hpp>
 #include "Logger.h"
 #include <stdexcept>
 #include <xxhash.h>
@@ -174,20 +174,20 @@ void AssetManager::Loop()
 
                 switch (asset.type)
                 {
-                    case AssetInfo::SHADER:
+                    case AssetInfo::VULKAN_SHADER:
                     {
-                        AssetShader* shader = Allocate<AssetShader>(entry.file->data, entry.file->size);
+                        AssetVulkanShader* shader = Allocate<AssetVulkanShader>(entry.file->data, entry.file->size);
                         shadersStorage.push_back(shader);
                         Redirect(entry.handle, shadersStorage.back());
                         break;
                     }
 
-                    case AssetInfo::MATERIAL:
+                    case AssetInfo::VULKAN_MATERIAL:
                     {
-                        AssetMaterial* material = Allocate<AssetMaterial>();
-                        if (entry.file->size < sizeof(AssetMaterial))
+                        AssetVulkanMaterial* material = Allocate<AssetVulkanMaterial>();
+                        if (entry.file->size < sizeof(AssetVulkanMaterial))
                             LOG(CRITICAL, "File size is less than needed for material");
-                        std::memcpy(material, entry.file->data, sizeof(AssetMaterial));
+                        std::memcpy(material, entry.file->data, sizeof(AssetVulkanMaterial));
                         materialsStorage.push_back(material);
                         Redirect(entry.handle, materialsStorage.back());
                         break;
@@ -340,7 +340,7 @@ void AssetManager::Release()
             Deallocate(resource);
     }
     binaryStorage.clear();
-    for (AssetShader* &resource : shadersStorage)
+    for (AssetVulkanShader* &resource : shadersStorage)
     {
         if (resource != nullptr)
             Deallocate(resource);
@@ -357,6 +357,6 @@ void AssetManager::LoadShaders()
     for (const std::filesystem::directory_entry &entry : std::filesystem::directory_iterator(shadersRoot))
     {
         if (entry.is_directory()) continue;
-        LoadAsync(AssetInfo::SHADER, entry.path());
+        LoadAsync(AssetInfo::VULKAN_SHADER, entry.path());
     }
 }

engine/src/FileSystem.cpp

@@ -1,6 +1,6 @@
 #include "FileSystem.hpp"
 #include "Logger.h"
-#include "allocator.hpp"
+#include <ee_utils/allocator.hpp>
 
 IFileSystem::~IFileSystem()
 {

engine/src/RenderInterface.cpp

@@ -1,119 +0,0 @@
-#include "RenderInterface.hpp"
-#include "Logger.h"
-#include <allocator.hpp>
-#include <stdexcept>
-
-IRenderer::IRenderer(GLFWwindow *window) :
-	isRunning(false),
-	isDrawing(false)
-{
-    this->window = window;
-	int width = -1, height = -1;
-	glfwGetFramebufferSize(window, &width, &height);
-	screenWidth.store(width);
-	screenHeight.store(height);
-}
-
-IRenderer::~IRenderer()
-{
-	Release();
-}
-
-void IRenderer::Start()
-{
-	if (isRunning)
-	{
-		LOG(CRITICAL, "Renderer can be started only once");
-		throw std::logic_error("Renderer can be started only once");
-	}
-
-    isRunning.store(true);
-	isDrawing.store(true);
-    renderThread = std::jthread([this](std::stop_token stop) {
-        this->stoken = &stop;
-        Threading();
-    });
-}
-
-void IRenderer::Threading()
-{
-    Logger::trace->Register_Thread(L"Renderer", 0);
-    LOG(INFO, "Renderer thread started");
-
-	Init();
-    Loop();
-    Release();
-}
-
-
-void IRenderer::Loop()
-{
-	RenderCommand commandBuffer;
-    while (!stoken->stop_requested())
-    {
-		while (commands.pop(commandBuffer))
-		{
-			ProcessCommand(commandBuffer);
-		}
-
-		Draw();
-    }
-}
-
-void IRenderer::ProcessCommand(const RenderCommand &command)
-{
-	switch(command.type)
-	{
-		case RenderCommand::SHUTDOWN:
-		{
-			LOG(INFO, "SHUTDOWN command");
-			Shutdown();
-			break;
-		}
-		
-		case RenderCommand::RESIZE_WINDOW:
-		{
-			LOG(INFO, "RESIZE_WINDOW command");
-
-			break;
-		}
-
-		default:
-		{
-			LOG(WARNING, "Unhandled command. Type id: %d", command.type);
-			break;
-		}
-	}
-}
-
-void IRenderer::Shutdown()
-{
-    renderThread.request_stop();
-}
-
-void IRenderer::Request(const RenderCommand &command)
-{
-	commands.push(command);
-}
-
-void IRenderer::Request(const RenderCommand::Type &type)
-{
-	commands.push(RenderCommand {.type = type});
-}
-
-void IRenderer::ResizeWindow(int width, int height)
-{
-	screenWidth.store(width);
-	screenHeight.store(height);
-	Request(RenderCommand::RESIZE_WINDOW);
-}
-
-void IRenderer::Release()
-{
-	Dispose();
-    LOG(INFO, "Renderer is released");
-    isRunning.store(false);
-}
-
-bool IRenderer::GetThreadStatus() { return isRunning.load(); }
-bool IRenderer::GetDrawStatus() { return isDrawing.load(); }

engine/src/main.cpp

@@ -1,15 +1,19 @@
 #include "Logger.h"
-#include <GLFW/glfw3.h>
+
+#include <ee_magnum/Renderer.hpp>
+#include <ee_utils/allocator.hpp>
 
 #include "compile_config.hpp"
 #include "Engine.hpp"
 
+#include <GLFW/glfw3.h>
+
 IP7_Trace* Logger::trace;
 
 int main(int argc, char **argv)
 {
 	// Setup P7 logger
-	IP7_Client *p7client = P7_Create_Client(P7_SINK);
+	IP7_Client *p7client = P7_Create_Client(P7_SINK P7_LOGS_PATH);
 	P7_Set_Crash_Handler();
 	Logger::trace = P7_Create_Trace(p7client, L"TC 1");
 	Logger::trace->Register_Thread(L"Main", 0);
@@ -18,7 +22,9 @@ int main(int argc, char **argv)
 
 	// Setup GLFW
 	glfwInit();
-	glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
+	
+	// Vulkan only
+	// glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
 
 	GLFWwindow *window = glfwCreateWindow(800, 600, "Etredia Empires", nullptr, nullptr);
 
@@ -26,39 +32,37 @@ int main(int argc, char **argv)
 		LOG(CRITICAL, "GLFW Window failed");
 	else LOG(INFO, "GLFW Window created");
 
+	glfwMakeContextCurrent(window);
+
 	// Setup assets
 	AssetManager assetManager;
 	assetManager.Start();
-	assetManager.LoadShaders();
+	//assetManager.LoadShaders();
 
 	// Setup Renderer
 	// assetManager.LoadAsync(AssetInfo::MATERIAL, "assets/materials/helloworld.mat");
 	// AssetHandle baseMaterialHandle = assetManager.Find("assets/materials/helloworld.mat");
 	// AssetMaterial baseMaterial = assetManager.Get<AssetMaterial>(baseMaterialHandle);
-	// IRenderer renderer(window);
-	// renderer.Start();
 
 	//Setup Engine
 	Engine::assetManager = &assetManager;
-	//Engine::renderer = &renderer;
+	Engine::renderer = reinterpret_cast<IRenderer*>(Allocate<MagnumRenderer>(window));
 	
 	glfwSetFramebufferSizeCallback(window, [](GLFWwindow *window, int width, int height) {
 		Engine::renderer->ResizeWindow(width, height);
 	});
 
-	// Process GLFW events
+	// Game loop
 	while(!glfwWindowShouldClose(window))
 	{
+		Engine::renderer->Draw();
+
+		glfwSwapBuffers(window);
 		glfwPollEvents();
 	}
 
 	// Free memory
 	LOG(INFO, "Exit...");
-	if (Engine::renderer != nullptr)
-	{ // Wait for renderer to clean and shutdown
-		Engine::renderer->Shutdown();
-		while(Engine::renderer->GetThreadStatus());
-	}
 	if (Engine::assetManager != nullptr)
 	{ // Wait for asset manager to clean and shutdown
 		Engine::assetManager->Shutdown();
@@ -66,6 +70,7 @@ int main(int argc, char **argv)
 	}
 	glfwDestroyWindow(window);
 	glfwTerminate();
+	//TODO: check Unregister in other threads and make threaded module base class
 	Logger::trace->Unregister_Thread(0);
 	Logger::trace->Release();
 	p7client->Release();

renderers/magnum-renderer/CMakeLists.txt

@@ -0,0 +1,57 @@
+cmake_minimum_required (VERSION 3.8)
+
+if (POLICY CMP0141)
+  cmake_policy(SET CMP0141 NEW)
+  set(CMAKE_MSVC_DEBUG_INFORMATION_FORMAT "$<IF:$<AND:$<C_COMPILER_ID:MSVC>,$<CXX_COMPILER_ID:MSVC>>,$<$<CONFIG:Debug,RelWithDebInfo>:EditAndContinue>,$<$<CONFIG:Debug,RelWithDebInfo>:ProgramDatabase>>")
+endif()
+
+set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON)
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
+project (magnum-renderer)
+
+# List sources
+
+file(GLOB_RECURSE SOURCES CONFIGURE_DEPENDS
+    "src/*.cpp"
+    "src/*.c"
+    "include/*.hpp"
+    "include/*.h"
+)
+
+# Find dependencies
+
+if (WIN32)
+  set(MAGNUM_CONTEXT WglContext)
+elseif(UNIX)
+  set(MAGNUM_CONTEXT GlxContext)
+else()
+  message(FATAL_ERROR "No supported context for system")
+endif()
+
+set(MAGNUM_WITH_GLFWAPPLICATION ON)
+find_package(Magnum REQUIRED
+    GL
+    GlfwApplication
+    Shaders
+)
+
+# Link library
+
+add_library(${PROJECT_NAME} ${SOURCES})
+
+target_link_libraries(${PROJECT_NAME} PUBLIC engine-api)
+target_link_libraries(${PROJECT_NAME} PUBLIC utils)
+
+target_link_libraries(${PROJECT_NAME} PRIVATE p7)
+target_link_libraries(${PROJECT_NAME} PRIVATE
+    Magnum::GL
+    Magnum::GlfwApplication
+    Magnum::Shaders
+    Magnum::Magnum)
+
+target_include_directories(${PROJECT_NAME} PUBLIC include/)
+
+if (CMAKE_VERSION VERSION_GREATER 3.12)
+  set_property(TARGET ${PROJECT_NAME} PROPERTY CXX_STANDARD 20)
+endif()

renderers/magnum-renderer/include/ee_magnum/Renderer.hpp

@@ -0,0 +1,26 @@
+#pragma once
+
+#undef min
+#undef max
+
+#include <Magnum/Platform/GLContext.h>
+#include <GLFW/glfw3.h>
+
+#include <ee_engine_api/RenderInterface.hpp>
+
+using namespace Magnum;
+
+class MagnumRenderer : public IRenderer
+{
+public:
+    MagnumRenderer(GLFWwindow *window);
+    ~MagnumRenderer();
+
+protected:
+    void Clear() override;
+    void DrawMap() override;
+    void DrawUI() override;
+
+private:
+    Platform::GLContext context;
+};

renderers/magnum-renderer/src/Renderer.cpp

@@ -0,0 +1,58 @@
+#include "Logger.h"
+#include <ee_magnum/Renderer.hpp>
+
+#include <Magnum/GL/Buffer.h>
+#include <Magnum/GL/DefaultFramebuffer.h>
+#include <Magnum/GL/Mesh.h>
+#include <Magnum/Math/Color.h>
+#include <Magnum/Shaders/VertexColor.h>
+
+#include <Corrade/Utility/Debug.h>
+
+#include <string>
+
+using namespace Math::Literals;
+
+MagnumRenderer::MagnumRenderer(GLFWwindow *window) : IRenderer(window)
+{
+
+}
+
+MagnumRenderer::~MagnumRenderer()
+{
+    
+}
+
+void MagnumRenderer::Clear()
+{
+    GL::defaultFramebuffer.clear(GL::FramebufferClear::Color);
+}
+
+void MagnumRenderer::DrawMap()
+{
+    //TEST TRIANGLE
+    struct TriangleVertex {
+        Vector2 position;
+        Color3 color;
+    };
+    const TriangleVertex vertices[]{
+        {{-0.5f, -0.5f}, 0xff0000_rgbf},    /* Left vertex, red color */
+        {{ 0.5f, -0.5f}, 0x00ff00_rgbf},    /* Right vertex, green color */
+        {{ 0.0f,  0.5f}, 0x0000ff_rgbf}     /* Top vertex, blue color */
+    };
+
+    GL::Mesh mesh;
+    mesh.setCount((int)Containers::arraySize(vertices))
+        .addVertexBuffer(GL::Buffer{vertices}, 0,
+            Shaders::VertexColor2D::Position{},
+            Shaders::VertexColor2D::Color3{});
+
+    Shaders::VertexColor2D shader;
+
+    shader.draw(mesh);
+}
+
+void MagnumRenderer::DrawUI()
+{
+    
+}

server/CMakeLists.txt

@@ -8,10 +8,10 @@ endif()
 set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON)
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 
-project ("ECSAPI")
+project ("server")
 
-add_subdirectory ("Economy")
-add_subdirectory ("Economy/test")
+add_subdirectory ("economy")
+add_subdirectory ("economy/test")
 
-add_subdirectory ("ECS")
-add_subdirectory ("ECS/test")
+add_subdirectory ("ecs")
+add_subdirectory ("ecs/test")

utils/CMakeLists.txt

@@ -1,4 +1,26 @@
+if (POLICY CMP0141)
+  cmake_policy(SET CMP0141 NEW)
+  set(CMAKE_MSVC_DEBUG_INFORMATION_FORMAT "$<IF:$<AND:$<C_COMPILER_ID:MSVC>,$<CXX_COMPILER_ID:MSVC>>,$<$<CONFIG:Debug,RelWithDebInfo>:EditAndContinue>,$<$<CONFIG:Debug,RelWithDebInfo>:ProgramDatabase>>")
+endif()
+
+set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON)
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
+
 project(utils)
 
-add_library(${PROJECT_NAME} INTERFACE)
-target_include_directories(${PROJECT_NAME} INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/include)
+file(GLOB_RECURSE SOURCES CONFIGURE_DEPENDS
+    "src/*.cpp"
+    "src/*.c"
+    "include/*.hpp"
+    "include/*.h"
+)
+
+
+# Find dependencies
+
+# Link library
+
+add_library(${PROJECT_NAME} ${SOURCES})
+
+target_include_directories(${PROJECT_NAME} PUBLIC include/)

vcpkg.json

@@ -7,6 +7,7 @@
 		"vulkan",
 		"glfw3",
 		"glm",
+		{"name": "magnum", "features": ["glfwapplication"]},
 		"rmlui",
 		"gtest"
 	]