Renamed Queue to submitCommands

Author: Raelr

engine/render/renderer/platform/vulkan/Fence.h

@@ -79,8 +79,11 @@ class Fence
         return Get(index);
     }
 
+    // TODO (Aryeh): Add some form of bounds checking?
     /**
      * Gets the raw vulkan Fence pointer stored by the wrapper
+     * @warn this method does not bounds check the index. It is the user's responsibility to make
+     * sure the index is valid
      * @param index the index to access, defaults to 0
      * @return the pointer to the raw vulkan pointer
      */

engine/render/renderer/platform/vulkan/Swapchain.cpp

@@ -10,7 +10,7 @@
 
 #include "Context.h"
 #include "utils/Device.h"
-#include "utils/Queue.h"
+#include "utils/SubmitCommands.h"
 #include "utils/Swapchain.h"
 #include "utils/TypeAdaptor.h"
 

engine/render/renderer/platform/vulkan/utils/Queue.h

@@ -6,7 +6,7 @@
 //      https://opensource.org/licenses/Zlib
 //
 
-#include "Queue.h"
+#include "SubmitCommands.h"
 
 #include <utils/Logging.h>
 

engine/render/renderer/platform/vulkan/utils/Queue.cpp renamed to engine/render/renderer/platform/vulkan/utils/SubmitCommands.cpp

@@ -0,0 +1,148 @@
+//
+//  Copyright (c) 2022 Jonathan Moallem (@J-Mo63) & Aryeh Zinn (@Raelr)
+//
+//  This code is released under an unmodified zlib license.
+//  For conditions of distribution and use, please see:
+//      https://opensource.org/licenses/Zlib
+//
+
+#ifndef SIEGE_ENGINE_SUBMIT_COMMANDS_H
+#define SIEGE_ENGINE_SUBMIT_COMMANDS_H
+
+#include <utils/collections/StackArray.h>
+#include <volk/volk.h>
+
+#include "Types.h"
+
+namespace Siege::Vulkan::Utils
+{
+
+/**
+ * Specifies the number of acceptable semaphores which can be submitted for signalling at any point
+ * in time
+ */
+static inline constexpr size_t MAX_SEMAPHORES = 10;
+
+/**
+ * The SubmitGraphicsCommand type handles all requirements for submitting draw commands to
+ * the GPU's graphics queue. The purpose is to act as a readable storage container for submitting
+ * graphics commands to the GPU
+ */
+struct SubmitGraphicsCommand
+{
+    /**
+     * The number of command buffers which can be submitted for any single command submission
+     */
+    static inline constexpr size_t MAX_COMMAND_BUFFERS = 10;
+
+    /**
+     * Specifies the Queue to submit to
+     * @param targetQueue the queue to submit commands to
+     * @return A reference to the command builder
+     */
+    SubmitGraphicsCommand& ToQueue(VkQueue targetQueue);
+
+    /**
+     * Specifies which semaphores to wait on before submitting the commands
+     * @param list a list of semaphores to wait on before submitting the commands
+     * @return A reference to the command builder
+     */
+    SubmitGraphicsCommand& WaitOnSemaphores(std::initializer_list<VkSemaphore> list);
+
+    /**
+     * Specifies which command buffers to submit to the graphics queue
+     * @param list a list of all command buffers to use for drawing
+     * @return A reference to the command builder
+     */
+    SubmitGraphicsCommand& WithCommandBuffers(std::initializer_list<VkCommandBuffer> list);
+
+    /**
+     * Specifies which semaphores to signal once the submission has completed
+     * @param list a list of semaphores to signal once submission is complete
+     * @return A reference to the command builder
+     */
+    SubmitGraphicsCommand& SignalSemaphores(std::initializer_list<VkSemaphore> list);
+
+    /**
+     * Specifies which pipeline stages the command applies to (vertex, fragment... etc)
+     * @param list a list of the pipeline stages the command will affect
+     * @return A reference to the command builder
+     */
+    SubmitGraphicsCommand& WithPipelineStages(std::initializer_list<VkPipelineStageFlags> list);
+
+    /**
+     * Submits the command to the graphics queue
+     * @param inFlightFence the per-frame fence the command should be submitted to
+     */
+    void Submit(VkFence inFlightFence);
+
+    VkQueue queue {VK_NULL_HANDLE};
+    ::Siege::Utils::MSArray<VkSemaphore, MAX_SEMAPHORES> waitSemaphores;
+    ::Siege::Utils::MSArray<VkCommandBuffer, MAX_COMMAND_BUFFERS> commandBuffers;
+    ::Siege::Utils::MSArray<VkSemaphore, MAX_SEMAPHORES> signalSemaphores;
+    ::Siege::Utils::MSArray<VkPipelineStageFlags, MAX_SEMAPHORES> waitDstStageMask;
+};
+
+/**
+ * The SubmitPresentCommand type handles all requirements for submitting commands to the present
+ * queue (the present queue actually handles the drawing of images to the screen). It acts as a
+ * storage container for all data required to submit commands to the present queue.
+ */
+struct SubmitPresentCommand
+{
+    /**
+     * The maximum number of swapchains to use for submission
+     */
+    static inline constexpr size_t MAX_SWAPCHAINS = 10;
+    /**
+     * The maximum number of images (represented by indices) which can be submitted at once
+     */
+    static inline constexpr size_t MAX_INDICES = 10;
+
+    /**
+     * Specifies the Queue to submit to
+     * @param targetQueue the queue to submit commands to
+     * @return A reference to the command builder
+     */
+    SubmitPresentCommand& ToQueue(VkQueue targetQueue);
+
+    /**
+     * Specifies which semaphores to signal once the submission has completed
+     * @param list a list of semaphores to signal once submission is complete
+     * @return A reference to the command builder
+     */
+    SubmitPresentCommand& SignalSemaphores(std::initializer_list<VkSemaphore> list);
+
+    /**
+     * Specifies which swapchains the command will apply to
+     * @param list a list of swapchains to use for submission
+     * @return A reference to the command builder
+     */
+    SubmitPresentCommand& ForSwapchains(std::initializer_list<VkSwapchainKHR> list);
+
+    /**
+     * Specifies which images to use for submission
+     * @param list a list of images to be used for presentation
+     * @return A reference to the command builder
+     */
+    SubmitPresentCommand& WithImageIndices(std::initializer_list<uint32_t> list);
+
+    /**
+     * @brief Submits the command to the present queue
+     * @return the result of the submission. Can return the following:\n
+     * SUCCESS - The submission was successful\n
+     * SUBOPTIMAL - The swapchain no longer matches the surface exactly (this can happen when a
+     * window is resized)\n OUT_OF_DATE - A surface has changed in such a way that the swapchain is
+     * no longer compatible with it\n RESIZED - The window has been resized and we must rebuild our
+     * swapchain to match the new extents\n
+     */
+    Utils::Result Submit();
+
+    VkQueue queue {VK_NULL_HANDLE};
+    ::Siege::Utils::MSArray<VkSemaphore, MAX_SEMAPHORES> signalSemaphores;
+    ::Siege::Utils::MSArray<VkSwapchainKHR, MAX_SWAPCHAINS> swapchains;
+    ::Siege::Utils::MSArray<uint32_t, MAX_INDICES> indices;
+};
+} // namespace Siege::Vulkan::Utils
+
+#endif // SIEGE_ENGINE_SUBMIT_COMMANDS_H

