add an event listener

Author: rfdickerson

CMakeLists.txt

@@ -47,7 +47,9 @@ add_executable(Reactor src/core/main.cpp
         src/vulkan/UniformManager.cpp
         src/vulkan/UniformManager.hpp
         src/vulkan/ShaderModule.cpp
-        src/vulkan/ShaderModule.hpp)
+        src/vulkan/ShaderModule.hpp
+        src/core/EventManager.hpp
+        src/core/EventManager.cpp)
 
 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/EventManager.cpp

@@ -0,0 +1,28 @@
+#include "EventManager.hpp"
+
+namespace reactor {
+
+void EventManager::subscribe(EventType type, IEventListener *listener) {
+    m_listeners[type].push_back(listener);
+}
+
+void EventManager::unsubscribe(EventType type, IEventListener *listener) {
+    auto& listeners = m_listeners[type];
+    listeners.erase(std::remove(listeners.begin(), listeners.end(), listener), listeners.end());
+}
+
+void EventManager::post(const Event &event) {
+    if (m_listeners.find(event.type) == m_listeners.end()) {
+        // no listeners, so nothing to do.
+        return;
+    }
+
+    for (auto listener : m_listeners.at(event.type)) {
+        listener->onEvent(event);
+    }
+
+}
+
+
+
+}

src/core/EventManager.hpp

@@ -0,0 +1,41 @@
+#pragma once
+#include <unordered_map>
+#include <vector>
+
+namespace reactor {
+
+enum class EventType {
+    MouseMoved,
+    KeyPressed,
+    KeyReleased,
+};
+
+struct Event {
+    EventType type;
+    union {
+        struct {
+            double x, y;
+        } mouseMove;
+        struct {
+            int key;
+        } keyboard;
+    };
+};
+
+class IEventListener {
+public:
+    virtual ~IEventListener() = default;
+    virtual void onEvent(const Event& event) = 0;
+};
+
+class EventManager {
+public:
+    void subscribe(EventType type, IEventListener* listener);
+    void unsubscribe(EventType type, IEventListener* listener);
+    void post(const Event& event);
+
+private:
+    std::unordered_map<EventType, std::vector<IEventListener*>> m_listeners;
+};
+
+}

src/core/Window.cpp

