From b8bd56392c1f2e40fc40490c0f09f1f28a8a0acd Mon Sep 17 00:00:00 2001
From: binaryDiv <lexi@binarydiv.dev>
Date: Wed, 26 Nov 2025 01:57:08 +0100
Subject: [PATCH] Implement ResourceManager and TextureLoader

---
 assets/neofox.png              | Bin 0 -> 12902 bytes
 src/core/engine.cppm           |  20 +++---
 src/core/render_server.cppm    |  81 ++++++++++++++++++++++
 src/core/renderer.cppm         |  47 -------------
 src/core/resource_manager.cppm | 122 +++++++++++++++++++++++++++++++++
 src/core/texture_loader.cppm   |  35 ++++++++++
 src/game/game.cppm             |  54 ++++++++++-----
 src/game/sprite.cppm           |  24 +++----
 8 files changed, 290 insertions(+), 93 deletions(-)
 create mode 100644 assets/neofox.png
 create mode 100644 src/core/render_server.cppm
 delete mode 100644 src/core/renderer.cppm
 create mode 100644 src/core/resource_manager.cppm
 create mode 100644 src/core/texture_loader.cppm

diff --git a/assets/neofox.png b/assets/neofox.png
new file mode 100644
index 0000000000000000000000000000000000000000..64dd563415c0341c930fd7fb94be62fb00ba7c26
GIT binary patch
literal 12902
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
UCqdu*uL7j{NK3I&-tyJ|1LeTW!~g&Q

literal 0
HcmV?d00001

diff --git a/src/core/engine.cppm b/src/core/engine.cppm
index 3d50323..fda4019 100644
--- a/src/core/engine.cppm
+++ b/src/core/engine.cppm
@@ -7,13 +7,11 @@ module;
 export module core.engine;
 
 import config;
-import core.renderer;
+import core.render_server;
 import wrappers.sdl;
 
 export namespace core
 {
-    using Window = sdl::Window;
-
     class Engine
     {
         // Whether this class is currently instantiated (to prevent multiple instances)
@@ -22,13 +20,13 @@ export namespace core
         // If this is set to false, the application will exit
         bool keep_running_ = true;
 
-        Window window_;
-        Renderer renderer_;
+        sdl::Window window_;
+        RenderServer render_server_;
 
         // Private constructor
-        Engine(Window&& window, Renderer&& renderer)
+        Engine(sdl::Window&& window, sdl::Renderer&& renderer)
             : window_{std::move(window)},
-              renderer_{std::move(renderer)}
+              render_server_{std::move(renderer)}
         {
             instantiated_ = true;
         }
@@ -62,7 +60,7 @@ export namespace core
                 return std::unique_ptr<Engine>{
                     new Engine{
                         std::move(sdl_window),
-                        Renderer{std::move(sdl_renderer)}
+                        std::move(sdl_renderer)
                     }
                 };
             }
@@ -72,14 +70,14 @@ export namespace core
                 return keep_running_;
             }
 
-            Window& get_window()
+            sdl::Window& get_window()
             {
                 return window_;
             }
 
-            Renderer& get_renderer()
+            RenderServer& get_render_server()
             {
-                return renderer_;
+                return render_server_;
             }
 
             // Handles an SDL event. Returns true if the event has been handled.
diff --git a/src/core/render_server.cppm b/src/core/render_server.cppm
new file mode 100644
index 0000000..c159769
--- /dev/null
+++ b/src/core/render_server.cppm
@@ -0,0 +1,81 @@
+module;
+
+#include <string>
+#include <utility>
+
+export module core.render_server;
+
+import core.resource_manager;
+import core.texture_loader;
+import wrappers.sdl;
+
+export namespace core
+{
+    using TextureID = unsigned int;
+    using TextureManager = ResourceManager<TextureID, sdl::Texture, TextureLoader>;
+
+    class RenderServer
+    {
+        sdl::Renderer renderer_;
+        TextureLoader texture_loader_;
+        TextureManager texture_manager_;
+
+        public:
+            RenderServer() = delete;
+
+            explicit RenderServer(sdl::Renderer&& renderer)
+                : renderer_{std::move(renderer)},
+                  texture_loader_{renderer_},
+                  texture_manager_{texture_loader_}
+            {}
+
+            // No copy or move operations
+            RenderServer(const RenderServer&) = delete;
+            RenderServer& operator=(const RenderServer&) = delete;
+            RenderServer(RenderServer&&) = delete;
+            RenderServer& operator=(RenderServer&&) = delete;
+
+            ~RenderServer() = default;
+
+            constexpr sdl::Renderer& get_renderer()
+            {
+                return renderer_;
+            }
+
+            /**
+             * Loads a texture from a file (if not loaded yet) and returns its texture ID.
+             */
+            constexpr TextureID load_texture(const std::string& filename)
+            {
+                return texture_manager_.load_resource_by_name(filename);
+            }
+
+            void start_frame() const
+            {
+                renderer_.clear();
+            }
+
+            void finish_frame() const
+            {
+                renderer_.present();
+            }
+
+            constexpr void render_texture(
+                const TextureID texture_id,
+                const sdl::FRect* src_rect,
+                const sdl::FRect* dest_rect
+            ) const
+            {
+                render_texture(texture_manager_.get_resource(texture_id), src_rect, dest_rect);
+            }
+
+            void render_texture(
+                const sdl::Texture& texture,
+                const sdl::FRect* src_rect,
+                const sdl::FRect* dest_rect
+            ) const
+            {
+                renderer_.render_texture(texture, src_rect, dest_rect);
+            }
+    };
+}
diff --git a/src/core/renderer.cppm b/src/core/renderer.cppm
deleted file mode 100644
index 1704c2f..0000000
--- a/src/core/renderer.cppm
+++ /dev/null
@@ -1,47 +0,0 @@
-module;
-
-#include <utility>
-
-export module core.renderer;
-
-import wrappers.sdl;
-
-export namespace core
-{
-    // TODO: Rename this class to RenderServer or something to distinguish it from sdl::Renderer?
-    class Renderer
-    {
-        sdl::Renderer sdl_renderer_;
-
-        public:
-            Renderer() = delete;
-
-            explicit Renderer(sdl::Renderer&& sdl_renderer)
-                : sdl_renderer_{std::move(sdl_renderer)}
-            {}
-
-            constexpr sdl::Renderer& get_sdl_renderer()
-            {
-                return sdl_renderer_;
-            }
-
-            void start_frame() const
-            {
-                sdl_renderer_.clear();
-            }
-
-            void finish_frame() const
-            {
-                sdl_renderer_.present();
-            }
-
-            void render_texture(
-                const sdl::Texture& texture,
-                const sdl::FRect* src_rect,
-                const sdl::FRect* dest_rect
-            ) const
-            {
-                sdl_renderer_.render_texture(texture, src_rect, dest_rect);
-            }
-    };
-}
diff --git a/src/core/resource_manager.cppm b/src/core/resource_manager.cppm
new file mode 100644
index 0000000..2e947f5
--- /dev/null
+++ b/src/core/resource_manager.cppm
@@ -0,0 +1,122 @@
+module;
+
+#include <cassert>
+#include <map>
+#include <optional>
+#include <string>
+#include <vector>
+
+export module core.resource_manager;
+
+export namespace core
+{
+    template <typename ResourceLoaderType, typename ResourceType>
+    concept IsResourceLoader = requires(ResourceLoaderType loader, const std::string& name)
+    {
+        { loader.load_resource(name) } -> std::same_as<ResourceType>;
+    };
+
+    template <
+        typename ResourceIDType,
+        typename ResourceType,
+        IsResourceLoader<ResourceType> ResourceLoaderType
+    >
+    class ResourceManager
+    {
+        // Resource loader
+        ResourceLoaderType& resource_loader_;
+
+        // Registry of loaded resources, array index is resource ID
+        std::vector<ResourceType> resource_registry_;
+
+        // Mapping of all loaded resources from (file) name to resource ID
+        std::map<std::string, ResourceIDType> resource_name_map_;
+
+        public:
+            ResourceManager() = delete;
+
+            explicit ResourceManager(ResourceLoaderType& resource_loader)
+                : resource_loader_{resource_loader}
+            {}
+
+            // No copy or move operations
+            ResourceManager(const ResourceManager&) = delete;
+            ResourceManager& operator=(const ResourceManager&) = delete;
+            ResourceManager(ResourceManager&&) = delete;
+            ResourceManager& operator=(ResourceManager&&) = delete;
+
+            ~ResourceManager() = default;
+
+            /**
+             * Adds a new resource to the registry and returns its ID.
+             */
+            ResourceIDType add_resource(ResourceType&& resource)
+            {
+                // Add resource to end of vector
+                resource_registry_.push_back(std::move(resource));
+
+                // Return the index of the newly added resource
+                return static_cast<ResourceIDType>(resource_registry_.size() - 1);
+            }
+
+            /**
+             * Adds a new resource to the registry, associates the name with it and returns its ID.
+             */
+            ResourceIDType add_resource(ResourceType&& resource, const std::string& name)
+            {
+                // Add resource
+                ResourceIDType resource_id = add_resource(std::move(resource));
+
+                // Associate name with resource ID for future access
+                resource_name_map_.emplace(name, resource_id);
+
+                return resource_id;
+            }
+
+            /**
+             * Gets the resource ID for a given resource name, or `std::nullopt` if the resource was not found.
+             */
+            std::optional<ResourceIDType> get_resource_id_by_name(const std::string& name) const
+            {
+                // Check if resource is already loaded
+                if (
+                    const auto search = resource_name_map_.find(name);
+                    search != resource_name_map_.end()
+                ) {
+                    // Return resource ID
+                    return search->second;
+                }
+
+                return std::nullopt;
+            }
+
+            /**
+             * Loads a resource (e.g. from a file) and adds it to the registry if it isn't loaded yet.
+             * Returns the resource ID.
+             */
+            ResourceIDType load_resource_by_name(const std::string& name)
+            {
+                // Check if resource is already loaded
+                if (
+                    auto resource_id = get_resource_id_by_name(name);
+                    resource_id.has_value()
+                ) {
+                    return resource_id.value();
+                }
+
+                // Load resource and add it to the registry
+                return add_resource(resource_loader_.load_resource(name), name);
+            }
+
+            /**
+             * Returns a reference to the resource with the given ID.
+             * The reference is not guaranteed to be valid after adding new resources to the registry.
+             * Assumes that the resource ID is valid.
+             */
+            const ResourceType& get_resource(const ResourceIDType resource_id) const
+            {
+                assert(resource_id < resource_registry_.size());
+                return resource_registry_[resource_id];
+            }
+    };
+}
diff --git a/src/core/texture_loader.cppm b/src/core/texture_loader.cppm
new file mode 100644
index 0000000..32548c4
--- /dev/null
+++ b/src/core/texture_loader.cppm
@@ -0,0 +1,35 @@
+module;
+
+#include <string>
+
+export module core.texture_loader;
+
+import core.resource_manager;
+import wrappers.sdl;
+import wrappers.sdl_image;
+
+export namespace core
+{
+    class TextureLoader
+    {
+        sdl::Renderer& renderer_;
+
+        public:
+            explicit TextureLoader(sdl::Renderer& renderer)
+                : renderer_{renderer}
+            {}
+
+            // No copy or move operations (reference)
+            TextureLoader(const TextureLoader&) = delete;
+            TextureLoader& operator=(const TextureLoader&) = delete;
+            TextureLoader(TextureLoader&&) = delete;
+            TextureLoader& operator=(TextureLoader&&) = delete;
+
+            ~TextureLoader() = default;
+
+            sdl::Texture load_resource(const std::string& filename) const
+            {
+                return sdl_image::LoadTexture(renderer_, filename);
+            }
+    };
+}
diff --git a/src/game/game.cppm b/src/game/game.cppm
index 1d68ace..04f43f5 100644
--- a/src/game/game.cppm
+++ b/src/game/game.cppm
@@ -2,12 +2,13 @@ module;
 
 #include <cassert>
 #include <memory>
+#include <vector>
 #include <SDL3/SDL.h>
 
 export module game.game;
 
 import core.engine;
-import core.renderer;
+import core.render_server;
 import game.sprite;
 import wrappers.sdl;
 import wrappers.sdl_image;
@@ -22,21 +23,18 @@ export namespace game
         // Reference to the engine
         core::Engine& engine_;
 
-        // Sprite for testing
-        std::unique_ptr<Sprite> sprite_{nullptr};
+        // Sprites for testing
+        Sprite player_sprite_;
+        std::vector<Sprite> sprites_;
 
         // Private constructor
         explicit Game(core::Engine& engine)
-            : engine_(engine)
-        {
-            // TODO: Texture should be a reference/pointer to an object managed by a ResourceManager or similar.
-            auto texture = sdl_image::LoadTexture(
-                engine_.get_renderer().get_sdl_renderer(),
-                "assets/neocat.png"
-            );
-
-            sprite_ = std::make_unique<Sprite>(std::move(texture), 100, 100);
-        }
+            : engine_(engine),
+              player_sprite_{
+                  engine_.get_render_server().load_texture("assets/neocat.png"),
+                  sdl::FRect{0, 0, 100, 100}
+              }
+        {}
 
         public:
             Game() = delete;
@@ -62,15 +60,28 @@ export namespace game
             }
 
             // Handles an SDL event. Returns true if the event has been handled.
