.gitmodules

@@ -66,6 +66,18 @@
 	path = modules/tone_mapping/lib/glsl-tone-map
 	url = https://github.com/dmnsgn/glsl-tone-map.git
 	branch = main
+[submodule "modules/denoising/lib/FidelityFX-Denoiser"]
+	path = modules/denoising/lib/FidelityFX-Denoiser
+	url = https://github.com/GPUOpen-Effects/FidelityFX-Denoiser.git
+	branch = master
+[submodule "modules/denoising/lib/FidelityFX-SSSR"]
+	path = modules/denoising/lib/FidelityFX-SSSR
+	url = https://github.com/GPUOpen-Effects/FidelityFX-SSSR.git
+	branch = master
+[submodule "modules/denoising/lib/Hybrid-Shadows"]
+	path = modules/denoising/lib/Hybrid-Shadows
+	url = https://github.com/GPUOpen-Effects/Hybrid-Shadows.git
+	branch = master
 [submodule "modules/asset_loader/lib/wuffs-mirror-release-c"]
 	path = modules/asset_loader/lib/wuffs-mirror-release-c
 	url = https://github.com/google/wuffs-mirror-release-c.git

README.md

@@ -47,6 +47,7 @@ the framework if used. You can configure/adjust the build using CMake if necessa
  - [Algorithm](modules/algorithm/README.md)
  - [Asset-Loader](modules/asset_loader/README.md)
  - [Camera](modules/asset_loader/README.md)
+ - [Denoising](modules/denoising/README.md)
  - [Effects](modules/effects/README.md)
  - [Geometry](modules/geometry/README.md)
  - [GUI](modules/gui/README.md)

modules/CMakeLists.txt

@@ -6,6 +6,7 @@ set(vkcv_modules_libraries)
 add_subdirectory(algorithm)
 add_subdirectory(asset_loader)
 add_subdirectory(camera)
+add_subdirectory(denoising)
 add_subdirectory(effects)
 add_subdirectory(geometry)
 add_subdirectory(gui)

modules/denoising/CMakeLists.txt

+cmake_minimum_required(VERSION 3.16)
+project(vkcv_denoising)
+
+# setting c++ standard for the project
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+set(vkcv_denoising_source ${PROJECT_SOURCE_DIR}/src)
+set(vkcv_denoising_include ${PROJECT_SOURCE_DIR}/include)
+
+set(vkcv_denoising_sources
+		${vkcv_denoising_include}/vkcv/denoising/Denoiser.hpp
+		${vkcv_denoising_source}/vkcv/denoising/Denoiser.cpp
+		
+		${vkcv_denoising_include}/vkcv/denoising/ShadowDenoiser.hpp
+		${vkcv_denoising_source}/vkcv/denoising/ShadowDenoiser.cpp
+		
+		${vkcv_denoising_include}/vkcv/denoising/ReflectionDenoiser.hpp
+		${vkcv_denoising_source}/vkcv/denoising/ReflectionDenoiser.cpp
+)
+
+filter_headers(vkcv_denoising_sources ${vkcv_denoising_include} vkcv_denoising_headers)
+
+# Setup some path variables to load libraries
+set(vkcv_denoising_lib lib)
+set(vkcv_denoising_lib_path ${PROJECT_SOURCE_DIR}/${vkcv_denoising_lib})
+
+# Check and load FidelityFX_Denoiser
+include(config/FidelityFX_Denoiser.cmake)
+
+# Add compile definitions depending on the build context of the module
+add_compile_definitions(${vkcv_denoising_definitions})
+
+set(vkcv_denoising_shaders ${PROJECT_SOURCE_DIR}/shaders)
+
+# adding source files to the project
+add_library(vkcv_denoising ${vkcv_build_attribute} ${vkcv_denoising_sources})
+set_target_properties(vkcv_denoising PROPERTIES PUBLIC_HEADER "${vkcv_denoising_headers}")
+
+# link the required libraries to the module
+target_link_libraries(vkcv_denoising
+		${vkcv_denoising_libraries}
+		vkcv
+		vkcv_shader_compiler
+)
+
+# including headers of dependencies and the VkCV framework
+target_include_directories(vkcv_denoising SYSTEM BEFORE PRIVATE
+		${vkcv_denoising_includes}
+		${vkcv_include}
+		${vkcv_includes}
+		${vkcv_shader_compiler_include}
+)
+
+# add the own include directory for public headers
+target_include_directories(vkcv_denoising BEFORE PUBLIC ${vkcv_denoising_include})
+
+if (vkcv_parent_scope)
+	list(APPEND vkcv_modules_includes ${vkcv_denoising_include})
+	list(APPEND vkcv_modules_libraries vkcv_denoising)
+	
+	set(vkcv_modules_includes ${vkcv_modules_includes} PARENT_SCOPE)
+	set(vkcv_modules_libraries ${vkcv_modules_libraries} PARENT_SCOPE)
+endif()
+
+install(TARGETS vkcv_denoising PUBLIC_HEADER DESTINATION
+		${CMAKE_INSTALL_INCLUDEDIR}/vkcv/denoising)