engine/render/renderer/platform/vulkan/utils/SubmitCommands.h

@@ -267,7 +267,7 @@ class MHArray
      * @param index the index of the element we want to check
      * @return `true` if this element has been set, `false` if it has not
      */
-    bool Active(size_t index) const
+    bool IsActive(size_t index) const
     {
         return bitField.IsSet(index + 1);
     }

engine/utils/collections/HeapArray.h

@@ -123,7 +123,7 @@ class MIter
     {
         ptr = arrPtr->Data() && arrPtr->Count() > 0 ? arrPtr : nullptr;
 
-        while (ptr && !ptr->Active(index)) index++;
+        while (ptr && !ptr->IsActive(index)) index++;
     }
 
     /**
@@ -136,7 +136,7 @@ class MIter
     {
         // If the next element in the array is invalid, keep incrementing until we find one that
         // is
-        while (ptr->Data() && !ptr->Active(index + 1)) index++;
+        while (ptr->Data() && !ptr->IsActive(index + 1)) index++;
 
         // TODO: Profile if using a reinterpret cast would be faster here
         ptr = index < ptr->Size() ? ptr : 0;

engine/utils/collections/Iterators.h

@@ -389,7 +389,7 @@ class MSArray
      * @param index the index of the element being searched for.
      * @return true if the index has been previously assigned to.
      */
-    inline bool Active(size_t index) const
+    inline bool IsActive(size_t index) const
     {
         return bitField.IsSet(index + 1);
     }

engine/utils/collections/StackArray.h

@@ -49,10 +49,10 @@ UTEST(test_MSArray, CreateHeapArrayFromRawArray)
     ASSERT_EQ(array.Size(), 4);
     ASSERT_NE(array.Data(), nullptr);
 
