Starting a new rendering system

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

+#pragma once
+
+#include <engine/io/Window.hpp>
+#include <engine/graphics/utility/module.hpp>
+#include <engine/graphics/front/engine/TextureArray.hpp>
+
+namespace megu {
+    class Renderable {
+        public:
+            template <class T>
+            void accept(const Window & window, const Camera & camera, Module<T> & modul, const TextureArray & array) {
+                modul.render(window, camera, *static_cast<T *>(this), array);
+            }
+    };
+}
\ No newline at end of file

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

+#include "Sprite.hpp"
+
+namespace megu {
+    Sprite::Sprite(const Texture & texture)
+    : _frame(0, 0, texture.width(), texture.height()), _texture(texture) {
+        this->_transformation.scale(static_cast<float>(texture.width()), static_cast<float>(texture.height()));
+    }
+
+    Sprite::Sprite(const Texture & texture, const glm::vec4 & frame)
+    : _frame(frame), _texture(texture) {
+        this->_transformation.move(frame.x, frame.y);
+        this->_transformation.scale(frame.z, frame.w);
+    }
+}
\ No newline at end of file

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

+#pragma once
+
+#include <engine/graphics/back/geometry/Transformable.hpp>
+#include <engine/graphics/back/textures/Texture.hpp> 
+#include <engine/graphics/front/geometry/Quads.hpp>
+
+
+namespace megu {
+    class Sprite  {
+        public:
+            Sprite(const Texture &);
+            Sprite(const Texture &, const glm::vec4 &);
+
+            inline void setFrame(const glm::vec4 & frame) {this->_frame = frame;}
+
+            inline const glm::vec4      & frame()           const {return this->_frame;}
+            inline const Texture        & texture()         const {return this->_texture;}
+            inline const Quads          & geometry()        const {return this->_geometry;}
+            inline const Transformable  & transformation()  const {return this->_transformation;}
+
+        private:
+            glm::vec4 _frame;
+            Texture _texture;
+            Quads _geometry;
+            Transformable _transformation;
+    };
+}
\ No newline at end of file

source/engine/graphics/utility/isometric_sorter.cpp

 #include "isometric_sorter.hpp"
 
 #include <engine/graphics/front/object/Image.hpp>