-            bool handle_event(const sdl::Event* event) const
+            bool handle_event(const sdl::Event* event)
             {
                 if (event->type == SDL_EVENT_MOUSE_MOTION) {
-                    sprite_->move(
+                    player_sprite_.move(
                         event->motion.x - 50,
                         event->motion.y - 50
                     );
                     return true;
                 }
+
+                if (event->type == SDL_EVENT_MOUSE_BUTTON_UP) {
+                    sprites_.emplace_back(
+                        engine_.get_render_server().load_texture("assets/neofox.png"),
+                        sdl::FRect{
+                            event->motion.x - 50,
+                            event->motion.y - 50,
+                            100, 100
+                        }
+                    );
+                    return true;
+                }
+
                 return false;
             }
 
@@ -80,10 +91,15 @@ export namespace game
 
             void render() const
             {
-                const auto& renderer = engine_.get_renderer();
-                renderer.start_frame();
-                sprite_->draw(renderer);
-                renderer.finish_frame();
+                const auto& render_server = engine_.get_render_server();
+                render_server.start_frame();
+
+                for (const Sprite& sprite : sprites_) {
+                    sprite.draw(render_server);
+                }
+                player_sprite_.draw(render_server);
+
+                render_server.finish_frame();
             }
 
             void shutdown()
diff --git a/src/game/sprite.cppm b/src/game/sprite.cppm
index 901ea28..cd297c3 100644
--- a/src/game/sprite.cppm
+++ b/src/game/sprite.cppm
@@ -1,11 +1,10 @@
 module;
 
-#include <utility>
 #include <SDL3/SDL.h>
 
 export module game.sprite;
 
-import core.renderer;
+import core.render_server;
 import wrappers.sdl;
 
 // TODO: Move this to a different namespace (core, drawing, ...?)
@@ -13,21 +12,14 @@ export namespace game
 {
     class Sprite
     {
-        // TODO: Texture should be a reference/pointer to an object managed by a ResourceManager or similar.
-        sdl::Texture texture_;
+        core::TextureID texture_id_;
         sdl::FRect dest_rect_{0, 0, 0, 0};
 
         public:
-            explicit Sprite(
-                sdl::Texture&& texture,
-                const int width,
-                const int height
-            )
-                : texture_{std::move(texture)}
-            {
-                dest_rect_.w = static_cast<float>(width);
-                dest_rect_.h = static_cast<float>(height);
-            }
+            explicit Sprite(const core::TextureID texture_id, const sdl::FRect dest_rect)
+                : texture_id_{texture_id},
+                  dest_rect_{dest_rect}
+            {}
 
             void move(const float x, const float y)
             {
@@ -35,9 +27,9 @@ export namespace game
                 dest_rect_.y = y;
             }
 
-            void draw(const core::Renderer& renderer) const
+            void draw(const core::RenderServer& render_server) const
             {
-                renderer.render_texture(texture_, nullptr, &dest_rect_);
+                render_server.render_texture(texture_id_, nullptr, &dest_rect_);
             }
     };
 }