From dfa5f78af2f68bed5907555e19aba87536fee9be Mon Sep 17 00:00:00 2001
From: Delta18-Git <64347927+Delta18-Git@users.noreply.github.com>
Date: Wed, 14 May 2025 22:22:32 +0530
Subject: [PATCH 1/7] feat(resource manager): adds manager for textures adds a
 resource manager for loading and unloading assets, as well as for lazily
 creating textures

---
 CMakeLists.txt                   |  1 +
 include/engine/core/resource.hpp | 29 +++++++++++++++
 include/engine/core/texture.hpp  |  4 +--
 include/engine/engine.hpp        |  5 +--
 include/vendored/vendored.cmake  | 10 ++++--
 src/engine/core/resource.cpp     | 62 ++++++++++++++++++++++++++++++++
 src/engine/core/texture.cpp      |  5 +++
 src/engine/engine.cpp            |  4 +++
 8 files changed, 113 insertions(+), 7 deletions(-)
 create mode 100644 include/engine/core/resource.hpp
 create mode 100644 src/engine/core/resource.cpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 23190e3..a4e05de 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -34,6 +34,7 @@ target_link_libraries(GameEngine
     PRIVATE
     SDL3::SDL3
     SDL3_ttf::SDL3_ttf
+    SDL3_image::SDL3_image
     imgui_sdl3
     spdlog
 )
diff --git a/include/engine/core/resource.hpp b/include/engine/core/resource.hpp
new file mode 100644
index 0000000..8351109
--- /dev/null
+++ b/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
diff --git a/include/engine/core/texture.hpp b/include/engine/core/texture.hpp
index 72a8b83..55f60d6 100644
--- a/include/engine/core/texture.hpp
+++ b/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; }
diff --git a/include/engine/engine.hpp b/include/engine/engine.hpp
index 408d401..2b46f01 100644
--- a/include/engine/engine.hpp
+++ b/include/engine/engine.hpp
@@ -1,5 +1,6 @@
 #ifndef _ENGINE_HPP
 #define _ENGINE_HPP
+#include <engine/core/resource.hpp>
 #include <engine/core/event.hpp>
 #include <engine/core/renderer.hpp>
 #include <engine/core/window.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;
diff --git a/include/vendored/vendored.cmake b/include/vendored/vendored.cmake
index b6740aa..c64e94d 100644
--- a/include/vendored/vendored.cmake
+++ b/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
diff --git a/src/engine/core/resource.cpp b/src/engine/core/resource.cpp
new file mode 100644
index 0000000..0c191d4
--- /dev/null
+++ b/src/engine/core/resource.cpp
@@ -0,0 +1,62 @@
+#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>();
+    texture->SetTexture(IMG_LoadTexture(m_renderer.GetSDLRenderer(),
+                                        std::string(path).c_str()));
+    m_textureMap.emplace(path, std::move(texture));
+}
+
+} // namespace Engine
diff --git a/src/engine/core/texture.cpp b/src/engine/core/texture.cpp
index 7a281d0..6a02a57 100644
--- a/src/engine/core/texture.cpp
+++ b/src/engine/core/texture.cpp
@@ -8,4 +8,9 @@ Texture::~Texture() {
         m_texture = nullptr;
     }
 }
+void Texture::SetTexture(SDL_Texture *texture) {
+    m_texture = texture;
+    m_width = m_texture->w;
+    m_height = m_texture->h;
+}
 } // namespace Engine
diff --git a/src/engine/engine.cpp b/src/engine/engine.cpp
index 1646536..203b9ee 100644
--- a/src/engine/engine.cpp
+++ b/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

From e92cd7b8d986a6b68b61994eab1cede93e914009 Mon Sep 17 00:00:00 2001
From: Delta18-Git <64347927+Delta18-Git@users.noreply.github.com>
Date: Sat, 17 May 2025 18:30:00 +0530
Subject: [PATCH 2/7] test: add interactive sprite layer test

adds a test including sprite rendering
showcasing the enderable transformations
as well as the layer interactions
---
 include/engine/engine.hpp        |   2 +-
 tests/res/kenney-pixel-char1.png | Bin 0 -> 254 bytes
 tests/res/kenney-pixel-char2.png | Bin 0 -> 258 bytes
 tests/sprite_layer.cpp           | 180 +++++++++++++++++++++++++++++++
 4 files changed, 181 insertions(+), 1 deletion(-)
 create mode 100644 tests/res/kenney-pixel-char1.png
 create mode 100644 tests/res/kenney-pixel-char2.png
 create mode 100644 tests/sprite_layer.cpp

diff --git a/include/engine/engine.hpp b/include/engine/engine.hpp
index 2b46f01..be4e877 100644
--- a/include/engine/engine.hpp
+++ b/include/engine/engine.hpp
@@ -1,8 +1,8 @@
 #ifndef _ENGINE_HPP
 #define _ENGINE_HPP
