source/engine/graphics/back/geometry/Geometry.hpp

@@ -60,6 +60,7 @@ namespace megu {
 
             static Layout_t Layout() {return Counter<megu::layout::Value>::Count<L...>();}
             static const Vertices_t & Vertices()  {return T::Vertices();}
+            static const size_t & Count() {return T::Count();}
     };
 
     template <class T, Primitive_t P, layout::Value ... L>

source/engine/graphics/back/shaders/Program.cpp

@@ -181,4 +181,15 @@ namespace megu {
     void Program::setUniform(const std::string & name, const std::set<std::reference_wrapper<const glm::mat4>> & value) const {
         glUniformMatrix4fv(this->_locations.at(name), static_cast<GLsizei>(value.size()), GL_FALSE, glm::value_ptr(value.begin()->get()));
     }
+
+    void Program::setUniform(const std::string & name, const void * data, size_t size, GLenum type) const {
+        switch (type) {
+            case GL_FLOAT:
+                glUniform4fv(this->_locations.at(name), static_cast<GLsizei>(size), static_cast<const float*>(data));
+                break;
+            
+            default:
+                break;
+        }
+    }
 }
\ No newline at end of file

source/engine/graphics/back/shaders/Program.hpp

@@ -71,5 +71,7 @@ namespace megu {
 
             void setUniform(const std::string &, const std::vector<std::reference_wrapper<const glm::mat4>> &) const;
             void setUniform(const std::string &, const std::set<std::reference_wrapper<const glm::mat4>> &) const;
+
+            void setUniform(const std::string &, const void *, size_t, GLenum = GL_FLOAT) const;
     };
 }
\ No newline at end of file

source/engine/graphics/front/engine/Engine.cpp