@@ -3,7 +3,8 @@
 
 namespace reactor {
     // The constructor initializes GLFW and creates the window.
-    Window::Window(int width, int height, std::string title) : m_title(std::move(title)) {
+    Window::Window(int width, int height, std::string title, EventManager& eventManager) :
+m_width(width), m_height(height), m_title(title), m_eventManager(eventManager) {
         // Initialize the GLFW library.
         if (!glfwInit()) {
             throw std::runtime_error("Failed to initialize GLFW!");
@@ -19,12 +20,11 @@ namespace reactor {
             throw std::runtime_error("Failed to create GLFW window!");
         }
 
-        // Store a pointer to this Window instance in the GLFW window's user data.
-        // This allows us to retrieve it in the static callback.
         glfwSetWindowUserPointer(m_window, this);
-
-        // Set the static callback function for framebuffer resize events.
         glfwSetFramebufferSizeCallback(m_window, framebufferResizeCallback);
+
+        glfwSetKeyCallback(m_window, keyCallback);
+        glfwSetCursorPosCallback(m_window, mouseButtonCallback);
     }
 
     // The destructor cleans up GLFW resources.
@@ -59,12 +59,38 @@ namespace reactor {
 
 
     // This is the static callback that GLFW invokes when the window is resized.
-    void Window::framebufferResizeCallback(GLFWwindow* window, int width, int height) {
+    void Window::framebufferResizeCallback(GLFWwindow *window, int width, int height) {
         // Retrieve the pointer to our Window class instance.
-        auto* windowInstance = static_cast<Window*>(glfwGetWindowUserPointer(window));
+        auto *windowInstance = static_cast<Window *>(glfwGetWindowUserPointer(window));
         if (windowInstance) {
             // Set the flag indicating that a resize has occurred.
             windowInstance->m_framebufferResized = true;
         }
     }
-}
+    void Window::keyCallback(GLFWwindow *window, int key, int scancode, int action, int mods) {
+        auto* windowInstance = static_cast<Window*>(glfwGetWindowUserPointer(window));
+        if (!windowInstance) return;
+
+        Event event{};
+        if (action == GLFW_PRESS) {
+            event.type = EventType::KeyPressed;
+            event.keyboard.key = key;
+            windowInstance->m_eventManager.post(event);
+        } else if (action == GLFW_RELEASE) {
+            event.type = EventType::KeyReleased;
+            event.keyboard.key = key;
+            windowInstance->m_eventManager.post(event);
+        }
+
+    }
+    void Window::mouseButtonCallback(GLFWwindow *window, double xpos, double ypos) {
+        auto* windowInstance = static_cast<Window*>(glfwGetWindowUserPointer(window));
+        if (!windowInstance) return;
+        Event event{};
+        event.type = EventType::MouseMoved;
+        event.mouseMove.x = xpos;
+        event.mouseMove.y = ypos;
+        windowInstance->m_eventManager.post(event);
+
+    }
+    } // namespace reactor

src/core/Window.hpp

@@ -6,14 +6,15 @@
 #define WINDOW_HPP
 
 #include <string>
-#include <functional>
 #include <vulkan/vulkan.hpp>
+#include "EventManager.hpp"
 
 namespace reactor {
 
+
     class Window {
     public:
-        Window(int width, int height, std::string title);
+        Window(int width, int height, std::string title, EventManager& eventManager);
         ~Window();
 
         // Prevent copying and moving to ensure a single owner for the window resource.
@@ -50,8 +51,13 @@ namespace reactor {
     private:
         // This is the static callback function that GLFW will call on resize events.
         static void framebufferResizeCallback(GLFWwindow* window, int width, int height);
+        static void keyCallback(GLFWwindow* window, int key, int scancode, int action, int mods);
+        static void mouseButtonCallback(GLFWwindow* window, double xpos, double ypos);
 
         GLFWwindow* m_window = nullptr;
+        EventManager& m_eventManager;
+        int m_width;
+        int m_height;
         std::string m_title;
         bool m_framebufferResized = false;
     };

src/vulkan/Buffer.cpp

@@ -8,8 +8,8 @@
 
 namespace reactor {
 
-    Buffer::Buffer(Allocator &allocator, vk::DeviceSize size, vk::BufferUsageFlags usage, VmaMemoryUsage memoryUsage)
-        : m_allocator(allocator), m_size(size)
+    Buffer::Buffer(Allocator &allocator, vk::DeviceSize size, vk::BufferUsageFlags usage, VmaMemoryUsage memoryUsage, std::string name)
+        : m_allocator(allocator), m_size(size), m_name(name)
     {
         vk::BufferCreateInfo bufferInfo = {};
         bufferInfo.size = size;
@@ -36,7 +36,7 @@ namespace reactor {
         if (m_buffer && m_allocation) {
             vmaDestroyBuffer(m_allocator.get(), m_buffer, m_allocation);
 
-            spdlog::info("Buffer destroyed");
+            spdlog::info("Buffer {} destroyed", m_name.c_str());
 
             m_buffer = nullptr;
             m_allocation = nullptr;

src/vulkan/Buffer.hpp

@@ -8,10 +8,12 @@ namespace reactor {
 
 class Buffer {
 public:
-    Buffer(Allocator& allocator, vk::DeviceSize size, vk::BufferUsageFlags usage, VmaMemoryUsage memoryUsage);
+    Buffer(Allocator& allocator, vk::DeviceSize size, vk::BufferUsageFlags usage, VmaMemoryUsage memoryUsage, std::string name="");
 
     ~Buffer();
 
+    [[nodiscard]] const std::string& getName() const { return m_name; }
+
     // Non-copyable
     Buffer(const Buffer&) = delete;
     Buffer& operator=(const Buffer&) = delete;
@@ -27,6 +29,8 @@ class Buffer {
     vk::Buffer m_buffer = VK_NULL_HANDLE;
     VmaAllocation m_allocation = VK_NULL_HANDLE;
     vk::DeviceSize m_size = 0;
+
+    std::string m_name;
 };
 
 } // reactor

src/vulkan/UniformManager.cpp

@@ -17,7 +17,7 @@ std::vector<std::unique_ptr<Buffer>>
              m_allocator,
              size,
              vk::BufferUsageFlagBits::eUniformBuffer,
-             VmaMemoryUsage::VMA_MEMORY_USAGE_CPU_TO_GPU));
+             VMA_MEMORY_USAGE_CPU_TO_GPU, "Uniform buffer"));
      }
      return buffers;
  }

src/vulkan/VulkanRenderer.cpp

@@ -27,9 +27,13 @@ VulkanRenderer::VulkanRenderer(const RendererConfig &config) : m_config(config)
 }
 
 void VulkanRenderer::createCoreVulkanObjects() {
+    m_eventManager = std::make_unique<EventManager>();
     m_window =
-        std::make_unique<Window>(static_cast<int>(m_config.windowWidth),
-                                 static_cast<int>(m_config.windowHeight), m_config.windowTitle);
+        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_allocator = std::make_unique<Allocator>(m_context->physicalDevice(), m_context->device(),
                                               m_context->instance());

src/vulkan/VulkanRenderer.hpp

@@ -7,6 +7,7 @@
 #include <memory>
 
 #include "../core/Window.hpp"
+#include "../core/EventManager.hpp"
 #include "../imgui/Imgui.hpp"
 #include "Allocator.hpp"
 #include "DescriptorSet.hpp"
@@ -44,6 +45,7 @@ class VulkanRenderer {
 
 private:
     RendererConfig m_config{};
+    std::unique_ptr<EventManager> m_eventManager;
     std::unique_ptr<VulkanContext> m_context;
     std::unique_ptr<Window> m_window;
     std::unique_ptr<Swapchain> m_swapchain;