Ray Tracing Pipeline

include/nbl/asset/ECommonEnums.h

@@ -11,7 +11,7 @@ enum E_PIPELINE_BIND_POINT : uint8_t
 {
     EPBP_GRAPHICS = 0,
     EPBP_COMPUTE,
-
+    EPBP_RAY_TRACING,
     EPBP_COUNT
 };
 

include/nbl/asset/IPipeline.h

@@ -54,45 +54,57 @@ class IPipeline
 					// Compute Pipelines only
 					//DISPATCH_BASE = 1<<4,
 
-					// Weird extension
+					// This is for NV-raytracing extension. Now this is done via IDeferredOperation
 					//DEFER_COMPILE_NV = 1<<5,
 
-					CAPTURE_STATISTICS = 1<<6,
-					CAPTURE_INTERNAL_REPRESENTATIONS = 1<<7,
+					// We use Renderdoc to take care of this for us,
+					// we won't be parsing the statistics and internal representation ourselves.
+					//CAPTURE_STATISTICS = 1<<6,
+					//CAPTURE_INTERNAL_REPRESENTATIONS = 1<<7,
 
-					// We require Pipeline Cache Control feature so those are satisfied:
-					// https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VkComputePipelineCreateInfo.html#VUID-VkComputePipelineCreateInfo-pipelineCreationCacheControl-02875
+					// Will soon be deprecated due to
+					// https://github.com/Devsh-Graphics-Programming/Nabla/issues/854
 					FAIL_ON_PIPELINE_COMPILE_REQUIRED = 1<<8,
 					EARLY_RETURN_ON_FAILURE = 1<<9,
 
-					LINK_TIME_OPTIMIZATION = 1<<10,
+					// Will be exposed later with the IPipelineLibrary asset implementation
+					// https://github.com/Devsh-Graphics-Programming/Nabla/issues/853
+					//LINK_TIME_OPTIMIZATION = 1<<10,
 
-					//Not Supported Yet
+					// Won't be exposed because we'll introduce Libraries as a separate object/asset-type
+					// https://github.com/Devsh-Graphics-Programming/Nabla/issues/853
 					//CREATE_LIBRARY = 1<<11,
 
 					// Ray Tracing Pipelines only
-					//RAY_TRACING_SKIP_TRIANGLES_BIT_KHR = 1<<12,
-					//RAY_TRACING_SKIP_AABBS_BIT_KHR = 1<<13,
-					//RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR = 1<<14,
-					//RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR = 1<<15,
-					//RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR = 1<<16,
-					//RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR = 1<<17,
-
-					// Not Supported Yet
+					//SKIP_BUILT_IN_PRIMITIVES = 1<<12,
+					//SKIP_AABBS = 1<<13,
+					//NO_NULL_ANY_HIT_SHADERS = 1<<14,
+					//NO_NULL_CLOSEST_HIT_SHADERS = 1<<15,
+					//NO_NULL_MISS_SHADERS = 1<<16,
+					//NO_NULL_INTERSECTION_SHADERS = 1<<17,
+
+					// There is a new Device Generated Commands extension with its own flag that will deprecate this
 					//INDIRECT_BINDABLE_NV = 1<<18,
 
 					// Ray Tracing Pipelines only
+          // For debug tools
 					//RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR = 1<<19,
-					//RAY_TRACING_ALLOW_MOTION_BIT_NV = 1<<20,
+
+					// Ray Tracing Pipelines only
+					//ALLOW_MOTION = 1<<20,
 
 					// Graphics Pipelineonly (we don't support subpass shading)
 					//RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 1<<21,
 					//RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT = 1<<22,
 
-					RETAIN_LINK_TIME_OPTIMIZATION_INFO = 1<<23,
+					// Will be exposed later with the IPipelineLibrary asset implementation
+					// https://github.com/Devsh-Graphics-Programming/Nabla/issues/853
+					//RETAIN_LINK_TIME_OPTIMIZATION_INFO = 1<<23,
 
 					// Ray Tracing Pipelines only
 					//RAY_TRACING_OPACITY_MICROMAP_BIT_EXT = 1<<24,
