finish refactor

7 files changed, 99 insertions, 70 deletions

diff --git a/src/first_app.cpp b/src/first_app.cpp
index e460c6b..7be857d 100755
--- a/src/first_app.cpp
+++ b/src/first_app.cpp
@@ -1,32 +1,20 @@
 #include "first_app.hpp"
 
 #include "xe_camera.hpp"
+#include "xe_engine.hpp"
 #include "xe_game_object.hpp"
 #include "xe_model.hpp"
+#include "xe_render_system.hpp"
 #include "keyboard_movement_controller.hpp"
-
+#include "simple_renderer.hpp"
 
 #define GLM_FORCE_RADIANS
 #define GLM_FORCE_DEPTH_ZERO_TO_ONE
 #include <glm/glm.hpp>
 #include <glm/gtc/constants.hpp>
-
 #include <array>
-#include <chrono> 
-#include <cassert>
-#include <stdexcept>
-#include <iostream>
-namespace xe {
-
-struct UniformBuffer {
-  alignas(16) glm::mat4 projectionView{1.f};
-  alignas(4) glm::vec3 lightDirection = glm::normalize(glm::vec3{-1.f, 3.f, 1.f});
-};
 
-struct PushConstant {
-  alignas(16) glm::mat4 modelMatrix{1.f};
-  alignas(16) glm::mat4 normalMatrix{1.f};
-};
+namespace app {
 
 FirstApp::FirstApp() : xeEngine{WIDTH, HEIGHT, "Hello, Vulkan!"} {
   loadGameObjects();
@@ -36,53 +24,23 @@ FirstApp::~FirstApp() {}
 
 void FirstApp::run() {
 
-  std::unique_ptr<XeRenderSystem> simpleRenderSystem = xeEngine.createRenderSystem(
-    "res/shaders/simple_shader.vert.spv",
-    "res/shaders/simple_shader.frag.spv", 
-    sizeof(PushConstant), 
-    sizeof(UniformBuffer));
+  SimpleRenderer renderer{xeEngine};
+    
+  xeEngine.getCamera().setViewTarget(glm::vec3(-1.f, -2.f, 20.f), glm::vec3(0.f, 0.f, 2.5f));
 
-  XeCamera camera{};
-  camera.setViewTarget(glm::vec3(-1.f, -2.f, 20.f), glm::vec3(0.f, 0.f, 2.5f));
-
-  auto viewerObject = XeGameObject::createGameObject();
+  auto viewerObject = xe::XeGameObject::createGameObject();
   KeyboardMovementController cameraController{};
 
-  auto currentTime = std::chrono::high_resolution_clock::now();
-
-  while (!xeEngine.getWindow().shouldClose()) {
-    glfwPollEvents();
+  while (xeEngine.poll()) {
 
-    auto newTime = std::chrono::high_resolution_clock::now();
-    float frameTime = std::chrono::duration<float, std::chrono::seconds::period>(newTime - currentTime).count();
-    currentTime = newTime;
+    float frameTime = xeEngine.getFrameTime();
 
     cameraController.moveInPlaneXZ(xeEngine.getWindow().getGLFWwindow(), frameTime, viewerObject);
-    camera.setViewYXZ(viewerObject.transform.translation, viewerObject.transform.rotation);
-
-    float aspect = xeEngine.getRenderer().getAspectRatio();
-    camera.setPerspectiveProjection(glm::radians(50.f), aspect, 0.1f, 100.f);
+    xeEngine.getCamera().setViewYXZ(viewerObject.transform.translation, viewerObject.transform.rotation);
 
     if(xeEngine.beginFrame()) {
-
-      PushConstant pc{};
-      pc.modelMatrix = gameObjects[0].transform.mat4();
-      pc.normalMatrix = gameObjects[0].transform.normalMatrix();
-
-      UniformBuffer ubo{};
-      ubo.projectionView = camera.getProjection() * camera.getView();
-      
-      xeEngine.render(
-        *simpleRenderSystem,
-        gameObjects,
-        &pc,
-        sizeof(pc),
-        &ubo,
-        sizeof(ubo)
-      );
-
+      renderer.render(gameObjects, xeEngine.getCamera());
       xeEngine.endFrame();
-
     }
   }
 
@@ -91,13 +49,20 @@ void FirstApp::run() {
 }
 
 void FirstApp::loadGameObjects() {
-  std::shared_ptr<XeModel> xeModel = xeEngine.createModel("res/models/stanford-dragon.obj");
+  std::shared_ptr<xe::XeModel> xeModel = xeEngine.loadModelFromFile("res/models/stanford-dragon.obj");
+
+  auto dragon = xe::XeGameObject::createGameObject();
+  dragon.model = xeModel;
+  dragon.transform.translation = {.0f, .0f, 2.5f};
+  dragon.transform.scale = {.5f, .5f, .5f};
+  gameObjects.push_back(std::move(dragon));
 
-  auto cube = XeGameObject::createGameObject();
-  cube.model = xeModel;
-  cube.transform.translation = {.0f, .0f, 2.5f};
-  cube.transform.scale = {.5f, .5f, .5f};
-  gameObjects.push_back(std::move(cube));
+  auto dragon2 = xe::XeGameObject::createGameObject();
+  dragon2.model = xeModel;
+  dragon2.transform.translation = {5.0f, .0f, -1.5f};
+  dragon2.transform.rotation.y = glm::radians(90.f);
+  dragon2.transform.scale = {.35f, .35f, .35f};
+  gameObjects.push_back(std::move(dragon2));
 }
 
 }
\ No newline at end of file
diff --git a/src/first_app.hpp b/src/first_app.hpp
index 081113d..d8942ab 100755
--- a/src/first_app.hpp
+++ b/src/first_app.hpp
@@ -7,11 +7,9 @@
 #include <memory>
 #include <vector>
 
-namespace xe {
+namespace app {
 class FirstApp {
   public:
-    static constexpr int WIDTH = 800;
-    static constexpr int HEIGHT = 600;
 
     FirstApp();
     ~FirstApp();
@@ -22,10 +20,14 @@ class FirstApp {
     void run();
 
   private:
+  
+    static constexpr int WIDTH = 800;
+    static constexpr int HEIGHT = 600;
+
     void loadGameObjects();
 
-    XeEngine xeEngine;
+    xe::XeEngine xeEngine;
 
-    std::vector<XeGameObject> gameObjects;
+    std::vector<xe::XeGameObject> gameObjects;
 };
 }
\ No newline at end of file
diff --git a/src/keyboard_movement_controller.cpp b/src/keyboard_movement_controller.cpp
index 6782709..325693e 100644
--- a/src/keyboard_movement_controller.cpp
+++ b/src/keyboard_movement_controller.cpp
@@ -4,9 +4,9 @@
 #include <glm/geometric.hpp>
 #include <limits>
 
-namespace xe {
+namespace app {
 
-void KeyboardMovementController::moveInPlaneXZ(GLFWwindow* window, float dt, XeGameObject& gameObject) {
+void KeyboardMovementController::moveInPlaneXZ(GLFWwindow* window, float dt, xe::XeGameObject& gameObject) {
   glm::vec3 rotate{0};
   if(glfwGetKey(window, keys.lookRight) == GLFW_PRESS) rotate.y += 1.f;
   if(glfwGetKey(window, keys.lookLeft) == GLFW_PRESS) rotate.y -= 1.f;
diff --git a/src/keyboard_movement_controller.hpp b/src/keyboard_movement_controller.hpp
index b90d361..b3e3a15 100644
--- a/src/keyboard_movement_controller.hpp
+++ b/src/keyboard_movement_controller.hpp
@@ -4,7 +4,7 @@
 #include "xe_window.hpp"
 #include <GLFW/glfw3.h>
 
-namespace xe {
+namespace app {
   class KeyboardMovementController {
 
     public:
@@ -21,7 +21,7 @@ namespace xe {
         int lookDown = GLFW_KEY_DOWN;
       };
 
-      void moveInPlaneXZ(GLFWwindow* window, float dt, XeGameObject& gameObject);
+      void moveInPlaneXZ(GLFWwindow* window, float dt, xe::XeGameObject& gameObject);
 
       KeyMappings keys{};
       float moveSpeed{3.f};
diff --git a/src/main.cpp b/src/main.cpp
index 30b64d9..fa0804d 100755
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -5,7 +5,7 @@
 #include <stdexcept>
 
 int main() {
-    xe::FirstApp app{};
+    app::FirstApp app{};
 
     try {
         app.run();
diff --git a/src/simple_renderer.cpp b/src/simple_renderer.cpp
new file mode 100644
index 0000000..b4c115a
--- /dev/null
+++ b/src/simple_renderer.cpp
@@ -0,0 +1,26 @@
+#include "simple_renderer.hpp"
+
+namespace app {
+
+SimpleRenderer::SimpleRenderer(xe::XeEngine &xeEngine) 
+  : xeRenderSystem{xeEngine, "res/shaders/simple_shader.vert.spv", "res/shaders/simple_shader.frag.spv", sizeof(PushConstant), sizeof(UniformBuffer)} {};
+
+void SimpleRenderer::render(std::vector<xe::XeGameObject> &gameObjects, xe::XeCamera &xeCamera) {
+
+  UniformBuffer ubo{};
+  ubo.projectionView = xeCamera.getProjection() * xeCamera.getView();
+  xeRenderSystem.loadUniformObject(&ubo, sizeof(ubo));
+
+  for(auto &obj : gameObjects) {
+    PushConstant pc{};
+    pc.modelMatrix = obj.transform.mat4();
+    pc.normalMatrix = obj.transform.normalMatrix();
+    xeRenderSystem.loadPushConstant(&pc, sizeof(pc));
+    xeRenderSystem.render(obj);
+  }
+
+  xeRenderSystem.stop();
+
+}
+
+}
\ No newline at end of file
diff --git a/src/simple_renderer.hpp b/src/simple_renderer.hpp
new file mode 100644
index 0000000..22ba0b4
--- /dev/null
+++ b/src/simple_renderer.hpp
@@ -0,0 +1,36 @@
+#pragma once
+
+#include "xe_render_system.hpp"
+#include <string>
+
+namespace app {
+
+struct UniformBuffer {
+  alignas(16) glm::mat4 projectionView{1.f};
+  alignas(4) glm::vec3 lightDirection = glm::normalize(glm::vec3{-1.f, 3.f, 1.f});
+};
+
+struct PushConstant {
+  alignas(16) glm::mat4 modelMatrix{1.f};
+  alignas(16) glm::mat4 normalMatrix{1.f};
+};
+
+class SimpleRenderer {
+
+  public:
+
+    SimpleRenderer(xe::XeEngine &xeEngine);
+
+    ~SimpleRenderer() {};
+
+    SimpleRenderer(const SimpleRenderer&) = delete;
+    SimpleRenderer operator=(const SimpleRenderer&) = delete;
+
+    void render(std::vector<xe::XeGameObject> &gameObjects, xe::XeCamera &xeCamera);
+
+  private:
+    xe::XeRenderSystem xeRenderSystem;
+
+};
+
+}
\ No newline at end of file