IShader, no more conversions, stage is now part of spec info.

include/nbl/asset/IRayTracingPipeline.h

@@ -81,7 +81,7 @@ class IRayTracingPipeline : public IPipeline<PipelineLayoutType>, public IRayTra
       #undef base_flag
 
       protected:
-        using SpecInfo = ShaderType::SSpecInfo;
+        using SpecInfo = IPipelineBase::SShaderSpecInfo;
         template<typename ExtraLambda>
         inline bool impl_valid(ExtraLambda&& extra) const
         {
@@ -94,10 +94,10 @@ class IRayTracingPipeline : public IPipeline<PipelineLayoutType>, public IRayTra
             {
               if (!extra(info))
                 return false;
-              const auto stage = info.shader->getStage();
-              if ((stage & ~ICPUShader::E_SHADER_STAGE::ESS_ALL_RAY_TRACING) != 0)
+              const auto stage = info.stage;
+              if ((stage & ~IShader::E_SHADER_STAGE::ESS_ALL_RAY_TRACING) != 0)
                 return false;
-              if (!std::has_single_bit<std::underlying_type_t<ICPUShader::E_SHADER_STAGE>>(stage))
+              if (!std::has_single_bit<std::underlying_type_t<IShader::E_SHADER_STAGE>>(stage))
                 return false;
             }
             else
@@ -107,12 +107,12 @@ class IRayTracingPipeline : public IPipeline<PipelineLayoutType>, public IRayTra
             }
           }
 
-          auto getShaderStage = [this](size_t index) -> ICPUShader::E_SHADER_STAGE
+          auto getShaderStage = [this](size_t index) -> IShader::E_SHADER_STAGE
             {
-              return shaders[index].shader->getStage();
+              return shaders[index].stage;
             };
 
-          auto isValidShaderIndex = [this, getShaderStage](size_t index, ICPUShader::E_SHADER_STAGE expectedStage, bool is_unused_shader_forbidden) -> bool
+          auto isValidShaderIndex = [this, getShaderStage](size_t index, IShader::E_SHADER_STAGE expectedStage, bool is_unused_shader_forbidden) -> bool
             {
               if (index == SShaderGroupsParams::SIndex::Unused)
                 return !is_unused_shader_forbidden;
@@ -123,7 +123,7 @@ class IRayTracingPipeline : public IPipeline<PipelineLayoutType>, public IRayTra
               return true;
             };
 
-          if (!isValidShaderIndex(shaderGroups.raygen.index, ICPUShader::E_SHADER_STAGE::ESS_RAYGEN, true))
+          if (!isValidShaderIndex(shaderGroups.raygen.index, IShader::E_SHADER_STAGE::ESS_RAYGEN, true))
           {
             return false;
           }
@@ -132,33 +132,33 @@ class IRayTracingPipeline : public IPipeline<PipelineLayoutType>, public IRayTra
           {
             // https://docs.vulkan.org/spec/latest/chapters/pipelines.html#VUID-VkRayTracingPipelineCreateInfoKHR-flags-03470
             if (!isValidShaderIndex(shaderGroup.anyHit, 
-              ICPUShader::E_SHADER_STAGE::ESS_ANY_HIT,
+              IShader::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,
+              IShader::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,
+              IShader::E_SHADER_STAGE::ESS_INTERSECTION,
               false))
               return false;
           }
 
           for (const auto& shaderGroup : shaderGroups.misses)
           {
             if (!isValidShaderIndex(shaderGroup.index, 
-              ICPUShader::E_SHADER_STAGE::ESS_MISS, 
+              IShader::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))
+            if (!isValidShaderIndex(shaderGroup.index, IShader::E_SHADER_STAGE::ESS_CALLABLE, false))
               return false;
           }
           return true;

include/nbl/asset/utils/ISPIRVDebloater.h

