1 files changed, 45 insertions, 24 deletions

diff --git a/engine/xe_render_system.hpp b/engine/xe_render_system.hpp
index 098727c..c783610 100644
--- a/engine/xe_render_system.hpp
+++ b/engine/xe_render_system.hpp
@@ -13,15 +13,31 @@
 #include <stdexcept>
 #include <iostream>
 #include <map>
+#include <vector>
 
 namespace xe {
 
-class XeRenderSystem {
+class RenderSystem {
   public:
   
     class Builder {
       public:
-        Builder(XeEngine &xeEngine, std::string vert, std::string frag) : xeEngine{xeEngine}, vert{vert}, frag{frag} {}
+        Builder(Engine &xeEngine, std::string vert, std::string frag) : xeEngine{xeEngine}, vert{vert}, frag{frag} {}
+
+        Builder& addVertexBinding(uint32_t binding, uint32_t dimension, uint32_t offset){
+          if(dimension == 1)
+            attributeDescptions.push_back({binding, 0, VK_FORMAT_R32_SFLOAT, offset});
+          if(dimension == 2)
+            attributeDescptions.push_back({binding, 0, VK_FORMAT_R32G32_SFLOAT, offset});
+          if(dimension == 3)
+            attributeDescptions.push_back({binding, 0, VK_FORMAT_R32G32B32_SFLOAT, offset});
+          return *this;
+        }
+
+        Builder& setVertexSize(uint32_t size) {
+          vertexSize = size;
+          return *this;
+        }
 
         Builder& addPushConstant(uint32_t size) {
           pushCunstantDataSize = size;
@@ -33,7 +49,7 @@ class XeRenderSystem {
           return *this;
         }
 
-        Builder& addTextureBinding(uint32_t binding, XeImage* image) {
+        Builder& addTextureBinding(uint32_t binding, Image* image) {
           imageBindings[binding] = image;
           return *this;
         }
@@ -43,44 +59,49 @@ class XeRenderSystem {
           return *this;
         }
 
-        std::unique_ptr<XeRenderSystem> build() {
-          return std::make_unique<XeRenderSystem>(xeEngine, std::move(vert), std::move(frag), std::move(uniformBindings), std::move(imageBindings), std::move(pushCunstantDataSize), std::move(cullingEnabled));
+        std::unique_ptr<RenderSystem> build() {
+          return std::make_unique<RenderSystem>(xeEngine, std::move(vert), std::move(frag), std::move(uniformBindings), std::move(imageBindings), std::move(pushCunstantDataSize), std::move(cullingEnabled), std::move(attributeDescptions), std::move(vertexSize));
         }
 
       private:
 
         std::map<uint32_t, uint32_t> uniformBindings{};
-        std::map<uint32_t, XeImage*> imageBindings{};
+        std::map<uint32_t, Image*> imageBindings{};
         uint32_t pushCunstantDataSize{0};
 
+        std::vector<VkVertexInputAttributeDescription> attributeDescptions{};
+        uint32_t vertexSize;
+
         std::string vert;
         std::string frag;
 
         bool cullingEnabled{false};
 
-        XeEngine &xeEngine;
+        Engine &xeEngine;
     };
 
-    XeRenderSystem(
-      XeEngine &xeEngine,
+    RenderSystem(
+      Engine &xeEngine,
       std::string vert,
       std::string frag,
       std::map<uint32_t, uint32_t> uniformBindings,
-      std::map<uint32_t, XeImage*> imageBindings,
+      std::map<uint32_t, Image*> imageBindings,
       uint32_t pushCunstantDataSize,
-      bool cullingEnabled
+      bool cullingEnabled,
+      std::vector<VkVertexInputAttributeDescription> attributeDescptions,
+      uint32_t vertexSize
     );
 
-    ~XeRenderSystem();
+    ~RenderSystem();
 
-    XeRenderSystem(const XeRenderSystem &) = delete;
-    XeRenderSystem operator=(const XeRenderSystem &) = delete;
+    RenderSystem(const RenderSystem &) = delete;
+    RenderSystem operator=(const RenderSystem &) = delete;
 
     void start();
     void loadPushConstant(void *pushConstantData);
     void loadUniformObject(uint32_t binding, void *uniformBufferData);
-    void loadTexture(uint32_t binding, XeImage *image);
-    void render(XeGameObject &gameObject);
+    void loadTexture(uint32_t binding, Image *image);
+    void render(GameObject &gameObject);
     void stop();
 
   private:
@@ -91,18 +112,18 @@ class XeRenderSystem {
     void createDescriptorSets();
     void updateDescriptorSet(int frameIndex, bool allocate);
     void createPipelineLayout();
-    void createPipeline(VkRenderPass renderPass, std::string vert, std::string frag, bool cullingEnabled);
+    void createPipeline(VkRenderPass renderPass, std::string vert, std::string frag, bool cullingEnabled, std::vector<VkVertexInputAttributeDescription> attributeDescptions, uint32_t vertexSize);
 
     bool boundPipeline{false};
     bool boundDescriptor{false};
 
   
-    XeDevice& xeDevice;
-    XeRenderer& xeRenderer;
+    Device& xeDevice;
+    Renderer& xeRenderer;
 
-    std::map<uint32_t, std::vector<std::unique_ptr<XeBuffer>>> uboBuffers{};
+    std::map<uint32_t, std::vector<std::unique_ptr<Buffer>>> uboBuffers{};
     std::map<uint32_t, uint32_t> uniformBindings;
-    std::map<uint32_t, XeImage*> imageBindings;
+    std::map<uint32_t, Image*> imageBindings;
     std::vector<VkDescriptorSet> descriptorSets;
 
     uint32_t pushCunstantDataSize;
@@ -110,9 +131,9 @@ class XeRenderSystem {
     VkSampler textureSampler;
     
     VkPipelineLayout pipelineLayout;
-    std::unique_ptr<XePipeline> xePipeline;
-    std::unique_ptr<XeDescriptorPool> &xeDescriptorPool;
-    std::unique_ptr<XeDescriptorSetLayout> xeDescriptorSetLayout;
+    std::unique_ptr<Pipeline> xePipeline;
+    std::unique_ptr<DescriptorPool> &xeDescriptorPool;
+    std::unique_ptr<DescriptorSetLayout> xeDescriptorSetLayout;
 
 };