add an Application class

Author: rfdickerson

CMakeLists.txt

@@ -53,7 +53,9 @@ add_executable(Reactor src/core/main.cpp
         src/core/Camera.cpp
         src/core/Camera.hpp
         src/core/OrbitController.cpp
-        src/core/OrbitController.hpp)
+        src/core/OrbitController.hpp
+        src/core/Application.cpp
+        src/core/Application.hpp)
 
 target_link_libraries(Reactor PRIVATE Vulkan::Vulkan Vulkan::Headers glfw fmt::fmt spdlog::spdlog GPUOpen::VulkanMemoryAllocator glm::glm)
 target_link_libraries(Reactor PRIVATE imgui::imgui)

src/core/Application.cpp

@@ -0,0 +1,44 @@
+#include "Application.hpp"
+
+namespace reactor {
+
+ Application::Application() {
+     initialize();
+ }
+
+Application::~Application() = default;
+
+void Application::initialize() {
+    m_eventManager = std::make_unique<EventManager>();
+
+    m_window = std::make_unique<Window>(1280, 720, "Reactor", *m_eventManager);
+    m_camera = std::make_unique<Camera>();
+    m_orbitController = std::make_unique<OrbitController>(*m_camera);
+
+    // subscribe controller to input events.
+    m_eventManager->subscribe(EventType::MouseMoved, m_orbitController.get());
+    m_eventManager->subscribe(EventType::MouseButtonPressed, m_orbitController.get());
+    m_eventManager->subscribe(EventType::MouseButtonReleased, m_orbitController.get());
+
+    RendererConfig config{
+        .windowWidth = 1280,
+        .windowHeight = 720,
+        .windowTitle = "Reactor",
+        .vertShaderPath = "../resources/shaders/triangle.vert.spv",
+        .fragShaderPath = "../resources/shaders/triangle.frag.spv",
+        .compositeVertShaderPath = "../resources/shaders/composite.vert.spv",
+        .compositeFragShaderPath = "../resources/shaders/composite.frag.spv"
+    };
+
+    m_renderer = std::make_unique<VulkanRenderer>(config, *m_window, *m_camera);
+}
+
+void Application::run() {
+    while (!m_window->shouldClose()) {
+        m_window->pollEvents();
+        m_renderer->drawFrame();
+    }
+}
+
+
+} // reactor

src/core/Application.hpp

@@ -0,0 +1,31 @@
+#pragma once
+
+#include "Camera.hpp"
+#include "EventManager.hpp"
+#include "OrbitController.hpp"
+#include "Window.hpp"
+#include "../vulkan/VulkanRenderer.hpp"
+#include <memory>
+
+namespace reactor {
+
+class Application {
+public:
+    Application();
+    ~Application();
+
+    void run();
+
+private:
+    void initialize();
+
+    std::unique_ptr<EventManager> m_eventManager;
+    std::unique_ptr<Window> m_window;
+    std::unique_ptr<Camera> m_camera;
+    std::unique_ptr<OrbitController> m_orbitController;
+    std::unique_ptr<VulkanRenderer> m_renderer;
+
+};
+
+} // namespace reactor
+

src/core/main.cpp

@@ -1,20 +1,16 @@
 
 #include "../vulkan/VulkanContext.hpp"
 #include "../vulkan/VulkanRenderer.hpp"
+#include "Application.hpp"
 #include "Window.hpp"
 
 int main() {
 
-    reactor::RendererConfig config;
-    config.windowWidth = 1280;
-    config.windowHeight = 720;
-    config.windowTitle = "Reactor";
-    config.vertShaderPath = "../resources/shaders/triangle.vert.spv";
-    config.fragShaderPath = "../resources/shaders/triangle.frag.spv";
-    config.compositeVertShaderPath = "../resources/shaders/composite.vert.spv";
-    config.compositeFragShaderPath = "../resources/shaders/composite.frag.spv";
-
-    reactor::VulkanRenderer renderer(config);
-    renderer.run();
-    return 0;
+    try {
+        reactor::Application app;
+        app.run();
+    } catch (const std::exception& e) {
+        return EXIT_FAILURE;
+    }
+    return EXIT_SUCCESS;
 }

src/vulkan/VulkanRenderer.cpp

@@ -6,10 +6,10 @@
 
 #include <glm/glm.hpp>
 #include <glm/gtc/matrix_transform.hpp>