-    ASSERT_TRUE(array.Active(0));
-    ASSERT_TRUE(array.Active(1));
-    ASSERT_TRUE(array.Active(2));
-    ASSERT_TRUE(array.Active(3));
+    ASSERT_TRUE(array.IsActive(0));
+    ASSERT_TRUE(array.IsActive(1));
+    ASSERT_TRUE(array.IsActive(2));
+    ASSERT_TRUE(array.IsActive(3));
 
     ASSERT_EQ(array[0], 1);
     ASSERT_EQ(array[1], 2);
@@ -187,12 +187,12 @@ UTEST(test_HeapArray, CheckElementIsActive)
 
     array[0] = 1;
 
-    ASSERT_TRUE(array.Active(0));
-    ASSERT_FALSE(array.Active(1));
+    ASSERT_TRUE(array.IsActive(0));
+    ASSERT_FALSE(array.IsActive(1));
 
     array[1] = 2;
 
-    ASSERT_TRUE(array.Active(1));
+    ASSERT_TRUE(array.IsActive(1));
 }
 
 UTEST(test_HeapArray, RemoveElementByIndex)
@@ -202,22 +202,22 @@ UTEST(test_HeapArray, RemoveElementByIndex)
     array[0] = 1;
 
     ASSERT_EQ(array.Count(), 1);
-    ASSERT_TRUE(array.Active(0));
+    ASSERT_TRUE(array.IsActive(0));
 
     array[1] = 2;
 
     ASSERT_EQ(array.Count(), 2);
-    ASSERT_TRUE(array.Active(1));
+    ASSERT_TRUE(array.IsActive(1));
 
     array.Remove(1);
 
     ASSERT_EQ(array.Count(), 1);
-    ASSERT_FALSE(array.Active(1));
+    ASSERT_FALSE(array.IsActive(1));
 
     array.Remove(0);
 
     ASSERT_EQ(array.Count(), 0);
-    ASSERT_FALSE(array.Active(0));
+    ASSERT_FALSE(array.IsActive(0));
 }
 
 UTEST(test_HeapArray, CopyArray)
@@ -519,14 +519,14 @@ UTEST(test_MHArray, ResizeArray)
     ASSERT_EQ(array[2], 3);
     ASSERT_EQ(array[3], 4);
 
-    ASSERT_FALSE(array.Active(4));
-    ASSERT_FALSE(array.Active(5));
+    ASSERT_FALSE(array.IsActive(4));
+    ASSERT_FALSE(array.IsActive(5));
 
     array[4] = 5;
     array[5] = 6;
 
-    ASSERT_TRUE(array.Active(4));
-    ASSERT_TRUE(array.Active(5));
+    ASSERT_TRUE(array.IsActive(4));
+    ASSERT_TRUE(array.IsActive(5));
 
     ASSERT_EQ(array[4], 5);
     ASSERT_EQ(array[5], 6);
@@ -553,10 +553,10 @@ UTEST(test_MHArray, ResizeArrayToSmallerSize)
     ASSERT_EQ(array[0], 1);
     ASSERT_EQ(array[1], 2);
 
-    ASSERT_TRUE(array.Active(0));
-    ASSERT_TRUE(array.Active(1));
-    ASSERT_FALSE(array.Active(2));
-    ASSERT_FALSE(array.Active(3));
+    ASSERT_TRUE(array.IsActive(0));
+    ASSERT_TRUE(array.IsActive(1));
+    ASSERT_FALSE(array.IsActive(2));
+    ASSERT_FALSE(array.IsActive(3));
 }
 
 UTEST(test_MHArray, ResizeLargeArray)
@@ -575,7 +575,7 @@ UTEST(test_MHArray, ResizeLargeArray)
     ASSERT_EQ(array.Size(), 9);
     ASSERT_EQ(array.Count(), 9);
 
-    ASSERT_FALSE(array.Active(9));
+    ASSERT_FALSE(array.IsActive(9));
 }
 
 UTEST(test_MHArray, ClearArray)
@@ -593,8 +593,8 @@ UTEST(test_MHArray, ClearArray)
     ASSERT_EQ(array.Size(), 2);
     ASSERT_EQ(array.Count(), 0);
 
-    ASSERT_FALSE(array.Active(0));
-    ASSERT_FALSE(array.Active(1));
+    ASSERT_FALSE(array.IsActive(0));
+    ASSERT_FALSE(array.IsActive(1));
 }
 
 UTEST(test_MHArray, ClearEmptyArray)