-#include <engine/core/resource.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>
diff --git a/tests/res/kenney-pixel-char1.png b/tests/res/kenney-pixel-char1.png
new file mode 100644
index 0000000000000000000000000000000000000000..c6d7d7f681e1fb412b9b6ee6fb1bce408a4860b8
GIT binary patch
literal 254
zcmeAS@N?(olHy`uVBq!ia0vp^5+KaN3?zjj6;1;wmUKs7M+SzC{oH>NSwWHkJ|V6^
z+GJ*&vsZlEx848$|Bt%VW0LB=@7_nTNPAA89Ain4UoeBivm0qZPK&3DV~E7%+zW<$
zhYWaFFZiUsJH%MUs^Zu1MA*WZ<7lkpnqR+e{QDSiWd5fV?O&eR_8ZUGygux_vO9=p
ziXG#jS!`<rs<YZF$`-ezG&twU-E1s>5SQSe$nq;bXOAe)iPgOurt$8X%`b7+Z>|6P
wOztRq#ux*|*I&1u`XlhrZpVfmyQ0_Jvp0DO$!F}?19T6Ar>mdKI;Vst00C59^Z)<=

literal 0
HcmV?d00001

diff --git a/tests/res/kenney-pixel-char2.png b/tests/res/kenney-pixel-char2.png
new file mode 100644
index 0000000000000000000000000000000000000000..99d7f635aad5c201f69d43d5688823bdde9b560e
GIT binary patch
literal 258
zcmeAS@N?(olHy`uVBq!ia0vp^5+KaN3?zjj6;1;wmUKs7M+SzC{oH>NSwWHkJ|V6^
z`c2DHXRrAGr*HiSf?2!TJ!AIW`#9fgk2+9}u_VYZn8D%MjWi&q!_&nvMB;Mp1zWyD
z20W|}d{W;XVyt3S@e6pu{oqW<iFc<Gu3kTG|1sdm>`$80zD~MUw`gMFw5v=DyBp#;
zYGfuPKf2I#zEdverYMt)r%cV}5A!Ol-?45H;RrtxSE1Lx|AI{SRjw!8RVEwqb||E6
z4}N{Q`qq@S@trXS2R@h1uB_omR@d>lqPc9}l4dWH^Fj+mfNo;&boFyt=akR{05QsD
AdjJ3c

literal 0
HcmV?d00001

diff --git a/tests/sprite_layer.cpp b/tests/sprite_layer.cpp
new file mode 100644
index 0000000..3215bdd
--- /dev/null
+++ b/tests/sprite_layer.cpp
@@ -0,0 +1,180 @@
+#include <SDL3/SDL_keycode.h>
+#include <SDL3/SDL_log.h>
+#include <SDL3/SDL_main.h>
+#include <engine/engine.hpp>
+#include <memory>
+
+// Used in this example to keep track of selected object
+static int s_currentObj = 1;
+
+// A simple helper function that logs that a critical failure happens and
+// returns an app failure.
+SDL_AppResult SDL_Failure(const char *fmt) {
+    SDL_LogCritical(SDL_LOG_CATEGORY_ERROR, "%s: %s\n", fmt, SDL_GetError());
+    return SDL_APP_FAILURE;
+}
+
+// Initialises subsystems and initialises appState to be used by all other main
+// functions.
+SDL_AppResult SDL_AppInit(void **appState, int argc, char *argv[]) {
+    Engine::Engine *gameEngine = &Engine::Engine::Instance();
+    SDL_SetAppMetadata("GameEngine", "0.0.1",
+                       "org.acm.pesuecc.aiep.game-engine");
+    if (!gameEngine->Init()) {
+        SDL_LogCritical(SDL_LOG_CATEGORY_ERROR,
+                        "Failed to initialise game engine");
+        gameEngine->Shutdown();
+        return SDL_APP_FAILURE;
+    }
+    Engine::Window &gameWindow = gameEngine->GetWindow();
+    Engine::EventManager &events = gameEngine->GetEvents();
+    Engine::ResourceManager &res = gameEngine->GetResources();
+    Engine::RenderManager &rdrMgr = gameEngine->GetRenderManager();
+    gameWindow.SetDimensions(1000, 800);
+    events.RegisterCallback(
+        Engine::EventType::WindowResize, [&gameWindow](Engine::EventData data) {
+            SDL_Log("Window resized to %d x %d", data.window.width,
+                    data.window.height);
+            gameWindow.SetDimensions(data.window.width, data.window.height);
+        });
+    events.RegisterCallback(
+        Engine::EventType::MouseButtonDown,
+        [](Engine::EventData data) { SDL_Log("Mouse buttons pressed"); });
+    events.RegisterCallback(
+        Engine::EventType::MouseWheel, [](Engine::EventData data) {
+            SDL_Log("Mouse wheel scrolled: %.0f", data.mouse.y);
+        });
+    events.RegisterCallback(
+        Engine::EventType::MouseButtonUp,
+        [](Engine::EventData data) { SDL_Log("Mouse buttons released"); });
+    events.RegisterCallback(
+        Engine::EventType::MouseMove, [](Engine::EventData data) {
+            SDL_Log("Mouse moved to: (%.0f, %.0f)", data.mouse.x, data.mouse.y);
+        });
+    res.AddResource("tests/res/kenney-pixel-char1.png",
+                    Engine::ResourceType::Texture);
+    res.AddResource("tests/res/kenney-pixel-char2.png",
+                    Engine::ResourceType::Texture);
+    std::shared_ptr<Engine::Texture> tex1 =
+        res.FindTexture("tests/res/kenney-pixel-char1.png");
+    std::unique_ptr<Engine::Renderable> obj1 = std::make_unique<Engine::Sprite>(
+        std::move(tex1), Engine::Vector2(15, 25));
+    obj1->SetName("Character 1");
+    std::unique_ptr<Engine::Renderable> obj2 =
+        std::make_unique<Engine::RectangleShape>(Engine::Rect(270, 10, 60, 80),
+                                                 Engine::Color::Green());
+    obj2->SetName("Green Rectangle");
+    std::unique_ptr<Engine::Renderable> rectangle3 =
+        std::make_unique<Engine::RectangleShape>(Engine::Rect(10, 120, 60, 80),
+                                                 Engine::Color::Red());
+    rectangle3->SetName("Red Rectangle");
+    std::shared_ptr<Engine::Texture> tex2 =
+        res.FindTexture("tests/res/kenney-pixel-char2.png");
+    std::unique_ptr<Engine::Renderable> rectangle4 =
+        std::make_unique<Engine::Sprite>(std::move(tex2),
+                                         Engine::Vector2(300, 160));
+    rectangle4->SetName("Character 2");
+    rdrMgr.AddRenderable(std::move(obj1), Engine::Layers::WORLD);
+    rdrMgr.AddRenderable(std::move(obj2), Engine::Layers::ENTITIES);
+    rdrMgr.AddRenderable(std::move(rectangle3), Engine::Layers::FOREGROUND);
+    rdrMgr.AddRenderable(std::move(rectangle4), Engine::Layers::UI);
+    events.RegisterCallback(Engine::EventType::KeyDown,
+                            [](Engine::EventData data) {
+                                if (data.keyboard.keycode == SDLK_1) {
+                                    s_currentObj = 1;
+                                    SDL_Log("Character 1 selected");
+                                } else if (data.keyboard.keycode == SDLK_2) {
+                                    s_currentObj = 2;
+                                    SDL_Log("Green Rectangle selected");
+                                } else if (data.keyboard.keycode == SDLK_3) {
+                                    s_currentObj = 3;
+                                    SDL_Log("Red Rectangle selected");
+                                } else if (data.keyboard.keycode == SDLK_4) {
+                                    s_currentObj = 4;
+                                    SDL_Log("Character 2 selected");
+                                }
+                            });
+    events.RegisterCallback(
+        Engine::EventType::KeyDown, [&rdrMgr](Engine::EventData data) {
+            Engine::Renderable *obj = nullptr;
+            switch (s_currentObj) {
+            case 1:
+                obj = rdrMgr.GetRenderable("Character 1");
+                break;
+            case 2:
+                obj = rdrMgr.GetRenderable("Green Rectangle");
+                break;
+            case 3:
+                obj = rdrMgr.GetRenderable("Red Rectangle");
+                break;
+            case 4:
+                obj = rdrMgr.GetRenderable("Character 2");
+                break;
+            }
+            if (data.keyboard.keycode == SDLK_RIGHT) {
+                obj->TranslateX(10.0f);
+            } else if (data.keyboard.keycode == SDLK_LEFT) {
+                obj->TranslateX(-10.0f);
+            } else if (data.keyboard.keycode == SDLK_DOWN) {
+                obj->TranslateY(10.0f);
+            } else if (data.keyboard.keycode == SDLK_UP) {
+                obj->TranslateY(-10.0f);
+            } else if (data.keyboard.keycode == SDLK_RSHIFT) {
+                obj->Rotate(10.0f);
+            } else if (data.keyboard.keycode == SDLK_LSHIFT) {
+                obj->Rotate(-10.0f);
+            } else if (data.keyboard.keycode == SDLK_P) {
+                obj->Scale(1.1f);
+            } else if (data.keyboard.keycode == SDLK_Q) {
+                obj->Scale(0.9f);
+            } else if (data.keyboard.keycode == SDLK_SPACE) {
+                auto &layer = rdrMgr.GetLayer(s_currentObj * 100);
+                float opacity = layer.GetOpacity();
+                layer.SetOpacity(opacity + 0.1f);
+            } else if (data.keyboard.keycode == SDLK_LCTRL) {
+                auto &layer = rdrMgr.GetLayer(s_currentObj * 100);
+                float opacity = layer.GetOpacity();
+                layer.SetOpacity(opacity - 0.1f);
+            }
+        });
+    SDL_Log("Controls:\n1-4: Change selected object\n"
+            "Arrow Keys: Move object\n"
+            "RShift: Rotate Clockewise\n"
+            "LShift: Rotate Counter-Clockwise\n"
+            "P: Increase Scale\n"
+            "Q: Decrease Scale\n"
+            "Space: Increase Opacity\n"
+            "Ctrl: Decrease Opacity");
+    *appState = gameEngine;
+    return SDL_APP_CONTINUE;
+}
+
+// The event handling function called by SDL.
+// TODO: Try and make a genericsed function that is called from here to allow
+//       custom event handling to be added by a user.
+SDL_AppResult SDL_AppEvent(void *appState, SDL_Event *event) {
+    Engine::Engine *gameEngine = static_cast<Engine::Engine *>(appState);
+    if (event->type == SDL_EVENT_QUIT || event->type == SDL_EVENT_TERMINATING) {
+        return SDL_APP_SUCCESS;
+    } else {
+        gameEngine->GetEvents().ProcessEvent(event);
+    }
+    return SDL_APP_CONTINUE;
+}
+
+// The "main loop" of the window.
+SDL_AppResult SDL_AppIterate(void *appState) {
+    Engine::Engine *gameEngine = static_cast<Engine::Engine *>(appState);
+    gameEngine->GetRenderer().Clear(Engine::Color::Black());
+    gameEngine->GetRenderManager().RenderAll(gameEngine->GetRenderer());
+    gameEngine->GetRenderer().Present();
+    return SDL_APP_CONTINUE;
+}
+
+// Cleans up the initialised subsystems.
+void SDL_AppQuit(void *appState, SDL_AppResult result) {
+    Engine::Engine *gameEngine = static_cast<Engine::Engine *>(appState);
+    if (gameEngine != nullptr) {
+        gameEngine->Shutdown();
+    }
+}

From b101b24c103eacde5c5ca5bbb0e78ffee71d031d Mon Sep 17 00:00:00 2001
From: Delta18-Git <64347927+Delta18-Git@users.noreply.github.com>
Date: Fri, 23 May 2025 23:53:00 +0530
Subject: [PATCH 3/7] fix: replace logging with spdlog-based logging

for parity with main.cpp
---
 tests/sprite_layer.cpp | 56 ++++++++++++++++++++++++++++++++----------
 1 file changed, 43 insertions(+), 13 deletions(-)

diff --git a/tests/sprite_layer.cpp b/tests/sprite_layer.cpp
index 3215bdd..f38e084 100644
--- a/tests/sprite_layer.cpp
+++ b/tests/sprite_layer.cpp
@@ -2,6 +2,7 @@
 #include <SDL3/SDL_log.h>
 #include <SDL3/SDL_main.h>
 #include <engine/engine.hpp>
+#include <engine/logger.hpp>
 #include <memory>
 
 // Used in this example to keep track of selected object
@@ -21,11 +22,12 @@ SDL_AppResult SDL_AppInit(void **appState, int argc, char *argv[]) {
     SDL_SetAppMetadata("GameEngine", "0.0.1",
                        "org.acm.pesuecc.aiep.game-engine");
     if (!gameEngine->Init()) {
-        SDL_LogCritical(SDL_LOG_CATEGORY_ERROR,
-                        "Failed to initialise game engine");
+        SPDLOG_CRITICAL("Failed to initialize game engine.");
         gameEngine->Shutdown();
         return SDL_APP_FAILURE;
     }
+    SPDLOG_INFO("Game engine initialized successfully.");
+
     Engine::Window &gameWindow = gameEngine->GetWindow();
     Engine::EventManager &events = gameEngine->GetEvents();
     Engine::ResourceManager &res = gameEngine->GetResources();
@@ -33,28 +35,35 @@ SDL_AppResult SDL_AppInit(void **appState, int argc, char *argv[]) {
     gameWindow.SetDimensions(1000, 800);
     events.RegisterCallback(
         Engine::EventType::WindowResize, [&gameWindow](Engine::EventData data) {
-            SDL_Log("Window resized to %d x %d", data.window.width,
-                    data.window.height);
+            SPDLOG_INFO("Window resized to {} x {}", data.window.width,
+                        data.window.height);
             gameWindow.SetDimensions(data.window.width, data.window.height);
         });
     events.RegisterCallback(
         Engine::EventType::MouseButtonDown,
-        [](Engine::EventData data) { SDL_Log("Mouse buttons pressed"); });
+        [](Engine::EventData data) { SPDLOG_INFO("Mouse buttons pressed"); });
     events.RegisterCallback(
         Engine::EventType::MouseWheel, [](Engine::EventData data) {
-            SDL_Log("Mouse wheel scrolled: %.0f", data.mouse.y);
+            SPDLOG_INFO("Mouse wheel scrolled: {:.0f}", data.mouse.y);
         });
     events.RegisterCallback(
         Engine::EventType::MouseButtonUp,
-        [](Engine::EventData data) { SDL_Log("Mouse buttons released"); });
+        [](Engine::EventData data) { SPDLOG_INFO("Mouse buttons released."); });
     events.RegisterCallback(
         Engine::EventType::MouseMove, [](Engine::EventData data) {
-            SDL_Log("Mouse moved to: (%.0f, %.0f)", data.mouse.x, data.mouse.y);
+            SPDLOG_INFO("Mouse moved to: ({:.0f}, {:.0f})", data.mouse.x,
+                        data.mouse.y);
         });
+
+    SPDLOG_INFO("Creating renderable objects.");
+
+    SPDLOG_INFO("Importing textures.");
     res.AddResource("tests/res/kenney-pixel-char1.png",
                     Engine::ResourceType::Texture);
     res.AddResource("tests/res/kenney-pixel-char2.png",
                     Engine::ResourceType::Texture);
+
+    SPDLOG_INFO("Loading textures and creating renderable objects.");
     std::shared_ptr<Engine::Texture> tex1 =
         res.FindTexture("tests/res/kenney-pixel-char1.png");
     std::unique_ptr<Engine::Renderable> obj1 = std::make_unique<Engine::Sprite>(
@@ -74,24 +83,27 @@ SDL_AppResult SDL_AppInit(void **appState, int argc, char *argv[]) {
         std::make_unique<Engine::Sprite>(std::move(tex2),
                                          Engine::Vector2(300, 160));
     rectangle4->SetName("Character 2");
+
+    SPDLOG_INFO("Adding renderable objects to render manager.");
     rdrMgr.AddRenderable(std::move(obj1), Engine::Layers::WORLD);
     rdrMgr.AddRenderable(std::move(obj2), Engine::Layers::ENTITIES);
     rdrMgr.AddRenderable(std::move(rectangle3), Engine::Layers::FOREGROUND);
     rdrMgr.AddRenderable(std::move(rectangle4), Engine::Layers::UI);
+
     events.RegisterCallback(Engine::EventType::KeyDown,
                             [](Engine::EventData data) {
                                 if (data.keyboard.keycode == SDLK_1) {
                                     s_currentObj = 1;
-                                    SDL_Log("Character 1 selected");
+                                    SPDLOG_INFO("Character 1 selected");
                                 } else if (data.keyboard.keycode == SDLK_2) {
                                     s_currentObj = 2;
-                                    SDL_Log("Green Rectangle selected");
+                                    SPDLOG_INFO("Green Rectangle selected");
                                 } else if (data.keyboard.keycode == SDLK_3) {
                                     s_currentObj = 3;
-                                    SDL_Log("Red Rectangle selected");
+                                    SPDLOG_INFO("Red Rectangle selected");
                                 } else if (data.keyboard.keycode == SDLK_4) {
                                     s_currentObj = 4;
-                                    SDL_Log("Character 2 selected");
+                                    SPDLOG_INFO("Character 2 selected");
                                 }
                             });
     events.RegisterCallback(
@@ -137,7 +149,7 @@ SDL_AppResult SDL_AppInit(void **appState, int argc, char *argv[]) {
                 layer.SetOpacity(opacity - 0.1f);
             }
         });
-    SDL_Log("Controls:\n1-4: Change selected object\n"
+    SPDLOG_INFO("Controls:\n1-4: Change selected object\n"
             "Arrow Keys: Move object\n"
             "RShift: Rotate Clockewise\n"
             "LShift: Rotate Counter-Clockwise\n"
@@ -145,6 +157,8 @@ SDL_AppResult SDL_AppInit(void **appState, int argc, char *argv[]) {
             "Q: Decrease Scale\n"
             "Space: Increase Opacity\n"
             "Ctrl: Decrease Opacity");
+
+    SPDLOG_INFO("Application initialized successfully.");
     *appState = gameEngine;
     return SDL_APP_CONTINUE;
 }
@@ -155,8 +169,11 @@ SDL_AppResult SDL_AppInit(void **appState, int argc, char *argv[]) {
 SDL_AppResult SDL_AppEvent(void *appState, SDL_Event *event) {
     Engine::Engine *gameEngine = static_cast<Engine::Engine *>(appState);
     if (event->type == SDL_EVENT_QUIT || event->type == SDL_EVENT_TERMINATING) {
+        SPDLOG_INFO("Received SDL_EVENT_QUIT or SDL_EVENT_TERMINATING. Exiting "
+                    "application.");
         return SDL_APP_SUCCESS;
     } else {
+        SPDLOG_DEBUG("Processing SDL event of type: {}", event->type);
         gameEngine->GetEvents().ProcessEvent(event);
     }
     return SDL_APP_CONTINUE;
@@ -165,9 +182,18 @@ SDL_AppResult SDL_AppEvent(void *appState, SDL_Event *event) {
 // The "main loop" of the window.
 SDL_AppResult SDL_AppIterate(void *appState) {
     Engine::Engine *gameEngine = static_cast<Engine::Engine *>(appState);
+    SPDLOG_TRACE("Starting main loop iteration.");
+
+    SPDLOG_DEBUG("Clearing renderer with color: Black.");
     gameEngine->GetRenderer().Clear(Engine::Color::Black());
+
+    SPDLOG_DEBUG("Rendering all objects.");
     gameEngine->GetRenderManager().RenderAll(gameEngine->GetRenderer());
+
+    SPDLOG_DEBUG("Presenting rendered frame.");
     gameEngine->GetRenderer().Present();
+
+    SPDLOG_TRACE("Main loop iteration completed.");
     return SDL_APP_CONTINUE;
 }
 
@@ -175,6 +201,10 @@ SDL_AppResult SDL_AppIterate(void *appState) {
 void SDL_AppQuit(void *appState, SDL_AppResult result) {
     Engine::Engine *gameEngine = static_cast<Engine::Engine *>(appState);
     if (gameEngine != nullptr) {
+        SPDLOG_INFO("Shutting down game engine.");
         gameEngine->Shutdown();
+        SPDLOG_INFO("Game engine shutdown completed.");
+    } else {
+        SPDLOG_WARN("Game engine was null during shutdown.");
     }
 }

From abc793afa7af4f6143e761ad03b4e5b681553016 Mon Sep 17 00:00:00 2001
From: Delta18-Git <64347927+Delta18-Git@users.noreply.github.com>
Date: Sat, 24 May 2025 00:07:18 +0530
Subject: [PATCH 4/7] fix: remove example code from main

---
 src/main.cpp           | 133 +++++------------------------------------
 tests/sprite_layer.cpp |   8 +--
 2 files changed, 18 insertions(+), 123 deletions(-)

diff --git a/src/main.cpp b/src/main.cpp
index 93a353e..08deb27 100644
--- a/src/main.cpp
+++ b/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;
diff --git a/tests/sprite_layer.cpp b/tests/sprite_layer.cpp
index f38e084..611cd89 100644
--- a/tests/sprite_layer.cpp
+++ b/tests/sprite_layer.cpp
@@ -73,16 +73,16 @@ SDL_AppResult SDL_AppInit(void **appState, int argc, char *argv[]) {
         std::make_unique<Engine::RectangleShape>(Engine::Rect(270, 10, 60, 80),
                                                  Engine::Color::Green());
     obj2->SetName("Green Rectangle");
-    std::unique_ptr<Engine::Renderable> rectangle3 =
+    std::unique_ptr<Engine::Renderable> obj3 =
         std::make_unique<Engine::RectangleShape>(Engine::Rect(10, 120, 60, 80),
                                                  Engine::Color::Red());
-    rectangle3->SetName("Red Rectangle");
+    obj3->SetName("Red Rectangle");
     std::shared_ptr<Engine::Texture> tex2 =
         res.FindTexture("tests/res/kenney-pixel-char2.png");
-    std::unique_ptr<Engine::Renderable> rectangle4 =
+    std::unique_ptr<Engine::Renderable> obj4 =
         std::make_unique<Engine::Sprite>(std::move(tex2),
                                          Engine::Vector2(300, 160));
-    rectangle4->SetName("Character 2");
+    obj4->SetName("Character 2");
 
     SPDLOG_INFO("Adding renderable objects to render manager.");
     rdrMgr.AddRenderable(std::move(obj1), Engine::Layers::WORLD);

From 3d1f6a297e4d65160100cd89b10ccfeea73c07c6 Mon Sep 17 00:00:00 2001
From: Delta18-Git <64347927+Delta18-Git@users.noreply.github.com>
Date: Sat, 24 May 2025 01:48:44 +0530
Subject: [PATCH 5/7] fix(test/sprite_layer): make logging same as main

---
 tests/sprite_layer.cpp | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/tests/sprite_layer.cpp b/tests/sprite_layer.cpp
index 611cd89..e2df931 100644
--- a/tests/sprite_layer.cpp
+++ b/tests/sprite_layer.cpp
@@ -18,6 +18,9 @@ SDL_AppResult SDL_Failure(const char *fmt) {
 // Initialises subsystems and initialises appState to be used by all other main
 // functions.
 SDL_AppResult SDL_AppInit(void **appState, int argc, char *argv[]) {
+    SPDLOG_INFO("Initializing application.");
+    Engine::Logging::Init();
+
     Engine::Engine *gameEngine = &Engine::Engine::Instance();
     SDL_SetAppMetadata("GameEngine", "0.0.1",
                        "org.acm.pesuecc.aiep.game-engine");

From 4207b473b5b0d4c6a08ce59ce147d8e2c75377a5 Mon Sep 17 00:00:00 2001
From: Delta18-Git <64347927+Delta18-Git@users.noreply.github.com>
Date: Sat, 24 May 2025 01:50:37 +0530
Subject: [PATCH 6/7] feat(test/collision): add AABB based collision example

with logging and sprite loading
---
 tests/collision.cpp | 298 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 298 insertions(+)
 create mode 100644 tests/collision.cpp

diff --git a/tests/collision.cpp b/tests/collision.cpp
new file mode 100644
index 0000000..b06887d
--- /dev/null
+++ b/tests/collision.cpp
@@ -0,0 +1,298 @@
+#include <SDL3/SDL_keycode.h>
+#include <SDL3/SDL_log.h>
+#include <SDL3/SDL_main.h>
+#include <engine/engine.hpp>
+#include <engine/logger.hpp>
+#include <memory>
+
+// Used in this example to keep track of selected object
+static int s_currentObj = 1;
+
+// A simple helper function that logs that a critical failure happens and
+// returns an app failure.
+SDL_AppResult SDL_Failure(const char *fmt) {
+    SDL_LogCritical(SDL_LOG_CATEGORY_ERROR, "%s: %s\n", fmt, SDL_GetError());
+    return SDL_APP_FAILURE;
+}
+
+// Initialises subsystems and initialises appState to be used by all other main
+// functions.
+SDL_AppResult SDL_AppInit(void **appState, int argc, char *argv[]) {
+    SPDLOG_INFO("Initializing application.");
+    Engine::Logging::Init();
+
+    Engine::Engine *gameEngine = &Engine::Engine::Instance();
+    SDL_SetAppMetadata("GameEngine", "0.0.1",
+                       "org.acm.pesuecc.aiep.game-engine");
+
+    SPDLOG_INFO("Initializing game engine.");
+    if (!gameEngine->Init()) {
+        SPDLOG_CRITICAL("Failed to initialize game engine.");
+        gameEngine->Shutdown();
+        return SDL_APP_FAILURE;
+    }
+    SPDLOG_INFO("Game engine initialized successfully.");
+
+    Engine::Window &gameWindow = gameEngine->GetWindow();
+    Engine::EventManager &events = gameEngine->GetEvents();
+    Engine::ResourceManager &res = gameEngine->GetResources();
+    Engine::RenderManager &rdrMgr = gameEngine->GetRenderManager();
+    gameWindow.SetDimensions(1000, 800);
+    events.RegisterCallback(
+        Engine::EventType::WindowResize, [&gameWindow](Engine::EventData data) {
+            SPDLOG_INFO("Window resized to {} x {}", data.window.width,
+                        data.window.height);
+            gameWindow.SetDimensions(data.window.width, data.window.height);
+        });
+    events.RegisterCallback(
+        Engine::EventType::MouseButtonDown,
+        [](Engine::EventData data) { SPDLOG_INFO("Mouse buttons pressed"); });
+    events.RegisterCallback(
+        Engine::EventType::MouseWheel, [](Engine::EventData data) {
+            SPDLOG_INFO("Mouse wheel scrolled: {:.0f}", data.mouse.y);
+        });
+    events.RegisterCallback(
+        Engine::EventType::MouseButtonUp,
+        [](Engine::EventData data) { SPDLOG_INFO("Mouse buttons released."); });
+    events.RegisterCallback(Engine::EventType::MouseMove,
+                            [](Engine::EventData data) {
+                                SPDLOG_INFO("Mouse moved to: ({:.0f}, {:.0f})",
+                                            data.mouse.x, data.mouse.y);
+                            });
+
+    SPDLOG_INFO("Importing texture.");
+    res.AddResource("tests/res/kenney-pixel-char1.png",
+                    Engine::ResourceType::Texture);
+
+    SPDLOG_INFO("Loading textures and creating renderable objects.");
+    std::shared_ptr<Engine::Texture> tex1 =
+        res.FindTexture("tests/res/kenney-pixel-char1.png");
+    std::unique_ptr<Engine::Renderable> obj1 = std::make_unique<Engine::Sprite>(
+        std::move(tex1), Engine::Vector2(100, 200));
+    obj1->SetName("Character");
+    std::unique_ptr<Engine::Renderable> obj2 =
+        std::make_unique<Engine::RectangleShape>(Engine::Rect(10, 200, 60, 80),
+                                                 Engine::Color::Green());
+    obj2->SetName("Green Rectangle");
+    std::unique_ptr<Engine::Renderable> obj3 =
+        std::make_unique<Engine::RectangleShape>(Engine::Rect(900, 200, 60, 80),
+                                                 Engine::Color::Red());
+    obj3->SetName("Red Rectangle");
+
+    SPDLOG_INFO("Adding renderable objects to render manager.");
+    rdrMgr.AddRenderable(std::move(obj1), Engine::Layers::WORLD);
+    rdrMgr.AddRenderable(std::move(obj2), Engine::Layers::ENTITIES);
+    rdrMgr.AddRenderable(std::move(obj3), Engine::Layers::FOREGROUND);
+
+    events.RegisterCallback(Engine::EventType::KeyDown,
+                            [](Engine::EventData data) {
+                                if (data.keyboard.keycode == SDLK_1) {
+                                    s_currentObj = 1;
+                                    SPDLOG_INFO("Character selected");
+                                } else if (data.keyboard.keycode == SDLK_2) {
+                                    s_currentObj = 2;
+                                    SPDLOG_INFO("Green Rectangle selected");
+                                } else if (data.keyboard.keycode == SDLK_3) {
+                                    s_currentObj = 3;
+                                    SPDLOG_INFO("Red Rectangle selected");
+                                }
+                            });
+
+    auto getAABB = [](const Engine::Renderable *renderable,
+                      const Engine::Vector2 &position) -> Engine::Rect {
+        Engine::Vector2 scale = renderable->GetScale();
+        Engine::Vector2 pivot = renderable->GetPivot();
+        float scaledWidth = 0.0f;
+        float scaledHeight = 0.0f;
+
+        if (renderable->GetType() == Engine::RenderableType::Sprite) {
+            const Engine::Sprite *sprite =
+                static_cast<const Engine::Sprite *>(renderable);
+            scaledWidth = sprite->GetSourceRect().w * scale.x;
+            scaledHeight = sprite->GetSourceRect().h * scale.y;
+        } else if (renderable->GetType() == Engine::RenderableType::Rectangle) {
+            const Engine::RectangleShape *rectShape =
+                static_cast<const Engine::RectangleShape *>(renderable);
+            scaledWidth = rectShape->GetWidth() * scale.x;
+            scaledHeight = rectShape->GetHeight() * scale.y;
+        } else {
+            // empty rect for other types for now
+            return Engine::Rect(position.x, position.y, 0, 0);
+        }
+
+        float aabbX = position.x - (pivot.x * scaledWidth);
+        float aabbY = position.y - (pivot.y * scaledHeight);
+
+        return Engine::Rect(aabbX, aabbY, scaledWidth, scaledHeight);
+    };
+
+    auto checkCollision = [](const Engine::Rect &r1,
+                             const Engine::Rect &r2) -> bool {
+        const float epsilon = 1e-4f; // due to floating point errors
+        return r1.x < r2.x + r2.w - epsilon && r1.x + r1.w > r2.x + epsilon &&
+               r1.y < r2.y + r2.h - epsilon && r1.y + r1.h > r2.y + epsilon;
+    };
+
+    events.RegisterCallback(
+        Engine::EventType::KeyDown,
+        [&rdrMgr, getAABB, checkCollision](Engine::EventData data) {
+            Engine::Renderable *obj = nullptr;
+            Engine::Renderable *rect1 = rdrMgr.GetRenderable("Green Rectangle");
+            Engine::Renderable *rect2 = rdrMgr.GetRenderable("Red Rectangle");
+            Engine::Renderable *character = rdrMgr.GetRenderable("Character");
+            switch (s_currentObj) {
+            case 1:
+                obj = character;
+                break;
+            case 2:
+                obj = rect1;
+                break;
+            case 3:
+                obj = rect2;
+                break;
+            }
+
+            Engine::Vector2 move_delta = {0.0f, 0.0f};
+            bool is_movement_key = false;
+
+            if (data.keyboard.keycode == SDLK_RIGHT) {
+                move_delta.x = 10.0f;
+                is_movement_key = true;
+            } else if (data.keyboard.keycode == SDLK_LEFT) {
+                move_delta.x = -10.0f;
+                is_movement_key = true;
+            } else if (data.keyboard.keycode == SDLK_DOWN) {
+                move_delta.y = 10.0f;
+                is_movement_key = true;
+            } else if (data.keyboard.keycode == SDLK_UP) {
+                move_delta.y = -10.0f;
+                is_movement_key = true;
+            }
+
+            if (is_movement_key) {
+                Engine::Vector2 next_pos = obj->GetPosition() + move_delta;
+                Engine::Rect obj_next_aabb = getAABB(obj, next_pos);
+                // SPDLOG_TRACE("Moving object AABB (potential next pos): x={},
+                // "
+                //             "y={}, w={}, h={}",
+                //             obj_next_aabb.x, obj_next_aabb.y,
+                //             obj_next_aabb.w, obj_next_aabb.h);
+                bool collision = false;
+                if (obj != character && character) {
+                    Engine::Rect char_current_aabb =
+                        getAABB(character, character->GetPosition());
+                    // SPDLOG_TRACE("Checking against Character AABB (current "
+                    //             "pos): x={}, y={}, w={}, h={}",
+                    //             char_current_aabb.x, char_current_aabb.y,
+                    //             char_current_aabb.w, char_current_aabb.h);
+                    if (checkCollision(obj_next_aabb, char_current_aabb)) {
+                        collision = true;
+                    }
+                }
+                if (!collision && obj != rect1 && rect1) {
+                    Engine::Rect rect1_current_aabb =
+                        getAABB(rect1, rect1->GetPosition());
+                    // SPDLOG_TRACE("Checking against Green Rectangle AABB "
+                    //             "(current pos): x={}, y={}, w={}, h={}",
+                    //             rect1_current_aabb.x, rect1_current_aabb.y,
+                    //             rect1_current_aabb.w, rect1_current_aabb.h);
+                    if (checkCollision(obj_next_aabb, rect1_current_aabb)) {
+                        collision = true;
+                    }
+                }
+                if (!collision && obj != rect2 && rect2) {
+                    Engine::Rect rect2_current_aabb =
+                        getAABB(rect2, rect2->GetPosition());
+                    // SPDLOG_TRACE("Checking against Red Rectangle AABB
+                    // (current "
+                    //             "pos): x={}, y={}, w={}, h={}",
+                    //             rect2_current_aabb.x, rect2_current_aabb.y,
+                    //             rect2_current_aabb.w, rect2_current_aabb.h);
+                    if (checkCollision(obj_next_aabb, rect2_current_aabb)) {
+                        collision = true;
+                    }
+                }
+                if (!collision) {
+                    obj->SetPosition(next_pos);
+                } else {
+                    SPDLOG_INFO("Collision prevented movement!");
+                }
+            }
+
+            if (data.keyboard.keycode == SDLK_P) {
+                obj->Scale(1.1f);
+            } else if (data.keyboard.keycode == SDLK_Q) {
+                obj->Scale(0.9f);
+            } else if (data.keyboard.keycode == SDLK_SPACE) {
+                int layer_id = s_currentObj * 100;
+                if (rdrMgr.HasLayer(layer_id)) {
+                    Engine::Layer &layer = rdrMgr.GetLayer(layer_id);
+                    float opacity = layer.GetOpacity();
+                    layer.SetOpacity(opacity + 0.1f);
+                }
+            } else if (data.keyboard.keycode == SDLK_LCTRL) {
+                int layer_id = s_currentObj * 100;
+                if (rdrMgr.HasLayer(layer_id)) {
+                    Engine::Layer &layer = rdrMgr.GetLayer(layer_id);
+                    float opacity = layer.GetOpacity();
+                    layer.SetOpacity(opacity + 0.1f);
+                }
+            }
+        });
+    SPDLOG_INFO("Controls:\n1-3: Change selected object\n"
+                "Arrow Keys: Move object\n"
+                "P: Increase Scale\n"
+                "Q: Decrease Scale\n"
+                "Space: Increase Opacity\n"
+                "Ctrl: Decrease Opacity");
+
+    SPDLOG_INFO("Application initialized successfully.");
+    *appState = gameEngine;
+    return SDL_APP_CONTINUE;
+}
+
+// The event handling function called by SDL.
+// TODO: Try and make a genericsed function that is called from here to allow
+//       custom event handling to be added by a user.
+SDL_AppResult SDL_AppEvent(void *appState, SDL_Event *event) {
+    Engine::Engine *gameEngine = static_cast<Engine::Engine *>(appState);
+    if (event->type == SDL_EVENT_QUIT || event->type == SDL_EVENT_TERMINATING) {
+        SPDLOG_INFO("Received SDL_EVENT_QUIT or SDL_EVENT_TERMINATING. Exiting "
+                    "application.");
+        return SDL_APP_SUCCESS;
+    } else {
+        SPDLOG_DEBUG("Processing SDL event of type: {}", event->type);
+        gameEngine->GetEvents().ProcessEvent(event);
+    }
+    return SDL_APP_CONTINUE;
+}
+
+// The "main loop" of the window.
+SDL_AppResult SDL_AppIterate(void *appState) {
+    Engine::Engine *gameEngine = static_cast<Engine::Engine *>(appState);
+    SPDLOG_TRACE("Starting main loop iteration.");
+
+    SPDLOG_DEBUG("Clearing renderer with color: Black.");
+    gameEngine->GetRenderer().Clear(Engine::Color::Black());
+
+    SPDLOG_DEBUG("Rendering all objects.");
+    gameEngine->GetRenderManager().RenderAll(gameEngine->GetRenderer());
+
+    SPDLOG_DEBUG("Presenting rendered frame.");
+    gameEngine->GetRenderer().Present();
+
+    SPDLOG_TRACE("Main loop iteration completed.");
+    return SDL_APP_CONTINUE;
+}
+
+// Cleans up the initialised subsystems.
+void SDL_AppQuit(void *appState, SDL_AppResult result) {
+    Engine::Engine *gameEngine = static_cast<Engine::Engine *>(appState);
+    if (gameEngine != nullptr) {
+        SPDLOG_INFO("Shutting down game engine.");
+        gameEngine->Shutdown();
+        SPDLOG_INFO("Game engine shutdown completed.");
+    } else {
+        SPDLOG_WARN("Game engine was null during shutdown.");
+    }
+}

From 5d45fddf095a79c19f4b674e2aa328c423ac3a9a Mon Sep 17 00:00:00 2001
From: Delta18-Git <64347927+Delta18-Git@users.noreply.github.com>
Date: Sat, 24 May 2025 02:09:59 +0530
Subject: [PATCH 7/7] fix: prevent UB in the texture allocation

---
 src/engine/core/resource.cpp | 9 +++++++--
 src/engine/core/texture.cpp  | 4 ++++
 2 files changed, 11 insertions(+), 2 deletions(-)

diff --git a/src/engine/core/resource.cpp b/src/engine/core/resource.cpp
index 0c191d4..96e740c 100644
--- a/src/engine/core/resource.cpp
+++ b/src/engine/core/resource.cpp
@@ -54,8 +54,13 @@ ResourceManager::FindTexture(const std::string_view path) {
 
 void ResourceManager::CreateTexture(const std::string_view path) {
     std::shared_ptr<Texture> texture = std::make_shared<Texture>();
-    texture->SetTexture(IMG_LoadTexture(m_renderer.GetSDLRenderer(),
-                                        std::string(path).c_str()));
+    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));
 }
 
diff --git a/src/engine/core/texture.cpp b/src/engine/core/texture.cpp
index 6a02a57..222e45f 100644
--- a/src/engine/core/texture.cpp
+++ b/src/engine/core/texture.cpp
@@ -9,6 +9,10 @@ Texture::~Texture() {
     }
 }
 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;