Precompile and cache EX31 path tracer variants

31_HLSLPathTracer/CMakeLists.txt

@@ -1,10 +1,19 @@
-include(common RESULT_VARIABLE RES)
-
-if(NOT RES)
-	message(FATAL_ERROR "common.cmake not found. Should be in {repo_root}/cmake directory")
-endif()
+include(common)
+include("${CMAKE_CURRENT_SOURCE_DIR}/pt.cmake")
+include("${CMAKE_CURRENT_SOURCE_DIR}/pt.variant_ids.cmake")
 
 if(NBL_BUILD_IMGUI)
+	# EX31 keeps triangle polygon-method variants as separate precompiled entrypoints.
+	# This keeps polygon-method choice compile-time and avoids runtime shader switching on this axis.
+	# On AMD Ryzen 5 5600G with Radeon Graphics (6C/12T),
+	# a Visual Studio Debug x64 full rebuild of the SPIR-V project completed in about 19.789 s.
+	set(PT_CACHE_ROOT "pipeline/cache" CACHE STRING
+		"Relative cache root written to path_tracer.runtime.json in the common bin directory. The runtime resolves this path relative to the JSON file location. Empty disables the generated dev-mode JSON and falls back to --pipeline-cache-dir or LocalAppData."
+	)
+	if(IS_ABSOLUTE "${PT_CACHE_ROOT}")
+		message(FATAL_ERROR "PT_CACHE_ROOT must stay relative because the runtime resolves it against path_tracer.runtime.json")
+	endif()
+
 	set(NBL_INCLUDE_SERACH_DIRECTORIES
 		"${CMAKE_CURRENT_SOURCE_DIR}/include"
 	)
@@ -16,25 +25,69 @@ if(NBL_BUILD_IMGUI)
 	)
 
 	nbl_create_executable_project("" "" "${NBL_INCLUDE_SERACH_DIRECTORIES}" "${NBL_LIBRARIES}" "${NBL_EXECUTABLE_PROJECT_CREATION_PCH_TARGET}")
