feat: add a resource manager for loading textures

CMakeLists.txt

@@ -34,6 +34,7 @@ target_link_libraries(GameEngine
     PRIVATE
     SDL3::SDL3
     SDL3_ttf::SDL3_ttf
+    SDL3_image::SDL3_image
     imgui_sdl3
     spdlog
 )

include/engine/core/resource.hpp

@@ -0,0 +1,29 @@
+#ifndef RESOURCE_HPP
+#define RESOURCE_HPP
+#include <engine/core/renderer.hpp>
+#include <engine/core/texture.hpp>
+#include <memory>
+#include <string_view>
+#include <unordered_map>
+namespace Engine {
+// add more resource types later (font, audio)
+enum class ResourceType { Texture };
+class ResourceManager {
+  public:
+    explicit ResourceManager(Renderer &renderer);
+    ~ResourceManager();
+
+    void AddResource(const std::string &path, ResourceType type);
+    bool RemoveResource(const std::string_view path, ResourceType type);
+
+    std::shared_ptr<Texture> FindTexture(const std::string_view path);
+
+  private:
+    void CreateTexture(const std::string_view path);
+
+    Renderer &m_renderer;
+    std::unordered_map<std::string, ResourceType> m_resourcePaths;
+    std::unordered_map<std::string_view, std::shared_ptr<Texture>> m_textureMap;
+};
+} // namespace Engine
+#endif

include/engine/core/texture.hpp