+
+					// Not supported yet, and we will move to dynamic rendering, so this might never be supported
 					//COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 1<<25,
 					//DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 1<<26,
 
@@ -107,7 +119,8 @@ class IPipeline
 		inline const PipelineLayout* getLayout() const {return m_layout.get();}
 
 	protected:
-		inline IPipeline(core::smart_refctd_ptr<const PipelineLayout>&& _layout) : m_layout(std::move(_layout)) {}
+		inline IPipeline(core::smart_refctd_ptr<const PipelineLayout>&& _layout)
+      : m_layout(std::move(_layout)) {}
 
 		core::smart_refctd_ptr<const PipelineLayout> m_layout;
 };

include/nbl/asset/IRayTracingPipeline.h

@@ -0,0 +1,207 @@
+#ifndef _NBL_ASSET_I_RAY_TRACING_PIPELINE_H_INCLUDED_
+#define _NBL_ASSET_I_RAY_TRACING_PIPELINE_H_INCLUDED_
+
+#include "nbl/asset/IShader.h"
+#include "nbl/asset/IPipeline.h"
+
+#include <span>
+#include <bit>
+#include <type_traits>
+
+namespace nbl::asset
+{
+
+class IRayTracingPipelineBase : public virtual core::IReferenceCounted
+{
+  public:
+    struct SShaderGroupsParams
+    {
+      struct SIndex
+      {
+        constexpr static inline uint32_t Unused = 0xffFFffFFu;
+        uint32_t index = Unused;
+      };
+
+      struct SHitGroup
+      {
+        uint32_t closestHit = SIndex::Unused;
+        uint32_t anyHit = SIndex::Unused;
+        uint32_t intersection = SIndex::Unused;
+      };
+
+      SIndex raygen;
+      std::span<SIndex> misses;
+      std::span<SHitGroup> hits;
+      std::span<SIndex> callables;
+
+      inline uint32_t getShaderGroupCount() const
+      {
+        return 1 + hits.size() + misses.size() + callables.size();
+      }
+
+    };
+    using SGeneralShaderGroup = SShaderGroupsParams::SIndex;
+    using SHitShaderGroup = SShaderGroupsParams::SHitGroup;
+
+    struct SCachedCreationParams final
+    {
+      uint32_t maxRecursionDepth : 6 = 0;
+      uint32_t dynamicStackSize : 1 = false;
+    };
+};
+
+template<typename PipelineLayoutType, typename ShaderType>
+class IRayTracingPipeline : public IPipeline<PipelineLayoutType>, public IRayTracingPipelineBase
+{
+    using base_creation_params_t = IPipeline<PipelineLayoutType>::SCreationParams;
+  public:
+
+    using SGeneralShaderGroupContainer = core::smart_refctd_dynamic_array<SGeneralShaderGroup>;
+    using SHitShaderGroupContainer = core::smart_refctd_dynamic_array<SHitShaderGroup>;
+
+    struct SCreationParams : base_creation_params_t
+    {
+      public:
+      #define base_flag(F) static_cast<uint64_t>(base_creation_params_t::FLAGS::F)
+      enum class FLAGS : uint64_t
+      {
+          NONE = base_flag(NONE),
+          DISABLE_OPTIMIZATIONS = base_flag(DISABLE_OPTIMIZATIONS),
+          ALLOW_DERIVATIVES = base_flag(ALLOW_DERIVATIVES),
+          FAIL_ON_PIPELINE_COMPILE_REQUIRED = base_flag(FAIL_ON_PIPELINE_COMPILE_REQUIRED),
+          EARLY_RETURN_ON_FAILURE = base_flag(EARLY_RETURN_ON_FAILURE),
+          SKIP_BUILT_IN_PRIMITIVES = 1<<12,
+          SKIP_AABBS = 1<<13,
+          NO_NULL_ANY_HIT_SHADERS = 1<<14,
+          NO_NULL_CLOSEST_HIT_SHADERS = 1<<15,
+          NO_NULL_MISS_SHADERS = 1<<16,
+          NO_NULL_INTERSECTION_SHADERS = 1<<17,
+          ALLOW_MOTION = 1<<20,
+      };
+      #undef base_flag
+
+      protected:
+        using SpecInfo = ShaderType::SSpecInfo;
+        template<typename ExtraLambda>
+        inline bool impl_valid(ExtraLambda&& extra) const
+        {
+          if (!IPipeline<PipelineLayoutType>::SCreationParams::layout)
+            return false;
+
+          for (const auto info : shaders)
+          {
+            if (info.shader)
+            {
+              if (!extra(info))
+                return false;
+              const auto stage = info.shader->getStage();
+              if ((stage & ~ICPUShader::E_SHADER_STAGE::ESS_ALL_RAY_TRACING) != 0)
+                return false;
+              if (!std::has_single_bit<std::underlying_type_t<ICPUShader::E_SHADER_STAGE>>(stage))
+                return false;
+            }
+            else
+            {
+              // every shader must not be null. use SIndex::Unused to represent unused shader.
+              return false;
+            }
+          }
+
+          auto getShaderStage = [this](size_t index) -> ICPUShader::E_SHADER_STAGE
+            {
+              return shaders[index].shader->getStage();
+            };
+
+          auto isValidShaderIndex = [this, getShaderStage](size_t index, ICPUShader::E_SHADER_STAGE expectedStage, bool is_unused_shader_forbidden) -> bool
+            {
+              if (index == SShaderGroupsParams::SIndex::Unused)
+                return !is_unused_shader_forbidden;
+              if (index >= shaders.size())
+                return false;
+              if (getShaderStage(index) != expectedStage)
+                return false;
+              return true;
+            };
+
+          if (!isValidShaderIndex(shaderGroups.raygen.index, ICPUShader::E_SHADER_STAGE::ESS_RAYGEN, true))
+          {
+            return false;
+          }
+
+          for (const auto& shaderGroup : shaderGroups.hits)
+          {
+            // https://docs.vulkan.org/spec/latest/chapters/pipelines.html#VUID-VkRayTracingPipelineCreateInfoKHR-flags-03470
+            if (!isValidShaderIndex(shaderGroup.anyHit, 
+              ICPUShader::E_SHADER_STAGE::ESS_ANY_HIT,
+              bool(flags & FLAGS::NO_NULL_ANY_HIT_SHADERS)))
+              return false;
+
+            // https://docs.vulkan.org/spec/latest/chapters/pipelines.html#VUID-VkRayTracingPipelineCreateInfoKHR-flags-03471
+            if (!isValidShaderIndex(shaderGroup.closestHit, 
+              ICPUShader::E_SHADER_STAGE::ESS_CLOSEST_HIT,
+              bool(flags & FLAGS::NO_NULL_CLOSEST_HIT_SHADERS)))
+              return false;
+
+            if (!isValidShaderIndex(shaderGroup.intersection, 
+              ICPUShader::E_SHADER_STAGE::ESS_INTERSECTION,
+              false))
+              return false;
+          }
+
+          for (const auto& shaderGroup : shaderGroups.misses)
+          {
+            if (!isValidShaderIndex(shaderGroup.index, 
+              ICPUShader::E_SHADER_STAGE::ESS_MISS, 
+              false))
+              return false;
+          }
+
+          for (const auto& shaderGroup : shaderGroups.callables)
+          {
+            if (!isValidShaderIndex(shaderGroup.index, ICPUShader::E_SHADER_STAGE::ESS_CALLABLE, false))
+              return false;
+          }
+          return true;
+        }
+
+      public:
+        inline bool valid() const
+        {
+          return impl_valid([](const SpecInfo& info)->bool
+          {
+            if (!info.valid())
+              return false;
+            return false;
+          });
+        }
+
+        std::span<const SpecInfo> shaders = {};
+        SShaderGroupsParams shaderGroups;
+        SCachedCreationParams cached = {};
+        // TODO: Could guess the required flags from SPIR-V introspection of declared caps
+        core::bitflag<FLAGS> flags = FLAGS::NONE;
+    };
+
+    inline const SCachedCreationParams& getCachedCreationParams() const { return m_params; }
+
+  protected:
+    explicit IRayTracingPipeline(const SCreationParams& _params) :
+      IPipeline<PipelineLayoutType>(core::smart_refctd_ptr<const PipelineLayoutType>(_params.layout)),
+      m_params(_params.cached),
+      m_raygenShaderGroup(_params.shaderGroups.raygen),
+      m_missShaderGroups(core::make_refctd_dynamic_array<SGeneralShaderGroupContainer>(_params.shaderGroups.misses)),
+      m_hitShaderGroups(core::make_refctd_dynamic_array<SHitShaderGroupContainer>(_params.shaderGroups.hits)),
+      m_callableShaderGroups(core::make_refctd_dynamic_array<SGeneralShaderGroupContainer>(_params.shaderGroups.callables))
+    {}
+
+    SCachedCreationParams m_params;
+    SGeneralShaderGroup m_raygenShaderGroup;
+    SGeneralShaderGroupContainer m_missShaderGroups;
+    SHitShaderGroupContainer m_hitShaderGroups;
+    SGeneralShaderGroupContainer m_callableShaderGroups;
+
+};
+
+}
+
+#endif

