Add kernel level tilemap

source/engine/graphics/front/module/TileArray_Module.cpp

@@ -34,10 +34,10 @@ namespace megu {
 
         size_t count = 0;
 
-        for(size_t y = 0; y < vertexArray.height(); ++y) {
         for(size_t x = 0; x < vertexArray.width(); ++x) {
+            for(size_t y = 0; y < vertexArray.height(); ++y) {
                 uOffsets.push_back(glm::translate(glm::mat4(1.f), {x, y, 0.f}));
-                uUvs.push_back(vertexArray.uvs()[y][x]);
+                uUvs.push_back(vertexArray.uvs()[x][y]);
 
                 if(count > 128) {
                     this->_program.setUniform("uOffsets", uOffsets);

source/engine/graphics/front/object/Renderable.hpp

@@ -57,7 +57,7 @@ namespace megu {
                     return typeid(T);
                 }
 
-                T _objects;
+                T & _objects;
                 Module<T> * _module;
             };
         

source/engine/graphics/front/object/Sprite.cpp

 #include "Sprite.hpp"
 
 namespace megu {
-    Sprite::Sprite(const std::filesystem::path & path)
+    Sprite::Sprite(const std::filesystem::path & path, bool flip)
     : _frame(0, 0, 0, 0) {
-        this->load(path, true);
+        this->load(path, flip);
+    }
+
+    Sprite::Sprite(const std::filesystem::path & path, const Frame & frame, bool flip)
+    : _frame(frame) {
+        this->load(path, flip);
     }
 
     void Sprite::load(const std::filesystem::path & path, bool flip) {

source/engine/graphics/front/object/Sprite.hpp

@@ -13,7 +13,8 @@ namespace megu {
         public:
             using Frame =  glm::vec4;
 
-            Sprite(const std::filesystem::path &);
+            Sprite(const std::filesystem::path &, bool = true);
+            Sprite(const std::filesystem::path &, const Frame &, bool = true);
 
             inline void setFrame(const Frame & frame) {this->_frame = frame;}
 
@@ -21,7 +22,15 @@ namespace megu {
             inline void setOrigine(const Vec2 & pos)    {this->_transformation.setOrigine(pos.x, pos.y);}
             inline void setSize(const Vec2 & size)      {this->_transformation.setScaling(size.x, size.y);}
             inline void setRotation(float a)            {this->_transformation.setRotation(a, Transformable::Axis::Z);}
-            inline void setLayer(float l)               {this->_transformation.setZ(l);}
+
+            inline const Vec3 & position()  const        {return this->_transformation.position();}
+            inline const Vec3 & origine()   const        {return this->_transformation.origine();}
+            inline const Vec3 & rotation()  const        {return this->_transformation.rotation();}
+            inline const Vec2 & size()      const        {return Vec2(this->_transformation.scaling().x, this->_transformation.scaling().y);}
+            
+            inline float x() const {return this->_transformation.x();}
+            inline float y() const {return this->_transformation.y();}
+            inline float z() const {return this->_transformation.z();}
 
             inline void move(const Vec2 & pos)          {this->_transformation.move({pos.x, pos.y, 0.f});}
             inline void scale(const Vec2 & size)        {this->_transformation.scale({size.x, size.y, 0.f});}

source/engine/graphics/front/object/TileArray.cpp

@@ -11,17 +11,12 @@ namespace megu {
         float twidth = static_cast<float>(this->_texture.width());
         float theight = static_cast<float>(this->_texture.height());
 
-        std::cout << twidth << "/" << theight << std::endl;
-
-        for(size_t y = 0; y < height; ++y) {
-            std::vector<glm::vec4> rows;
         for(size_t x = 0; x < width; ++x) {
+            std::vector<glm::vec4> rows;
+            for(size_t y = 0; y < height; ++y) {
                 rows.push_back({0.f, 0.f, twidth, theight});
             }
             this->_uvs.push_back(rows);
         }
-
-        std::cout << this->_uvs.size() << std::endl;
-        this->_transformation.scale({size, size, 1.f});
     }
 }
\ No newline at end of file

source/engine/graphics/front/object/TileArray.hpp

@@ -29,10 +29,13 @@ namespace megu {
             inline size_t height() const {return this->_height;}
             inline float size() const {return this->_size;}
 
+            inline void setUv(size_t x, size_t y, const glm::vec4 & uv) {this->_uvs[y][x] = uv;}
+
             inline const Transformable & transformation()  const {return this->_transformation;}
             inline const Texture & texture() const {return this->_texture;}
 
             inline const std::vector<std::vector<glm::vec4>> & uvs() const {return this->_uvs;}
+            std::vector<glm::vec4> & operator[](size_t index) {return this->_uvs[index];} 
 
         private:
             Transformable _transformation;

source/engine/utility/type.hpp

@@ -5,7 +5,7 @@
 
 namespace megu {
     using Vec2  = glm::vec2;
-    using Vec3  = glm::vec4;
+    using Vec3  = glm::vec3;
     using Vec4  = glm::vec4;
     using Color = glm::vec4;
 

source/game/Game.cpp

@@ -26,9 +26,9 @@ namespace megu::game {
             megu::game::Object object(path);
             kernel.add(&object);
             
-            megu::game::Object object2(path);
+            /*megu::game::Object object2(path);
             object2.tmp_setPos(20, 0);
-            kernel.add(&object2);
+            kernel.add(&object2);*/
             /* ------ */
 
             while(window.isOpen()) {

source/game/object/Test.cpp

@@ -2,5 +2,13 @@
 
 namespace megu::game {
     Object::Object(std::filesystem::path & path)
-    : _physic(0, 0, 64, 64), _graphic(path) {}
+    : _physic(0, 0, 64, 64), _graphic(path), _map("assets/tilemap.png", 2, 2, 16.f, 16) {
+        this->_graphic.setFrame({0.f, 0.f, 51.f, 98.f});
+        this->_graphic.setSize({51.f, 98.f});
+
+        this->_map.setValue(0, 0, 1);
+        this->_map.setValue(1, 0, 1);
+        this->_map.setValue(0, 1, 2);
+        this->_map.setValue(1, 1, 1);
+    }
 }
\ No newline at end of file

source/game/object/Test.hpp

@@ -3,21 +3,19 @@
 #include <kernel/back/props/Props.hpp>
 #include <kernel/front/component/physic/Fixed.hpp>
 #include <kernel/front/component/graphic/Sprite.hpp>
+#include <kernel/front/component/graphic/TileMap.hpp>
 
 namespace megu::game {
     class Object : public kernel::Props {
         public:
             Object(std::filesystem::path &);
 
-            inline kernel::Physical<kernel::PhysicEngine> & getPhysicComponent() override {return this->_physic;}
-            inline kernel::Graphical<kernel::GraphicEngine> & getGraphicComponent() override {return this->_graphic;}
-
-            inline void tmp_setPos(float x, float y) {
-                this->_graphic.tmp_setPos(x, y);
-            }
+            inline kernel::Physical<kernel::PhysicEngine> * getPhysicComponent() override {return &this->_physic;}
+            inline kernel::Graphical<kernel::GraphicEngine> * getGraphicComponent() override {return &this->_map;}
 
         private:
             kernel::Fixed _physic;
             kernel::Sprite _graphic;
+            kernel::Tilemap _map;
     };
 }
\ No newline at end of file

source/kernel/back/engine/GraphicEngine.cpp

@@ -4,10 +4,12 @@
 
 namespace megu::kernel {
     GraphicEngine::GraphicEngine(Window & window) 
-    : _engine(window), _renderer(360, 360) {}
+    : _engine(window), _renderer(360, 360), _tmp_ta("assets/textures/Tile_Test_3.png", 1, 1, 32.f) {}
 
     void GraphicEngine::boot(Kernel &) {
         this->_engine.push(0, this->_renderer);
+
+        //this->_engine.push(0, 0, this->_tmp_ta, &this->_tmp_mod);
     }
 
     void GraphicEngine::stop(Kernel &) {

source/kernel/back/engine/GraphicEngine.hpp

@@ -7,6 +7,9 @@
 #include <engine/graphics/front/engine/Engine.hpp>
 #include <engine/graphics/front/engine/Renderer.hpp>
 
+#include <engine/graphics/front/module/TileArray_Module.hpp>
+#include <engine/graphics/front/object/TileArray.hpp>
+
 #include <kernel/back/props/Graphical.hpp>
 
 namespace megu::kernel {
@@ -28,5 +31,8 @@ namespace megu::kernel {
         private:
             megu::GraphicEngine _engine;
             megu::Renderer _renderer;
+
+            megu::TileArray _tmp_ta;
+            megu::TileArray_Module _tmp_mod;
     };
 }
\ No newline at end of file

source/kernel/back/linker/GraphicLinker.hpp

 #pragma once
 
 #include "Linker.hpp"
+#include "PriorityPair.hpp"
 #include <kernel/back/engine/GraphicEngine.hpp>
 
 namespace megu::kernel {
-    struct Priority_Pair {
-        Priority layer;
-        Priority object;
-
-        bool operator<(const Priority_Pair & pp) const {
-            if(this->layer == pp.layer) {
-                return this->object < pp.object;
-            }
-            return this->layer < pp.layer;
-        }
-    };
-
     template <class T>
     class GraphicLinker : public Linker<GraphicEngine> {
         public:

source/kernel/back/linker/PriorityPair.hpp

+#pragma once
+
+#include <engine/utility/Priority.hpp>
+
+namespace megu::kernel {
+    struct Priority_Pair {
+        Priority layer;
+        Priority object;
+
+        bool operator<(const Priority_Pair & pp) const {
+            if(this->layer == pp.layer) {
+                return this->object < pp.object;
+            }
+            return this->layer < pp.layer;
+        }
+    };
+}
\ No newline at end of file

source/kernel/back/linker/UniqueLinker.hpp

+#pragma once
+
+#include "Linker.hpp"
+#include "PriorityPair.hpp"
+#include <kernel/back/engine/GraphicEngine.hpp>
+
+namespace megu::kernel {
+    template <class T>
+    class UniqueGraphicLinker : public Linker<GraphicEngine> {
+        public:
+            UniqueGraphicLinker();
+
+            void link(T &, Priority, Priority);
+            void link(GraphicEngine &) override;
+            void setModule(Module<T> *);
+
+            inline bool haveModule() const {return this->_module.get() != nullptr;}
+            inline ref_set<T> & objects() {return this->_object;}
+
+        private:
+            std::unique_ptr<Module<T>> _module;
+            std::map<Priority_Pair, ref_set<T>> _objects;
+            std::set<Priority_Pair> _waiting;
+    };
+}
+
+#include "UniqueLinker.tpp"
\ No newline at end of file

source/kernel/back/linker/UniqueLinker.tpp

+#include "UniqueLinker.hpp"
+
+namespace megu::kernel {
+    template <class T>
+    UniqueGraphicLinker<T>::UniqueGraphicLinker() 
+    : _module(nullptr) {}
+
+    template <class T>
+    void UniqueGraphicLinker<T>::link(T & object, Priority l, Priority o) {
+        auto layers = Priority_Pair{l, o};
+
+        this->_objects[layers].insert(object);
+        this->_waiting.insert(layers);
+    }
+
+    template <class T>
+    void UniqueGraphicLinker<T>::link(GraphicEngine & engine) {
+        for(const auto & layers : this->_waiting) {
+            for(auto & object : this->_objects[layers]) {
+                engine.get().push<T>(layers.layer, layers.object, object, this->_module.get());
+            }
+        }
+
+        this->_waiting.clear();
+    }
+
+    template <class T>
+    void UniqueGraphicLinker<T>::setModule(Module<T> * mod) {
+        this->_module = std::unique_ptr<Module<T>>(mod);
+    }
+}
\ No newline at end of file

source/kernel/back/props/Props.hpp

@@ -10,8 +10,8 @@
 namespace megu::kernel {
     class Props : public Identifiable {
         public:
-            virtual Physical<PhysicEngine> & getPhysicComponent() = 0;
-            virtual Graphical<GraphicEngine> & getGraphicComponent() = 0;
+            virtual Physical<PhysicEngine> * getPhysicComponent() = 0;
+            virtual Graphical<GraphicEngine> * getGraphicComponent() = 0;
             
     };
 }
\ No newline at end of file

source/kernel/front/Kernel.cpp

@@ -26,8 +26,14 @@ namespace megu::kernel {
 
     void Kernel::add(Props * props) {
         this->_props[props->id()] = props;
+        auto * pComponent = props->getPhysicComponent();
+        if(pComponent != nullptr) {
+            this->_pEngine.add(*this, *pComponent);
+        }
         
-        this->_pEngine.add(*this, props->getPhysicComponent());
-        this->_gEngine.add(*this, props->getGraphicComponent());
+        auto * gComponent = props->getGraphicComponent();
+        if(gComponent != nullptr) {
+            this->_gEngine.add(*this, *gComponent);
+        }
     }
 }
\ No newline at end of file