@@ -6,9 +6,7 @@ class Texture {
   public:
     Texture() = default;
     ~Texture();
-    // bool LoadFromFile(Renderer &renderer, const std::string &path);
-    // |- Handled by ResourceManager
-    void SetTexture(SDL_Texture *texture) { m_texture = texture; }
+    void SetTexture(SDL_Texture *texture);
     SDL_Texture *GetSDLTexture() const { return m_texture; }
     int GetWidth() const { return m_width; }
     int GetHeight() const { return m_height; }

include/engine/engine.hpp

@@ -2,6 +2,7 @@
 #define _ENGINE_HPP
 #include <engine/core/event.hpp>
 #include <engine/core/renderer.hpp>
+#include <engine/core/resource.hpp>
 #include <engine/core/window.hpp>
 #include <engine/render/manager.hpp>
 #include <engine/render/renderable.hpp>
@@ -28,7 +29,7 @@ class Engine {
     RenderManager &GetRenderManager();
     // InputHandler &GetInputs();
     // AudioSystem &GetAudio();
-    // ResourceManager &GetResources();
+    ResourceManager &GetResources();
     // Time &GetTime();
   private:
     Engine() = default;
@@ -41,12 +42,12 @@ class Engine {
     std::unique_ptr<Renderer> m_renderer;
     std::unique_ptr<EventManager> m_eventHandler;
     std::unique_ptr<RenderManager> m_renderManager;
+    std::unique_ptr<ResourceManager> m_resManager;
     // from main.cpp here as well
 
     // TODO: Later implementation
     // std::unique_ptr<InputHandler> m_inputHandler;
     // std::unique_ptr<AudioSystem> m_audioSystem;
-    // std::unique_ptr<ResourceManager> m_resManager;
     // std::unique_ptr<Time> m_time;
 
     bool m_initialized = false;

include/vendored/vendored.cmake

@@ -26,8 +26,14 @@ FetchContent_Declare(
     SOURCE_DIR ${CMAKE_SOURCE_DIR}/include/vendored/spdlog
     EXCLUDE_FROM_ALL
 )
-FetchContent_MakeAvailable(SDL3 SDL3_ttf spdlog)
-
+FetchContent_Declare(
+    SDL3_image
+    GIT_REPOSITORY https://github.com/libsdl-org/SDL_image.git
+    GIT_TAG release-3.2.4
+    SOURCE_DIR ${CMAKE_SOURCE_DIR}/include/vendored/SDL3_image
+    EXCLUDE_FROM_ALL
+)
+FetchContent_MakeAvailable(SDL3 SDL3_ttf SDL3_image spdlog)
 FetchContent_Populate(imgui
   URL https://github.com/ocornut/imgui/archive/master.zip
   SOURCE_DIR ${CMAKE_SOURCE_DIR}/include/vendored/imgui

src/engine/core/resource.cpp

@@ -0,0 +1,67 @@
+#include <SDL3_image/SDL_image.h>
+#include <engine/core/resource.hpp>
+#include <engine/core/texture.hpp>
+#include <memory>
+#include <string_view>
+namespace Engine {
+
+ResourceManager::ResourceManager(Renderer &renderer) : m_renderer(renderer) {}
+
+ResourceManager::~ResourceManager() {
+    m_resourcePaths.clear();
+    m_textureMap.clear();
+}
+
+void ResourceManager::AddResource(const std::string &path, ResourceType type) {
+    m_resourcePaths.emplace(path, type);
+}
+
+bool ResourceManager::RemoveResource(const std::string_view path,
+                                     ResourceType type) {
+    auto it_resPath = m_resourcePaths.find(std::string(path));
+    if (it_resPath == m_resourcePaths.end() || it_resPath->second != type) {
+        return false;
+    }
+    m_resourcePaths.erase(it_resPath);
+    switch (type) {
+    case ResourceType::Texture: {
+        auto it_texcache = m_textureMap.find(path);
+        if (it_texcache != m_textureMap.end()) {
+            m_textureMap.erase(it_texcache);
+        }
+        return true;
+    }
+    default:
+        return false;
+    }
+}
+
+std::shared_ptr<Texture>
+ResourceManager::FindTexture(const std::string_view path) {
+    auto it_tex = m_textureMap.find(path);
+    auto it_res = m_resourcePaths.find(std::string(path));
+    // if texture not loaded, and imported as asset and actually a texture
+    if (it_tex == m_textureMap.end() && it_res != m_resourcePaths.end() &&
+        it_res->second == ResourceType::Texture) {
+        CreateTexture(path);
+        return FindTexture(path);
+    } else if (it_tex == m_textureMap.end()) {
+        return nullptr; // else if resource not loaded but not (a texture or
+                        // imported as asset)
+    }
+    return it_tex->second;
+}
+
+void ResourceManager::CreateTexture(const std::string_view path) {
+    std::shared_ptr<Texture> texture = std::make_shared<Texture>();
+    SDL_Texture *sdlTex =
+        IMG_LoadTexture(m_renderer.GetSDLRenderer(), std::string(path).c_str());
+    if (sdlTex == nullptr) {
+        // TODO: add logging here
+        return;
+    }
+    texture->SetTexture(sdlTex);
+    m_textureMap.emplace(path, std::move(texture));
+}
+
+} // namespace Engine

src/engine/core/texture.cpp

@@ -8,4 +8,13 @@ Texture::~Texture() {
         m_texture = nullptr;
     }
 }
+void Texture::SetTexture(SDL_Texture *texture) {
+    if (texture == nullptr) {
+        // TODO: add logging here
+        return;
+    }
+    m_texture = texture;
+    m_width = m_texture->w;
+    m_height = m_texture->h;
+}
 } // namespace Engine

src/engine/engine.cpp

@@ -1,3 +1,4 @@
+#include "engine/core/resource.hpp"
 #include <engine/core/event.hpp>
 #include <engine/core/renderer.hpp>
 #include <engine/core/window.hpp>
@@ -27,6 +28,7 @@ bool Engine::Init() {
     // TODO: Impl other subsystems here
     m_eventHandler = std::make_unique<EventManager>();
     m_renderManager = std::make_unique<RenderManager>();
+    m_resManager = std::make_unique<ResourceManager>(*m_renderer);
     return true;
 }
 
@@ -44,4 +46,6 @@ Renderer &Engine::GetRenderer() { return *m_renderer; }
 EventManager &Engine::GetEvents() { return *m_eventHandler; }
 
 RenderManager &Engine::GetRenderManager() { return *m_renderManager; }
+
+ResourceManager &Engine::GetResources() { return *m_resManager; };
 } // namespace Engine

src/main.cpp

@@ -2,12 +2,6 @@
 #include <SDL3/SDL_main.h>
 #include <engine/engine.hpp>
 #include <engine/logger.hpp>
-#include <memory>
-#include <spdlog/sinks/basic_file_sink.h>
-#include <spdlog/spdlog.h>
-
-// Used in this example to keep track of selected object
-static int s_currentRect = 1;
 
 // Initialises subsystems and initialises appState to be used by all other main
 // functions.
@@ -37,22 +31,20 @@ SDL_AppResult SDL_AppInit(void **appState, int argc, char *argv[]) {
             gameEngine->GetWindow().SetDimensions(data.window.width,
                                                   data.window.height);
         });
