finish refactor

5 files changed, 94 insertions, 148 deletions

diff --git a/engine/xe_engine.cpp b/engine/xe_engine.cpp
index 6de221a..ea54bb4 100644
--- a/engine/xe_engine.cpp
+++ b/engine/xe_engine.cpp
@@ -1,16 +1,14 @@
 #include "xe_engine.hpp"
-#include "xe_descriptors.hpp"
+#include <chrono> 
 
-#include <string>
 namespace xe {
 
-XeEngine::XeEngine(int width, int height, std::string name) 
-  : xeWindow{width, height, name}, 
-    xeDevice{xeWindow}, 
-    xeRenderer{xeWindow, xeDevice},
-    xeCamera{} {
-    loadDescriptors();
-  };
+XeEngine::XeEngine(int width, int height, std::string name) : xeWindow{width, height, name}, 
+  xeDevice{xeWindow}, 
+  xeRenderer{xeWindow, xeDevice},
+  xeCamera{} {
+  loadDescriptors();
+};
 
 void XeEngine::loadDescriptors() {
   xeDescriptorPool = XeDescriptorPool::Builder(xeDevice)
@@ -24,45 +22,27 @@ void XeEngine::loadDescriptors() {
     .build();
 }
 
-std::unique_ptr<XeRenderSystem> XeEngine::createRenderSystem(const std::string &vert, const std::string &frag, uint32_t pushCunstantDataSize, uint32_t uniformBufferDataSize) {
-  return std::make_unique<XeRenderSystem>(
-    xeDevice,
-    xeRenderer,
-    *xeDescriptorPool,
-    *xeDescriptorSetLayout,
-    vert,
-    frag,
-    pushCunstantDataSize,
-    uniformBufferDataSize
-  );
-}
-
-std::shared_ptr<XeModel> XeEngine::createModel(const std::string &filename) {
+std::shared_ptr<XeModel> XeEngine::loadModelFromFile(const std::string &filename) {
   return XeModel::createModelFromFile(xeDevice, filename);
 }
 
-void XeEngine::render(
-  XeRenderSystem& xeRenderSystem, 
-  std::vector<XeGameObject>& gameObjects,
-  void* pushConstantData, 
-  uint32_t pushConstantSize, 
-  void* uniformBufferData, 
-  uint32_t uniformBufferSize) {
-
-  auto commandBuffer = xeRenderer.getCurrentCommandBuffer();
-  xeRenderer.beginSwapChainRenderPass(commandBuffer);
+std::shared_ptr<XeModel> XeEngine::loadModelFromData(std::vector<XeModel::Vertex> vertices, std::vector<uint32_t> indices) {
+  XeModel::Builder builder{};
+  builder.vertices = vertices;
+  if(&indices == NULL) { 
+    builder.indices = indices;
+  }
+  return std::make_shared<XeModel>(xeDevice, builder);
+}
 
-  xeRenderSystem.renderGameObjects(
-    xeRenderer.getFrameIndex(),
-    commandBuffer,
-    gameObjects,
-    pushConstantData,
-    pushConstantSize,
-    uniformBufferData,
-    uniformBufferSize
-  );
-  
-  xeRenderer.endSwapChainRenderPass(commandBuffer);
+bool XeEngine::poll() {
+  glfwPollEvents();
+  auto newTime = std::chrono::high_resolution_clock::now();
+  frameTime = std::chrono::duration<float, std::chrono::seconds::period>(newTime - currentTime).count();
+  currentTime = newTime;
+  float aspect = xeRenderer.getAspectRatio();
+  xeCamera.setPerspectiveProjection(glm::radians(FOV), aspect, 0.1f, 100.f);
+  return !xeWindow.shouldClose();
 }
 
 }
\ No newline at end of file
diff --git a/engine/xe_engine.hpp b/engine/xe_engine.hpp
index d9f79ca..d3862d4 100644
--- a/engine/xe_engine.hpp
+++ b/engine/xe_engine.hpp
@@ -3,8 +3,9 @@
 #include "xe_window.hpp"
 #include "xe_device.hpp"
 #include "xe_renderer.hpp"
-#include "xe_render_system.hpp"
+#include "xe_camera.hpp"
 #include "xe_descriptors.hpp"
+#include <chrono> 
 
 #include <string>
 namespace xe {
@@ -14,41 +15,25 @@ class XeEngine {
   public:
 
     XeEngine(int width, int height, std::string name);
+
     ~XeEngine() {};
 
     XeEngine(const XeEngine&) = delete;
     XeEngine operator=(const XeEngine&) = delete;
 
-    XeWindow& getWindow() { 
-      return xeWindow; 
-    };
-
-    XeRenderer& getRenderer() { 
-      return xeRenderer; 
-    };
-
-    XeCamera& getCamera() { 
-      return xeCamera; 
-    };
+    XeWindow& getWindow() {return xeWindow;}
+    XeCamera& getCamera() {return xeCamera;}
 
-    std::unique_ptr<XeRenderSystem> createRenderSystem(const std::string &vert, const std::string &frag, uint32_t pushCunstantDataSize, uint32_t uniformBufferDataSize);
-
-    std::shared_ptr<XeModel> createModel(const std::string &filename);
+    std::shared_ptr<XeModel> loadModelFromFile(const std::string &filename);
+    std::shared_ptr<XeModel> loadModelFromData(std::vector<XeModel::Vertex> vertices, std::vector<uint32_t> indices);
 
     bool beginFrame() { return xeRenderer.beginFrame(); }
-
-    void endFrame() { return xeRenderer.endFrame(); }
-
-    void render(
-      XeRenderSystem& xeRenderSystem, 
-      std::vector<XeGameObject>& gameObjects,
-      void* pushConstantData, 
-      uint32_t pushConstantSize, 
-      void* uniformBufferData, 
-      uint32_t uniformBufferSize);
-
+    void endFrame() { xeRenderer.endFrame(); }
     void close() { vkDeviceWaitIdle(xeDevice.device()); }
 
+    bool poll();
+    float getFrameTime() { return frameTime; }
+
   private:
 
     void loadDescriptors();
@@ -58,8 +43,15 @@ class XeEngine {
     XeRenderer xeRenderer;
     XeCamera xeCamera;
 
+    std::chrono::_V2::system_clock::time_point currentTime;
+    float frameTime;
+
+    float FOV = 50.f;
+
     std::unique_ptr<XeDescriptorPool> xeDescriptorPool;
     std::unique_ptr<XeDescriptorSetLayout> xeDescriptorSetLayout;
+
+    friend class XeRenderSystem;
 };
 
 }
\ No newline at end of file
diff --git a/engine/xe_frame_info.hpp b/engine/xe_frame_info.hpp
deleted file mode 100644
index 074895d..0000000
--- a/engine/xe_frame_info.hpp
+++ /dev/null
@@ -1,16 +0,0 @@
-#pragma once
-
-#include "xe_camera.hpp"
-
-#include <vulkan/vulkan.h>
-
-namespace xe {
-
-struct XeFrameInfo {
-    int frameIndex;
-    float frameTime;
-    VkCommandBuffer commandBuffer;
-    XeCamera &camera;
-};
-
-}
\ No newline at end of file
diff --git a/engine/xe_render_system.cpp b/engine/xe_render_system.cpp
index 8a28473..6726632 100644
--- a/engine/xe_render_system.cpp
+++ b/engine/xe_render_system.cpp
@@ -3,11 +3,11 @@
 #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 "xe_engine.hpp"
 
 #include <memory>
 #include <stdexcept>
@@ -17,18 +17,15 @@
 namespace xe {
 
 XeRenderSystem::XeRenderSystem(
-  XeDevice &device, 
-  XeRenderer &renderer, 
-  XeDescriptorPool &xeDescriptorPool, 
-  XeDescriptorSetLayout &xeDescriptorSetLayout, 
+  XeEngine &xeEngine,
   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);
+  : xeDevice{xeEngine.xeDevice}, xeRenderer{xeEngine.xeRenderer} {
+  createUniformBuffers(*xeEngine.xeDescriptorPool, *xeEngine.xeDescriptorSetLayout, uniformBufferDataSize);
+  createPipelineLayout(*xeEngine.xeDescriptorSetLayout, pushCunstantDataSize, uniformBufferDataSize);
+  createPipeline(xeRenderer.getSwapChainRenderPass(), vert, frag);
 }
 
 
@@ -108,55 +105,54 @@ void XeRenderSystem::createPipeline(VkRenderPass renderPass, std::string vert, s
   );
 }
 
-void XeRenderSystem::renderGameObjects(
-  int frameIndex, 
-  VkCommandBuffer commandBuffer, 
-  std::vector<XeGameObject> &gameObjects, 
-  void *pushConstantData, 
-  uint32_t pushConstantSize, 
-  void* uniformBufferData, 
-  uint32_t uniformBufferSize) {
-
-  uboBuffers[frameIndex]->writeToBuffer(uniformBufferData);
-  uboBuffers[frameIndex]->flush();
-
-  xePipeline->bind(commandBuffer);
-
-  if(pushConstantSize > 0) {
+void XeRenderSystem::loadPushConstant(void *pushConstantData, uint32_t pushConstantSize) {
+  if(!boundPipeline) {
+    xeRenderer.beginSwapChainRenderPass(xeRenderer.getCurrentCommandBuffer());
+    xePipeline->bind(xeRenderer.getCurrentCommandBuffer());
+    boundPipeline = true;
+  }
+  if(!boundDescriptor) {
     vkCmdBindDescriptorSets(
-        commandBuffer,
+        xeRenderer.getCurrentCommandBuffer(),
         VK_PIPELINE_BIND_POINT_GRAPHICS,
         pipelineLayout,
         0,
         1,
-        &descriptorSets[frameIndex],
+        &descriptorSets[xeRenderer.getFrameIndex()],
         0,
         nullptr);
+    boundDescriptor = true;
   }
-  
-  for (auto& obj: gameObjects) {
-
-    struct PushConstant {
-      glm::mat4 modelMatrix; 
-      glm::mat4 normalMatrix;
-    };
-
-    PushConstant pc = PushConstant{obj.transform.mat4(), obj.transform.normalMatrix()};
-
-    if(pushConstantSize > 0) {
-      vkCmdPushConstants(
-        commandBuffer, 
+  vkCmdPushConstants(
+        xeRenderer.getCurrentCommandBuffer(), 
         pipelineLayout, 
         VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT, 
         0, 
         pushConstantSize,
-        &pc);
-    }
+        pushConstantData);
+}
+
+void XeRenderSystem::loadUniformObject(void *uniformBufferData, uint32_t uniformBufferSize) {
+  uboBuffers[xeRenderer.getFrameIndex()]->writeToBuffer(uniformBufferData);
+  uboBuffers[xeRenderer.getFrameIndex()]->flush();
+}
 
-    obj.model->bind(commandBuffer);
-    obj.model->draw(commandBuffer);
+void XeRenderSystem::render(XeGameObject &gameObject) {
+  if(!boundPipeline){
+    xeRenderer.beginSwapChainRenderPass(xeRenderer.getCurrentCommandBuffer());
+    xePipeline->bind(xeRenderer.getCurrentCommandBuffer());
+    boundPipeline = true;
   }
 
+  gameObject.model->bind(xeRenderer.getCurrentCommandBuffer());
+  gameObject.model->draw(xeRenderer.getCurrentCommandBuffer());
+
+}
+
+void XeRenderSystem::stop() {
+  boundPipeline = false;
+  boundDescriptor = false;
+  xeRenderer.endSwapChainRenderPass(xeRenderer.getCurrentCommandBuffer());
 }
 
 }
\ No newline at end of file
diff --git a/engine/xe_render_system.hpp b/engine/xe_render_system.hpp
index 608e03a..fa56fdd 100644
--- a/engine/xe_render_system.hpp
+++ b/engine/xe_render_system.hpp
@@ -3,10 +3,10 @@
 #include <vulkan/vulkan.h>
 #include "xe_device.hpp"
 #include "xe_pipeline.hpp"
-#include "xe_frame_info.hpp"
 #include "xe_game_object.hpp"
 #include "xe_descriptors.hpp"
 #include "xe_renderer.hpp"
+#include "xe_engine.hpp"
 
 #include <memory>
 
@@ -14,42 +14,36 @@ namespace xe {
 
 class XeRenderSystem {
   public:
-
-    struct XeData{};
-    
+  
     XeRenderSystem(
-      XeDevice &device, 
-      XeRenderer &renderer, 
-      XeDescriptorPool &xeDescriptorPool, 
-      XeDescriptorSetLayout &xeDescriptorSetLayout,
+      XeEngine &xeEngine,
       std::string vert,
       std::string frag, 
       uint32_t pushCunstantDataSize,
       uint32_t uniformBufferDataSize
-      );
+    );
 
     ~XeRenderSystem();
 
     XeRenderSystem(const XeRenderSystem &) = delete;
     XeRenderSystem operator=(const XeRenderSystem &) = delete;
 
-    void setUnifroms(XeFrameInfo & frameInfo);
-
-    void renderGameObjects(
-      int frameIndex, 
-      VkCommandBuffer commandBuffer, 
-      std::vector<XeGameObject> &gameObjects, 
-      void *pushConstantData, 
-      uint32_t pushConstantSize, 
-      void* uniformBufferData, 
-      uint32_t uniformBufferSize);
+    void loadPushConstant(void *pushConstantData, uint32_t pushConstantSize);
+    void loadUniformObject(void *uniformBufferData, uint32_t uniformBufferSize);
+    void render(XeGameObject &gameObject);
+    void stop();
 
   private:
+  
     void createUniformBuffers(XeDescriptorPool &xeDescriptorPool, XeDescriptorSetLayout &xeDescriptorSetLayout, uint32_t uniformBufferDataSize);
     void createPipelineLayout(XeDescriptorSetLayout &xeDescriptorSetLayout, uint32_t pushCunstantDataSize, uint32_t uniformBufferDataSize);
     void createPipeline(VkRenderPass renderPass, std::string vert, std::string frag);
 
+    bool boundPipeline{false};
+    bool boundDescriptor{false};
+
     XeDevice& xeDevice;
+    XeRenderer& xeRenderer;
 
     std::unique_ptr<XePipeline> xePipeline;
     std::vector<std::unique_ptr<XeBuffer>> uboBuffers;