include/nbl/builtin/hlsl/enums.hlsl

@@ -29,6 +29,7 @@ enum ShaderStage : uint32_t
     ESS_INTERSECTION = 1 << 12,
     ESS_CALLABLE = 1 << 13,
     ESS_ALL_GRAPHICS = 0x0000001F,
+    ESS_ALL_RAY_TRACING = ESS_RAYGEN | ESS_ANY_HIT | ESS_CLOSEST_HIT | ESS_MISS | ESS_INTERSECTION | ESS_CALLABLE,
     ESS_ALL_OR_LIBRARY = 0x7fffffff
 };
 

include/nbl/builtin/hlsl/indirect_commands.hlsl

@@ -37,6 +37,24 @@ struct DispatchIndirectCommand_t
 	uint32_t  num_groups_z;
 };
 
+struct TraceRaysIndirectCommand_t
+{
+    uint64_t raygenShaderRecordAddress;
+    uint64_t raygenShaderRecordSize;
+    uint64_t missShaderBindingTableAddress;
+    uint64_t missShaderBindingTableSize;
+    uint64_t missShaderBindingTableStride;
+    uint64_t hitShaderBindingTableAddress;
+    uint64_t hitShaderBindingTableSize;
+    uint64_t hitShaderBindingTableStride;
+    uint64_t callableShaderBindingTableAddress;
+    uint64_t callableShaderBindingTableSize;
+    uint64_t callableShaderBindingTableStride;
+	uint32_t  width;
+	uint32_t  height;
+	uint32_t  depth;
+};
+
 }
 }
 