@@ -50,7 +50,7 @@ class ISPIRVDebloater final : public core::IReferenceCounted
         {
             const auto buffer = shader->getContent();
             const auto result = debloat(buffer, entryPoints, logger);
-            if (result && result.spirv.get() != nullptr)
+            if (result && result.spirv.get() == nullptr)
             {
                 return core::smart_refctd_ptr<const IShader>(shader);
             }

include/nbl/video/CVulkanRayTracingPipeline.h

@@ -4,16 +4,11 @@
 
 #include "nbl/video/IGPURayTracingPipeline.h"
 
-#include "nbl/video/CVulkanShader.h"
-
-
 namespace nbl::video
 {
 
 class CVulkanRayTracingPipeline final : public IGPURayTracingPipeline
 {
-    using ShaderRef = core::smart_refctd_ptr<const CVulkanShader>;
-    using ShaderContainer = core::smart_refctd_dynamic_array<ShaderRef>;
     using GeneralGroupStackSizeContainer = core::smart_refctd_dynamic_array<uint16_t>;
     using HitGroupStackSizeContainer = core::smart_refctd_dynamic_array<SHitGroupStackSize>;
 
@@ -45,7 +40,6 @@ class CVulkanRayTracingPipeline final : public IGPURayTracingPipeline
     ~CVulkanRayTracingPipeline() override;
 
     const VkPipeline m_vkPipeline;
-    ShaderContainer m_shaders;
     ShaderGroupHandleContainer m_shaderGroupHandles;
     uint16_t m_raygenStackSize;
     core::smart_refctd_dynamic_array<uint16_t> m_missStackSizes;

include/nbl/video/IGPURayTracingPipeline.h

@@ -10,9 +10,9 @@
 namespace nbl::video
 {
 
-class IGPURayTracingPipeline : public IBackendObject, public asset::IRayTracingPipeline<const IGPUPipelineLayout, const IGPUShader>
+class IGPURayTracingPipeline : public IBackendObject, public asset::IRayTracingPipeline<const IGPUPipelineLayout, const asset::IShader>
 {
-        using pipeline_t = asset::IRayTracingPipeline<const IGPUPipelineLayout,const IGPUShader>;
+        using pipeline_t = asset::IRayTracingPipeline<const IGPUPipelineLayout,const asset::IShader>;
 
     public:
 
@@ -42,7 +42,7 @@ class IGPURayTracingPipeline : public IBackendObject, public asset::IRayTracingP
                     .count=0,
                     .dataSize=0,
                 };
-                const bool valid = pipeline_t::SCreationParams::impl_valid([&retval](const IGPUShader::SSpecInfo& info)->bool
+                const bool valid = pipeline_t::SCreationParams::impl_valid([&retval](const SShaderSpecInfo& info)->bool
                 {
                     const auto dataSize = info.valid();
                     if (dataSize<0)
@@ -61,7 +61,7 @@ class IGPURayTracingPipeline : public IBackendObject, public asset::IRayTracingP
                 return retval;
             }
 
-            inline std::span<const IGPUShader::SSpecInfo> getShaders() const { return shaders; }
+            inline std::span<const SShaderSpecInfo> getShaders() const { return shaders; }
 
         };
 

src/nbl/asset/utils/ISPIRVDebloater.cpp

@@ -6,8 +6,6 @@
 #include "nbl/system/ILogger.h"
 #include "spirv-tools/libspirv.hpp"
 
-#include <iostream>
-
 using namespace nbl::asset;
 
 static constexpr spv_target_env SPIRV_VERSION = spv_target_env::SPV_ENV_UNIVERSAL_1_6;
@@ -28,21 +26,21 @@ ISPIRVDebloater::ISPIRVDebloater()
 }
 
 // This is for debugging temporarily. will be reworked after finish testing 
-static void printCapabilities(const uint32_t* spirv, uint32_t spirvDwordCount)
+static void printCapabilities(const uint32_t* spirv, uint32_t spirvDwordCount,nbl::system::logger_opt_ptr logger)
 {
-    spvtools::SpirvTools core(SPV_ENV_UNIVERSAL_1_6);
+    spvtools::SpirvTools core(SPIRV_VERSION);
     std::string disassembly;
     core.Disassemble(spirv, spirvDwordCount, &disassembly, SPV_BINARY_TO_TEXT_OPTION_NO_HEADER);
     std::stringstream ss(disassembly);
     std::string to;
-    const auto stringsToFind = std::array{ "OpCapability", "= OpFunction", "= OpRayQueryGetIntersectionTriangleVertexPositionsKHR", "OpFunctionEnd", "OpSpecConstant", "=OpType", "OpName" };
-    while(std::getline(ss,to,'\n')){
+    const auto stringsToFind = std::array{ "OpCapability", "= OpFunction","OpFunctionEnd", "OpSpecConstant", "=OpType"};
+    while(std::getline(ss, to, '\n')){
       if (to.size() > 1 && to.back() == ',') continue;
       for (const auto& stringToFind: stringsToFind)
       {
         if (to.find(stringToFind) != std::string::npos)
         {
-          std::cout << to <<std::endl;
+          logger.log("%s", nbl::system::ILogger::ELL_DEBUG, to.c_str());
         }
       }
     }
@@ -82,9 +80,6 @@ ISPIRVDebloater::Result ISPIRVDebloater::debloat(const  ICPUBuffer* spirvBuffer,
     const auto* spirv = static_cast<const uint32_t*>(spirvBuffer->getPointer());
     const auto spirvDwordCount = spirvBuffer->getSize() / 4;
 
-    std::cout << "Before strip capabilities: " << std::endl;
-    printCapabilities(spirv, spirvDwordCount);
-
     if (entryPoints.empty())
     {
        logger.log("Cannot retain zero multiple entry points!", system::ILogger::ELL_ERROR);
@@ -94,20 +89,7 @@ ISPIRVDebloater::Result ISPIRVDebloater::debloat(const  ICPUBuffer* spirvBuffer,
        };
     }
 
-    // We will remove found entry point one by one. We set all entry points as unfound initially
-    core::set<EntryPoint> unfoundEntryPoints;
-    for (const auto& entryPoint : entryPoints)
-    {
-       if (unfoundEntryPoints.find(entryPoint) != unfoundEntryPoints.end())
-       {
-           logger.log("Cannot retain multiple entry points with the same name and stage!", system::ILogger::ELL_ERROR);
-           return Result{
-              nullptr,
-              false
-           };
-       }
-       unfoundEntryPoints.insert(entryPoint);
-    }
+    auto foundEntryPoint = 0;
 
     const bool isInputSpirvValid  = validate(spirv, spirvDwordCount, logger);
     if (!isInputSpirvValid)
@@ -194,10 +176,10 @@ ISPIRVDebloater::Result ISPIRVDebloater::debloat(const  ICPUBuffer* spirvBuffer,
             };
         }
 
-        auto findEntryPointIt = unfoundEntryPoints.find(entryPoint);
-        if (findEntryPointIt != unfoundEntryPoints.end())
+        auto findEntryPointIt = entryPoints.find(entryPoint);
+        if (findEntryPointIt != entryPoints.end())
         {
-            unfoundEntryPoints.erase(findEntryPointIt);
+            foundEntryPoint += 1; // a valid spirv will have unique entry points, so this should works
         } else
         {
             if (needDebloat == false)
@@ -213,7 +195,7 @@ ISPIRVDebloater::Result ISPIRVDebloater::debloat(const  ICPUBuffer* spirvBuffer,
         minimizedSpirv.insert(minimizedSpirv.end(), spirv + curOffset, spirv + offset);
     }
 
-    const auto wereAllEntryPointsFound = unfoundEntryPoints.empty();
+    const auto wereAllEntryPointsFound = foundEntryPoint == entryPoints.size();
     if (!wereAllEntryPointsFound)
     {
         logger.log("Some entry point that is requested to be retained is not found in SPIR-V", system::ILogger::ELL_ERROR);
@@ -252,10 +234,18 @@ ISPIRVDebloater::Result ISPIRVDebloater::debloat(const  ICPUBuffer* spirvBuffer,
     assert(validate(minimizedSpirv.data(), minimizedSpirv.size(), logger));
 
     auto debloatedSpirv = m_optimizer->optimize(minimizedSpirv.data(), minimizedSpirv.size(), logger);
+
+#ifdef _NBL_DEBUG
+    logger.log("Before stripping capabilities:", nbl::system::ILogger::ELL_DEBUG);
+    printCapabilities(spirv, spirvDwordCount, logger);
+    logger.log("\n", nbl::system::ILogger::ELL_DEBUG);
+
     const auto* debloatedSpirvBuffer = static_cast<const uint32_t*>(debloatedSpirv->getPointer());
     const auto debloatedSpirvDwordCount = debloatedSpirv->getSize() / 4;
-    std::cout << "After strip capabilities: " << std::endl;
-    printCapabilities(debloatedSpirvBuffer, debloatedSpirvDwordCount);
+    logger.log("After stripping capabilities:", nbl::system::ILogger::ELL_DEBUG);
+    printCapabilities(debloatedSpirvBuffer, debloatedSpirvDwordCount, logger);
+    logger.log("\n", nbl::system::ILogger::ELL_DEBUG);
+#endif
 
     return {
       .spirv = std::move(debloatedSpirv),

src/nbl/video/CVulkanLogicalDevice.cpp

@@ -1466,6 +1466,8 @@ void CVulkanLogicalDevice::createRayTracingPipelines_impl(
     for (const auto& info : createInfos)
         maxShaderGroups += info.shaderGroups.getShaderGroupCount();
     core::vector<VkRayTracingPipelineCreateInfoKHR> vk_createInfos(createInfos.size(), { VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR,nullptr });
+    core::vector<VkShaderModuleCreateInfo> vk_shaderModule(maxShaderStages,{VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,nullptr, 0});
+    core::vector<std::string> entryPoints(maxShaderStages);
     core::vector<VkPipelineShaderStageRequiredSubgroupSizeCreateInfo> vk_requiredSubgroupSize(maxShaderStages,{
         VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO,nullptr
     });
@@ -1476,6 +1478,8 @@ void CVulkanLogicalDevice::createRayTracingPipelines_impl(
     core::vector<uint8_t> specializationData(validation.dataSize);
 
     auto outCreateInfo = vk_createInfos.data();
+    auto outShaderModule = vk_shaderModule.data();
+    auto outEntryPoints = entryPoints.data();
     auto outRequiredSubgroupSize = vk_requiredSubgroupSize.data();
     auto outShaderStage = vk_shaderStage.data();
     auto outShaderGroup = vk_shaderGroup.data();
@@ -1514,7 +1518,7 @@ void CVulkanLogicalDevice::createRayTracingPipelines_impl(
         outCreateInfo->pStages = outShaderStage;
         for (const auto& specInfo : info.shaders)
         {
-            *(outShaderStage++) = getVkShaderStageCreateInfoFrom(specInfo,outRequiredSubgroupSize,outSpecInfo,outSpecMapEntry,outSpecData);
+            *(outShaderStage++) = getVkShaderStageCreateInfoFrom(specInfo, outShaderModule, outEntryPoints, outRequiredSubgroupSize, outSpecInfo,outSpecMapEntry,outSpecData);
         }
         outCreateInfo->stageCount = std::distance<decltype(outCreateInfo->pStages)>(outCreateInfo->pStages,outShaderStage);
         assert(outCreateInfo->stageCount != 0);

src/nbl/video/CVulkanRayTracingPipeline.cpp

@@ -15,15 +15,11 @@ namespace nbl::video
     ShaderGroupHandleContainer&& shaderGroupHandles) :
     IGPURayTracingPipeline(params),
     m_vkPipeline(vk_pipeline),
-    m_shaders(core::make_refctd_dynamic_array<ShaderContainer>(params.shaders.size())),
     m_missStackSizes(core::make_refctd_dynamic_array<GeneralGroupStackSizeContainer>(params.shaderGroups.misses.size())),
     m_hitGroupStackSizes(core::make_refctd_dynamic_array<HitGroupStackSizeContainer>(params.shaderGroups.hits.size())),
     m_callableStackSizes(core::make_refctd_dynamic_array<GeneralGroupStackSizeContainer>(params.shaderGroups.hits.size())),
     m_shaderGroupHandles(std::move(shaderGroupHandles))
   {
-    for (size_t shaderIx = 0; shaderIx < params.shaders.size(); shaderIx++)
-      m_shaders->operator[](shaderIx) = ShaderRef(static_cast<const CVulkanShader*>(params.shaders[shaderIx].shader));
-
     const auto* vulkanDevice = static_cast<const CVulkanLogicalDevice*>(getOriginDevice());
     auto* vk = vulkanDevice->getFunctionTable();