more recatoring, doesnt compile

5 files changed, 227 insertions, 8 deletions

diff --git a/engine/xe_engine.cpp b/engine/xe_engine.cpp
index 8d2655a..ff9c95b 100644
--- a/engine/xe_engine.cpp
+++ b/engine/xe_engine.cpp
@@ -4,14 +4,35 @@
 namespace xe {
 
 XeEngine::XeEngine(int width, int height, std::string name) 
-  : xeWindow{width, height, name}, xeDevice{xeWindow}, xeRenderer{xeWindow, xeDevice} {};
+  : xeWindow{width, height, name}, xeDevice{xeWindow}, xeRenderer{xeWindow, xeDevice} {
+    loadDescriptors();
+  };
 
-void XeEngine::loadDescriptorPool() {
+XeEngine::~XeEngine() {};
+
+void XeEngine::loadDescriptors() {
   xeDescriptorPool = XeDescriptorPool::Builder(xeDevice)
     .setMaxSets(XeSwapChain::MAX_FRAMES_IN_FLIGHT)
     .addPoolSize(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, XeSwapChain::MAX_FRAMES_IN_FLIGHT)
     .addPoolSize(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, XeSwapChain::MAX_FRAMES_IN_FLIGHT)
     .build();
+
+  xeDescriptorSetLayout = XeDescriptorSetLayout::Builder(xeDevice)
+    .addBinding(0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_SHADER_STAGE_VERTEX_BIT)
+    .build();
+}
+
+std::unique_ptr<XeRenderSystem> XeEngine::createRenderSystem(const std::string &vert, const std::string &frag, typename pushCunstant, typename uniformBuffer) {
+  return std::make_unique<XeRenderSystem>(
+    xeDevice,
+    xeRenderer,
+    xeDescriptorPool,
+    xeDescriptorSetLayout,
+    vert,
+    frag,
+    pushCunstantDataSize,
+    uniformBufferDataSize
+  );
 }
 
 }
\ No newline at end of file
diff --git a/engine/xe_engine.hpp b/engine/xe_engine.hpp
index 93d3f8b..7beb962 100644
--- a/engine/xe_engine.hpp
+++ b/engine/xe_engine.hpp
@@ -3,6 +3,8 @@
 #include "xe_window.hpp"
 #include "xe_device.hpp"
 #include "xe_renderer.hpp"
+#include "xe_render_system.hpp"
+#include "xe_descriptors.hpp"
 
 namespace xe {
 
@@ -16,25 +18,26 @@ class XeEngine {
     XeEngine(const XeEngine&) = delete;
     XeEngine operator=(const XeEngine&) = delete;
 
-    const XeWindow& getWindow() const { 
+    XeWindow& getWindow() { 
       return xeWindow; 
     };
 
-    const XeRenderer& getRenderer() const { 
+    XeRenderer& getRenderer() { 
       return xeRenderer; 
     };
 
+    std::unique_ptr<XeRenderSystem> createRenderSystem(const std::string &vert, const std::string &frag, uint32_t pushCunstantDataSize, uint32_t uniformBufferDataSize);
 
   private:
 
-    void loadDescriptorPool();
+    void loadDescriptors();
 
     XeWindow xeWindow;
     XeDevice xeDevice;
     XeRenderer xeRenderer;
 
-    std::unique_ptr<XeDescriptorPool> xeDescriptorPool{};
-    std::unique_ptr<xe::XeDescriptorSetLayout> xeDescriptorSetLayout;
+    std::unique_ptr<XeDescriptorPool> xeDescriptorPool;
+    std::unique_ptr<XeDescriptorSetLayout> xeDescriptorSetLayout;
 };
 
 }
\ No newline at end of file
diff --git a/engine/xe_frame_info.hpp b/engine/xe_frame_info.hpp
index d6cf7cb..074895d 100644
--- a/engine/xe_frame_info.hpp
+++ b/engine/xe_frame_info.hpp
@@ -11,7 +11,6 @@ struct XeFrameInfo {
     float frameTime;
     VkCommandBuffer commandBuffer;
     XeCamera &camera;
-    VkDescriptorSet globalDescriptorSet;
 };
 
 }
\ No newline at end of file
diff --git a/engine/xe_render_system.cpp b/engine/xe_render_system.cpp
new file mode 100644
index 0000000..ec56972
--- /dev/null
+++ b/engine/xe_render_system.cpp
@@ -0,0 +1,145 @@
+#include "xe_render_system.hpp"
+
+#include <vulkan/vulkan.h>
+#include "xe_device.hpp"
+#include "xe_pipeline.hpp"
+#include "xe_frame_info.hpp"
+#include "xe_game_object.hpp"
+#include "xe_swap_chain.hpp"
+#include "xe_renderer.hpp"
+#include "xe_descriptors.hpp"
+
+#include <memory>
+#include <stdexcept>
+
+namespace xe {
+
+template <typename P, typename U>
+XeRenderSystem::XeRenderSystem(
+  XeDevice &device, 
+  XeRenderer &renderer, 
+  std::unique_ptr<XeDescriptorPool> &xeDescriptorPool, 
+  std::unique_ptr<XeDescriptorSetLayout> &xeDescriptorSetLayout, 
+  std::string vert,
+  std::string frag, 
+  uint32_t pushCunstantDataSize, 
+  uint32_t uniformBufferDataSize) 
+  : xeDevice{device} {
+  createUniformBuffers(xeDescriptorPool, xeDescriptorSetLayout, uniformBufferDataSize);
+  createPipelineLayout(xeDescriptorSetLayout, pushCunstantDataSize, uniformBufferDataSize);
+  createPipeline(renderer.getSwapChainRenderPass(), vert, frag);
+}
+
+
+template <typename P, typename U>
+XeRenderSystem::~XeRenderSystem() {};
+
+
+template <typename P, typename U>
+void XeRenderSystem::createUniformBuffers(std::unique_ptr<XeDescriptorPool> &xeDescriptorPool, std::unique_ptr<XeDescriptorSetLayout> &xeDescriptorSetLayout, uint32_t uniformBufferDataSize) {
+  if(uniformBufferDataSize == 0) return;
+
+  uboBuffers = std::vector<std::unique_ptr<XeBuffer>>(XeSwapChain::MAX_FRAMES_IN_FLIGHT);
+  for (int i = 0; i < uboBuffers.size(); i++) {
+    uboBuffers[i] = std::make_unique<XeBuffer>(
+      xeDevice,
+      uniformBufferDataSize,
+      XeSwapChain::MAX_FRAMES_IN_FLIGHT,
+      VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
+      VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT);
+    uboBuffers[i]->map();
+  }
+
+  descriptorSets = std::vector<VkDescriptorSet>(XeSwapChain::MAX_FRAMES_IN_FLIGHT);
+  for (int i = 0; i < descriptorSets.size(); i++) {
+    auto bufferInfo = uboBuffers[i]->descriptorInfo();
+    XeDescriptorWriter(*xeDescriptorSetLayout, *xeDescriptorPool)
+      .writeBuffer(0, &bufferInfo)
+      .build(descriptorSets[i]);
+  }
+}
+
+
+template <typename P, typename U>
+void XeRenderSystem::createPipelineLayout(std::unique_ptr<XeDescriptorSetLayout> &xeDescriptorSetLayout, uint32_t pushCunstantDataSize, uint32_t uniformBufferDataSize) {
+
+  VkPipelineLayoutCreateInfo pipelineLayoutInfo{};
+  pipelineLayoutInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
+
+  if (pushCunstantDataSize > 0) {
+    VkPushConstantRange pushConstantRange;
+    pushConstantRange.stageFlags = VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT;
+    pushConstantRange.offset = 0;
+    pushConstantRange.size = pushCunstantDataSize;
+    pipelineLayoutInfo.pushConstantRangeCount = 1;
+    pipelineLayoutInfo.pPushConstantRanges = &pushConstantRange;
+  } else {
+    pipelineLayoutInfo.pushConstantRangeCount = 0;
+    pipelineLayoutInfo.pPushConstantRanges = nullptr;
+  }
+
+  if (uniformBufferDataSize > 0) {
+    std::vector<VkDescriptorSetLayout> descriptorSetLayouts{xeDescriptorSetLayout->getDescriptorSetLayout()};
+    pipelineLayoutInfo.setLayoutCount = static_cast<uint32_t>(descriptorSetLayouts.size());
+    pipelineLayoutInfo.pSetLayouts = descriptorSetLayouts.data();
+  } else {
+    pipelineLayoutInfo.setLayoutCount = 0;
+    pipelineLayoutInfo.pSetLayouts = nullptr;
+  }
+
+  if(vkCreatePipelineLayout(xeDevice.device(), &pipelineLayoutInfo, nullptr, &pipelineLayout) != VK_SUCCESS) {
+    std::runtime_error("failed to create pipeline layout!");
+  }
+}
+
+
+template <typename P, typename U>
+void XeRenderSystem::createPipeline(VkRenderPass renderPass, std::string vert, std::string frag) {
+  assert(pipelineLayout != nullptr && "Cannot create pipeline before pipeline layout");
+
+  PipelineConfigInfo pipelineConfig{};
+  XePipeline::defaultPipelineConfigInfo(pipelineConfig);
+  pipelineConfig.renderPass = renderPass;
+  pipelineConfig.pipelineLayout = pipelineLayout;
+  xePipeline = std::make_unique<XePipeline>(
+    xeDevice,
+    vert,
+    frag,
+    pipelineConfig
+  );
+}
+
+
+template <typename P, typename U>
+void XeRenderSystem::renderGameObjects(XeFrameInfo &frameInfo, std::vector<XeGameObject> &gameObjects, XeRenderSystem::XeData pushConstantData) {
+  xePipeline->bind(frameInfo.commandBuffer);
+
+  if(uboBuffers.size() > 0) {
+    vkCmdBindDescriptorSets(
+        frameInfo.commandBuffer,
+        VK_PIPELINE_BIND_POINT_GRAPHICS,
+        pipelineLayout,
+        0,
+        1,
+        &descriptorSets[frameInfo.frameIndex],
+        0,
+        nullptr);
+  }
+  
+  for (auto& obj: gameObjects) {
+
+    vkCmdPushConstants(
+      frameInfo.commandBuffer, 
+      pipelineLayout, 
+      VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT, 
+      0, 
+      sizeof(pushConstantData),
+      &pushConstantData);
+
+    obj.model->bind(frameInfo.commandBuffer);
+    obj.model->draw(frameInfo.commandBuffer);
+  }
+
+}
+
+}
\ No newline at end of file
diff --git a/engine/xe_render_system.hpp b/engine/xe_render_system.hpp
new file mode 100644
index 0000000..42079df
--- /dev/null
+++ b/engine/xe_render_system.hpp
@@ -0,0 +1,51 @@
+#pragma once
+
+#include <vulkan/vulkan.h>
+#include "xe_device.hpp"
+#include "xe_pipeline.hpp"
+#include "xe_frame_info.hpp"
+#include "xe_game_object.hpp"
+
+#include <memory>
+
+namespace xe {
+
+template<typename P, typename U>
+class XeRenderSystem {
+  public:
+
+    struct XeData{};
+    
+    XeRenderSystem(
+      XeDevice &device, 
+      XeRenderer &renderer, 
+      std::unique_ptr<XeDescriptorPool> &xeDescriptorPool, 
+      std::unique_ptr<XeDescriptorSetLayout> &xeDescriptorSetLayout,
+      std::string vert,
+      std::string frag, 
+      uint32_t pushCunstantDataSize, 
+      uint32_t uniformBufferDataSize);
+
+    ~XeRenderSystem();
+
+    XeRenderSystem(const XeRenderSystem &) = delete;
+    XeRenderSystem operator=(const XeRenderSystem &) = delete;
+
+    void renderGameObjects(XeFrameInfo &frameInfo, std::vector<XeGameObject> &gameObjects, XeRenderSystem::XeData pushConstantData);
+
+  private:
+    void createUniformBuffers(std::unique_ptr<XeDescriptorPool> &xeDescriptorPool, std::unique_ptr<XeDescriptorSetLayout> &xeDescriptorSetLayout, uint32_t uniformBufferDataSize);
+    void createPipelineLayout(std::unique_ptr<XeDescriptorSetLayout> &xeDescriptorSetLayout, uint32_t pushCunstantDataSize, uint32_t uniformBufferDataSize);
+    void createPipeline(VkRenderPass renderPass, std::string vert, std::string frag);
+
+    XeDevice& xeDevice;
+
+    std::unique_ptr<XePipeline> xePipeline;
+    std::vector<std::unique_ptr<XeBuffer>> uboBuffers;
+    std::vector<VkDescriptorSet> descriptorSets;
+
+    VkPipelineLayout pipelineLayout;
+
+};
+
+}
\ No newline at end of file