Feature/vulkan first render (#545)

* First pass at InputLayout for Vulkan
Add support for RGBA_Float32

* Use VulkanModule and VulkanApi to handle accessing Vulkan types.

* First pass at Vulkan swap chain/Device queue.

* Added VulkanUtil for generic function functions.

* Move more functionality to VulkanApi and VulkanUtil.
Make Buffer able to initialize itself.

* More tidy up around VulkanDeviceQueue

* First pass use of VulkanDeviceQueue in VkRenderer

* First pass use of VulkanSwapChain on VkRenderer

* Added depth formats.
Binding for constant and vertex buffers for Vulkan.

* Setting up VkImageView on backbuffers.

* First pass support for setting up vkRenderPass.

* Fixes to work around Vulkan swap chain/verification issues.

* Added support for Pipeline and a pipeline cache.

* Working without waiting - because use of pipeline cache.

* Added support for VkFramebuffer in Vulkan.

* First pass at creating Vulkan graphics pipeline.

* More efforts to get Vulkan to render.

* Small improvement for checking of Binding flags.

* Removed setConstantBuffers from the Renderer interface - so that all resource binding takes place through the BindingState.
To make this work required a 'hack' in render-test main.cpp - so that the constant buffer binding that is needed in some tests is only added when it doesn't clash.

* RendererID -> unified into RendererType. Added getRendererType to Renderer interface.
Added ProjectionStyle, and function to get from RendererType.
Added getIdentityProjection to RendererUtil - to get projection that is the 'identity' - but hits the same pixels for all projection styles.

* Fix build problem on Win32 on Vulkan where should use VK_NULL_HANDLE.

* Improve naming, comments. Remove dead code.

* Remove unwanted comment.

1 files changed, 95 insertions, 0 deletions

diff --git a/tools/render-test/vk-device-queue.h b/tools/render-test/vk-device-queue.h
new file mode 100644
index 000000000..ea50cbd81
--- /dev/null
+++ b/tools/render-test/vk-device-queue.h
@@ -0,0 +1,95 @@
+// vk-swap-chain.h
+#pragma once
+
+#include "vk-api.h"
+
+namespace renderer_test {
+
+struct VulkanDeviceQueue
+{
+    enum 
+    {
+        kMaxCommandBuffers = 8,
+    };
+
+    enum class EventType
+    {
+        BeginFrame,
+        EndFrame,
+        CountOf,
+    };
+
+        /// Initialize - must be called before anything else can be done
+    SlangResult init(const VulkanApi& api, VkQueue queue, int queueIndex);
+
+        /// Flushes the current command list, and steps to next (internally this is equivalent to a stepA followed by stepB)
+    void flush();
+        /// Performs a full flush, and then waits for idle. 
+    void flushAndWait();
+
+        /// Blocks until all work submitted to GPU has completed
+    void waitForIdle() { m_api->vkQueueWaitIdle(m_queue); }
+
+        /// Set the graphics queue index (as set on init)
+    int getQueueIndex() const { return m_queueIndex; }
+
+
+        /// Make the specified event 'current' - meaning it's semaphone must be waited on
+    VkSemaphore makeCurrent(EventType eventType);
+        /// Makes the event no longer required to be waited on
+    void makeCompleted(EventType eventType);
+        /// Returns true if the event is already current
+    SLANG_FORCE_INLINE bool isCurrent(EventType eventType) const { return m_currentSemaphores[int(eventType)] != VK_NULL_HANDLE; }
+
+        /// Get the command buffer
+    VkCommandBuffer getCommandBuffer() const { return m_commandBuffer; }
+
+        /// Get the queue
+    VkQueue getQueue() const { return m_queue; }
+
+        /// Get the API
+    const VulkanApi* getApi() const { return m_api; }
+
+        /// Flushes the current command list 
+    void flushStepA();
+        /// Steps to next command buffer and opens. May block if command buffer is still in use
+    void flushStepB();
+
+        /// Dtor
+    ~VulkanDeviceQueue();
+
+    protected:
+        
+    struct Fence
+    {
+        VkFence fence;
+        bool active;
+        uint64_t value;
+    };
+
+    void _updateFenceAtIndex(int fenceIndex, bool blocking);
+
+    VkQueue m_queue = VK_NULL_HANDLE;
+
+    VkCommandPool m_commandPool = VK_NULL_HANDLE;
+    int m_numCommandBuffers = 0;
+    int m_commandBufferIndex = 0;
+    // There are the same amount of command buffers as fences
+    VkCommandBuffer m_commandBuffers[kMaxCommandBuffers] = { VK_NULL_HANDLE };
+
+    Fence m_fences[kMaxCommandBuffers] = { {VK_NULL_HANDLE, 0, 0u} };
+    
+    VkCommandBuffer m_commandBuffer = VK_NULL_HANDLE;
+
+    VkSemaphore m_semaphores[int(EventType::CountOf)];
+    VkSemaphore m_currentSemaphores[int(EventType::CountOf)];
+
+    uint64_t m_lastFenceCompleted = 1;
+    uint64_t m_nextFenceValue = 2;
+
+    int m_queueIndex = 0;
+
+    const VulkanApi* m_api = nullptr;
+};
+
+} // renderer_test