-#include <utility>
 
 namespace reactor {
-VulkanRenderer::VulkanRenderer(RendererConfig config) : m_config(std::move(config)) {
+VulkanRenderer::VulkanRenderer(const RendererConfig& config, Window& window, Camera& camera)
+: m_config(config), m_window(window), m_camera(camera) {
     createCoreVulkanObjects();
     createSwapchainAndFrameManager();
 
@@ -25,29 +25,17 @@ VulkanRenderer::VulkanRenderer(RendererConfig config) : m_config(std::move(confi
     createSampler();
     createDescriptorSets();
 
-    m_camera = std::make_unique<Camera>();
-    m_orbitController = std::make_unique<OrbitController>(*m_camera);
-    m_eventManager->subscribe(EventType::MouseMoved, m_orbitController.get());
-    m_eventManager->subscribe(EventType::MouseButtonPressed, m_orbitController.get());
-    m_eventManager->subscribe(EventType::MouseButtonReleased, m_orbitController.get());
 }
 
 void VulkanRenderer::createCoreVulkanObjects() {
-    m_eventManager = std::make_unique<EventManager>();
-    m_window =
-        std::make_unique<Window>(
-            m_config.windowWidth,
-            m_config.windowHeight,
-            m_config.windowTitle,
-            *m_eventManager);
-    m_context   = std::make_unique<VulkanContext>(m_window->getNativeWindow());
+    m_context   = std::make_unique<VulkanContext>(m_window.getNativeWindow());
     m_allocator = std::make_unique<Allocator>(m_context->physicalDevice(), m_context->device(),
                                               m_context->instance());
 }
 
 void VulkanRenderer::createSwapchainAndFrameManager() {
     m_swapchain = std::make_unique<Swapchain>(m_context->device(), m_context->physicalDevice(),
-                                              m_context->surface(), *m_window);
+                                              m_context->surface(), m_window);
 
     uint32_t swapchainImageCount = m_swapchain->getImageViews().size();
     m_frameManager = std::make_unique<FrameManager>(m_context->device(), *m_allocator, 0, 2,
@@ -89,36 +77,30 @@ void VulkanRenderer::createPipelineAndDescriptors() {
 }
 
 void VulkanRenderer::handleSwapchainResizing() {
-    if (m_window->wasResized()) {
-        vk::Extent2D size = m_window->getFramebufferSize();
+    if (m_window.wasResized()) {
+        vk::Extent2D size = m_window.getFramebufferSize();
         while (size.width == 0 || size.height == 0) {
             Window::waitEvents();
-            size = m_window->getFramebufferSize();
+            size = m_window.getFramebufferSize();
         }
         m_context->device().waitIdle();
         m_swapchain->recreate();
-        m_window->resetResizedFlag();
+        m_window.resetResizedFlag();
     }
 }
 
-void VulkanRenderer::setupUI() { m_imgui = std::make_unique<Imgui>(*m_context, *m_window); }
+void VulkanRenderer::setupUI() { m_imgui = std::make_unique<Imgui>(*m_context, m_window); }
 
 VulkanRenderer::~VulkanRenderer() {
+
+    m_context->device().waitIdle();
+
     for (auto i = 0; i < m_frameManager->getFramesInFlightCount(); ++i) {
         m_context->device().destroyImageView(m_msaaColorViews[i]);
         m_context->device().destroyImageView(m_resolveViews[i]);
     }
 }
 
-void VulkanRenderer::run() {
-    while (!m_window->shouldClose()) {
-        Window::pollEvents();
-        drawFrame();
-    }
-
-    m_context->device().waitIdle();
-}
-
 void VulkanRenderer::beginCommandBuffer(vk::CommandBuffer cmd) {
     cmd.begin({vk::CommandBufferUsageFlagBits::eOneTimeSubmit});
 }
@@ -221,8 +203,8 @@ void VulkanRenderer::drawFrame() {
     utils::setupViewportAndScissor(cmd, extent);
 
     SceneUBO ubo{};
-    ubo.view = m_camera->getView();
-    ubo.projection = m_camera->getProjection();
+    ubo.view = m_camera.getView();
+    ubo.projection = m_camera.getProjection();
 
     m_uniformManager->update<SceneUBO>(frameIdx, ubo);
 

src/vulkan/VulkanRenderer.hpp

@@ -1,14 +1,8 @@
-//
-// Created by Robert F. Dickerson on 6/9/25.
-//
+#pragma once
 
-#ifndef VULKANRENDERER_HPP
-#define VULKANRENDERER_HPP
 #include <memory>
 
 #include "../core/Camera.hpp"
-#include "../core/EventManager.hpp"
-#include "../core/OrbitController.hpp"
 #include "../core/Window.hpp"
 #include "../imgui/Imgui.hpp"
 #include "Allocator.hpp"
@@ -34,22 +28,19 @@ namespace reactor {
         std::string compositeFragShaderPath;
     };
 
-
-
 class VulkanRenderer {
 public:
-    explicit VulkanRenderer(RendererConfig  config);
+    VulkanRenderer(const RendererConfig& config, Window& window, Camera& camera);
     ~VulkanRenderer();
 
-    void run();
-
     void drawFrame();
 
 private:
-    RendererConfig m_config{};
-    std::unique_ptr<EventManager> m_eventManager;
+    const RendererConfig& m_config;
+    Window& m_window;
+    Camera& m_camera;
+
     std::unique_ptr<VulkanContext> m_context;
-    std::unique_ptr<Window> m_window;
     std::unique_ptr<Swapchain> m_swapchain;
     std::unique_ptr<Allocator> m_allocator;
     std::unique_ptr<FrameManager> m_frameManager;
@@ -59,9 +50,6 @@ class VulkanRenderer {
     std::unique_ptr<DescriptorSet> m_compositeDescriptorSet;
     std::unique_ptr<Sampler> m_sampler;
     std::unique_ptr<UniformManager> m_uniformManager;
-    std::unique_ptr<Camera> m_camera;
-    std::unique_ptr<OrbitController> m_orbitController;
-
     std::unique_ptr<Imgui> m_imgui;
 
     ImageStateTracker m_imageStateTracker;
@@ -85,7 +73,6 @@ class VulkanRenderer {
     void handleSwapchainResizing();
     void beginCommandBuffer(vk::CommandBuffer cmd);
     void beginDynamicRendering(vk::CommandBuffer cmd, vk::ImageView imageView, vk::Extent2D extent, bool clear);
-    void updateUniformBuffer(Buffer* uniformBuffer);
     void bindDescriptorSets(vk::CommandBuffer cmd);
     void drawGeometry(vk::CommandBuffer cmd);
     void renderUI(vk::CommandBuffer cmd) const;
@@ -98,4 +85,3 @@ class VulkanRenderer {
 
 }
 
-#endif //VULKANRENDERER_HPP