@@ -4,24 +4,22 @@
 
 namespace megu {
     GraphicEngine::GraphicEngine(Window & window, float w, float h) 
-    : _window(window), _renderer(w, h) {
+    : _window(window), _view(0, 0, w, h) {
         glViewport(0, 0, window.width(), window.height());
-        this->_renderer.setClearColor(NORMALIZE(135.f), NORMALIZE(170.f), NORMALIZE(255.f));
     } 
 
     GraphicEngine::GraphicEngine(Window & window) 
-    : _window(window), _renderer(window.width(), window.height()) {
+    : _window(window), _view(0, 0, window.width(), window.height()) {
         glViewport(0, 0, window.width(), window.height());
-        this->_renderer.setClearColor(NORMALIZE(135.f), NORMALIZE(170.f), NORMALIZE(255.f));
     }
 
-    void GraphicEngine::push(Priority priority, const Renderer & renderer) {
+    void GraphicEngine::push(Priority priority, Renderer & renderer) {
         this->_layers[priority] = std::make_unique<Layer>(renderer);
     }
 
-    void GraphicEngine::push(Priority layer_priority, Priority draw_priority, const DrawGroup & group) {
-        this->_layers[layer_priority]->push(draw_priority, group);
-    }
+    //void GraphicEngine::push(Priority layer_priority, Priority object_priority, GraphicObject & object) {
+    //    this->_layers[layer_priority].get()->push(object_priority, object);
+    //}
 
     void GraphicEngine::remove(Priority priority) {
         auto it = this->_layers.find(priority);
@@ -30,13 +28,6 @@ namespace megu {
         }
     }
 
-    void GraphicEngine::remove(Priority layer_priority, Priority draw_priority) {
-        auto it = this->_layers.find(layer_priority);
-        if(it != this->_layers.end()) {
-            it->second->remove(draw_priority);
-        }
-    }
-
     std::optional<std::reference_wrapper<const Layer>> GraphicEngine::get(Priority priority) const {
         const auto it = this->_layers.find(priority);
         if(it != this->_layers.end()) {
@@ -45,28 +36,29 @@ namespace megu {
         return {};
     }
 
-    std::optional<std::reference_wrapper<const DrawGroup>> GraphicEngine::get(Priority layer_priority, Priority draw_priority) const {
-        const auto it = this->_layers.find(layer_priority);
-        if(it != this->_layers.end()) {
-            return it->second->get(draw_priority);
-        }
-        return {};
-    }
-
     void GraphicEngine::step() {
         if(this->_window.isOpen()) {
             // Draw Layers
             TextureArray textures;
             for(auto & [priority, layer] : this->_layers) {
-                if(!layer.get()->empty()) {
+                const glm::vec2 & dimension = layer->renderer().dimension();
+                glViewport(0, 0, static_cast<GLsizei>(dimension.x), static_cast<GLsizei>(dimension.y));
                 textures.push_back(layer->draw(this->_window, textures));
             }
-            }
 
             // Merge Textures
             FrameBuffer::BindDefaultFrameBuffer();
-            this->_renderer.render(this->_window, this->_group, textures);
+            glViewport(0, 0, static_cast<GLsizei>(this->_window.width()), static_cast<GLsizei>(this->_window.height()));
+            glClear(GL_COLOR_BUFFER_BIT);
+            std::any any = 1;
+            this->_module.render(textures);
             this->_window.swapBuffers();
         }
     }
+
+    void GraphicEngine::setClearColor(float x, float y, float z) {
+        for(auto & [priority, layer] : this->_layers) {
+            layer.get()->renderer().setClearColor(x, y, z);
+        }
+    } 
 }
\ No newline at end of file

source/engine/graphics/front/engine/Engine.hpp

@@ -2,10 +2,10 @@
 
 #include <map>
 #include <optional>
-#include <engine/graphics/front/group/DrawGroup.hpp>
-#include <engine/graphics/front/group/FrameBufferGroup.hpp>
 
-#include "Renderer.hpp"
+#include <engine/graphics/front/module/FrameBufferModule.hpp>
+#include <engine/graphics/back/cameras/View.hpp>
+
 #include "Layer.hpp"
 
 namespace megu {
@@ -16,26 +16,28 @@ namespace megu {
             GraphicEngine(Window &);
            ~GraphicEngine() = default;
 
-            void push(Priority, const Renderer &);
-            void push(Priority, Priority, const DrawGroup &);
+            void push(Priority, Renderer &);
+
+            template <class T>
+            void push(Priority layer_priority, Priority object_priority, T & object) {
+                this->_layers[layer_priority].get()->push<T>(object_priority, object);
+            }
 
             void remove(Priority);
-            void remove(Priority, Priority);
 
             std::optional<std::reference_wrapper<const Layer>> get(Priority) const;
-            std::optional<std::reference_wrapper<const DrawGroup>> get(Priority, Priority) const;
 
             inline bool empty() const {return this->_layers.empty();}
-            inline const Renderer & renderer() const {return this->_renderer;}
             inline const std::map<Priority, std::unique_ptr<Layer>> & layers() const {return this->_layers;}
     
             void step();
+            void setClearColor(float, float, float);
 
         private:
             std::map<Priority, std::unique_ptr<Layer>> _layers;
-            Renderer _renderer;
-            FrameBufferGroup _group;
+            FrameBufferModule _module;
             Window & _window;
+            View _view;
 
     };
 }
\ No newline at end of file

source/engine/graphics/front/engine/Layer.cpp

@@ -3,37 +3,6 @@
 #include <iostream>
 
 namespace megu {
-    Layer::Layer(const Renderer & renderer) 
-    : _renderer(renderer), 
-      _frameBuffer(static_cast<GLuint>(renderer.dimension().x), static_cast<GLuint>(renderer.dimension().y)) {}
-
-    void Layer::push(Priority priority, const DrawGroup & group) {
-        this->_objects[priority] = &group;
-    }
-
-    void Layer::remove(Priority priority) {
-        auto it = this->_objects.find(priority);
-        if(it != this->_objects.end()) {
-            this->_objects.erase(it);
-        }
-    }
-
-    std::optional<std::reference_wrapper<const DrawGroup>> Layer::get(Priority priority) const {
-        const auto it = this->_objects.find(priority);
-        if(it != this->_objects.end()) {
-            return *it->second;
-        }
-        return {};
-    }
-
-    const Texture & Layer::draw(const Window & window, const TextureArray & textures) const {
-        this->_frameBuffer.bind();
-
-        for(auto &[priority, group] : this->_objects) {
-            this->_renderer.render(window, *group, textures);
-        }
-        
-        return this->_frameBuffer.texture();
-    }
-
+    Layer::Layer(Renderer & renderer) 
+    : _renderer(renderer), _frameBuffer(static_cast<GLuint>(renderer.dimension().x), static_cast<GLuint>(renderer.dimension().y)) {}
 }
\ No newline at end of file

source/engine/graphics/front/engine/Layer.hpp

@@ -2,8 +2,15 @@
 
 #include <map>
 #include <optional>
+#include <typeindex>
+#include <any>
+
 #include <engine/graphics/back/buffers/FrameBuffer.hpp>
-#include <engine/graphics/front/group/DrawGroup.hpp>
+#include <engine/graphics/front/object/Renderable.hpp>
+#include <engine/graphics/utility/reference_sorter.hpp>
+
+#include <engine/graphics/front/object/Renderable.hpp>
+#include <engine/graphics/front/module/QuadGraphicModule.hpp>
 
 #include "Priority.hpp" 
 #include "Renderer.hpp"
@@ -12,22 +19,30 @@ namespace megu {
     class Layer {
         public:
             Layer() = delete;
-            Layer(const Renderer &);
+            Layer(Renderer &);
            ~Layer() = default;
 
-            void push(Priority, const DrawGroup &); 
-            void remove(Priority);
-            std::optional<std::reference_wrapper<const DrawGroup>> get(Priority) const;
             
-            inline bool empty() const {return this->_objects.empty();}
             inline const Renderer & renderer() const {return this->_renderer;}
-            inline const std::map<Priority, DrawGroup const *> & groups() const {return this->_objects;}
 
-            virtual const Texture & draw(const Window &, const TextureArray &) const;
+            template <class T>
+            void push(Priority priority, T & object) {
+                this->_objects.insert({priority, Renderable(object, this->_module)});
+            }
+
+            const Texture & draw(const Window & w, const TextureArray & a) {
+                this->_frameBuffer.bind();
+                for(auto & [type, object] : this->_objects) {
+                    this->_renderer.render(w, object, a);
+                }
+               
+                return this->_frameBuffer.texture();
+            }
 
         private:
-            const Renderer & _renderer;
+            Renderer & _renderer;
             FrameBuffer _frameBuffer;
-            std::map<Priority, DrawGroup const*> _objects;
+            QuadGraphicModule _module;
+            std::map<Priority, Renderable> _objects;
     };
 }
\ No newline at end of file

source/engine/graphics/front/engine/Priority.hpp

@@ -11,4 +11,7 @@ namespace megu {
             return p1 != p2 ? p1 > p2 : &p1 > &p2;
         }
     };
+
+    template <class T>
+    using priority_map = std::map<Priority, T>;
 }
\ No newline at end of file

source/engine/graphics/front/engine/Renderer.cpp

@@ -7,10 +7,6 @@ namespace megu {
         glEnable(GL_BLEND);
     }
 
-    void Renderer::render(const Window & window, const DrawGroup & group, const TextureArray & textures) const {
-        group.draw(window, this->_view, textures);
-    }
-
     void Renderer::clear() const {
         glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
     }

source/engine/graphics/front/engine/Renderer.hpp

@@ -6,7 +6,11 @@
 #include <engine/graphics/back/buffers/FrameBuffer.hpp>
 #include <engine/graphics/back/cameras/View.hpp>
 
-#include <engine/graphics/front/group/DrawGroup.hpp> 
+#include <engine/io/Window.hpp>
+#include <engine/graphics/front/object/Renderable.hpp>
+#include <engine/graphics/front/engine/TextureArray.hpp>
+
+#include <engine/graphics/front/object/Renderable.hpp>
 
 namespace megu {
     class Renderer {
@@ -15,7 +19,10 @@ namespace megu {
             Renderer(float, float);
            ~Renderer() = default;
             
-            virtual void render(const Window &, const DrawGroup &, const TextureArray &) const;
+            void render(const Window & w, Renderable & r, const TextureArray & a) {
+                this->clear();
+                render_ext(r, w, this->_view, a);
+            }
 
             const glm::vec2 dimension() const {return this->_view.dimension();}
 

source/engine/graphics/front/geometry/Plane.hpp

@@ -6,6 +6,7 @@ namespace megu {
     class Plane : public Static_Geometry<Plane, QUADS, layout::FLAT, layout::TEXTURE> {
         public:
             inline static const Vertices_t & Vertices() {return Plane::_Vertices;}
+            inline static const size_t & Count() {return 4;}
             
         private:
             static Vertices_t _Vertices;

source/engine/graphics/front/geometry/Quads.hpp

@@ -6,6 +6,7 @@ namespace megu {
     class Quads : public Static_Geometry<Quads, QUADS, layout::FLAT, layout::TEXTURE> {
         public:
             inline static const Vertices_t & Vertices() {return Quads::_Vertices;}
+            inline static const size_t & Count() {return 4;}
             
         private:
             static Vertices_t _Vertices;

source/engine/graphics/front/geometry/Vertex.hpp

+#pragma once
+
+#include <glm/glm.hpp>
+
+namespace megu {
+    struct Vertex {
+        glm::vec2 _position;
+        glm::vec2 _texture;
+    };
+}
\ No newline at end of file

source/engine/graphics/front/group/DrawGroup.cpp

-#include "DrawGroup.hpp"
-
-namespace megu {
-    
-}
\ No newline at end of file

source/engine/graphics/front/group/DrawGroup.hpp

-#pragma once
-
-#include <engine/graphics/back/cameras/Camera.hpp>
-#include <engine/graphics/front/engine/TextureArray.hpp>
-#include <engine/io/Window.hpp>
-
-namespace megu {
-    class DrawGroup {
-        public:
-            virtual void draw(const Window &, const Camera &, const TextureArray &) const = 0;
-    };
-}
\ No newline at end of file

source/engine/graphics/front/group/ImageGroup.cpp

-#include "ImageGroup.hpp"
-
-#include <tuple>
-
-#include <engine/graphics/utility/array_generator.hpp>
-
-namespace megu {
-    ImageGroup::ImageGroup() 
-    : _vbo(this->_vao, Quads::Layout(), Quads::Vertices().size(), megu::EditMode::STATIC) {
-        Source vert("assets/shaders/Image-Instanced-Fat.vert", Source::Categorie::VERTEX);
-        this->_program.attach(vert);
-
-        Source frag("assets/shaders/Texture-Fat.frag", Source::Categorie::FRAGMENT);
-        this->_program.attach(frag);
-
-        this->_program.link();
-
-        this->_vbo << Quads::Vertices();
-
-        vert.release();
-        frag.release();
-    }
-
-    void ImageGroup::add(const Image & image) {
-        this->_images.insert(image);
-    }
-
-    void ImageGroup::update() {
-        std::set<std::reference_wrapper<const Image>, isometric_sorter> source = this->_images;
-        this->_images.clear();
-        for(auto & i : source) {
-            this->_images.insert(i);
-        }
-    }
-
-    void ImageGroup::draw(const Window & window, const Camera & camera, const TextureArray &) const {
-        this->_vao.bind();
-        this->_program.use();
-
-        std::vector<std::reference_wrapper<const Texture>> textures;
-
-        std::vector<glm::mat4> uModels;
-        std::vector<GLint> uTextures;
-
-        static auto uSampler = array_generator<GLint, 32>().array;         
-    
-        for(auto & image : this->_images) {
-            
-            std::vector<std::reference_wrapper<const Texture>>::iterator it = std::find(textures.begin(), textures.end(), image.get().texture());
-            if(it != textures.end()) {
-                uModels.push_back(image.get().transformation().model());
-                uTextures.push_back(static_cast<GLint>(it - textures.begin()));
-            }
-            else {
-                if(textures.size() >= 8 || uModels.size() >= 124) {
-                    this->_program.setUniform("uProj", camera.projection());
-                    this->_program.setUniform("uView", camera.view());
-                    this->_program.setUniform("uSampler", uSampler);
-                    this->_program.setUniform("uModel", uModels);
-                    this->_program.setUniform("uTextures", uTextures);
-
-                    glDrawArraysInstanced(Quads::Primitive(), 0, static_cast<GLsizei>(this->_vbo.size()), static_cast<GLsizei>(uModels.size()));
-
-                    textures.clear();
-                    uModels.clear();
-                    uTextures.clear();
-                }
-                
-                textures.push_back(image.get().texture());  
-                image.get().texture().bind(static_cast<GLint>(textures.size()-1));
-                uTextures.push_back(static_cast<GLint>(textures.size()-1)); 
-                uModels.push_back(image.get().transformation().model());
-            }
-        }
-
-        if(!textures.empty()) {
-            this->_program.setUniform("uProj", camera.projection());
-            this->_program.setUniform("uView", camera.view());
-            
-            
-            this->_program.setUniform("uSampler", uSampler);
-            this->_program.setUniform("uModel", uModels);
-            this->_program.setUniform("uTextures", uTextures);
-
-            glDrawArraysInstanced(Quads::Primitive(), 0, static_cast<GLsizei>(this->_vbo.size()), static_cast<GLsizei>(uModels.size())); 
-        }
-    }
-}
\ No newline at end of file

source/engine/graphics/front/group/FrameBufferGroup.cpp → source/engine/graphics/front/module/FrameBufferModule.cpp

-#include "FrameBufferGroup.hpp"
+#include "FrameBufferModule.hpp"
 
-#include <glm/gtc/matrix_transform.hpp>
 #include <engine/graphics/front/geometry/Plane.hpp>
 #include <engine/graphics/utility/array_generator.hpp>
 
 namespace megu {
-    FrameBufferGroup::FrameBufferGroup() 
-    : _vbo(this->_vao, Plane::Layout(), Plane::Vertices().size(), megu::EditMode::STATIC) {
+    FrameBufferModule::FrameBufferModule()
+    : _vbo(this->_vao, Plane::Layout(), Plane::Vertices(), megu::EditMode::STATIC) {
         megu::Source vert("assets/shaders/FrameBuffer-Instanced.vert", Source::Categorie::VERTEX);
         this->_program.attach(vert);
 
@@ -15,13 +14,11 @@ namespace megu {
 
         this->_program.link();
 
-        this->_vbo << Plane::Vertices();
-
         vert.release();
         frag.release();
     }
 
-    void FrameBufferGroup::draw(const Window & window, const Camera & camera, const TextureArray & textures) const {
+    void FrameBufferModule::render(const TextureArray & textures) {
         this->_program.use();
         this->_vao.bind();
 

source/engine/graphics/front/group/ImageGroup.hpp → source/engine/graphics/front/module/FrameBufferModule.hpp

 #pragma once
 
-#include "DrawGroup.hpp"
-
-
-#include <map>
-#include <list>
-#include <set>
-
-#include <engine/graphics/utility/isometric_sorter.hpp>
+#include <any>
 
 #include <engine/graphics/back/buffers/VertexArray.hpp>
 #include <engine/graphics/back/buffers/VerticeBuffer.hpp>
@@ -15,20 +8,17 @@
 
 #include <engine/graphics/front/object/Image.hpp>
 
+#include "Module.hpp"
+
 namespace megu {
-    class ImageGroup : public DrawGroup {
+    class FrameBufferModule {
        public:
-            ImageGroup();
-           ~ImageGroup() = default;
-
-            void draw(const Window &, const Camera &, const TextureArray &) const override;
+            FrameBufferModule();
+           ~FrameBufferModule() = default;
 
-            void add(const Image &);
-            void update();
+            void render(const TextureArray &);
 
         private:
-            std::set<std::reference_wrapper<const Image>, isometric_sorter> _images;
-            
             VertexArray _vao;
             VerticeBuffer _vbo;
             Program _program;

source/engine/graphics/front/module/Module.hpp

+#pragma once
+
+#include <engine/graphics/back/cameras/Camera.hpp>
+#include <engine/graphics/front/engine/TextureArray.hpp>
+#include <engine/graphics/utility/reference_sorter.hpp>
+#include <engine/io/Window.hpp>
+
+namespace megu {
+    template <class T>
+    class Module {
+        public:
+            virtual void draw(T &, const Window &, const Camera &, const TextureArray &) const = 0;
+    };
+
+    template <class ... Ts>
+    class Multy_Module : public Module<Ts> ... {};
+
+    template <class T>
+    using ref_set = std::set<std::reference_wrapper<T>, reference_sorter<T>>;
+
+    template <class T>
+    using Module_Array = Module<ref_set<T>>;
+
+    template <class ... Ts>
+    class Multy_Module_Array : public Module_Array<Ts> ... {};
+}
\ No newline at end of file