+#include <engine/graphics/front/object/Sprite.hpp>
 
 namespace megu {
     bool isometric_sorter::operator()(const Image & img1, const Image & img2) const {
@@ -18,4 +19,20 @@ namespace megu {
 
         return &img1 > &img2;
     }
+
+    bool isometric_sorter_sprite::operator()(const Sprite & img1, const Sprite & img2) const {
+        if(img1.transformation().z() != img2.transformation().z()) {
+            return img1.transformation().z() > img2.transformation().z();
+        }
+
+        if(img1.transformation().y() != img2.transformation().y()) {
+            return img1.transformation().y() > img2.transformation().y();
+        }
+
+        if(img1.transformation().x() != img2.transformation().x()) {
+            return img1.transformation().x() > img2.transformation().x();
+        }
+
+        return &img1 > &img2;
+    }
 }
\ No newline at end of file

source/engine/graphics/utility/isometric_sorter.hpp

@@ -2,9 +2,15 @@
 
 namespace megu {
     class Image;
+    class Sprite;
 
     class isometric_sorter {
         public:
             bool operator()(const Image & img1, const Image & img2) const;
     };
+
+     class isometric_sorter_sprite {
+        public:
+            bool operator()(const Sprite & img1, const Sprite & img2) const;
+    };
 }
\ No newline at end of file

source/engine/graphics/front/group/DrawGroup.hpp → source/engine/graphics/utility/module.hpp

@@ -5,8 +5,12 @@
 #include <engine/io/Window.hpp>
 
 namespace megu {
-    class DrawGroup {
+    template <class T>
+    class Module {
         public:
-            virtual void draw(const Window &, const Camera &, const TextureArray &) const = 0;
+            virtual void render(const Window &, const Camera &, T &, const TextureArray &) = 0;
     };
+
+    template <class ... Ts>
+    class Multi_Module : public Module<Ts> ... {};
 }
\ No newline at end of file

source/engine/graphics/utility/ref_set.hpp

+#pragma once
+
+#include <set>
+#include "reference_sorter.hpp"
+
+namespace megu {
+    template <class T>
+    using ref_set = std::set<std::reference_wrapper<T>, reference_sorter<T>>;
+}
\ No newline at end of file

source/main.cpp

 #include <iostream>
+#include <thread>
 
 #include <GL/glew.h>
 #include <GLFW/glfw3.h>
@@ -13,10 +14,8 @@
 #include <engine/io/Window.hpp>
 #include <engine/graphics/back/cameras/View.hpp>
 #include <engine/graphics/front/object/Image.hpp>
-#include <engine/graphics/front/group/ImageGroup.hpp>
 #include <engine/graphics/front/engine/Renderer.hpp>
 #include <engine/graphics/front/engine/Engine.hpp>
-#include <engine/graphics/front/group/VertexArrayGroup.hpp>
 #include <engine/graphics/errors.hpp>
 
 const float i_x =  1.f;
@@ -31,12 +30,14 @@ glm::vec2 to_screen_coordinate(const glm::vec2 & tile, float w, float h, float l
     };
 }
 
+/*
 megu::Vertex to_screen_coordinate(int x, int y, unsigned int u, unsigned int v, const megu::Texture & texture) {
     return {{x, y}, {static_cast<float>(u) / static_cast<float>(texture.width()), static_cast<float>(v) / static_cast<float>(texture.height())}};
 }
+*/
 
 //* Isometric : 
-/*
+
 int main(int argc, const char * argv[]) {
     try {
         //? Window
@@ -46,10 +47,6 @@ int main(int argc, const char * argv[]) {
 
         std::cout << "Window Inited" << std::endl;
        
-        //? Group
-        megu::ImageGroup group;
-        megu::ImageGroup group_2;
-       
         std::cout << "Group Inited" << std::endl;
 
         //? Image 1
@@ -117,10 +114,10 @@ int main(int argc, const char * argv[]) {
             ++x;
         }
 
-        for(auto & i : images) {
+        /*for(auto & i : images) {
             group.add(*i);
             i.get()->setSize({32.f, 32.f});
-        }
+        }*/
 
         std::cout << "Images 1 Inited" << std::endl;
 
@@ -159,26 +156,20 @@ int main(int argc, const char * argv[]) {
             ++x_2;
         }
 
-        for(auto & i : images_2) {
+        /*for(auto & i : images_2) {
             group_2.add(*i);
             i.get()->setSize({32.f, 32.f});
-        }
+        }*/
 
         std::cout << "Images 2 Inited" << std::endl;
 
-        //? ImGui
-        //ImGui::CreateContext();
-        //ImGui_ImplOpenGL3_Init();
-        //ImGui_ImplGlfw_InitForOpenGL(window.ptr(), true);
 
         //? Engines
         megu::GraphicEngine engine(window);
         megu::Renderer basic_renderer(360, 360);
 
         engine.push(0, basic_renderer);
-
-        engine.push(0, 0, group);
-        //engine.push(0, 0, group_2);
+        engine.push(0, 0, *images.front());
 
         //? Render Loop
         std::cout << "Render Loop Begin !" << std::endl;
@@ -209,8 +200,10 @@ int main(int argc, const char * argv[]) {
 
     return EXIT_SUCCESS;
 }
-*/
 
+
+//* Tilemap
+/*
 int main(int argc, const char * argv[]) {
     try {
         //? Window
@@ -232,10 +225,10 @@ int main(int argc, const char * argv[]) {
 
         megu::VerticesArray grid_1(megu::Quads::Primitive(), 4);
 
-        /*grid_1[0] = {{0.f,  0.f},  {0.0f,  0.0f}};
-        grid_1[1] = {{16.f, 0.f},  {0.5f,  0.0f}};
-        grid_1[2] = {{16.f, 16.f}, {0.5f,  0.5f}};
-        grid_1[3] = {{0.f,  16.f}, {0.0f,  0.5f}};*/
+        //grid_1[0] = {{0.f,  0.f},  {0.0f,  0.0f}};
+        //grid_1[1] = {{16.f, 0.f},  {0.5f,  0.0f}};
+        //grid_1[2] = {{16.f, 16.f}, {0.5f,  0.5f}};
+        //grid_1[3] = {{0.f,  16.f}, {0.0f,  0.5f}};
 
      
 
@@ -291,6 +284,96 @@ int main(int argc, const char * argv[]) {
         std::cerr << error.what() << std::endl;
     }
 
+    return EXIT_SUCCESS;
+}*/
+
+
+//* Sprite
+/*
+int main(int argc, const char * argv[]) {
+    try {
+        //? Window
+        megu::Window window;
+        window.open("Sprite Window", 360, 360);
+        megu::error::opengl_error::check();
+
+        std::cout << "Window Inited" << std::endl;
+
+        //? Group
+        megu::SpriteGroup group;
+        megu::ImageGroup group_2;
+       
+        std::cout << "Group Inited" << std::endl;
+
+        //? Grids
+
+        megu::Texture texture_1;
+        texture_1.store(megu::TextureBuffer("assets/textures/Neera.png"));
+
+        std::vector<glm::vec4> frames;
+        frames.push_back({0,   0, 51, 98});
+        frames.push_back({51,  0, 51, 98});
+        frames.push_back({102, 0, 51, 98});
+
+        frames.push_back({0,   98, 51, 98});
+        frames.push_back({51,  98, 51, 98});
+        frames.push_back({102, 98, 51, 98});
+
+        megu::Sprite neera(texture_1, frames[0]);
+        megu::Image image(texture_1);
+        //neera.scale(1.f, 1.f);
+
+        
+        group.add(neera);
+        group_2.add(image);
+
+        std::cout << "Sprite created" << std::endl;
+
+        //? Engines
+        megu::GraphicEngine engine(window);
+        megu::Renderer basic_renderer(128, 128);
+
+        engine.push(0, basic_renderer);
+        engine.push(0, 0, group);
+
+        //? Render Loop
+        std::cout << "Render Loop Begin !" << std::endl;
+
+        double previousTime = megu::Window::Time();
+        int frameCount = 0;
+
+        std::thread t([&frames, &window, &neera](){
+            size_t i = 0;
+            while(window.isOpen()) {
+                std::this_thread::sleep_for(std::chrono::milliseconds(30));
+                neera.setFrame(frames[i%frames.size()]);
+                ++i;
+            }
+        });
+
+        while(window.isOpen()) {
+            double currentTime = megu::Window::Time();
+            frameCount++;
+
+            if(currentTime - previousTime >= 1.0) {
+                window.setTitle(std::to_string(frameCount));
+
+                frameCount = 0;
+                previousTime = currentTime;
+            }
+
+            window.pollEvents();
+            engine.step();
+        }
+
+        t.join();
+        std::cout << "Render Loop End !" << std::endl;
+    }
+    catch(std::exception & error) {
+        std::cerr << error.what() << std::endl;
+    }
+
     return EXIT_SUCCESS;
 }
+*/