-    /*
-        gameEngine->GetEvents().RegisterCallback(
-            Engine::EventType::KeyDown, [](Engine::EventData data) {
-                SPDLOG_INFO("Key pressed: {} (keycode)", data.keyboard.keycode);
-                SPDLOG_INFO("Key pressed: {} (scancode)", static_cast<unsigned
-       int>(data.keyboard.scancode)); SPDLOG_INFO("Key pressed modifiers: {}",
-       data.keyboard.modifiers);
-            });
-        gameEngine->GetEvents().RegisterCallback(
-            Engine::EventType::KeyUp, [](Engine::EventData data) {
-                SPDLOG_INFO("Key released: {} (keycode)",
-       data.keyboard.keycode); SPDLOG_INFO("Key released: {} (scancode)",
-       static_cast<unsigned int>(data.keyboard.scancode)); SPDLOG_INFO("Key
-       released modifiers: {}", data.keyboard.modifiers);
-            });
-        */
+    gameEngine->GetEvents().RegisterCallback(
+        Engine::EventType::KeyDown, [](Engine::EventData data) {
+            SPDLOG_INFO("Key pressed: {} (keycode)", data.keyboard.keycode);
+            SPDLOG_INFO("Key pressed: {} (scancode)",
+                        static_cast<unsigned int>(data.keyboard.scancode));
+            SPDLOG_INFO("Key pressed modifiers: {}", data.keyboard.modifiers);
+        });
+    gameEngine->GetEvents().RegisterCallback(
+        Engine::EventType::KeyUp, [](Engine::EventData data) {
+            SPDLOG_INFO("Key released: {} (keycode)", data.keyboard.keycode);
+            SPDLOG_INFO("Key released: {} (scancode)",
+                        static_cast<unsigned int>(data.keyboard.scancode));
+            SPDLOG_INFO("Key released modifiers: {}", data.keyboard.modifiers);
+        });
     gameEngine->GetEvents().RegisterCallback(
         Engine::EventType::MouseButtonDown,
         [](Engine::EventData data) { SPDLOG_INFO("Mouse buttons pressed"); });
@@ -71,103 +63,6 @@ SDL_AppResult SDL_AppInit(void **appState, int argc, char *argv[]) {
                         data.mouse.y);
         });
 
