Threading for renderer, textures, entities, game state

src/renderer/renderer.cpp

@@ -5,31 +5,52 @@ namespace Game::Renderer {
     Renderer::Renderer() : mRenderer(nullptr) {}
 
     Renderer::~Renderer() {
+        destroy();
+    }
+
+    void Renderer::destroy() {
         if (mRenderer) {
             SDL_DestroyRenderer(mRenderer);
+            mRenderer = nullptr;
+            LOG("Destroyed Renderer");
         }
     }
 
     bool Renderer::init(SDL_Window* window) {
-        mRenderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
+        mRenderer = SDL_CreateRenderer(window, nullptr);
         if (!mRenderer) {
             std::string errorMsg = "Failed to create renderer: " + std::string(SDL_GetError());
             ERROR(errorMsg.c_str());
             return false;
         }
         
-        SDL_SetRenderDrawColor(mRenderer, 0, 0, 255, 255); // Temp
+        if (!SDL_SetRenderDrawColor(mRenderer, 0, 0, 255, 255)) {
+            ERROR("Failed to set renderer draw color: " << SDL_GetError());
+            return false;
+        }
         
         LOG("Renderer created successfully");
         
         return true;
     }
 
-    void Renderer::clear() {
-        SDL_RenderClear(mRenderer);
+    void Renderer::run(std::stop_token stoken) {
+        while (!stoken.stop_requested()) {
+            mClear();
+            // Get gamestate mutex and render the objects here; GameState::getState().objects or something, idk
+            mPresent();
+        }
     }
 
-    void Renderer::present() {
-        SDL_RenderPresent(mRenderer);
+    void Renderer::mClear() {
+        if (!SDL_RenderClear(mRenderer)) {
+            ERROR("Failed to clear renderer: " << SDL_GetError());
+        }
+    }
+
+    void Renderer::mPresent() {
+        if (!SDL_RenderPresent(mRenderer)) {
+            ERROR("Failed to present renderer: " << SDL_GetError());
+        }
     }
 }

src/renderer/texture.cpp

@@ -0,0 +1,33 @@
+#include <renderer/texture.hpp>
+
+namespace Game::Renderer {
+    Texture::Texture(std::string& path, Renderer* renderer, std::string id)
+        : mTex(nullptr), mId(id) {
+        SDL_Surface* surf = IMG_Load(path.c_str());
+        if (!surf) {
+            ERROR("Failed to load image at " << path);
+            return;
+        }
+
+        mTex = SDL_CreateTextureFromSurface(renderer->getSDLRenderer(), surf);
+        SDL_DestroySurface(surf);
+
+    }
+
+    Texture::Texture(const Texture& other) {
+        // Copy the references, since copying memory would require re-initing a bunch of things - for now
+        this->mTex = other.mTex;
+    }
+
+    Texture& Texture::operator=(const Texture& other) {
+        // Same reasoning
+        this->mTex = other.mTex;
+        return *this;
+    }
+
+    Texture::~Texture() {
+        if (mTex)
+            SDL_DestroyTexture(mTex);
+        LOG("Destroyed texture '" << mId << "'")
+    }
+}

src/state/gamestate.cpp

@@ -0,0 +1,25 @@
+#include <state/gamestate.hpp>
+#include <iostream>
+
+namespace Game::State {
+    // TODO: Caller should also hold these locks
+    const std::vector<Object::Entity>& GameState::getEntities() {
+        std::shared_lock lock(mMutex);
+        return mEntities;
+    }
+    
+    std::vector<Object::Entity>* GameState::getEntitiesRef() {
+        std::shared_lock lock(mMutex);
+        return &mEntities;
+    }
+    
+    Object::Entity* GameState::getAtIndex(size_t at) {
+        std::shared_lock lock(mMutex);
+        try {
+            return &mEntities.at(at);
+        } catch (const std::out_of_range& e) {
+            WARN("Tried to access entity from GameState out of range!");
+            return nullptr;
+        }
+    }
+}

src/window/window.cpp

@@ -1,21 +1,33 @@
 #include <window/window.hpp>
 
 namespace Game::Window {
-    Window::Window() : mWindow(nullptr), mRunning(false), mRenderer() {}
+    Window::Window() : mWindow(nullptr), mRunning(false) {
+    }
 
     Window::~Window() {
+        // Stop render thread
+        if (mRenderThread.joinable()) {
+            mRenderThread.request_stop();
+            mRenderThread.join();
+        }
+
+        mRenderer.destroy();
+
         if (mWindow) {
             SDL_DestroyWindow(mWindow);
             mWindow = nullptr;
-            mRunning = false;
             LOG("Window destroyed successfully");
-            SDL_Quit();
         }
+        SDL_Quit();
     }
 
     bool Window::init(int width, int height, const std::string& title) {
-        if (SDL_Init(SDL_INIT_VIDEO) < 0) { return false; }
-        mWindow = SDL_CreateWindow(title.c_str(), SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, width, height, SDL_WINDOW_SHOWN);
+        if (!SDL_Init(SDL_INIT_VIDEO)) {
+            ERROR("Failed to initialize SDL: " << SDL_GetError());
+            return false;
+        }
+
+        mWindow = SDL_CreateWindow(title.c_str(), width, height, SDL_WINDOW_RESIZABLE);
         if (!mWindow) {
             ERROR("Failed to create window: " << SDL_GetError());
             SDL_Quit();
@@ -24,12 +36,14 @@ namespace Game::Window {
 
         LOG("Window created successfully");
 
+        // Spawn new thread for renderer        
         if (!mRenderer.init(mWindow)) {
             SDL_DestroyWindow(mWindow);
             mWindow = nullptr;
             SDL_Quit();
             return false;
         }
+        mRenderThread = std::jthread(std::bind_front(&Renderer::Renderer::run, &mRenderer));
 
         mRunning = true;
 
@@ -40,16 +54,12 @@ namespace Game::Window {
         SDL_Event event;
         while (mRunning) {
             while (SDL_PollEvent(&event)) {
-                if (event.type == SDL_QUIT) {
+                if (event.type == SDL_EVENT_QUIT) {
                     mRunning = false;
                 }
 
                 // Handle other events (e.g., keyboard, mouse) here
             }
-
-            mRenderer.clear();
-            // Render game objects here
-            mRenderer.present();
         }
     }
 }