Enabled build time shader compilation in example 10

Author: Przemog1

10_CountingSort/CMakeLists.txt

@@ -22,3 +22,71 @@ if(NBL_EMBED_BUILTIN_RESOURCES)
 
 	LINK_BUILTIN_RESOURCES_TO_TARGET(${EXECUTABLE_NAME} ${_BR_TARGET_})
 endif()
+
+set(OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/auto-gen")
+set(DEPENDS
+	app_resources/common.hlsl
+	app_resources/prefix_sum_shader.comp.hlsl
+	app_resources/scatter_shader.comp.hlsl
+)
+target_sources(${EXECUTABLE_NAME} PRIVATE ${DEPENDS})
+set_source_files_properties(${DEPENDS} PROPERTIES HEADER_FILE_ONLY ON)
+
+set(SM 6_8)
+set(REQUIRED_CAPS [=[
+	{
+	  "kind": "limits",
+	  "name": "maxComputeWorkGroupInvocations",
+	  "type": "uint32_t",
+	  "values": [256,512,1024]
+	},
+	{
+	  "kind": "limits",
+	  "name": "maxComputeSharedMemorySize",
+	  "type": "uint32_t",
+	  "values": [16384, 32768, 65536]
+	}
+]=])
+
+set(JSON [=[
+[
+	{
+		"INPUT": "app_resources/prefix_sum_shader.comp.hlsl",
+		"KEY": "prefix_sum_shader",
+		"CAPS": [${REQUIRED_CAPS}]
+    },
+    {
+		"INPUT": "app_resources/scatter_shader.comp.hlsl",
+		"KEY": "scatter_shader",
+		"CAPS": [${REQUIRED_CAPS}]
+    }
+]
+]=])
+string(CONFIGURE "${JSON}" JSON)
+
+set(COMPILE_OPTIONS
+    -I "${CMAKE_CURRENT_SOURCE_DIR}"
+    -O3
+    -T lib_${SM}
+)
+
+NBL_CREATE_NSC_COMPILE_RULES(
+    TARGET ${EXECUTABLE_NAME}SPIRV
+    LINK_TO ${EXECUTABLE_NAME}
+    DEPENDS ${DEPENDS}
+    BINARY_DIR ${OUTPUT_DIRECTORY}
+    MOUNT_POINT_DEFINE NBL_THIS_EXAMPLE_BUILD_MOUNT_POINT
+    COMMON_OPTIONS ${COMPILE_OPTIONS}
+    OUTPUT_VAR KEYS
+    INCLUDE nbl/this_example/builtin/build/spirv/keys.hpp
+    NAMESPACE nbl::this_example::builtin::build
+    INPUTS ${JSON}
+)
+
+NBL_CREATE_RESOURCE_ARCHIVE(
+    NAMESPACE nbl::this_example::builtin::build
+    TARGET ${EXECUTABLE_NAME}_builtinsBuild
+    LINK_TO ${EXECUTABLE_NAME}
+    BIND ${OUTPUT_DIRECTORY}
+    BUILTINS ${KEYS}
+)

10_CountingSort/app_resources/common.hlsl

@@ -22,6 +22,10 @@ using namespace nbl::hlsl;
 #ifdef __HLSL_VERSION
 #include "nbl/builtin/hlsl/bda/bda_accessor.hlsl"
 
+static const uint32_t WorkgroupSize = DeviceConfigCaps::maxComputeWorkGroupInvocations;
+static const uint32_t MaxBucketCount = (DeviceConfigCaps::maxComputeSharedMemorySize / sizeof(uint32_t)) / 2;
+static const uint32_t BucketCount = (MaxBucketCount > 3000) ? 3000 : MaxBucketCount;
+
 using Ptr = bda::__ptr<uint32_t>;
 using PtrAccessor = BdaAccessor<uint32_t>;
 
@@ -54,6 +58,8 @@ uint32_t3 glsl::gl_WorkGroupSize()
 {
     return uint32_t3(WorkgroupSize, 1, 1);
 }
+
+
 #endif
 
 #endif

10_CountingSort/main.cpp

@@ -1,4 +1,5 @@
 #include "nbl/examples/examples.hpp"
+#include "nbl/this_example/builtin/build/spirv/keys.hpp"
 
 using namespace nbl;
 using namespace nbl::core;
@@ -32,49 +33,59 @@ class CountingSortApp final : public application_templates::MonoDeviceApplicatio
 				return false;
 
 			auto limits = m_physicalDevice->getLimits();
+			constexpr std::array<uint32_t, 3u> AllowedMaxComputeSharedMemorySizes = {
+				16384, 32768, 65536
+			};
+
+			auto upperBoundSharedMemSize = std::upper_bound(AllowedMaxComputeSharedMemorySizes.begin(), AllowedMaxComputeSharedMemorySizes.end(), limits.maxComputeSharedMemorySize);
+			// devices which support less than 16KB of max compute shared memory size are not supported
+			if (upperBoundSharedMemSize == AllowedMaxComputeSharedMemorySizes.begin())
+			{
+				m_logger->log("maxComputeSharedMemorySize is too low (%u)", ILogger::E_LOG_LEVEL::ELL_ERROR, limits.maxComputeSharedMemorySize);
+				exit(0);
+			}
+
+			limits.maxComputeSharedMemorySize = *(upperBoundSharedMemSize - 1);
+
 			const uint32_t WorkgroupSize = limits.maxComputeWorkGroupInvocations;
 			const uint32_t MaxBucketCount = (limits.maxComputeSharedMemorySize / sizeof(uint32_t)) / 2;
 			constexpr uint32_t element_count = 100000;
 			const uint32_t bucket_count = std::min((uint32_t)3000, MaxBucketCount);
 			const uint32_t elements_per_thread = ceil((float)ceil((float)element_count / limits.computeUnits) / WorkgroupSize);
 
-			auto prepShader = [&](const core::string& path) -> smart_refctd_ptr<IShader>
+			auto loadPrecompiledShader = [&]<core::StringLiteral ShaderKey>() -> smart_refctd_ptr<IShader>
 			{
 				// this time we load a shader directly from a file
 				IAssetLoader::SAssetLoadParams lp = {};
 				lp.logger = m_logger.get();
-				lp.workingDirectory = ""; // virtual root
-				auto assetBundle = m_assetMgr->getAsset(path,lp);
+				lp.workingDirectory = "app_resources"; // virtual root
+				auto key = nbl::this_example::builtin::build::get_spirv_key<ShaderKey>(limits, m_physicalDevice->getFeatures());
+				auto assetBundle = m_assetMgr->getAsset(key.data(), lp);
 				const auto assets = assetBundle.getContents();
 				if (assets.empty())
 				{
 					logFail("Could not load shader!");
 					return nullptr;
 				}
 
-				auto source = IAsset::castDown<IShader>(assets[0]);
+				auto shader = IAsset::castDown<IShader>(assets[0]);
 				// The down-cast should not fail!
-				assert(source);
+				assert(shader);
 
 				// There's two ways of doing stuff like this:
 				// 1. this - modifying the asset after load
 				// 2. creating a short shader source file that includes the asset you would have wanted to load
-				auto overrideSource = CHLSLCompiler::createOverridenCopy(
-					source.get(), "#define WorkgroupSize %d\n#define BucketCount %d\n",
-					WorkgroupSize, bucket_count
-				);
+				// 
+				//auto overrideSource = CHLSLCompiler::createOverridenCopy(
+				//	source.get(), "#define WorkgroupSize %d\n#define BucketCount %d\n",
+				//	WorkgroupSize, bucket_count
+				//);
 
 				// this time we skip the use of the asset converter since the IShader->IGPUShader path is quick and simple
-				auto shader = m_device->compileShader({ overrideSource.get() });
-				if (!shader)
-				{
-					logFail("Creation of Prefix Sum Shader from CPU Shader source failed!");
-					return nullptr;
-				}
 				return shader;
 			};
-			auto prefixSumShader = prepShader("app_resources/prefix_sum_shader.comp.hlsl");
-			auto scatterShader = prepShader("app_resources/scatter_shader.comp.hlsl");
+			auto prefixSumShader = loadPrecompiledShader.operator()<"prefix_sum_shader">(); // "app_resources/prefix_sum_shader.comp.hlsl"
+			auto scatterShader = loadPrecompiledShader.operator()<"scatter_shader">(); // "app_resources/scatter_shader.comp.hlsl"
 
 			// People love Reflection but I prefer Shader Sources instead!
 			const nbl::asset::SPushConstantRange pcRange = { .stageFlags = IShader::E_SHADER_STAGE::ESS_COMPUTE,.offset = 0,.size = sizeof(CountingPushData) };