A thin, but real RHI

Axiom/RHI/IRHI.h

@@ -19,6 +19,16 @@ enum class RHIPipelineType : uint8_t {
   Compute,
 };
 
+enum class RHIBindPoint : uint8_t {
+  Graphics = 0,
+  Compute,
+};
+
+enum class RHIIndexType : uint8_t {
+  UInt16 = 0,
+  UInt32,
+};
+
 enum class RHICommandStage : uint8_t {
   All = 0,
   Draw,
@@ -118,6 +128,8 @@ class IRHISwapchain;
 class IRHIFence;
 class IRHISemaphore;
 
+using RHINativeHandle = uintptr_t;
+
 struct RHIQueueWaitInfo {
   IRHISemaphore *Semaphore{nullptr};
   uint64_t Value{0};
@@ -138,6 +150,44 @@ class IRHICommandList {
   virtual void End() = 0;
   [[nodiscard]] virtual bool IsRecording() const = 0;
   [[nodiscard]] virtual RHIQueueType GetQueueType() const = 0;
+  [[nodiscard]] virtual RHINativeHandle GetNativeCommandBuffer() const = 0;
+
+  virtual void BeginRendering(const void *RenderingInfo) = 0;
+  virtual void EndRendering() = 0;
+  virtual void SetViewport(const void *Viewport) = 0;
+  virtual void SetScissor(const void *Scissor) = 0;
+  virtual void BindPipeline(RHIBindPoint BindPoint,
+                            RHINativeHandle Pipeline) = 0;
+  virtual void BindDescriptorSet(RHIBindPoint BindPoint,
+                                 RHINativeHandle PipelineLayout,
+                                 uint32_t FirstSet,
+                                 std::span<const RHINativeHandle> Sets) = 0;
+  virtual void PushConstants(RHINativeHandle PipelineLayout,
+                             uint32_t ShaderStages, uint32_t Offset,
+                             uint32_t Size, const void *Data) = 0;
+  virtual void BindVertexBuffer(uint32_t FirstBinding, RHINativeHandle Buffer,
+                                uint64_t Offset) = 0;
+  virtual void BindIndexBuffer(RHINativeHandle Buffer, uint64_t Offset,
+                               RHIIndexType IndexType) = 0;
+  virtual void DrawIndexed(uint32_t IndexCount, uint32_t InstanceCount,
+                           uint32_t FirstIndex, int32_t VertexOffset,
+                           uint32_t FirstInstance) = 0;
+  virtual void DrawIndexedIndirect(RHINativeHandle Buffer, uint64_t Offset,
+                                   uint32_t DrawCount, uint32_t Stride) = 0;
+  virtual void Dispatch(uint32_t GroupCountX, uint32_t GroupCountY,
+                        uint32_t GroupCountZ) = 0;
+  virtual void CopyBuffer(RHINativeHandle SourceBuffer,
+                          RHINativeHandle DestinationBuffer,
+                          const void *CopyRegion) = 0;
+  virtual void CopyBufferToImage(RHINativeHandle SourceBuffer,
+                                 RHINativeHandle DestinationImage,
+                                 uint32_t DestinationImageLayout,
+                                 const void *CopyRegion) = 0;
+  virtual void CopyImageToBuffer(RHINativeHandle SourceImage,
+                                 uint32_t SourceImageLayout,
+                                 RHINativeHandle DestinationBuffer,
+                                 const void *CopyRegion) = 0;
+  virtual void PipelineBarrier(const void *DependencyInfo) = 0;
 };
 
 class IRHIQueue {

AxiomInternal/AxiomRHI/Vulkan/VulkanDrawSubmissionSystem.cpp

@@ -96,7 +96,7 @@ void VulkanDrawSubmissionSystem::Init(const CreateInfo &CreateInfo) {
 }
 
 void VulkanDrawSubmissionSystem::SetRecordPreparedScenePasses(
-    std::function<void(VkCommandBuffer, RenderScene &, uint64_t, RendererViewMode)>
+    std::function<void(IRHICommandList &, RenderScene &, uint64_t, RendererViewMode)>
         RecordPreparedScenePasses) {
   m_RecordPreparedScenePasses = std::move(RecordPreparedScenePasses);
 }
@@ -396,14 +396,14 @@ void VulkanDrawSubmissionSystem::ClearDepthImage(VkCommandBuffer CommandBuffer,
                           PreviousLayout, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL);
 }
 
-void VulkanDrawSubmissionSystem::DrawMeshes(VkCommandBuffer CommandBuffer,
+void VulkanDrawSubmissionSystem::DrawMeshes(IRHICommandList &CommandList,
                                             RenderScene &Scene,
                                             uint64_t FrameNumber,
                                             RendererViewMode ViewMode) {
   if (!m_RecordPreparedScenePasses) {
     return;
   }
-  m_RecordPreparedScenePasses(CommandBuffer, Scene, FrameNumber, ViewMode);
+  m_RecordPreparedScenePasses(CommandList, Scene, FrameNumber, ViewMode);
 }
 
 void VulkanDrawSubmissionSystem::RecordOffscreenCapture(
@@ -629,7 +629,7 @@ void VulkanDrawSubmissionSystem::DrawFrame(const FrameRequest &Request) {
                        VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT,
                        MeshFrame.TimestampQueryPool, 2);
   if (Request.ActiveScene != nullptr) {
-    DrawMeshes(CommandBuffer, *Request.ActiveScene, Request.FrameNumber,
+    DrawMeshes(CommandList, *Request.ActiveScene, Request.FrameNumber,
                Request.ViewMode);
   }
   vkCmdWriteTimestamp2(CommandBuffer,

AxiomInternal/AxiomRHI/Vulkan/VulkanDrawSubmissionSystem.h

@@ -2,6 +2,7 @@
 
 #include "Renderer/RenderScene.h"
 #include "Renderer/RenderSurface.h"
+#include "RHI/IRHI.h"
 #include "AxiomRHI/Vulkan/VulkanCommandContext.h"
 #include "AxiomRHI/Vulkan/VulkanDeletionQueue.h"
 #include "AxiomRHI/Vulkan/VulkanDevice.h"
@@ -34,7 +35,7 @@ class VulkanDrawSubmissionSystem {
     VulkanOcclusionCulling &OcclusionCulling;
     bool EnableImGui{false};
     bool HasPresentationSurface{false};
-    std::function<void(VkCommandBuffer, RenderScene &, uint64_t,
+    std::function<void(IRHICommandList &, RenderScene &, uint64_t,
                        RendererViewMode)>
         RecordPreparedScenePasses;
     std::function<void()> DestroyResourceManagerHDRTexture;
@@ -51,7 +52,7 @@ class VulkanDrawSubmissionSystem {
   void Init(const CreateInfo &CreateInfo);
   void Shutdown();
   void SetRecordPreparedScenePasses(
-      std::function<void(VkCommandBuffer, RenderScene &, uint64_t,
+      std::function<void(IRHICommandList &, RenderScene &, uint64_t,
                          RendererViewMode)> RecordPreparedScenePasses);
 
   void BeginFrame(bool StopRendering);
@@ -80,7 +81,7 @@ class VulkanDrawSubmissionSystem {
   void CollectCompletedTransfers();
   void CollectFrameStats(MeshFrameResources &Frame);
   void ClearDepthImage(VkCommandBuffer CommandBuffer, uint64_t FrameNumber);
-  void DrawMeshes(VkCommandBuffer CommandBuffer, RenderScene &Scene,
+  void DrawMeshes(IRHICommandList &CommandList, RenderScene &Scene,
                   uint64_t FrameNumber, RendererViewMode ViewMode);
   void RecordOffscreenCapture(VkCommandBuffer CommandBuffer,
                               const AllocatedBuffer &ReadbackBuffer,
@@ -108,7 +109,7 @@ class VulkanDrawSubmissionSystem {
   bool m_EnableImGui{false};
   bool m_HasPresentationSurface{false};
   bool m_IsInitialized{false};
-  std::function<void(VkCommandBuffer, RenderScene &, uint64_t, RendererViewMode)>
+  std::function<void(IRHICommandList &, RenderScene &, uint64_t, RendererViewMode)>
       m_RecordPreparedScenePasses;
 
   VulkanGizmoRenderer m_GizmoRenderer;

AxiomInternal/AxiomRHI/Vulkan/VulkanRhiObjects.cpp

@@ -31,6 +31,146 @@ void VulkanCommandList::End() {
   m_IsRecording = false;
 }
 
+void VulkanCommandList::BeginRendering(const void *RenderingInfo) {
+  vkCmdBeginRendering(
+      m_CommandBuffer, static_cast<const VkRenderingInfo *>(RenderingInfo));
+}
+
+void VulkanCommandList::EndRendering() { vkCmdEndRendering(m_CommandBuffer); }
+
+void VulkanCommandList::SetViewport(const void *Viewport) {
+  vkCmdSetViewport(m_CommandBuffer, 0, 1,
+                   static_cast<const VkViewport *>(Viewport));
+}
+
+void VulkanCommandList::SetScissor(const void *Scissor) {
+  vkCmdSetScissor(m_CommandBuffer, 0, 1, static_cast<const VkRect2D *>(Scissor));
+}
+
+void VulkanCommandList::BindPipeline(RHIBindPoint BindPoint,
+                                     RHINativeHandle Pipeline) {
+  vkCmdBindPipeline(m_CommandBuffer, ToVulkanBindPoint(BindPoint),
+                    DecodeNativeHandle<VkPipeline>(Pipeline));
+}
+
+void VulkanCommandList::BindDescriptorSet(
+    RHIBindPoint BindPoint, RHINativeHandle PipelineLayout, uint32_t FirstSet,
+    std::span<const RHINativeHandle> Sets) {
+  std::vector<VkDescriptorSet> DescriptorSets;
+  DescriptorSets.reserve(Sets.size());
+  for (RHINativeHandle Set : Sets) {
+    DescriptorSets.push_back(DecodeNativeHandle<VkDescriptorSet>(Set));
+  }
+
+  vkCmdBindDescriptorSets(
+      m_CommandBuffer, ToVulkanBindPoint(BindPoint),
+      DecodeNativeHandle<VkPipelineLayout>(PipelineLayout), FirstSet,
+      static_cast<uint32_t>(DescriptorSets.size()), DescriptorSets.data(), 0,
+      VK_NULL_HANDLE);
+}
+
+void VulkanCommandList::PushConstants(RHINativeHandle PipelineLayout,
+                                      uint32_t ShaderStages, uint32_t Offset,
+                                      uint32_t Size, const void *Data) {
+  vkCmdPushConstants(m_CommandBuffer,
+                     DecodeNativeHandle<VkPipelineLayout>(PipelineLayout),
+                     static_cast<VkShaderStageFlags>(ShaderStages), Offset, Size,
+                     Data);
+}
+
+void VulkanCommandList::BindVertexBuffer(uint32_t FirstBinding,
+                                         RHINativeHandle Buffer,
+                                         uint64_t Offset) {
+  const VkBuffer VulkanBuffer = DecodeNativeHandle<VkBuffer>(Buffer);
+  const VkDeviceSize VulkanOffset = static_cast<VkDeviceSize>(Offset);
+  vkCmdBindVertexBuffers(m_CommandBuffer, FirstBinding, 1, &VulkanBuffer,
+                         &VulkanOffset);
+}
+
+void VulkanCommandList::BindIndexBuffer(RHINativeHandle Buffer, uint64_t Offset,
+                                        RHIIndexType IndexType) {
+  vkCmdBindIndexBuffer(m_CommandBuffer, DecodeNativeHandle<VkBuffer>(Buffer),
+                       static_cast<VkDeviceSize>(Offset),
+                       ToVulkanIndexType(IndexType));
+}
+
+void VulkanCommandList::DrawIndexed(uint32_t IndexCount, uint32_t InstanceCount,
+                                    uint32_t FirstIndex, int32_t VertexOffset,
+                                    uint32_t FirstInstance) {
+  vkCmdDrawIndexed(m_CommandBuffer, IndexCount, InstanceCount, FirstIndex,
+                   VertexOffset, FirstInstance);
+}
+
+void VulkanCommandList::DrawIndexedIndirect(RHINativeHandle Buffer,
+                                            uint64_t Offset, uint32_t DrawCount,
+                                            uint32_t Stride) {
+  vkCmdDrawIndexedIndirect(m_CommandBuffer, DecodeNativeHandle<VkBuffer>(Buffer),
+                           static_cast<VkDeviceSize>(Offset), DrawCount, Stride);
+}
+
+void VulkanCommandList::Dispatch(uint32_t GroupCountX, uint32_t GroupCountY,
+                                 uint32_t GroupCountZ) {
+  vkCmdDispatch(m_CommandBuffer, GroupCountX, GroupCountY, GroupCountZ);
+}
+
+void VulkanCommandList::CopyBuffer(RHINativeHandle SourceBuffer,
+                                   RHINativeHandle DestinationBuffer,
+                                   const void *CopyRegion) {
+  vkCmdCopyBuffer(m_CommandBuffer, DecodeNativeHandle<VkBuffer>(SourceBuffer),
+                  DecodeNativeHandle<VkBuffer>(DestinationBuffer), 1,
+                  static_cast<const VkBufferCopy *>(CopyRegion));
+}
+
+void VulkanCommandList::CopyBufferToImage(RHINativeHandle SourceBuffer,
+                                          RHINativeHandle DestinationImage,
+                                          uint32_t DestinationImageLayout,
+                                          const void *CopyRegion) {
+  vkCmdCopyBufferToImage(
+      m_CommandBuffer, DecodeNativeHandle<VkBuffer>(SourceBuffer),
+      DecodeNativeHandle<VkImage>(DestinationImage),
+      static_cast<VkImageLayout>(DestinationImageLayout), 1,
+      static_cast<const VkBufferImageCopy *>(CopyRegion));
+}
+
+void VulkanCommandList::CopyImageToBuffer(RHINativeHandle SourceImage,
+                                          uint32_t SourceImageLayout,
+                                          RHINativeHandle DestinationBuffer,
+                                          const void *CopyRegion) {
+  vkCmdCopyImageToBuffer(
+      m_CommandBuffer, DecodeNativeHandle<VkImage>(SourceImage),
+      static_cast<VkImageLayout>(SourceImageLayout),
+      DecodeNativeHandle<VkBuffer>(DestinationBuffer), 1,
+      static_cast<const VkBufferImageCopy *>(CopyRegion));
+}
+
+void VulkanCommandList::PipelineBarrier(const void *DependencyInfo) {
+  vkCmdPipelineBarrier2(
+      m_CommandBuffer, static_cast<const VkDependencyInfo *>(DependencyInfo));
+}
+
+VkPipelineBindPoint
+VulkanCommandList::ToVulkanBindPoint(RHIBindPoint BindPoint) {
+  switch (BindPoint) {
+  case RHIBindPoint::Graphics:
+    return VK_PIPELINE_BIND_POINT_GRAPHICS;
+  case RHIBindPoint::Compute:
+    return VK_PIPELINE_BIND_POINT_COMPUTE;
+  }
+
+  return VK_PIPELINE_BIND_POINT_GRAPHICS;
+}
+
+VkIndexType VulkanCommandList::ToVulkanIndexType(RHIIndexType IndexType) {
+  switch (IndexType) {
+  case RHIIndexType::UInt16:
+    return VK_INDEX_TYPE_UINT16;
+  case RHIIndexType::UInt32:
+    return VK_INDEX_TYPE_UINT32;
+  }
+
+  return VK_INDEX_TYPE_UINT32;
+}
+
 VulkanFence::~VulkanFence() {
   if (m_OwnsFence && m_Device != VK_NULL_HANDLE && m_Fence != VK_NULL_HANDLE) {
     vkDestroyFence(m_Device, m_Fence, VK_NULL_HANDLE);

AxiomInternal/AxiomRHI/Vulkan/VulkanRhiObjects.h

@@ -5,6 +5,7 @@
 #include "AxiomRHI/Vulkan/VulkanTypes.h"
 
 #include <memory>
+#include <type_traits>
 
 namespace Axiom {
 class VulkanCommandList final : public IRHICommandList {
@@ -18,10 +19,67 @@ class VulkanCommandList final : public IRHICommandList {
   void End() override;
   bool IsRecording() const override { return m_IsRecording; }
   RHIQueueType GetQueueType() const override { return m_QueueType; }
+  RHINativeHandle GetNativeCommandBuffer() const override {
+    return EncodeNativeHandle(m_CommandBuffer);
+  }
 
   VkCommandBuffer GetCommandBuffer() const { return m_CommandBuffer; }
+  void BeginRendering(const void *RenderingInfo) override;
+  void EndRendering() override;
+  void SetViewport(const void *Viewport) override;
+  void SetScissor(const void *Scissor) override;
+  void BindPipeline(RHIBindPoint BindPoint, RHINativeHandle Pipeline) override;
+  void BindDescriptorSet(RHIBindPoint BindPoint, RHINativeHandle PipelineLayout,
+                         uint32_t FirstSet,
+                         std::span<const RHINativeHandle> Sets) override;
+  void PushConstants(RHINativeHandle PipelineLayout, uint32_t ShaderStages,
+                     uint32_t Offset, uint32_t Size, const void *Data) override;
+  void BindVertexBuffer(uint32_t FirstBinding, RHINativeHandle Buffer,
+                        uint64_t Offset) override;
+  void BindIndexBuffer(RHINativeHandle Buffer, uint64_t Offset,
+                       RHIIndexType IndexType) override;
+  void DrawIndexed(uint32_t IndexCount, uint32_t InstanceCount,
+                   uint32_t FirstIndex, int32_t VertexOffset,
+                   uint32_t FirstInstance) override;
+  void DrawIndexedIndirect(RHINativeHandle Buffer, uint64_t Offset,
+                           uint32_t DrawCount, uint32_t Stride) override;
+  void Dispatch(uint32_t GroupCountX, uint32_t GroupCountY,
+                uint32_t GroupCountZ) override;
+  void CopyBuffer(RHINativeHandle SourceBuffer,
+                  RHINativeHandle DestinationBuffer,
+                  const void *CopyRegion) override;
+  void CopyBufferToImage(RHINativeHandle SourceBuffer,
+                         RHINativeHandle DestinationImage,
+                         uint32_t DestinationImageLayout,
+                         const void *CopyRegion) override;
+  void CopyImageToBuffer(RHINativeHandle SourceImage,
+                         uint32_t SourceImageLayout,
+                         RHINativeHandle DestinationBuffer,
+                         const void *CopyRegion) override;
+  void PipelineBarrier(const void *DependencyInfo) override;
+
+  template <typename VulkanHandle>
+  static RHINativeHandle EncodeNativeHandle(VulkanHandle Handle) {
+    if constexpr (std::is_pointer_v<VulkanHandle>) {
+      return reinterpret_cast<RHINativeHandle>(Handle);
+    } else {
+      return static_cast<RHINativeHandle>(Handle);
+    }
+  }
 
 private:
+  template <typename VulkanHandle>
+  static VulkanHandle DecodeNativeHandle(RHINativeHandle Handle) {
+    if constexpr (std::is_pointer_v<VulkanHandle>) {
+      return reinterpret_cast<VulkanHandle>(Handle);
+    } else {
+      return static_cast<VulkanHandle>(Handle);
+    }
+  }
+
+  static VkPipelineBindPoint ToVulkanBindPoint(RHIBindPoint BindPoint);
+  static VkIndexType ToVulkanIndexType(RHIIndexType IndexType);
+
   VkDevice m_Device{VK_NULL_HANDLE};
   VkCommandPool m_CommandPool{VK_NULL_HANDLE};
   VkCommandBuffer m_CommandBuffer{VK_NULL_HANDLE};