-    SPDLOG_INFO("Creating renderable objects.");
-    std::unique_ptr<Engine::Renderable> rectangle1 =
-        std::make_unique<Engine::RectangleShape>(Engine::Rect(10, 10, 60, 80),
-                                                 Engine::Color::Blue());
-    rectangle1->SetName("Rectangle1");
-
-    std::unique_ptr<Engine::Renderable> rectangle2 =
-        std::make_unique<Engine::RectangleShape>(Engine::Rect(270, 10, 60, 80),
-                                                 Engine::Color::Green());
-    rectangle2->SetName("Rectangle2");
-
-    std::unique_ptr<Engine::Renderable> rectangle3 =
-        std::make_unique<Engine::RectangleShape>(Engine::Rect(10, 120, 60, 80),
-                                                 Engine::Color::Red());
-    rectangle3->SetName("Rectangle3");
-
-    std::unique_ptr<Engine::Renderable> rectangle4 =
-        std::make_unique<Engine::RectangleShape>(Engine::Rect(270, 120, 60, 80),
-                                                 Engine::Color::White());
-    rectangle4->SetName("Rectangle4");
-
-    SPDLOG_INFO("Adding renderable objects to render manager.");
-    gameEngine->GetRenderManager().AddRenderable(std::move(rectangle1),
-                                                 Engine::Layers::WORLD);
-    gameEngine->GetRenderManager().AddRenderable(std::move(rectangle2),
-                                                 Engine::Layers::ENTITIES);
-    gameEngine->GetRenderManager().AddRenderable(std::move(rectangle3),
-                                                 Engine::Layers::FOREGROUND);
-    gameEngine->GetRenderManager().AddRenderable(std::move(rectangle4),
-                                                 Engine::Layers::UI);
-
-    gameEngine->GetEvents().RegisterCallback(
-        Engine::EventType::KeyDown, [](Engine::EventData data) {
-            if (data.keyboard.keycode == SDLK_1) {
-                s_currentRect = 1;
-                SPDLOG_INFO("Rectangle 1 selected");
-            } else if (data.keyboard.keycode == SDLK_2) {
-                s_currentRect = 2;
-                SPDLOG_INFO("Rectangle 2 selected");
-            } else if (data.keyboard.keycode == SDLK_3) {
-                s_currentRect = 3;
-                SPDLOG_INFO("Rectangle 3 selected");
-            } else if (data.keyboard.keycode == SDLK_4) {
-                s_currentRect = 4;
-                SPDLOG_INFO("Rectangle 4 selected");
-            }
-        });
-    gameEngine->GetEvents().RegisterCallback(
-        Engine::EventType::KeyDown, [gameEngine](Engine::EventData data) {
-            Engine::Renderable *rect = nullptr;
-            switch (s_currentRect) {
-            case 1:
-                rect =
-                    gameEngine->GetRenderManager().GetRenderable("Rectangle1");
-                break;
-            case 2:
-                rect =
-                    gameEngine->GetRenderManager().GetRenderable("Rectangle2");
-                break;
-            case 3:
-                rect =
-                    gameEngine->GetRenderManager().GetRenderable("Rectangle3");
-                break;
-            case 4:
-                rect =
-                    gameEngine->GetRenderManager().GetRenderable("Rectangle4");
-                break;
-            }
-            if (data.keyboard.keycode == SDLK_RIGHT) {
-                rect->TranslateX(10.0f);
-            } else if (data.keyboard.keycode == SDLK_LEFT) {
-                rect->TranslateX(-10.0f);
-            } else if (data.keyboard.keycode == SDLK_DOWN) {
-                rect->TranslateY(10.0f);
-            } else if (data.keyboard.keycode == SDLK_UP) {
-                rect->TranslateY(-10.0f);
-            } else if (data.keyboard.keycode == SDLK_RSHIFT) {
-                rect->Rotate(10.0f);
-            } else if (data.keyboard.keycode == SDLK_LSHIFT) {
-                rect->Rotate(-10.0f);
-            } else if (data.keyboard.keycode == SDLK_P) {
-                rect->Scale(1.1f);
-            } else if (data.keyboard.keycode == SDLK_Q) {
-                rect->Scale(0.9f);
-            } else if (data.keyboard.keycode == SDLK_SPACE) {
-                auto &layer = gameEngine->GetRenderManager().GetLayer(
-                    s_currentRect * 100);
-                float opacity = layer.GetOpacity();
-                layer.SetOpacity(opacity + 0.1f);
-            } else if (data.keyboard.keycode == SDLK_LCTRL) {
-                auto &layer = gameEngine->GetRenderManager().GetLayer(
-                    s_currentRect * 100);
-                float opacity = layer.GetOpacity();
-                layer.SetOpacity(opacity - 0.1f);
-            }
-        });
-    SPDLOG_INFO("Object Rectangle controlled.");
     SPDLOG_INFO("Application initialized successfully.");
     *appState = gameEngine;
     return SDL_APP_CONTINUE;