modules/denoising/README.md

+# Denoising
+
+A VkCV module to use denoising on images in realtime after rendering
+
+## Build
+
+### Dependencies (required):
+
+| Name of dependency                                                            | Used as submodule |
+|-------------------------------------------------------------------------------|-------------------|
+| [FidelityFX-Denoiser](https://github.com/GPUOpen-Effects/FidelityFX-Denoiser) | ✅                 |
+
+## Docs
+
+Here is a [link](https://userpages.uni-koblenz.de/~vkcv/doc/group__vkcv__denoising.html) to this module.

modules/denoising/config/FidelityFX_Denoiser.cmake

+
+use_git_submodule("${vkcv_denoising_lib_path}/FidelityFX-Denoiser" ffx_denoiser_status)
+
+if (${ffx_denoiser_status})
+	include_shader(${vkcv_denoising_lib_path}/FidelityFX-Denoiser/ffx-shadows-dnsr/ffx_denoiser_shadows_filter.h ${vkcv_denoising_include} ${vkcv_denoising_source})
+	include_shader(${vkcv_denoising_lib_path}/FidelityFX-Denoiser/ffx-shadows-dnsr/ffx_denoiser_shadows_prepare.h ${vkcv_denoising_include} ${vkcv_denoising_source})
+	include_shader(${vkcv_denoising_lib_path}/FidelityFX-Denoiser/ffx-shadows-dnsr/ffx_denoiser_shadows_tileclassification.h ${vkcv_denoising_include} ${vkcv_denoising_source})
+	include_shader(${vkcv_denoising_lib_path}/FidelityFX-Denoiser/ffx-shadows-dnsr/ffx_denoiser_shadows_util.h ${vkcv_denoising_include} ${vkcv_denoising_source})
+	
+	include_shader(${vkcv_denoising_lib_path}/FidelityFX-Denoiser/ffx-reflection-dnsr/ffx_denoiser_reflections_common.h ${vkcv_denoising_include} ${vkcv_denoising_source})
+	include_shader(${vkcv_denoising_lib_path}/FidelityFX-Denoiser/ffx-reflection-dnsr/ffx_denoiser_reflections_config.h ${vkcv_denoising_include} ${vkcv_denoising_source})
+	include_shader(${vkcv_denoising_lib_path}/FidelityFX-Denoiser/ffx-reflection-dnsr/ffx_denoiser_reflections_prefilter.h ${vkcv_denoising_include} ${vkcv_denoising_source})
+	include_shader(${vkcv_denoising_lib_path}/FidelityFX-Denoiser/ffx-reflection-dnsr/ffx_denoiser_reflections_reproject.h ${vkcv_denoising_include} ${vkcv_denoising_source})
+	include_shader(${vkcv_denoising_lib_path}/FidelityFX-Denoiser/ffx-reflection-dnsr/ffx_denoiser_reflections_resolve_temporal.h ${vkcv_denoising_include} ${vkcv_denoising_source})
+	
+	list(APPEND vkcv_denoising_sources ${vkcv_denoising_source}/ffx_denoiser_shadows_filter.h.cxx)
+	list(APPEND vkcv_denoising_sources ${vkcv_denoising_source}/ffx_denoiser_shadows_prepare.h.cxx)
+	list(APPEND vkcv_denoising_sources ${vkcv_denoising_source}/ffx_denoiser_shadows_tileclassification.h.cxx)
+	list(APPEND vkcv_denoising_sources ${vkcv_denoising_source}/ffx_denoiser_shadows_util.h.cxx)
+	
+	list(APPEND vkcv_denoising_sources ${vkcv_denoising_source}/ffx_denoiser_reflections_common.h.cxx)
+	list(APPEND vkcv_denoising_sources ${vkcv_denoising_source}/ffx_denoiser_reflections_config.h.cxx)
+	list(APPEND vkcv_denoising_sources ${vkcv_denoising_source}/ffx_denoiser_reflections_prefilter.h.cxx)
+	list(APPEND vkcv_denoising_sources ${vkcv_denoising_source}/ffx_denoiser_reflections_reproject.h.cxx)
+	list(APPEND vkcv_denoising_sources ${vkcv_denoising_source}/ffx_denoiser_reflections_resolve_temporal.h.cxx)
+endif ()
+
+use_git_submodule("${vkcv_denoising_lib_path}/Hybrid-Shadows" ffx_denoiser_shadows_status)
+
+if (${ffx_denoiser_shadows_status})
+	include_shader(${vkcv_denoising_lib_path}/Hybrid-Shadows/src/Shaders/filter_soft_shadows_pass_d3d12.hlsl ${vkcv_denoising_include} ${vkcv_denoising_source})
+	include_shader(${vkcv_denoising_lib_path}/Hybrid-Shadows/src/Shaders/prepare_shadow_mask_d3d12.hlsl ${vkcv_denoising_include} ${vkcv_denoising_source})
+	include_shader(${vkcv_denoising_lib_path}/Hybrid-Shadows/src/Shaders/tile_classification_d3d12.hlsl ${vkcv_denoising_include} ${vkcv_denoising_source})
+	
+	list(APPEND vkcv_denoising_sources ${vkcv_denoising_source}/filter_soft_shadows_pass_d3d12.hlsl.cxx)
+	list(APPEND vkcv_denoising_sources ${vkcv_denoising_source}/prepare_shadow_mask_d3d12.hlsl.cxx)
+	list(APPEND vkcv_denoising_sources ${vkcv_denoising_source}/tile_classification_d3d12.hlsl.cxx)
+endif()
+
+use_git_submodule("${vkcv_denoising_lib_path}/FidelityFX-SSSR" ffx_denoiser_reflections_status)
+
+if (${ffx_denoiser_reflections_status})
+	include_shader(${vkcv_denoising_lib_path}/FidelityFX-SSSR/sample/src/Shaders/Common.hlsl ${vkcv_denoising_include} ${vkcv_denoising_source})
+	include_shader(${vkcv_denoising_lib_path}/FidelityFX-SSSR/sample/src/Shaders/Prefilter.hlsl ${vkcv_denoising_include} ${vkcv_denoising_source})
+	include_shader(${vkcv_denoising_lib_path}/FidelityFX-SSSR/sample/src/Shaders/Reproject.hlsl ${vkcv_denoising_include} ${vkcv_denoising_source})
+	include_shader(${vkcv_denoising_lib_path}/FidelityFX-SSSR/sample/src/Shaders/ResolveTemporal.hlsl ${vkcv_denoising_include} ${vkcv_denoising_source})
+	
+	list(APPEND vkcv_denoising_sources ${vkcv_denoising_source}/Common.hlsl.cxx)
+	list(APPEND vkcv_denoising_sources ${vkcv_denoising_source}/Prefilter.hlsl.cxx)
+	list(APPEND vkcv_denoising_sources ${vkcv_denoising_source}/Reproject.hlsl.cxx)
+	list(APPEND vkcv_denoising_sources ${vkcv_denoising_source}/ResolveTemporal.hlsl.cxx)
+endif()

modules/denoising/include/vkcv/denoising/Denoiser.hpp

+#pragma once
+
+#include <vkcv/Core.hpp>
+
+namespace vkcv::denoising {
+	
+	class Denoiser {
+	protected:
+		/**
+         * Reference to the current Core instance.
+         */
+		Core& m_core;
+		
+	public:
+		/**
+         * Constructor to create a denoiser instance.
+         *
+         * @param[in,out] core Reference to a Core instance
+         */
+		explicit Denoiser(Core& core);
+	
+		~Denoiser() = default;
+		
+		/**
+         * Record the commands of the given denoiser instance to
+         * reduce the noise from the image of the input handle and
+         * pass the important details to the output image handle.
+         *
+         * @param[in] cmdStream Command stream handle to record commands
+         * @param[in] input Input image handle
+         * @param[in] output Output image handle
+         */
+		virtual void recordDenoising(const CommandStreamHandle& cmdStream,
+									 const ImageHandle& input,
+									 const ImageHandle& output) = 0;
+		
+	};
+	
+}

modules/denoising/include/vkcv/denoising/ReflectionDenoiser.hpp

+#pragma once
+
+#include "Denoiser.hpp"
+
+namespace vkcv::denoising {
+	
+	class ReflectionDenoiser : public Denoiser {
+	private:
+		ComputePipelineHandle m_prefilterPipeline;
+		ComputePipelineHandle m_reprojectPipeline;
+		ComputePipelineHandle m_resolveTemporalPipeline;
+
+		/**
+		 * The common descriptor set layout.
+		 */
+		DescriptorSetLayoutHandle m_commonDescriptorSetLayout;
+
+		/**
+		 * The common descriptor set.
+		 */
+		DescriptorSetHandle m_commonDescriptorSet;
+		
+		/**
+		 * The descriptor set layout of the filter pipeline.
+		 */
+		DescriptorSetLayoutHandle m_prefilterDescriptorSetLayout;
+		
+		/**
+		 * The descriptor set for the filter pipeline.
+		 */
+		DescriptorSetHandle m_prefilterDescriptorSet;
+		
+		/**
+		 * The descriptor set layout of the reproject pipeline.
+		 */
+		DescriptorSetLayoutHandle m_reprojectDescriptorSetLayout;
+		
+		/**
+		 * The descriptor set for the reproject pipeline.
+		 */
+		DescriptorSetHandle m_reprojectDescriptorSet;
+		
+		/**
+		 * The descriptor set layout of the resolve temporal pipeline.
+		 */
+		DescriptorSetLayoutHandle m_resolveTemporalDescriptorSetLayout;
+		
+		/**
+		 * The descriptor set for the resolve temporal pipeline.
+		 */
+		DescriptorSetHandle m_resolveTemporalDescriptorSet;
+		
+	public:
+		/**
+		 * Constructor to create a reflection denoiser instance.
+		 *
+		 * @param[in,out] core Reference to a Core instance
+		 */
+		explicit ReflectionDenoiser(Core& core);
+		
+		/**
+		 * Record the commands of the given reflection denoiser instance
+		 * to reduce the noise from the image of the input handle and
+		 * pass the important details to the output image handle.
+		 *
+		 * @param[in] cmdStream Command stream handle to record commands
+		 * @param[in] input Input image handle
+		 * @param[in] output Output image handle
+		 */
+		void recordDenoising(const CommandStreamHandle& cmdStream,
+							 const ImageHandle& input,
+							 const ImageHandle& output) override;
+		
+	};
+	
+}

modules/denoising/include/vkcv/denoising/ShadowDenoiser.hpp

+#pragma once
+
+#include <vkcv/Handles.hpp>
+
+#include "Denoiser.hpp"
+
+namespace vkcv::denoising {
+	
+	class ShadowDenoiser : public Denoiser {
+	private:
+		ComputePipelineHandle m_filterPipeline;
+		ComputePipelineHandle m_preparePipeline;
+		ComputePipelineHandle m_tileClassificationPipeline;
+		
+		/**
+         * The descriptor set layout of the filter pipeline.
+         */
+		DescriptorSetLayoutHandle m_filterDescriptorSetLayout;
+		
+		/**
+		 * The descriptor set for the filter pipeline.
+		 */
+		DescriptorSetHandle m_filterDescriptorSet;
+		
+		/**
+         * The descriptor set layout of the prepare pipeline.
+         */
+		DescriptorSetLayoutHandle m_prepareDescriptorSetLayout;
+		
+		/**
+		 * The descriptor set for the prepare pipeline.
+		 */
+		DescriptorSetHandle m_prepareDescriptorSet;
+		
+		/**
+         * The descriptor set layout of the tile classification
+         * pipeline.
+         */
+		DescriptorSetLayoutHandle m_tileClassificationDescriptorSetLayout;
+		
+		/**
+		 * The descriptor set for the tile classification
+		 * pipeline.
+		 */
+		DescriptorSetHandle m_tileClassificationDescriptorSet;
+	
+	public:
+		/**
+         * Constructor to create a shadow denoiser instance.
+         *
+         * @param[in,out] core Reference to a Core instance
+         */
+		explicit ShadowDenoiser(Core& core);
+		
+		/**
+         * Record the commands of the given shadow denoiser instance
+         * to reduce the noise from the image of the input handle and
+         * pass the important details to the output image handle.
+         *
+         * @param[in] cmdStream Command stream handle to record commands
+         * @param[in] input Input image handle
+         * @param[in] output Output image handle
+         */
+		void recordDenoising(const CommandStreamHandle& cmdStream,
+							 const ImageHandle& input,
+							 const ImageHandle& output) override;
+		
+	};
+	
+}

FidelityFX-Denoiser @ 137a7c6f

+Subproject commit 137a7c6fc8c5bec914cf1f0b586e1d7badb9f64c

FidelityFX-SSSR @ 34dcacd1

+Subproject commit 34dcacd1feefcfab2855b82e76c7d711f2020a75

Hybrid-Shadows @ 0cf18422

+Subproject commit 0cf18422a73eda8b4a23870091372a7717387f3e

modules/denoising/src/vkcv/denoising/Denoiser.cpp

+
+#include "vkcv/denoising/Denoiser.hpp"
+
+namespace vkcv::denoising {
+	
+	Denoiser::Denoiser(Core &core) : m_core(core) {}
+	
+}

modules/denoising/src/vkcv/denoising/ReflectionDenoiser.cpp

+
+#include "vkcv/denoising/ReflectionDenoiser.hpp"
+
+#include <vkcv/File.hpp>
+#include <vkcv/shader/SlangCompiler.hpp>
+
+#include "ffx_denoiser_reflections_common.h.hxx"
+#include "ffx_denoiser_reflections_config.h.hxx"
+#include "ffx_denoiser_reflections_prefilter.h.hxx"
+#include "ffx_denoiser_reflections_reproject.h.hxx"
+#include "ffx_denoiser_reflections_resolve_temporal.h.hxx"
+
+#include "Common.hlsl.hxx"
+#include "Prefilter.hlsl.hxx"
+#include "Reproject.hlsl.hxx"
+#include "ResolveTemporal.hlsl.hxx"
+
+namespace vkcv::denoising {
+	
+	static DescriptorBindings getDescriptorBindings(uint32_t step) {
+		DescriptorBindings descriptorBindings = {};
+		uint32_t inputs, outputs;
+
+		switch (step) {
+			case 0:
+				{
+					auto binding = DescriptorBinding {
+						0,
+						DescriptorType::UNIFORM_BUFFER,
+						1,
+						ShaderStage::COMPUTE,
+						false,
+						false
+					};
+
+					descriptorBindings.insert(std::make_pair(0, binding));
+				}
+
+				return descriptorBindings;
+			case 1:
+				inputs = 7;
+				outputs = 3;
+				break;
+			case 2:
+				inputs = 13;
+				outputs = 4;
+				break;
+			case 3:
+				inputs = 6;
+				outputs = 3;
+				break;
+			default:
+				return descriptorBindings;
+		}
+
+		for (uint32_t i = 0; i < inputs; i++) {
+			auto input_binding = DescriptorBinding {
+				i,
+				DescriptorType::IMAGE_SAMPLED,
+				1,
+				ShaderStage::COMPUTE,
+				false,
+				false
+			};
+
+			descriptorBindings.insert(std::make_pair(i, input_binding));
+		}
+
+		{
+			auto sampler_binding = DescriptorBinding {
+				inputs + 0,
+				DescriptorType::SAMPLER,
+				1,
+				ShaderStage::COMPUTE,
+				false,
+				false
+			};
+
+			descriptorBindings.insert(std::make_pair(inputs + 0, sampler_binding));
+		}
+
+		for (uint32_t i = 0; i < outputs; i++) {
+			auto output_binding = DescriptorBinding {
+				inputs + 1 + i,
+				DescriptorType::IMAGE_STORAGE,
+				1,
+				ShaderStage::COMPUTE,
+				false,
+				false
+			};
+
+			descriptorBindings.insert(std::make_pair(inputs + 1 + i, output_binding));
+		}
+
+		{
+			auto buffer_binding = DescriptorBinding {
+				inputs + 1 + outputs,
+				DescriptorType::STORAGE_BUFFER,
+				1,
+				ShaderStage::COMPUTE,
+				false,
+				false
+			};
+
+			descriptorBindings.insert(std::make_pair(inputs + 1 + outputs, buffer_binding));
+		}
+		
+		return descriptorBindings;
+	}
+	
+	ReflectionDenoiser::ReflectionDenoiser(Core &core) :
+	Denoiser(core),
+
+	m_prefilterPipeline(),
+	m_reprojectPipeline(),
+	m_resolveTemporalPipeline(),
+
+	m_commonDescriptorSetLayout(m_core.createDescriptorSetLayout(getDescriptorBindings(0))),
+	m_commonDescriptorSet(m_core.createDescriptorSet(m_commonDescriptorSetLayout)),
+
+	m_prefilterDescriptorSetLayout(m_core.createDescriptorSetLayout(getDescriptorBindings(1))),
+	m_prefilterDescriptorSet(m_core.createDescriptorSet(m_prefilterDescriptorSetLayout)),
+
+	m_reprojectDescriptorSetLayout(m_core.createDescriptorSetLayout(getDescriptorBindings(2))),
+	m_reprojectDescriptorSet(m_core.createDescriptorSet(m_reprojectDescriptorSetLayout)),
+
+	m_resolveTemporalDescriptorSetLayout(m_core.createDescriptorSetLayout(getDescriptorBindings(3))),
+	m_resolveTemporalDescriptorSet(m_core.createDescriptorSet(m_resolveTemporalDescriptorSetLayout))
+	{
+		vkcv::shader::SlangCompiler compiler (vkcv::shader::SlangCompileProfile::HLSL);
+		
+		{
+			ShaderProgram program;
+			compiler.compileSourceWithHeaders(
+					vkcv::ShaderStage::COMPUTE,
+					PREFILTER_HLSL_SHADER,
+					{
+						{ "ffx_denoiser_reflections_common.h", FFX_DENOISER_REFLECTIONS_COMMON_H_SHADER },
+						{ "ffx_denoiser_reflections_config.h", FFX_DENOISER_REFLECTIONS_CONFIG_H_SHADER },
+						{ "ffx_denoiser_reflections_prefilter.h", FFX_DENOISER_REFLECTIONS_PREFILTER_H_SHADER },
+						{ "Common.hlsl", COMMON_HLSL_SHADER }
+					},
+					[&program](vkcv::ShaderStage shaderStage,
+							   const std::filesystem::path& path) {
+						program.addShader(shaderStage, path);
+					}
+			);
+			
+			m_prefilterPipeline = m_core.createComputePipeline({ program, {
+				m_commonDescriptorSetLayout,
+				m_prefilterDescriptorSetLayout
+			}});
+			
+			DescriptorWrites writes;
+			m_core.writeDescriptorSet(m_prefilterDescriptorSet, writes);
+		}
+		
+		{
+			ShaderProgram program;
+			compiler.compileSourceWithHeaders(
+					vkcv::ShaderStage::COMPUTE,
+					REPROJECT_HLSL_SHADER,
+					{
+							{ "ffx_denoiser_reflections_common.h", FFX_DENOISER_REFLECTIONS_COMMON_H_SHADER },
+							{ "ffx_denoiser_reflections_config.h", FFX_DENOISER_REFLECTIONS_CONFIG_H_SHADER },
+							{ "ffx_denoiser_reflections_reproject.h", FFX_DENOISER_REFLECTIONS_REPROJECT_H_SHADER },
+							{ "Common.hlsl", COMMON_HLSL_SHADER }
+					},
+					[&program](vkcv::ShaderStage shaderStage,
+							   const std::filesystem::path& path) {
+						program.addShader(shaderStage, path);
+					}
+			);
+			
+			m_reprojectPipeline = m_core.createComputePipeline({ program, {
+				m_commonDescriptorSetLayout,
+				m_reprojectDescriptorSetLayout
+			}});
+			
+			DescriptorWrites writes;
+			m_core.writeDescriptorSet(m_reprojectDescriptorSet, writes);
+		}
+		
+		{
+			ShaderProgram program;
+			compiler.compileSourceWithHeaders(
+					vkcv::ShaderStage::COMPUTE,
+					RESOLVETEMPORAL_HLSL_SHADER,
+					{
+							{ "ffx_denoiser_reflections_common.h", FFX_DENOISER_REFLECTIONS_COMMON_H_SHADER },
+							{ "ffx_denoiser_reflections_config.h", FFX_DENOISER_REFLECTIONS_CONFIG_H_SHADER },
+							{ "ffx_denoiser_reflections_resolve_temporal.h", FFX_DENOISER_REFLECTIONS_RESOLVE_TEMPORAL_H_SHADER },
+							{ "Common.hlsl", COMMON_HLSL_SHADER }
+					},
+					[&program](vkcv::ShaderStage shaderStage,
+							   const std::filesystem::path& path) {
+						program.addShader(shaderStage, path);
+					}
+			);
+			
+			m_resolveTemporalPipeline = m_core.createComputePipeline({ program, {
+				m_commonDescriptorSetLayout,
+				m_resolveTemporalDescriptorSetLayout
+			}});
+			
+			DescriptorWrites writes;
+			m_core.writeDescriptorSet(m_resolveTemporalDescriptorSet, writes);
+		}
+	}
+	
+	void ReflectionDenoiser::recordDenoising(const CommandStreamHandle &cmdStream, const ImageHandle &input,
+											 const ImageHandle &output) {
+		
+	}
+	
+}

modules/denoising/src/vkcv/denoising/ShadowDenoiser.cpp

+
+#include "vkcv/denoising/ShadowDenoiser.hpp"
+
+#include <vkcv/File.hpp>
+#include <vkcv/shader/HLSLCompiler.hpp>
+
+#include "ffx_denoiser_shadows_filter.h.hxx"
+#include "ffx_denoiser_shadows_prepare.h.hxx"
+#include "ffx_denoiser_shadows_tileclassification.h.hxx"
+#include "ffx_denoiser_shadows_util.h.hxx"
+
+#include "filter_soft_shadows_pass_d3d12.hlsl.hxx"
+#include "prepare_shadow_mask_d3d12.hlsl.hxx"
+#include "tile_classification_d3d12.hlsl.hxx"
+
+namespace vkcv::denoising {
+	
+	static DescriptorBindings getDescriptorBindings() {
+		DescriptorBindings descriptorBindings = {};
+		
+		return descriptorBindings;
+	}
+	
+	ShadowDenoiser::ShadowDenoiser(Core &core) :
+	Denoiser(core),
+	
+	m_filterPipeline(),
+	m_preparePipeline(),
+	m_tileClassificationPipeline(),
+	
+	m_filterDescriptorSetLayout(m_core.createDescriptorSetLayout(getDescriptorBindings())),
+	m_filterDescriptorSet(m_core.createDescriptorSet(m_filterDescriptorSetLayout)),
+	
+	m_prepareDescriptorSetLayout(m_core.createDescriptorSetLayout(getDescriptorBindings())),
+	m_prepareDescriptorSet(m_core.createDescriptorSet(m_prepareDescriptorSetLayout)),
+	
+	m_tileClassificationDescriptorSetLayout(m_core.createDescriptorSetLayout(getDescriptorBindings())),
+	m_tileClassificationDescriptorSet(m_core.createDescriptorSet(m_tileClassificationDescriptorSetLayout))
+	{
+		vkcv::shader::HLSLCompiler compiler;
+		
+		{
+			ShaderProgram program;
+			compiler.compileSourceWithHeaders(
+					vkcv::ShaderStage::COMPUTE,
+					FILTER_SOFT_SHADOWS_PASS_D3D12_HLSL_SHADER,
+					{
+							{ "ffx_shadows_dnsr/ffx_denoiser_shadows_filter.h", FFX_DENOISER_SHADOWS_FILTER_H_SHADER },
+							{ "ffx_shadows_dnsr/ffx_denoiser_shadows_util.h", FFX_DENOISER_SHADOWS_UTIL_H_SHADER }
+					},
+					[&program](vkcv::ShaderStage shaderStage,
+							   const std::filesystem::path& path) {
+						program.addShader(shaderStage, path);
+					}
+			);
+			
+			m_filterPipeline = m_core.createComputePipeline({ program, {
+					m_filterDescriptorSetLayout
+			}});
+			
+			DescriptorWrites writes;
+			m_core.writeDescriptorSet(m_filterDescriptorSet, writes);
+		}
+		
+		{
+			ShaderProgram program;
+			compiler.compileSourceWithHeaders(
+					vkcv::ShaderStage::COMPUTE,
+					PREPARE_SHADOW_MASK_D3D12_HLSL_SHADER,
+					{
+						{ "ffx_shadows_dnsr/ffx_denoiser_shadows_prepare.h", FFX_DENOISER_SHADOWS_PREPARE_H_SHADER },
+						{ "ffx_shadows_dnsr/ffx_denoiser_shadows_util.h", FFX_DENOISER_SHADOWS_UTIL_H_SHADER }
+					},
+					[&program](vkcv::ShaderStage shaderStage,
+							   const std::filesystem::path& path) {
+						program.addShader(shaderStage, path);
+					}
+			);
+			
+			m_preparePipeline = m_core.createComputePipeline({ program, {
+					m_prepareDescriptorSetLayout
+			}});
+			
+			DescriptorWrites writes;
+			m_core.writeDescriptorSet(m_prepareDescriptorSet, writes);
+		}
+		
+		{
+			ShaderProgram program;
+			compiler.compileSourceWithHeaders(
+					vkcv::ShaderStage::COMPUTE,
+					TILE_CLASSIFICATION_D3D12_HLSL_SHADER,
+					{
+							{ "ffx_shadows_dnsr/ffx_denoiser_shadows_tileclassification.h", FFX_DENOISER_SHADOWS_TILECLASSIFICATION_H_SHADER },
+							{ "ffx_shadows_dnsr/ffx_denoiser_shadows_util.h", FFX_DENOISER_SHADOWS_UTIL_H_SHADER }
+					},
+					[&program](vkcv::ShaderStage shaderStage,
+							   const std::filesystem::path& path) {
+						program.addShader(shaderStage, path);
+					}
+			);
+			
+			m_tileClassificationPipeline = m_core.createComputePipeline({ program, {
+					m_tileClassificationDescriptorSetLayout
+			}});
+			
+			DescriptorWrites writes;
+			m_core.writeDescriptorSet(m_tileClassificationDescriptorSet, writes);
+		}
+	}
+	
+	void ShadowDenoiser::recordDenoising(const CommandStreamHandle &cmdStream,
+										 const ImageHandle &input,
+										 const ImageHandle &output) {
+		
+	}
+	
+}

modules/shader_compiler/include/vkcv/shader/Compiler.hpp

@@ -37,6 +37,16 @@ namespace vkcv::shader {
          */
 		Dictionary<std::string, std::string> m_defines;
 		
+		/**
+		 * Process the shader source code for further compilation or inclusion.
+		 *
+		 * Ideally this method will not do anything at all!
+		 *
+		 * @param[in] shaderSource Source of shader
+		 * @return Processed source of shader
+		 */
+		virtual std::string processShaderSource(const std::string& shaderSource);
+		
 	public:
         /**
          * Compile a shader from source for a target stage with a custom shader

modules/shader_compiler/include/vkcv/shader/HLSLCompiler.hpp

@@ -22,7 +22,7 @@ namespace vkcv::shader {
 	class HLSLCompiler : public GlslangCompiler {
 	private:
 		HLSLCompileTarget m_target;
-	
+		
 	public:
 		/**
 		 * The constructor of a runtime HLSL shader compiler instance.

modules/shader_compiler/src/vkcv/shader/Compiler.cpp

@@ -7,6 +7,10 @@
 
 namespace vkcv::shader {
 	
+	std::string Compiler::processShaderSource(const std::string &shaderSource) {
+		return shaderSource;
+	}
+	
 	bool Compiler::compileSourceWithHeaders(ShaderStage shaderStage,
 											const std::string &shaderSource,
 											const Dictionary<std::filesystem::path, std::string> &shaderHeaders,
@@ -24,7 +28,7 @@ namespace vkcv::shader {
 				std::filesystem::create_directories(directory / header.first.parent_path());
 			}
 			
-			if (!writeTextToFile(directory / header.first, header.second)) {
+			if (!writeTextToFile(directory / header.first, processShaderSource(header.second))) {
 				return false;
 			}
 		}

modules/shader_compiler/src/vkcv/shader/GLSLCompiler.cpp

@@ -190,7 +190,7 @@ namespace vkcv::shader {
 		}
 
 		glslang::TProgram program;
-		std::string source (shaderSource);
+		std::string source = processShaderSource(shaderSource);
 		
 		if (!m_defines.empty()) {
 			std::ostringstream defines;

modules/shader_compiler/src/vkcv/shader/HLSLCompiler.cpp

@@ -162,7 +162,7 @@ namespace vkcv::shader {
 			vkcv_log(LogLevel::ERROR, "Shader stage not supported");
 			return false;
 		}
-		
+
 		glslang::TShader shader (language);
 		shader.setEntryPoint("main");
 		
@@ -181,7 +181,7 @@ namespace vkcv::shader {
 		);
 		
 		glslang::TProgram program;
-		std::string source (shaderSource);
+		std::string source = processShaderSource(shaderSource);
 		
 		if (!m_defines.empty()) {
 			std::ostringstream defines;