renderiranje - nazaj na singlethreaded ker me SDL ne mara :(

include/game/player.hpp

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <object/entity.hpp>
+
+namespace Game::AGame {
+    class Player : public Object::Entity {
+        using Object::Entity::Entity;
+
+        public:
+            void start() override;
+            void update() override;
+    };
+}

include/object/entity.hpp

@@ -2,24 +2,47 @@
 
 #include <string>
 #include <utils.hpp>
+#include <object/transform.hpp>
+#include <SDL3/SDL.h>
+#include <SDL3_image/SDL_image.h>
+#include <utility>
+#include <memory>
 
 namespace Game::Renderer {
+    class Renderer;
     class Texture;
 }
 
 namespace Game::Object {
     class Entity {
         public:
-            Entity(std::string& name, Game::Renderer::Texture* tex) : mName(name), mTex(tex) {}
+            Entity(std::string name, std::shared_ptr<Game::Renderer::Texture> tex, Transform transform) : mName(name), mTex(tex), mTransform(transform), mIsActive(true) { LOG("Created Entity: " << mName); }
             // I will define the copy and move constructors later - just deleted for now
-            DISABLE_COPY_AND_MOVE(Entity);
+            Entity(const Entity&);
+            Entity& operator=(const Entity&);
+            Entity(Entity&&) noexcept;
+            Entity& operator=(Entity&&) noexcept;
             ~Entity();
 
-            void start();
-            void update();
+            virtual void start() = 0;
+            virtual void update() = 0;
+            void render(Game::Renderer::Renderer* renderer);
+
+            // Setters and getters
+            void setTexture(std::shared_ptr<Game::Renderer::Texture> tex) { mTex = tex; }
+            void setName(const std::string& name) { mName = name; }
+            void setTransform(const Transform& transform) { mTransform = transform; }
+            void setActive(bool active) { mIsActive = active; }
+            std::shared_ptr<Game::Renderer::Texture> getTexture() { return mTex; }
+            std::string getName() { return mName; }
+            Transform* getTransform() { return &mTransform; }
+            bool isActive() { return mIsActive; }
         protected:
             std::string mName;
-            Game::Renderer::Texture* mTex;
+            std::shared_ptr<Game::Renderer::Texture> mTex;
+            Transform mTransform;
+            bool mIsActive;
         private:
+            float mScaleConstant = 0.25f;
     };
 }

include/object/transform.hpp

@@ -0,0 +1,11 @@
+#pragma once
+
+namespace Game::Object {
+    typedef struct {
+        float x, y;
+        float rotation; // In degrees, clockwise
+        float scaleX, scaleY;
+    } Transform;
+
+    constexpr Transform DEFAULT_TRANSFORM{0.f, 0.f, 0.f, 1.f, 1.f};
+}

include/renderer/renderer.hpp

@@ -13,7 +13,7 @@ namespace Game::Renderer {
             ~Renderer();
 
             bool init(SDL_Window* window);
-            void run(std::stop_token stoken);
+            void renderFrame();
             void destroy();
 
             SDL_Renderer* getSDLRenderer() { return mRenderer; }

include/renderer/texture.hpp

@@ -4,16 +4,18 @@
 #include <SDL3_image/SDL_image.h>
 #include <string>
 #include <utils.hpp>
-#include <renderer/renderer.hpp>
 
 namespace Game::Renderer {
     class Texture {
         public:
-            Texture(std::string& path, Renderer* renderer, std::string id = "noname");
+            Texture(const std::string& path, SDL_Renderer* renderer, std::string id = "noname");
             Texture(const Texture&);
             Texture& operator=(const Texture&);
             DISABLE_MOVE(Texture);
             ~Texture();
+
+            SDL_Texture* getSDLTexture();
+            std::string getId();
         private:
             SDL_Texture* mTex;
             std::string mId;

include/state/gamestate.hpp

@@ -1,7 +1,7 @@
 #pragma once
 
-#include <shared_mutex>
 #include <vector>
+#include <memory>
 #include <utils.hpp>
 #include <object/entity.hpp>
 
@@ -10,15 +10,14 @@ namespace Game::State {
         public:
             static GameState& getInstance() { static GameState instance; return instance; }
 
-            // Retrieve a COPY of the entities - Only used by renderer, use getAtIndex() for generic access
-            const std::vector<Object::Entity>& getEntities();
             // Retrieve a REFERENCE of the entities; DANGEROUS!
-            std::vector<Object::Entity>* getEntitiesRef();
+            std::vector<std::unique_ptr<Object::Entity>>* getEntitiesRef();
             // Update entity at index, by REFERENCE
             Object::Entity* getAtIndex(size_t at);
 
+            void addEntity(std::unique_ptr<Object::Entity> entity);
+
         private:
-            mutable std::shared_mutex mMutex;
-            std::vector<Object::Entity> mEntities;
+            std::vector<std::unique_ptr<Object::Entity>> mEntities;
     };
 }

include/utils.hpp

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <iostream>
+
 #define DISABLE_COPY(Class) \
     Class(const Class&) = delete; \
     Class& operator=(const Class&) = delete;
@@ -23,9 +25,7 @@
 
 #define GAME_ENTITY(ClassName) \
     class ClassName : public Object::Entity { \
-        using Object::Entity::Entity; // Inherit constructors \
-
-
+        using Object::Entity::Entity;
 
 #define END_GAME_ENTITY() \
-    };
+    };

include/window/window.hpp

@@ -6,9 +6,7 @@
 
 #include <utils.hpp>
 #include <renderer/renderer.hpp>
-#include <thread>
-#include <functional>
-#include <chrono>
+#include <state/gamestate.hpp>
 
 namespace Game::Window {
     class Window {
@@ -20,10 +18,11 @@ namespace Game::Window {
             bool init(int width, int height, const std::string& title);
             void run();
 
+            Renderer::Renderer* getRenderer() { return &mRenderer; }
+
         private:
             SDL_Window* mWindow;
             Renderer::Renderer mRenderer;
-            std::jthread mRenderThread;
             bool mRunning;
     };
 }