+	add_dependencies(${EXECUTABLE_NAME} argparse)
+	target_include_directories(${EXECUTABLE_NAME} PUBLIC $<TARGET_PROPERTY:argparse,INTERFACE_INCLUDE_DIRECTORIES>)
+	target_compile_definitions(${EXECUTABLE_NAME} PRIVATE PATH_TRACER_BUILD_CONFIG_NAME=\"$<CONFIG>\")
+	if(NOT PT_CACHE_ROOT STREQUAL "")
+		string(REPLACE "\\" "/" PT_CACHE_ROOT_JSON "${PT_CACHE_ROOT}")
+		configure_file(
+			"${CMAKE_CURRENT_SOURCE_DIR}/path_tracer.runtime.json.in"
+			"${CMAKE_CURRENT_BINARY_DIR}/path_tracer.runtime.json"
+			@ONLY
+		)
+		file(GENERATE
+			OUTPUT "$<TARGET_FILE_DIR:${EXECUTABLE_NAME}>/path_tracer.runtime.json"
+			INPUT "${CMAKE_CURRENT_BINARY_DIR}/path_tracer.runtime.json"
+		)
+	endif()
 
-	if(NBL_EMBED_BUILTIN_RESOURCES)
-		set(_BR_TARGET_ ${EXECUTABLE_NAME}_builtinResourceData)
-		set(RESOURCE_DIR "app_resources")
-
-		get_filename_component(_SEARCH_DIRECTORIES_ "${CMAKE_CURRENT_SOURCE_DIR}" ABSOLUTE)
-		get_filename_component(_OUTPUT_DIRECTORY_SOURCE_ "${CMAKE_CURRENT_BINARY_DIR}/src" ABSOLUTE)
-		get_filename_component(_OUTPUT_DIRECTORY_HEADER_ "${CMAKE_CURRENT_BINARY_DIR}/include" ABSOLUTE)
-
-		file(GLOB_RECURSE BUILTIN_RESOURCE_FILES RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}/${RESOURCE_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}/${RESOURCE_DIR}/*")
+	set(SM 6_8)
+	set(OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/auto-gen")
+	set(COMPILE_OPTIONS
+		-I "${CMAKE_CURRENT_SOURCE_DIR}/include"
+		-I "${CMAKE_CURRENT_SOURCE_DIR}/app_resources/hlsl"
+		-I "${NBL_ROOT_PATH}/include" # workaround, the same thing like in IES I will address this issue later
+		-T "lib_${SM}"
+		-Wno-conversion
+		-Wno-sign-conversion
+		-Wno-float-conversion
+		-Wno-shorten-64-to-32
+		-Wno-shadow
+		-Wno-literal-range
+	)
 
-		foreach(RES_FILE ${BUILTIN_RESOURCE_FILES})
-			LIST_BUILTIN_RESOURCE(RESOURCES_TO_EMBED "${RES_FILE}")
-		endforeach()
+	# Keep the payload flat and explicit here. Once Nabla PR #988 lands, these per-rule compile axes should move to first-class packaged-variant support there.
+	PT_APPEND_SPIRV_RULE(VAR JSON INPUT "app_resources/hlsl/spirv/pt.compute.sphere.proxy.hlsl" KEY "pt.compute.sphere" COMPILE_OPTIONS "-DPT_VARIANT_USE_RWMC=0" "-DPT_VARIANT_SCENE_KIND=${PT_SCENE_SPHERE}" "-DPT_VARIANT_ENTRYPOINT_KIND=${PT_ENTRYPOINT_COMBINED}")
+	PT_APPEND_SPIRV_RULE(VAR JSON INPUT "app_resources/hlsl/spirv/pt.compute.sphere.rwmc.proxy.hlsl" KEY "pt.compute.sphere.rwmc" COMPILE_OPTIONS "-DPT_VARIANT_USE_RWMC=1" "-DPT_VARIANT_SCENE_KIND=${PT_SCENE_SPHERE}" "-DPT_VARIANT_ENTRYPOINT_KIND=${PT_ENTRYPOINT_COMBINED}")
+	PT_APPEND_SPIRV_RULE(VAR JSON INPUT "app_resources/hlsl/spirv/pt.compute.triangle.linear.proxy.hlsl" KEY "pt.compute.triangle.linear" COMPILE_OPTIONS "-DPT_VARIANT_USE_RWMC=0" "-DPT_VARIANT_ENTRYPOINT_KIND=${PT_ENTRYPOINT_LINEAR}")
+	PT_APPEND_SPIRV_RULE(VAR JSON INPUT "app_resources/hlsl/spirv/pt.compute.triangle.persistent.proxy.hlsl" KEY "pt.compute.triangle.persistent" COMPILE_OPTIONS "-DPT_VARIANT_USE_RWMC=0" "-DPT_VARIANT_ENTRYPOINT_KIND=${PT_ENTRYPOINT_PERSISTENT}")
+	PT_APPEND_SPIRV_RULE(VAR JSON INPUT "app_resources/hlsl/spirv/pt.compute.triangle.rwmc.linear.proxy.hlsl" KEY "pt.compute.triangle.rwmc.linear" COMPILE_OPTIONS "-DPT_VARIANT_USE_RWMC=1" "-DPT_VARIANT_ENTRYPOINT_KIND=${PT_ENTRYPOINT_LINEAR}")
+	PT_APPEND_SPIRV_RULE(VAR JSON INPUT "app_resources/hlsl/spirv/pt.compute.triangle.rwmc.persistent.proxy.hlsl" KEY "pt.compute.triangle.rwmc.persistent" COMPILE_OPTIONS "-DPT_VARIANT_USE_RWMC=1" "-DPT_VARIANT_ENTRYPOINT_KIND=${PT_ENTRYPOINT_PERSISTENT}")
+	PT_APPEND_SPIRV_RULE(VAR JSON INPUT "app_resources/hlsl/spirv/pt.compute.rectangle.rwmc.linear.proxy.hlsl" KEY "pt.compute.rectangle.rwmc.linear" COMPILE_OPTIONS "-DPT_VARIANT_USE_RWMC=1" "-DPT_VARIANT_SCENE_KIND=${PT_SCENE_RECTANGLE}" "-DPT_VARIANT_ENTRYPOINT_KIND=${PT_ENTRYPOINT_LINEAR}")
+	PT_APPEND_SPIRV_RULE(VAR JSON INPUT "app_resources/hlsl/spirv/pt.compute.rectangle.rwmc.persistent.proxy.hlsl" KEY "pt.compute.rectangle.rwmc.persistent" COMPILE_OPTIONS "-DPT_VARIANT_USE_RWMC=1" "-DPT_VARIANT_SCENE_KIND=${PT_SCENE_RECTANGLE}" "-DPT_VARIANT_ENTRYPOINT_KIND=${PT_ENTRYPOINT_PERSISTENT}")
+	PT_APPEND_SPIRV_RULE(VAR JSON INPUT "app_resources/hlsl/spirv/pt.compute.rectangle.proxy.hlsl" KEY "pt.compute.rectangle" COMPILE_OPTIONS "-DPT_VARIANT_USE_RWMC=0" "-DPT_VARIANT_SCENE_KIND=${PT_SCENE_RECTANGLE}" "-DPT_VARIANT_ENTRYPOINT_KIND=${PT_ENTRYPOINT_COMBINED}")
+	PT_APPEND_SPIRV_RULE(VAR JSON INPUT "app_resources/hlsl/resolve.comp.hlsl" KEY "pt.compute.resolve")
+	PT_APPEND_SPIRV_RULE(VAR JSON INPUT "app_resources/hlsl/spirv/pt.misc.proxy.hlsl" KEY "pt.misc")
+	PT_FINALIZE_JSON_PAYLOAD(INOUT JSON)
 
-		ADD_CUSTOM_BUILTIN_RESOURCES(${_BR_TARGET_} RESOURCES_TO_EMBED "${_SEARCH_DIRECTORIES_}" "${RESOURCE_DIR}" "nbl::this_example::builtin" "${_OUTPUT_DIRECTORY_HEADER_}" "${_OUTPUT_DIRECTORY_SOURCE_}")
+	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}
+	)
 
-		LINK_BUILTIN_RESOURCES_TO_TARGET(${EXECUTABLE_NAME} ${_BR_TARGET_})
-	endif()
+	NBL_CREATE_RESOURCE_ARCHIVE(
+		NAMESPACE nbl::this_example::builtin::build
+		TARGET ${EXECUTABLE_NAME}_builtinsBuild
+		LINK_TO ${EXECUTABLE_NAME}
+		BIND ${OUTPUT_DIRECTORY}
+		BUILTINS ${KEYS}
+	)
 endif()
-
-

31_HLSLPathTracer/app_resources/hlsl/compute.render.common.hlsl

@@ -0,0 +1,62 @@
+#ifndef PATH_TRACER_USE_RWMC
+#error PATH_TRACER_USE_RWMC must be defined before including compute.render.common.hlsl
+#endif
+
+#ifndef PATH_TRACER_ENABLE_LINEAR
+#define PATH_TRACER_ENABLE_LINEAR 1
+#endif
+
+#ifndef PATH_TRACER_ENABLE_PERSISTENT
+#define PATH_TRACER_ENABLE_PERSISTENT 1
+#endif
+
+#if !PATH_TRACER_ENABLE_LINEAR && !PATH_TRACER_ENABLE_PERSISTENT
+#error At least one path tracer entrypoint mode must be enabled
+#endif
+
+#include "nbl/builtin/hlsl/cpp_compat.hlsl"
+#include "nbl/builtin/hlsl/glsl_compat/core.hlsl"
+#include "nbl/builtin/hlsl/random/pcg.hlsl"
+#include "nbl/builtin/hlsl/random/xoroshiro.hlsl"
+#if PATH_TRACER_ENABLE_PERSISTENT
+#include "nbl/builtin/hlsl/morton.hlsl"
+#endif
+#include "nbl/builtin/hlsl/bxdf/reflection.hlsl"
+#include "nbl/builtin/hlsl/bxdf/transmission.hlsl"
+#include "nbl/builtin/hlsl/path_tracing/basic_ray_gen.hlsl"
+#include "nbl/builtin/hlsl/path_tracing/unidirectional.hlsl"
+#include "render_common.hlsl"
+
+#if PATH_TRACER_USE_RWMC
+#include "nbl/builtin/hlsl/rwmc/CascadeAccumulator.hlsl"
+#include "render_rwmc_common.hlsl"
+#else
+#include "nbl/builtin/hlsl/path_tracing/default_accumulator.hlsl"
+#endif
+
+#if PATH_TRACER_USE_RWMC
+[[vk::push_constant]] RenderRWMCPushConstants pc;
+#else
+[[vk::push_constant]] RenderPushConstants pc;
+#endif
+
+[[vk::combinedImageSampler]] [[vk::binding(0, 0)]] Texture2D<float3> envMap;
+[[vk::combinedImageSampler]] [[vk::binding(0, 0)]] SamplerState envSampler;
+
+[[vk::combinedImageSampler]] [[vk::binding(1, 0)]] Texture2D<uint2> scramblebuf;
+[[vk::combinedImageSampler]] [[vk::binding(1, 0)]] SamplerState scrambleSampler;
+
+[[vk::image_format("rgba16f")]] [[vk::binding(2, 0)]] RWTexture2DArray<float32_t4> outImage;
+
+#if PATH_TRACER_USE_RWMC
+[[vk::image_format("rgba16f")]] [[vk::binding(3, 0)]] RWTexture2DArray<float32_t4> cascade;
+#endif
+
+#include "example_common.hlsl"
+#include "rand_gen.hlsl"
+#include "intersector.hlsl"
+#include "material_system.hlsl"
+#include "next_event_estimator.hlsl"
+
+using namespace nbl;
+using namespace hlsl;

31_HLSLPathTracer/app_resources/hlsl/compute.render.linear.entrypoints.hlsl

@@ -0,0 +1,21 @@
+#ifndef PATH_TRACER_ENTRYPOINT_NAME
+#define PATH_TRACER_ENTRYPOINT_NAME main
+#endif
+
+#ifndef PATH_TRACER_ENTRYPOINT_POLYGON_METHOD
+#define PATH_TRACER_ENTRYPOINT_POLYGON_METHOD PPM_APPROX_PROJECTED_SOLID_ANGLE
+#endif
+
+#if !PATH_TRACER_ENABLE_LINEAR
+#error Linear entrypoint requested while PATH_TRACER_ENABLE_LINEAR is disabled
+#endif
+
+[numthreads(RenderWorkgroupSize, 1, 1)]
+[shader("compute")]
+void PATH_TRACER_ENTRYPOINT_NAME(uint32_t3 threadID : SV_DispatchThreadID)
+{
+	pathtracer_render_variant::runLinear<PATH_TRACER_ENTRYPOINT_POLYGON_METHOD>(threadID);
+}
+
+#undef PATH_TRACER_ENTRYPOINT_POLYGON_METHOD
+#undef PATH_TRACER_ENTRYPOINT_NAME

31_HLSLPathTracer/app_resources/hlsl/compute.render.persistent.entrypoints.hlsl

@@ -0,0 +1,21 @@
+#ifndef PATH_TRACER_ENTRYPOINT_NAME
+#define PATH_TRACER_ENTRYPOINT_NAME mainPersistent
+#endif
+
+#ifndef PATH_TRACER_ENTRYPOINT_POLYGON_METHOD
+#define PATH_TRACER_ENTRYPOINT_POLYGON_METHOD PPM_APPROX_PROJECTED_SOLID_ANGLE
+#endif
+
+#if !PATH_TRACER_ENABLE_PERSISTENT
+#error Persistent entrypoint requested while PATH_TRACER_ENABLE_PERSISTENT is disabled
+#endif
+
+[numthreads(RenderWorkgroupSize, 1, 1)]
+[shader("compute")]
+void PATH_TRACER_ENTRYPOINT_NAME(uint32_t3 threadID : SV_DispatchThreadID)
+{
+	pathtracer_render_variant::runPersistent<PATH_TRACER_ENTRYPOINT_POLYGON_METHOD>();
+}
+
+#undef PATH_TRACER_ENTRYPOINT_POLYGON_METHOD
+#undef PATH_TRACER_ENTRYPOINT_NAME

31_HLSLPathTracer/app_resources/hlsl/compute_render_scene_impl.hlsl

@@ -0,0 +1,159 @@
+#ifndef PATH_TRACER_USE_RWMC
+#error PATH_TRACER_USE_RWMC must be defined before including compute_render_scene_impl.hlsl
+#endif
+
+namespace pathtracer_render_variant
+{
+using namespace nbl;
+using namespace hlsl;
+
+using ray_dir_info_t = bxdf::ray_dir_info::SBasic<float>;
+using iso_interaction = PTIsotropicInteraction<ray_dir_info_t, spectral_t>;
+using aniso_interaction = PTAnisotropicInteraction<iso_interaction>;
+using sample_t = bxdf::SLightSample<ray_dir_info_t>;
+using iso_cache = bxdf::SIsotropicMicrofacetCache<float>;
+using aniso_cache = bxdf::SAnisotropicMicrofacetCache<iso_cache>;
+
+using iso_config_t = PTIsoConfiguration<sample_t, iso_interaction, spectral_t>;
+using iso_microfacet_config_t = PTIsoMicrofacetConfiguration<sample_t, iso_interaction, iso_cache, spectral_t>;
+
+using diffuse_bxdf_type = bxdf::reflection::SOrenNayar<iso_config_t>;
+using conductor_bxdf_type = bxdf::reflection::SGGXIsotropic<iso_microfacet_config_t>;
+using dielectric_bxdf_type = bxdf::transmission::SGGXDielectricIsotropic<iso_microfacet_config_t>;
+using iri_conductor_bxdf_type = bxdf::reflection::SIridescent<iso_microfacet_config_t>;
+using iri_dielectric_bxdf_type = bxdf::transmission::SIridescent<iso_microfacet_config_t>;
+
+using payload_type = Payload<float>;
+using randgen_type = RandomUniformND<Xoroshiro64Star, 3>;
+using material_system_type = MaterialSystem<bxdfnode_type, diffuse_bxdf_type, conductor_bxdf_type, dielectric_bxdf_type, iri_conductor_bxdf_type, iri_dielectric_bxdf_type, scene_type>;
+
+#if PATH_TRACER_USE_RWMC
+using accumulator_type = rwmc::CascadeAccumulator<rwmc::DefaultCascades<float32_t3, CascadeCount> >;
+#else
+using accumulator_type = path_tracing::DefaultAccumulator<float32_t3>;
+#endif
+
+template<NEEPolygonMethod PPM>
+struct SVariantTypes
+{
+	using ray_type = Ray<payload_type, PPM>;
+	using raygen_type = path_tracing::BasicRayGenerator<ray_type>;
+	using intersector_type = Intersector<ray_type, scene_type, aniso_interaction>;
+	using nee_type = NextEventEstimator<scene_type, light_type, ray_type, sample_t, aniso_interaction, LIGHT_TYPE, PPM>;
+	using pathtracer_type = path_tracing::Unidirectional<randgen_type, ray_type, intersector_type, material_system_type, nee_type, accumulator_type, scene_type>;
+};
+
+RenderPushConstants getRenderPushConstants()
+{
+#if PATH_TRACER_USE_RWMC
+	return ::pc.renderPushConstants;
+#else
+	return ::pc;
+#endif
+}
+
+template<NEEPolygonMethod PPM>
+void tracePixel(int32_t2 coords)
+{
+	const RenderPushConstants renderPushConstants = getRenderPushConstants();
+	using variant_types = SVariantTypes<PPM>;
+
+	uint32_t width, height, imageArraySize;
+	::outImage.GetDimensions(width, height, imageArraySize);
+	if (any(coords < int32_t2(0, 0)) || any(coords >= int32_t2(width, height)))
+		return;
+
+	float32_t2 texCoord = float32_t2(coords) / float32_t2(width, height);
+	texCoord.y = 1.0 - texCoord.y;
+
+	if (((renderPushConstants.depth - 1) >> MaxDepthLog2) > 0 || ((renderPushConstants.sampleCount - 1) >> MaxSamplesLog2) > 0)
+	{
+		::outImage[uint3(coords.x, coords.y, 0)] = float32_t4(1.0, 0.0, 0.0, 1.0);
+		return;
+	}
+
+	typename variant_types::pathtracer_type pathtracer;
+
+	uint2 scrambleDim;
+	::scramblebuf.GetDimensions(scrambleDim.x, scrambleDim.y);
+	const float32_t2 pixOffsetParam = float32_t2(1.0, 1.0) / float32_t2(scrambleDim);
+
+	float32_t4 NDC = float32_t4(texCoord * float32_t2(2.0, -2.0) + float32_t2(-1.0, 1.0), 0.0, 1.0);
+	float32_t3 camPos;
+	{
+		float32_t4 tmp = mul(renderPushConstants.invMVP, NDC);
+		camPos = tmp.xyz / tmp.w;
+		NDC.z = 1.0;
+	}
+
+	scene_type scene;
+	scene.updateLight(renderPushConstants.generalPurposeLightMatrix);
+
+	typename variant_types::raygen_type rayGen;
+	rayGen.pixOffsetParam = pixOffsetParam;
+	rayGen.camPos = camPos;
+	rayGen.NDC = NDC;
+	rayGen.invMVP = renderPushConstants.invMVP;
+
+	pathtracer.scene = scene;
+	pathtracer.randGen = randgen_type::create(::scramblebuf[coords].rg, renderPushConstants.pSampleSequence);
+	pathtracer.nee.lights = lights;
+	pathtracer.materialSystem.bxdfs = bxdfs;
+	pathtracer.bxdfPdfThreshold = 0.0001;
+	pathtracer.lumaContributionThreshold = hlsl::dot(colorspace::scRGBtoXYZ[1], colorspace::eotf::sRGB(hlsl::promote<spectral_t>(1.0 / 255.0)));
+	pathtracer.spectralTypeToLumaCoeffs = colorspace::scRGBtoXYZ[1];
+
+#if PATH_TRACER_USE_RWMC
+	accumulator_type accumulator = accumulator_type::create(::pc.splattingParameters);
+#else
+	accumulator_type accumulator = accumulator_type::create();
+#endif
+
+	for (int i = 0; i < renderPushConstants.sampleCount; ++i)
+	{
+		const float32_t3 uvw = pathtracer.randGen(0u, i);
+		typename variant_types::ray_type ray = rayGen.generate(uvw);
+		ray.initPayload();
+		pathtracer.sampleMeasure(ray, i, renderPushConstants.depth, accumulator);
+	}
+
+#if PATH_TRACER_USE_RWMC
+	for (uint32_t i = 0; i < CascadeCount; ++i)
+		::cascade[uint3(coords.x, coords.y, i)] = float32_t4(accumulator.accumulation.data[i], 1.0f);
+#else
+	::outImage[uint3(coords.x, coords.y, 0)] = float32_t4(accumulator.accumulation, 1.0);
+#endif
+}
+
+#if PATH_TRACER_ENABLE_LINEAR
+template<NEEPolygonMethod PPM>
+void runLinear(uint32_t3 threadID)
+{
+	uint32_t width, height, imageArraySize;
+	::outImage.GetDimensions(width, height, imageArraySize);
+	tracePixel<PPM>(int32_t2(threadID.x % width, threadID.x / width));
+}
+#endif
+
+#if PATH_TRACER_ENABLE_PERSISTENT
+template<NEEPolygonMethod PPM>
+void runPersistent()
+{
+	uint32_t width, height, imageArraySize;
+	::outImage.GetDimensions(width, height, imageArraySize);
+	const uint32_t numWorkgroupsX = width / RenderWorkgroupSizeSqrt;
+	const uint32_t numWorkgroupsY = height / RenderWorkgroupSizeSqrt;
+
+	[loop]
+	for (uint32_t wgBase = glsl::gl_WorkGroupID().x; wgBase < numWorkgroupsX * numWorkgroupsY; wgBase += glsl::gl_NumWorkGroups().x)
+	{
+		const int32_t2 wgCoords = int32_t2(wgBase % numWorkgroupsX, wgBase / numWorkgroupsX);
+		morton::code<true, 32, 2> mc;
+		mc.value = glsl::gl_LocalInvocationIndex().x;
+		const int32_t2 localCoords = _static_cast<int32_t2>(mc);
+		tracePixel<PPM>(wgCoords * int32_t2(RenderWorkgroupSizeSqrt, RenderWorkgroupSizeSqrt) + localCoords);
+	}
+}
+#endif
+}
+#undef PATH_TRACER_USE_RWMC

31_HLSLPathTracer/app_resources/hlsl/imgui.unified.hlsl

@@ -0,0 +1,9 @@
+#define NBL_TEXTURES_BINDING_IX 0
+#define NBL_SAMPLER_STATES_BINDING_IX 1
+#define NBL_TEXTURES_SET_IX 0
+#define NBL_SAMPLER_STATES_SET_IX 0
+#define NBL_TEXTURES_COUNT 1
+#define NBL_SAMPLERS_COUNT 2
+
+#include "nbl/ext/ImGui/builtin/hlsl/fragment.hlsl"
+#include "nbl/ext/ImGui/builtin/hlsl/vertex.hlsl"