include/nbl/video/CVulkanCommon.h

@@ -1082,7 +1082,33 @@ inline asset::IRenderpass::STORE_OP getAttachmentStoreOpFrom(const VkAttachmentS
     return static_cast<asset::IRenderpass::STORE_OP>(op);
 }
 
+inline VkPipelineBindPoint getVkPipelineBindPointFrom(asset::E_PIPELINE_BIND_POINT bindPoint)
+{
+    switch (bindPoint)
+    {
+    case asset::EPBP_GRAPHICS:
+      return VK_PIPELINE_BIND_POINT_GRAPHICS;
+    case asset::EPBP_COMPUTE:
+      return VK_PIPELINE_BIND_POINT_COMPUTE;
+    case asset::EPBP_RAY_TRACING:
+      return VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR;
+    default:
+        assert(!"Invalid code path.");
+        return VK_PIPELINE_BIND_POINT_MAX_ENUM;
+    }
+}
 
+inline VkStridedDeviceAddressRegionKHR getVkStridedDeviceAddressRegion(const asset::SBufferRange<const IGPUBuffer>& range, uint32_t stride)
+{
+    if (range.buffer.get() == nullptr)
+        return {};
+
+    return {
+        .deviceAddress = range.buffer->getDeviceAddress() + range.offset,
+        .stride = stride,
+        .size = range.size,
+    };
+}
 }
 
 #endif