Hlsl path tracer example

3rdparty/dxc/CMakeLists.txt

@@ -15,6 +15,7 @@ list(APPEND NBL_DXC_CMAKE_OPTIONS "-DCLANG_ENABLE_STATIC_ANALYZER:BOOL=OFF")
 list(APPEND NBL_DXC_CMAKE_OPTIONS "-DCLANG_INCLUDE_TESTS:BOOL=Off")
 list(APPEND NBL_DXC_CMAKE_OPTIONS "-DLLVM_INCLUDE_TESTS:BOOL=Off")
 list(APPEND NBL_DXC_CMAKE_OPTIONS "-DHLSL_INCLUDE_TESTS:BOOL=OFF")
+list(APPEND NBL_DXC_CMAKE_OPTIONS "-DLLVM_INCLUDE_UTILS:BOOL=OFF")
 list(APPEND NBL_DXC_CMAKE_OPTIONS "-DLLVM_TARGETS_TO_BUILD:STRING=None")
 list(APPEND NBL_DXC_CMAKE_OPTIONS "-DLLVM_INCLUDE_DOCS:BOOL=OFF")
 list(APPEND NBL_DXC_CMAKE_OPTIONS "-DLLVM_INCLUDE_TESTS:BOOL=OFF")

CMakeLists.txt

@@ -48,9 +48,10 @@ endif()
 
 find_package(Vulkan)
 if (Vulkan_FOUND)
-	message(STATUS "Building with Vulkan driver")
+	message(STATUS "Found Vulkan SDK")
+	cmake_path(GET Vulkan_INCLUDE_DIR PARENT_PATH VULKAN_SDK)
 else()
-	message(STATUS "Vulkan driver is not enabled")
+	message(STATUS "Vulkan SDK is not found")
 endif()
 
 option(NBL_COMPILE_WITH_CUDA "Compile with CUDA interop?" OFF)
@@ -280,5 +281,5 @@ add_subdirectory(artifacts)
 
 option(NBL_CPACK_INCLUDE_EXAMPLES "CPack with examples and media" ON)
 include(cpack/package)
-
+include(build/info)
 export(TARGETS ${_NBL_3RDPARTY_TARGETS_} Nabla NAMESPACE Nabla:: APPEND FILE ${NBL_ROOT_PATH_BINARY}/NablaExport.cmake)

cmake/build/info.cmake

@@ -0,0 +1,38 @@
+include_guard(GLOBAL)
+
+if (NOT DEFINED NBL_ROOT_PATH_BINARY)
+	message(FATAL_ERROR "NBL_ROOT_PATH_BINARY is not defined or it's empty")
+endif()
+
+if(NOT TARGET gtml)
+	message(FATAL_ERROR "gtml target not defined!")
+endif()
+
+set(OUTPUT_DIR "${NBL_ROOT_PATH_BINARY}")
+
+if(Vulkan_FOUND)
+	set(VKSDK_INFO_CMD "${VULKAN_SDK}/bin/vulkaninfoSDK" -j -o "${OUTPUT_DIR}/vulkan-info.json")
+else()
+	set(VKSDK_INFO_CMD "${CMAKE_COMMAND}" -E touch "${OUTPUT_DIR}/vulkan-info.json")
+endif()
+
+execute_process(COMMAND ${VKSDK_INFO_CMD})
+execute_process(COMMAND "${CMAKE_COMMAND}" -E capabilities OUTPUT_VARIABLE PIPE)
+file(WRITE "${OUTPUT_DIR}/cmake-caps.json" "${PIPE}")
+
+get_target_property(GTML_SOURCES gtml SOURCES)
+list(FILTER GTML_SOURCES INCLUDE REGEX "git_info\\.cpp$")
+
+set(BUILD_INFO_DEPENDENCIES 
+	"${OUTPUT_DIR}/vulkan-info.json"
+	"${OUTPUT_DIR}/cmake-caps.json"
+	CMakeCache.txt
+	CMakeFiles/CMakeConfigureLog.yaml
+	${GTML_SOURCES}
+)
+
+add_custom_target(nbl_build_info 
+	DEPENDS ${BUILD_INFO_DEPENDENCIES} gtml
+	COMMAND "${CMAKE_COMMAND}" -E tar c build_info.zip --format=zip ${BUILD_INFO_DEPENDENCIES}
+	COMMENT "Generating \"${NBL_ROOT_PATH_BINARY}/build_info.zip\", attach this within your issue"
+)

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