Created ResourceManager class, Improved efficiency

Use ResourceManager to load and manage fonts and textures. This removes
the need for constant calling of getRenderer from RenderWindow.hpp

It also reduces code for fixing memory leak. Rather than manually
freeing the memory for each texture, the ResourceManager class handles
it automatically when the program exits.

ResourceManager also uses an unordered_map to cache loaded textures and
fonts, improving efficiency by avoiding redundant loading operations.

The file size of Meowstro.cpp has decreased a bit thanks to this but
there are still many more improvements needed to dismantle the code
and make it more modular, maintainable, and testable.

Author: Hugo-RM

CMakeLists.txt

@@ -40,6 +40,7 @@ set(SOURCES
     src/Font.cpp
     src/Sprite.cpp
     src/GameStats.cpp
+    src/ResourceManager.cpp
 )
 
 set(HEADERS
@@ -50,6 +51,7 @@ set(HEADERS
     include/Font.hpp
     include/Sprite.hpp
     include/GameStats.hpp
+    include/ResourceManager.hpp
 )
 
 add_executable(meowstro ${SOURCES} ${HEADERS})

include/Font.hpp

@@ -5,13 +5,8 @@ Description: Font class, handles the logic when rendering a true type font text
 */
 #ifndef FONT_H
 #define FONT_H
-/*
-It is very important to note that I didn't download the necessary library (ttf) in order to work.
-Nor have I downloaded the font that we decided to use for the project, that being Comic Sans.
-As I was literally passing out while writing this because it was so late and rarely have time.
-This also explains why there is no driver file to test, again, passing out, so hypothetically this should work.
-*/
-#include <SDL.h> // Not sure if this needs to be .hpp, again, verge of passing out
+
+#include <SDL.h>
 #include <SDL_ttf.h>
 #include <string>
 
@@ -21,7 +16,7 @@ class Font
 {
     public:
         Font(); // Basic Constructor 
-        ~Font(); // Destructor (fancy)
+        ~Font(); // Destructor
         bool load(const string& fontPath, int fontSz); // Allows us to add a font file
         void unload(); // Clean up (or unload) the font
 

include/RenderWindow.hpp

@@ -1,13 +1,11 @@
 #pragma once
 #include <SDL.h>
-#include <SDL_image.h>
 #include "Entity.hpp"
 
 class RenderWindow
 {
 public:
 	RenderWindow(const char *title, int w, int h, Uint32 windowFlags = SDL_WINDOW_SHOWN);
-	SDL_Texture *loadTexture(const char *filePath);
 	void clear();
 	void render(Entity& entity);
 	void display();

include/ResourceManager.hpp

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <SDL.h>
+#include <SDL_image.h>
+#include <unordered_map>
+#include <string>
+#include "Font.hpp"
+
+class ResourceManager {
+public:
+    ResourceManager(SDL_Renderer* renderer);
+    ~ResourceManager();
+
+    // Texture management
+    SDL_Texture* loadTexture(const std::string& filePath);
+    SDL_Texture* createTextTexture(const std::string& fontPath, int fontSize, const std::string& text, SDL_Color color);
+    
+    // Font management
+    Font* getFont(const std::string& fontPath, int fontSize);
+    
+    // Manual cleanup (called automatically in destructor)
+    void cleanup();
+
+private:
+    SDL_Renderer* renderer;
+    std::unordered_map<std::string, SDL_Texture*> textures;
+    std::unordered_map<std::string, Font*> fonts;
+    
+    // Helper to generate unique keys
+    std::string generateFontKey(const std::string& fontPath, int fontSize) const;
+    std::string generateTextKey(const std::string& fontPath, int fontSize, const std::string& text, SDL_Color color) const;
+};

src/Font.cpp

@@ -3,11 +3,11 @@
 
 using namespace std;
 
-Font::Font() : font(nullptr) {} // Init ptr 2 nullptr
+Font::Font() : font(nullptr) {}
 
 Font::~Font()
 {
-    unload(); // Makin sure memory is nice n tidy
+    unload();
 }
 
 bool Font::load(const string& fontPath, int fontSz)

src/RenderWindow.cpp

@@ -13,17 +13,6 @@ RenderWindow::RenderWindow(const char *title, int w, int h, Uint32 windowFlags)
 	renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
 	SDL_SetRenderDrawColor(renderer, 100, 115, 180, 185);
 }
-
-SDL_Texture *RenderWindow::loadTexture(const char *filePath)
-{
-	SDL_Texture *texture = NULL;
-	texture = IMG_LoadTexture(renderer, filePath);
-
-	if (texture == NULL)
-		std::cout << "IMG_LoadTexture failed. ERROR: " << SDL_GetError() << std::endl;
-
-	return texture;
-}
 void RenderWindow::clear()
 {
 	SDL_RenderClear(renderer);

src/ResourceManager.cpp

@@ -0,0 +1,100 @@
+#include "ResourceManager.hpp"
+#include <iostream>
+
+ResourceManager::ResourceManager(SDL_Renderer* renderer) : renderer(renderer) {}
+
+ResourceManager::~ResourceManager() {
+    cleanup();
+}
+
+SDL_Texture* ResourceManager::loadTexture(const std::string& filePath) {
+    // Check if texture already loaded
+    auto it = textures.find(filePath);
+    if (it != textures.end()) {
+        return it->second;
+    }
+    
+    // Load new texture
+    SDL_Texture* texture = IMG_LoadTexture(renderer, filePath.c_str());
+    if (!texture) {
+        std::cerr << "Failed to load texture: " << filePath << " SDL_Error: " << SDL_GetError() << std::endl;
+        return nullptr;
+    }
+    
+    // Cache the texture
+    textures[filePath] = texture;
+    return texture;
+}
+
+SDL_Texture* ResourceManager::createTextTexture(const std::string& fontPath, int fontSize, const std::string& text, SDL_Color color) {
+    std::string textKey = generateTextKey(fontPath, fontSize, text, color);
+    
+    // Check if text texture already exists
+    auto it = textures.find(textKey);
+    if (it != textures.end()) {
+        return it->second;
+    }
+    
+    // Get or load font
+    Font* font = getFont(fontPath, fontSize);
+    if (!font) {
+        return nullptr;
+    }
+    
+    // Create text texture
+    SDL_Texture* textTexture = font->renderText(renderer, text, color);
+    if (textTexture) {
+        textures[textKey] = textTexture;
+    }
+    
+    return textTexture;
+}
+
+Font* ResourceManager::getFont(const std::string& fontPath, int fontSize) {
+    std::string fontKey = generateFontKey(fontPath, fontSize);
+    
+    // Check if font already loaded
+    auto it = fonts.find(fontKey);
+    if (it != fonts.end()) {
+        return it->second;
+    }
+    
+    // Load new font
+    Font* font = new Font();
+    if (!font->load(fontPath, fontSize)) {
+        delete font;
+        return nullptr;
+    }
+    
+    // Cache the font
+    fonts[fontKey] = font;
+    return font;
+}
+
+void ResourceManager::cleanup() {
+    // Clean up all textures
+    for (auto& pair : textures) {
+        if (pair.second) {
+            SDL_DestroyTexture(pair.second);
+        }
+    }
+    textures.clear();
+    
+    // Clean up all fonts
+    for (auto& pair : fonts) {
+        if (pair.second) {
+            delete pair.second;
+        }
+    }
+    fonts.clear();
+}
+
+std::string ResourceManager::generateFontKey(const std::string& fontPath, int fontSize) const {
+    return fontPath + "_" + std::to_string(fontSize);
+}
+
+std::string ResourceManager::generateTextKey(const std::string& fontPath, int fontSize, const std::string& text, SDL_Color color) const {
+    return fontPath + "_" + std::to_string(fontSize) + "_" + text + "_" + 
+           std::to_string(color.r) + "_" + std::to_string(color.g) + "_" + 
+           std::to_string(color.b) + "_" + std::to_string(color.a);
+}