Changed key and mouse button callback signatures

src/Engine/Graphics/Command.h

@@ -21,6 +21,7 @@ class RenderCommand {
     virtual void draw(uint32 vertexCount, uint32 instanceCount, int32 firstVertex, uint32 firstInstance) = 0;
     virtual void drawIndirect(Gfx::PShaderBuffer buffer, uint64 offset, uint32 drawCount, uint32 stride) = 0;
     virtual void drawIndexed(uint32 indexCount, uint32 instanceCount, int32 firstIndex, uint32 vertexOffset, uint32 firstInstance) = 0;
+    virtual void drawIndexedIndirect(Gfx::PShaderBuffer buffer, uint64 offset, uint32 drawCount, uint32 stride) = 0;
     virtual void drawMesh(uint32 groupX, uint32 groupY, uint32 groupZ) = 0;
     virtual void drawMeshIndirect(Gfx::PShaderBuffer buffer, uint64 offset, uint32 drawCount, uint32 stride) = 0;
     virtual void traceRays(uint32 width, uint32 height, uint32 depth) = 0;

src/Engine/Graphics/Descriptor.h

@@ -59,7 +59,7 @@ class DescriptorSet {
     DescriptorSet(PDescriptorLayout layout);
     virtual ~DescriptorSet();
     virtual void writeChanges() = 0;
-    virtual void updateConstants(const std::string& name, uint32 offset, void* data) = 0;
+    virtual void updateConstants(const std::string& name, uint32 offset, const void* data) = 0;
     virtual void updateBuffer(const std::string& name, uint32 index, Gfx::PShaderBuffer shaderBuffer) = 0;
     virtual void updateBuffer(const std::string& name, uint32 index, Gfx::PVertexBuffer vertexBuffer) = 0;
     virtual void updateBuffer(const std::string& name, uint32 index, Gfx::PIndexBuffer indexBuffer) = 0;

src/Engine/Graphics/Vulkan/Command.cpp

@@ -351,6 +351,12 @@ void RenderCommand::drawIndexed(uint32 indexCount, uint32 instanceCount, int32 f
     assert(threadId == std::this_thread::get_id());
     vkCmdDrawIndexed(handle, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
 }
+
+void RenderCommand::drawIndexedIndirect(Gfx::PShaderBuffer buffer, uint64 offset, uint32 drawCount, uint32 stride) {
+    assert(threadId == std::this_thread::get_id());
+    vkCmdDrawIndexedIndirect(handle, buffer.cast<ShaderBuffer>()->getHandle(), offset, drawCount, stride);
+}
+
 void RenderCommand::drawMesh(uint32 groupX, uint32 groupY, uint32 groupZ) {
     assert(threadId == std::this_thread::get_id());
     if (groupX * groupY * groupZ == 0) // any dimension is 0

src/Engine/Graphics/Vulkan/Command.h

@@ -83,6 +83,7 @@ class RenderCommand : public Gfx::RenderCommand {
     virtual void draw(uint32 vertexCount, uint32 instanceCount, int32 firstVertex, uint32 firstInstance) override;
     virtual void drawIndirect(Gfx::PShaderBuffer buffer, uint64 offset, uint32 drawCount, uint32 stride) override;
     virtual void drawIndexed(uint32 indexCount, uint32 instanceCount, int32 firstIndex, uint32 vertexOffset, uint32 firstInstance) override;
+    virtual void drawIndexedIndirect(Gfx::PShaderBuffer buffer, uint64 offset, uint32 drawCount, uint32 stride) override;
     virtual void drawMesh(uint32 groupX, uint32 groupY, uint32 groupZ) override;
     virtual void drawMeshIndirect(Gfx::PShaderBuffer buffer, uint64 offset, uint32 drawCount, uint32 stride) override;
     virtual void traceRays(uint32 width, uint32 height, uint32 depth) override;

src/Engine/Graphics/Vulkan/Descriptor.cpp

@@ -212,8 +212,8 @@ DescriptorSet::~DescriptorSet() {
     setHandle->isUsed = false;
 }
 
-void DescriptorSet::updateConstants(const std::string& mappingName, uint32 offset, void* data) {
-    std::memcpy(constantData.data() + owner->getLayout()->mappings[mappingName].constantOffset, (char*)data + offset,
+void DescriptorSet::updateConstants(const std::string& mappingName, uint32 offset, const void* data) {
+    std::memcpy(constantData.data() + owner->getLayout()->mappings[mappingName].constantOffset, (const char*)data + offset,
                 owner->getLayout()->mappings[mappingName].constantSize);
 }
 

src/Engine/Graphics/Vulkan/Descriptor.h

@@ -69,7 +69,7 @@ class DescriptorSet : public Gfx::DescriptorSet {
     DescriptorSet(PGraphics graphics, PDescriptorPool owner, PDescriptorSetHandle setHandle);
     virtual ~DescriptorSet();
     virtual void writeChanges() override;
-    virtual void updateConstants(const std::string& name, uint32 offset, void* data) override;
+    virtual void updateConstants(const std::string& name, uint32 offset, const void* data) override;
     virtual void updateBuffer(const std::string& name, uint32 index, Gfx::PShaderBuffer shaderBuffer) override;
     virtual void updateBuffer(const std::string& name, uint32 index, Gfx::PVertexBuffer vertexBuffer) override;
     virtual void updateBuffer(const std::string& name, uint32 index, Gfx::PIndexBuffer indexBuffer) override;

src/Engine/Graphics/Vulkan/Window.cpp

@@ -3,6 +3,7 @@
 #include "Enums.h"
 #include "Graphics.h"
 #include "Resources.h"
+#include <vulkan/vulkan_core.h>
 #define GLFW_EXPOSE_NATIVE_WAYLAND
 #define GLFW_EXPOSE_NATIVE_X11
 #include <GLFW/glfw3.h>
@@ -91,7 +92,7 @@ void glfwKeyCallback(GLFWwindow* handle, int key, int, int action, int modifier)
         return;
     }
     auto* window = static_cast<Seele::Vulkan::Window*>(glfwGetWindowUserPointer(handle));
-    window->keyPress(static_cast<Seele::KeyCode>(key), static_cast<InputAction>(action), static_cast<KeyModifier>(modifier));
+    window->keyPress(static_cast<Seele::KeyCode>(key), static_cast<InputAction>(action), modifier);
 }
 
 void glfwMouseMoveCallback(GLFWwindow* handle, double xpos, double ypos) {
@@ -101,7 +102,7 @@ void glfwMouseMoveCallback(GLFWwindow* handle, double xpos, double ypos) {
 
 void glfwMouseButtonCallback(GLFWwindow* handle, int button, int action, int modifier) {
     auto* window = static_cast<Seele::Vulkan::Window*>(glfwGetWindowUserPointer(handle));
-    window->mouseButton(static_cast<MouseButton>(button), static_cast<InputAction>(action), static_cast<KeyModifier>(modifier));
+    window->mouseButton(static_cast<MouseButton>(button), static_cast<InputAction>(action), static_cast<KeyModifierFlags>(modifier));
 }
 
 void glfwScrollCallback(GLFWwindow* handle, double xoffset, double yoffset) {
@@ -250,11 +251,11 @@ bool Seele::Vulkan::Window::shouldClose() const {
 
 Gfx::PTexture2D Seele::Vulkan::Window::getBackBuffer() const { return PTexture2D(swapChainTextures[currentImageIndex]); }
 
-void Seele::Vulkan::Window::setKeyCallback(std::function<void(Seele::KeyCode, InputAction, KeyModifier)> callback) { keyCallback = callback; }
+void Seele::Vulkan::Window::setKeyCallback(std::function<void(Seele::KeyCode, InputAction, KeyModifierFlags)> callback) { keyCallback = callback; }
 
 void Seele::Vulkan::Window::setMouseMoveCallback(std::function<void(double, double)> callback) { mouseMoveCallback = callback; }
 
-void Seele::Vulkan::Window::setMouseButtonCallback(std::function<void(MouseButton, InputAction, KeyModifier)> callback) { mouseButtonCallback = callback; }
+void Seele::Vulkan::Window::setMouseButtonCallback(std::function<void(MouseButton, InputAction, KeyModifierFlags)> callback) { mouseButtonCallback = callback; }
 
 void Seele::Vulkan::Window::setScrollCallback(std::function<void(double, double)> callback) { scrollCallback = callback; }
 
@@ -264,11 +265,11 @@ void Seele::Vulkan::Window::setCloseCallback(std::function<void()> callback) { c
 
 void Seele::Vulkan::Window::setResizeCallback(std::function<void(uint32, uint32)> callback) { resizeCallback = callback; }
 
-void Seele::Vulkan::Window::keyPress(Seele::KeyCode code, InputAction action, KeyModifier modifier) { keyCallback(code, action, modifier); }
+void Seele::Vulkan::Window::keyPress(Seele::KeyCode code, InputAction action, KeyModifierFlags modifier) { keyCallback(code, action, modifier); }
 
 void Seele::Vulkan::Window::mouseMove(double x, double y) { mouseMoveCallback(x, y); }
 
-void Seele::Vulkan::Window::mouseButton(MouseButton button, InputAction action, KeyModifier modifier) { mouseButtonCallback(button, action, modifier); }
+void Seele::Vulkan::Window::mouseButton(MouseButton button, InputAction action, KeyModifierFlags modifier) { mouseButtonCallback(button, action, modifier); }
 
 void Seele::Vulkan::Window::scroll(double x, double y) { scrollCallback(x, y); }
 

src/Engine/Graphics/Vulkan/Window.h

@@ -17,17 +17,17 @@ class Window : public Gfx::Window {
     virtual void endFrame() override;
     virtual Gfx::PTexture2D getBackBuffer() const override;
     virtual bool shouldClose() const override;
-    virtual void setKeyCallback(std::function<void(KeyCode, InputAction, KeyModifier)> callback) override;
+    virtual void setKeyCallback(std::function<void(KeyCode, InputAction, KeyModifierFlags)> callback) override;
     virtual void setMouseMoveCallback(std::function<void(double, double)> callback) override;
-    virtual void setMouseButtonCallback(std::function<void(MouseButton, InputAction, KeyModifier)> callback) override;
+    virtual void setMouseButtonCallback(std::function<void(MouseButton, InputAction, KeyModifierFlags)> callback) override;
     virtual void setScrollCallback(std::function<void(double, double)> callback) override;
     virtual void setFileCallback(std::function<void(int, const char**)> callback) override;
     virtual void setCloseCallback(std::function<void()> callback) override;
     virtual void setResizeCallback(std::function<void(uint32, uint32)> callback) override;
 
-    void keyPress(KeyCode code, InputAction action, KeyModifier modifier);
+    void keyPress(KeyCode code, InputAction action, KeyModifierFlags modifier);
     void mouseMove(double x, double y);
-    void mouseButton(MouseButton button, InputAction action, KeyModifier modifier);
+    void mouseButton(MouseButton button, InputAction action, KeyModifierFlags modifier);
     void scroll(double x, double y);
     void fileDrop(int num, const char** files);
     void close();
@@ -61,9 +61,9 @@ class Window : public Gfx::Window {
     uint32 currentImageIndex = 0;
     uint32 currentSemaphoreIndex = 0;
 
-    std::function<void(KeyCode, InputAction, KeyModifier)> keyCallback;
+    std::function<void(KeyCode, InputAction, KeyModifierFlags)> keyCallback;
     std::function<void(double, double)> mouseMoveCallback;
-    std::function<void(MouseButton, InputAction, KeyModifier)> mouseButtonCallback;
+    std::function<void(MouseButton, InputAction, KeyModifierFlags)> mouseButtonCallback;
     std::function<void(double, double)> scrollCallback;
     std::function<void(int, const char**)> fileCallback;
     std::function<void()> closeCallback;

src/Engine/Graphics/Window.h

@@ -15,9 +15,9 @@ class Window {
     virtual void endFrame() = 0;
     virtual bool shouldClose() const = 0;
     virtual PTexture2D getBackBuffer() const = 0;
-    virtual void setKeyCallback(std::function<void(KeyCode, InputAction, KeyModifier)> callback) = 0;
+    virtual void setKeyCallback(std::function<void(KeyCode, InputAction, KeyModifierFlags)> callback) = 0;
     virtual void setMouseMoveCallback(std::function<void(double, double)> callback) = 0;
-    virtual void setMouseButtonCallback(std::function<void(MouseButton, InputAction, KeyModifier)> callback) = 0;
+    virtual void setMouseButtonCallback(std::function<void(MouseButton, InputAction, KeyModifierFlags)> callback) = 0;
     virtual void setScrollCallback(std::function<void(double, double)> callback) = 0;
     virtual void setFileCallback(std::function<void(int, const char**)> callback) = 0;
     virtual void setCloseCallback(std::function<void()> callback) = 0;

src/Engine/System/KeyboardInput.cpp

@@ -25,14 +25,14 @@ void KeyboardInput::update(Component::KeyboardInput& input) {
     scrollY = 0;
 }
 
-void KeyboardInput::keyCallback(KeyCode code, InputAction action, KeyModifier) { keys[code] = action != InputAction::RELEASE; }
+void KeyboardInput::keyCallback(KeyCode code, InputAction action, KeyModifierFlags) { keys[code] = action != InputAction::RELEASE; }
 
 void KeyboardInput::mouseCallback(double x, double y) {
     mouseX = (float)x;
     mouseY = (float)y;
 }
 
-void KeyboardInput::mouseButtonCallback(MouseButton button, InputAction action, KeyModifier) {
+void KeyboardInput::mouseButtonCallback(MouseButton button, InputAction action, KeyModifierFlags) {
     if (button == MouseButton::MOUSE_BUTTON_1) {
         mouse1 = action != InputAction::RELEASE;
     }

src/Engine/System/KeyboardInput.h

@@ -9,9 +9,9 @@ class KeyboardInput : public ComponentSystem<Component::KeyboardInput> {
     KeyboardInput(PScene scene);
     virtual ~KeyboardInput();
     virtual void update(Component::KeyboardInput& input) override;
-    void keyCallback(KeyCode code, InputAction action, KeyModifier modifier);
+    void keyCallback(KeyCode code, InputAction action, KeyModifierFlags modifier);
     void mouseCallback(double xPos, double yPos);
-    void mouseButtonCallback(MouseButton button, InputAction action, KeyModifier modifier);
+    void mouseButtonCallback(MouseButton button, InputAction action, KeyModifierFlags modifier);
     void scrollCallback(double xScroll, double yScroll);
 
   private:

src/Engine/Window/GameView.cpp

@@ -95,11 +95,11 @@ void GameView::reloadGame() {
     systemGraph->addSystem(new System::CameraUpdater(scene));
 }
 
-void GameView::keyCallback(KeyCode code, InputAction action, KeyModifier modifier) { keyboardSystem->keyCallback(code, action, modifier); }
+void GameView::keyCallback(KeyCode code, InputAction action, KeyModifierFlags modifier) { keyboardSystem->keyCallback(code, action, modifier); }
 
 void GameView::mouseMoveCallback(double xPos, double yPos) { keyboardSystem->mouseCallback(xPos, yPos); }
 
-void GameView::mouseButtonCallback(MouseButton button, InputAction action, KeyModifier modifier) {
+void GameView::mouseButtonCallback(MouseButton button, InputAction action, KeyModifierFlags modifier) {
     keyboardSystem->mouseButtonCallback(button, action, modifier);
 }
 

src/Engine/Window/GameView.h

@@ -35,9 +35,9 @@ class GameView : public View {
     System::PKeyboardInput keyboardSystem;
     float updateTime = 0;
 
-    virtual void keyCallback(Seele::KeyCode code, Seele::InputAction action, Seele::KeyModifier modifier) override;
+    virtual void keyCallback(KeyCode code, InputAction action, KeyModifierFlags modifier) override;
     virtual void mouseMoveCallback(double xPos, double yPos) override;
-    virtual void mouseButtonCallback(Seele::MouseButton button, Seele::InputAction action, Seele::KeyModifier modifier) override;
+    virtual void mouseButtonCallback(MouseButton button, InputAction action, KeyModifierFlags modifier) override;
     virtual void scrollCallback(double xOffset, double yOffset) override;
     virtual void fileCallback(int count, const char** paths) override;
 };

src/Engine/Window/View.h

@@ -28,9 +28,9 @@ class View {
     PWindow owner;
     std::string name;
 
-    virtual void keyCallback(KeyCode code, InputAction action, KeyModifier modifier) = 0;
+    virtual void keyCallback(KeyCode code, InputAction action, uint32_t modifier) = 0;
     virtual void mouseMoveCallback(double xPos, double yPos) = 0;
-    virtual void mouseButtonCallback(MouseButton button, InputAction action, KeyModifier modifier) = 0;
+    virtual void mouseButtonCallback(MouseButton button, InputAction action, uint32_t modifier) = 0;
     virtual void scrollCallback(double xOffset, double yOffset) = 0;
     virtual void fileCallback(int count, const char** paths) = 0;
     friend class Window;