Test font pas fini

src/Engine/Core/Systems/Resources/CResourceManager.hpp

@@ -7,6 +7,7 @@
 #include "Audio/CAudioManager.hpp"
 #include "Shader/CShadersManager.hpp"
 #include "Texture/CTextureManager.hpp"
+#include "Font/CFontManager.hpp"
 
 class CResourceManager{
     private:
@@ -16,6 +17,10 @@ class CResourceManager{
         CTextureManager m_textureManager;
         CAudioManager m_audioManager;
         CShadersManager m_shaderManager;
+        CFontManager m_fontManager;
+        CModel2DManager m_model2DManager;
+        CMaterial2DManager m_material2DManager;
+        CMesh2DManager m_mesh2DManager;
     public:
         CModelManager&    models()    { return m_modelManager; }
         CMeshManager&     meshes()    { return m_meshManager; }
@@ -23,6 +28,10 @@ class CResourceManager{
         CTextureManager&  textures()  { return m_textureManager; }
         CAudioManager&  sounds()  { return m_audioManager; }
         CShadersManager&  shaders()  { return m_shaderManager; }
+        CFontManager&  fonts() { return m_fontManager; }
+        CModel2DManager& models2D() {return m_model2DManager;}
+        CMaterial2DManager& materials2D() {return m_material2DManager;}
+        CMesh2DManager&     meshes2D()    { return m_mesh2DManager; }
 
         const CModelManager&    models()    const { return m_modelManager; }
         const CMeshManager&     meshes()    const { return m_meshManager; }
@@ -30,6 +39,10 @@ class CResourceManager{
         const CTextureManager&  textures()  const { return m_textureManager; }
         const CAudioManager&  sounds() const { return m_audioManager; }
         const CShadersManager&  shaders() const { return m_shaderManager; }
+        const CFontManager&  fonts() const { return m_fontManager; }
+        const CModel2DManager& models2D() const {return m_model2DManager;}
+        const CMaterial2DManager& materials2D() const {return m_material2DManager;}
+        const CMesh2DManager&     meshes2D()    const { return m_mesh2DManager; }
 
         void cleanup() {
             m_modelManager.clear();
@@ -37,6 +50,10 @@ class CResourceManager{
             m_meshManager.clear();
             m_textureManager.clear();
             m_audioManager.clear();
+            m_fontManager.clear();
+            m_model2DManager.clear();
+            m_material2DManager.clear();
+            m_mesh2DManager.clear();
             m_shaderManager.clear();
         }
 };

src/Engine/Core/Systems/Resources/Font/CFontManager.hpp

@@ -0,0 +1,48 @@
+#ifndef CFONTMANAGER_HPP
+#define CFONTMANAGER_HPP
+
+#include "../../Graphics/Data/Font/CFont.hpp"
+
+#include "../CAbstractResourceManager.hpp"
+#include <filesystem>
+#include <optional>
+#include <stdexcept>
+
+class CFontManager : public CAbstractResourceManager<CosmicCore::CFont>
+{
+    public:
+
+        CosmicCore::CFont* loadFont(const std::string& path) {
+            auto cached = get(path);
+            if (cached) return cached.value();
+            std::optional<std::string> jsonPath = std::nullopt;
+            std::optional<std::string> pngPath = std::nullopt;
+
+            for (const auto& entry : std::filesystem::directory_iterator(path)) 
+            {
+                if(entry.is_regular_file())
+                {
+                    // Converting the path to const char * in the
+                    // subsequent lines
+                    std::filesystem::path extension = entry.path().extension();
+                    if(extension == ".json")
+                    {
+                        jsonPath = entry.path().string();
+                    }
+                    else if(extension == ".png")
+                    {
+                        pngPath = entry.path().string();
+                    }
+                }
+            }
+            if(!jsonPath || !pngPath)
+            {
+                throw std::runtime_error("Font is not a valid folder. Must contain a json and a png");
+            }
+            auto font = std::make_unique<CosmicCore::CFont>();
+            font->init(*jsonPath, *pngPath);
+            return add(path, std::move(font));
+        }
+};
+
+ #endif

src/Engine/Core/Systems/Resources/Material/CMaterialManager.hpp

@@ -2,8 +2,10 @@
 #define CMATERIALMANAGER_HPP
 
 #include "../../Graphics/Data/Material/CMaterial.hpp"
+#include "../../Graphics/Data/Material/CMaterial2D.hpp"
 
 #include "../CAbstractResourceManager.hpp"
+#include "Core/Systems/Graphics/Data/Texture/CTexture.hpp"
 
 class CMaterialManager : public CAbstractResourceManager<CMaterial>
 {
@@ -21,5 +23,75 @@ class CMaterialManager : public CAbstractResourceManager<CMaterial>
             return add(key, std::move(mat));
         }
 };
+using namespace CosmicCore;
+class CMaterial2DManager : public CAbstractResourceManager<CMaterial2D>
+{
+    public:
+        /*CMaterial2D* createRectMaterial(const std::string& key,
+                                        glm::vec4 color,
+                                        CShaderImplVulkan* shader)
+        {
+            auto mat          = std::make_unique<CosmicCore::CMaterial2D>();
+            mat->m_shapeType = E2DShapeType::Rect;
+            mat->shader       = shader;
+            mat->m_color = color;
+            mat->build();
+            return add(key, std::move(mat));
+        }
+
+        CMaterial2D* createCircleMaterial(const std::string& key,
+                                glm::vec4 color,
+                                CShaderImplVulkan* shader)
+        {
+            auto mat          = std::make_unique<CosmicCore::CMaterial2D>();
+            mat->m_shapeType = E2DShapeType::Circle;
+            mat->shader       = shader;
+            mat->m_color = color;
+            mat->build();
+            return add(key, std::move(mat));
+        }
+
+        CMaterial2D* createRoundedRectMaterial(const std::string& key,
+                                    glm::vec4 color,
+                                    float radius,
+                                    CShaderImplVulkan* shader)
+        {
+            auto mat          = std::make_unique<CosmicCore::CMaterial2D>();
+            mat->m_shapeType = E2DShapeType::RoundedRect;
+            mat->shader       = shader;
+            mat->m_color = color;
+            mat->m_cornerRadius = radius;
+            mat->build();
+            return add(key, std::move(mat));
+        }
+
+        CMaterial2D* createTextureMaterial(const std::string& key,
+                                        glm::vec4 color,
+                                        CTexture* texture,
+                                        CShaderImplVulkan* shader)
+        {
+            auto mat          = std::make_unique<CosmicCore::CMaterial2D>();
+            mat->m_shapeType = E2DShapeType::Rect;
+            mat->shader       = shader;
+            mat->m_color = color;
+            mat->m_texture = texture;
+            mat->build();
+            return add(key, std::move(mat));
+        }
+
+        CMaterial2D* createText(const std::string& key,
+            glm::vec4 color,
+            CFont* font,
+            CShaderImplVulkan* shader)
+        {
+            auto mat          = std::make_unique<CMaterial2D>();
+            mat->m_shapeType = E2DShapeType::Rect;
+            mat->shader       = shader;
+            mat->m_color = color;
+            mat->m_font = font;
+            mat->build();
+            return add(key, std::move(mat));
+        }*/
+};
 
  #endif

src/Engine/Core/Systems/Resources/Mesh/CMeshManager.hpp

@@ -2,10 +2,16 @@
 #define CMESHMANAGER_HPP
 
 #include "../../Graphics/Data/Mesh/CMesh.hpp"
+#include "../../Graphics/Data/Mesh/CMesh2D.hpp"
+
 #include "../CAbstractResourceManager.hpp"
 
 class CMeshManager : public CAbstractResourceManager<CMesh>
 {
+};
+
+class CMesh2DManager : public CAbstractResourceManager<CosmicCore::CMesh2D>
+{
 };
 
  #endif

src/Engine/Core/Systems/Resources/Model/CModelManager.hpp

@@ -2,10 +2,16 @@
 #define CMODELMANAGER_HPP
 
 #include "../../Graphics/Data//Model/CModel.hpp"
+#include "../../Graphics/Data//Model/CModel2D.hpp"
 
 #include "../CAbstractResourceManager.hpp"
+
 class CModelManager : public CAbstractResourceManager<CModel>
 {
+};
+
+class CModel2DManager : public CAbstractResourceManager<CosmicCore::CModel2D>
+{
 };
 
  #endif