From df3573e3bdb1b8d54231e66376afc0d85c329893 Mon Sep 17 00:00:00 2001 From: dzhdan Date: Tue, 21 Mar 2023 14:37:46 +0400 Subject: [PATCH] v4.1.0: HIGHLIGHTS: - SH denoisers: SH (spherical harmonics) resolve replaced with a higher quality & specular-compatible SG (spherical gaussian) resolve - SH denoisers: introduced re-jittering after denoising which is essential for upscaling techniques - NRD: significantly reduced shader compilation & code linkage times - NRD: usability improvements - RELAX: added SH denoisers - REBLUR: bug fixes DETAILS: - SH denoisers: SH (spherical harmonics) resolve replaced with a higher quality & specular-compatible SG (spherical gaussian) resolve - SH denoisers: introduced re-jittering after denoising which is essential for upscaling techniques - NRD: introduced "ShaderMake" - NRD: usability improvement: removed "NRD_HEADER_ONLY" (added "NRD_INTERNAL" macro on the NRD side) - NRD: usability improvement: for internal compilation matrix packing is set to "column_major", to override possible "-Zpr" setting in the compiler command line - RELAX: added SH denoisers - RELAX: fixed regression for specular surface history weight - REBLUR: improved reprojection on surfaces with variadic roughness - REBLUR: fixed a resolution scale related bug in TS - REBLUR: slightly increased "lobeAngleFraction" - REBLUR: fixed smb-based accumulation for very high roughness - fixed VK validation errors after migrating to VK v1.3.239 - fixes for Linux - Cmake improvements - updated scripts - updated dependencies - updated README & UPDATE - refactoring --- .gitmodules | 5 + 1-Deploy.sh | 2 +- 2-Build.bat | 4 +- 2-Build.sh | 4 +- 4-Clean.bat | 1 + 4-Clean.sh | 1 + CMakeLists.txt | 328 ++--- External/MathLib | 2 +- External/ShaderMake | 1 + Images/Resolve.jpg | Bin 0 -> 191475 bytes Include/NRD.h | 6 +- Include/NRDDescs.h | 22 +- Include/NRDSettings.h | 4 +- Integration/NRDIntegration.h | 4 +- Integration/NRDIntegration.hpp | 2 +- README.md | 77 +- Resources/Version.h | 4 +- ShaderCompilation.cmake | 149 --- Shaders.cfg | 237 ++++ Shaders/Include/Common.hlsli | 25 + Shaders/Include/NRD.hlsli | 665 ++++++++--- Shaders/Include/REBLUR/REBLUR_Common.hlsli | 26 - .../REBLUR_Common_SpecularSpatialFilter.hlsli | 4 +- Shaders/Include/REBLUR/REBLUR_Config.hlsli | 9 +- .../REBLUR_DiffuseSpecular_HistoryFix.hlsli | 4 +- ...DiffuseSpecular_TemporalAccumulation.hlsli | 36 +- ...iffuseSpecular_TemporalStabilization.hlsli | 30 +- Shaders/Include/RELAX/RELAX_Common.hlsli | 70 +- .../RELAX/RELAX_DiffuseSpecular_Atrous.hlsli | 34 + .../RELAX_DiffuseSpecular_AtrousSmem.hlsli | 50 +- ...ELAX_DiffuseSpecular_HistoryClamping.hlsli | 47 +- .../RELAX_DiffuseSpecular_HistoryFix.hlsli | 43 +- ...iffuseSpecular_HitDistReconstruction.hlsli | 5 - .../RELAX/RELAX_DiffuseSpecular_PrePass.hlsli | 62 +- ...DiffuseSpecular_TemporalAccumulation.hlsli | 146 ++- Shaders/Include/SIGMA/SIGMA_Common.hlsli | 2 +- ...ular_TemporalStabilization.resources.hlsli | 6 +- ...LAX_DiffuseSpecular_Atrous.resources.hlsli | 29 + ...DiffuseSpecular_AtrousSmem.resources.hlsli | 21 + ...seSpecular_HistoryClamping.resources.hlsli | 28 + ...DiffuseSpecular_HistoryFix.resources.hlsli | 20 + ...AX_DiffuseSpecular_PrePass.resources.hlsli | 20 + ...cular_TemporalAccumulation.resources.hlsli | 32 + Shaders/Source/Clear_f.cs.hlsl | 6 +- Shaders/Source/Clear_ui.cs.hlsl | 6 +- ...R_DiffuseDirectionalOcclusion_Blur.cs.hlsl | 12 +- ...useDirectionalOcclusion_HistoryFix.cs.hlsl | 12 +- ...ffuseDirectionalOcclusion_PostBlur.cs.hlsl | 12 +- ...n_PostBlur_NoTemporalStabilization.cs.hlsl | 12 +- ...iffuseDirectionalOcclusion_PrePass.cs.hlsl | 12 +- ...onalOcclusion_TemporalAccumulation.cs.hlsl | 12 +- ...nalOcclusion_TemporalStabilization.cs.hlsl | 12 +- .../REBLUR_DiffuseOcclusion_Blur.cs.hlsl | 12 +- ...REBLUR_DiffuseOcclusion_HistoryFix.cs.hlsl | 12 +- ...useOcclusion_HitDistReconstruction.cs.hlsl | 12 +- ...cclusion_HitDistReconstruction_5x5.cs.hlsl | 12 +- ...n_PostBlur_NoTemporalStabilization.cs.hlsl | 12 +- .../REBLUR_DiffuseOcclusion_PrePass.cs.hlsl | 12 +- ...fuseOcclusion_TemporalAccumulation.cs.hlsl | 12 +- Shaders/Source/REBLUR_DiffuseSh_Blur.cs.hlsl | 12 +- ...UR_DiffuseSh_CopyStabilizedHistory.cs.hlsl | 10 +- .../REBLUR_DiffuseSh_HistoryFix.cs.hlsl | 12 +- .../Source/REBLUR_DiffuseSh_PostBlur.cs.hlsl | 12 +- ...h_PostBlur_NoTemporalStabilization.cs.hlsl | 12 +- .../Source/REBLUR_DiffuseSh_PrePass.cs.hlsl | 12 +- .../REBLUR_DiffuseSh_SplitScreen.cs.hlsl | 12 +- ...LUR_DiffuseSh_TemporalAccumulation.cs.hlsl | 12 +- ...UR_DiffuseSh_TemporalStabilization.cs.hlsl | 12 +- ...BLUR_DiffuseSpecularOcclusion_Blur.cs.hlsl | 12 +- ...iffuseSpecularOcclusion_HistoryFix.cs.hlsl | 12 +- ...larOcclusion_HitDistReconstruction.cs.hlsl | 12 +- ...cclusion_HitDistReconstruction_5x5.cs.hlsl | 12 +- ...n_PostBlur_NoTemporalStabilization.cs.hlsl | 12 +- ...R_DiffuseSpecularOcclusion_PrePass.cs.hlsl | 12 +- ...ularOcclusion_TemporalAccumulation.cs.hlsl | 12 +- .../REBLUR_DiffuseSpecularSh_Blur.cs.hlsl | 12 +- ...seSpecularSh_CopyStabilizedHistory.cs.hlsl | 10 +- ...EBLUR_DiffuseSpecularSh_HistoryFix.cs.hlsl | 12 +- .../REBLUR_DiffuseSpecularSh_PostBlur.cs.hlsl | 12 +- ...h_PostBlur_NoTemporalStabilization.cs.hlsl | 12 +- .../REBLUR_DiffuseSpecularSh_PrePass.cs.hlsl | 12 +- ...BLUR_DiffuseSpecularSh_SplitScreen.cs.hlsl | 12 +- ...useSpecularSh_TemporalAccumulation.cs.hlsl | 12 +- ...seSpecularSh_TemporalStabilization.cs.hlsl | 12 +- .../REBLUR_DiffuseSpecular_Blur.cs.hlsl | 12 +- ...fuseSpecular_CopyStabilizedHistory.cs.hlsl | 10 +- .../REBLUR_DiffuseSpecular_HistoryFix.cs.hlsl | 12 +- ...fuseSpecular_HitDistReconstruction.cs.hlsl | 12 +- ...Specular_HitDistReconstruction_5x5.cs.hlsl | 12 +- .../REBLUR_DiffuseSpecular_PostBlur.cs.hlsl | 12 +- ...r_PostBlur_NoTemporalStabilization.cs.hlsl | 12 +- .../REBLUR_DiffuseSpecular_PrePass.cs.hlsl | 12 +- ...REBLUR_DiffuseSpecular_SplitScreen.cs.hlsl | 12 +- ...ffuseSpecular_TemporalAccumulation.cs.hlsl | 12 +- ...fuseSpecular_TemporalStabilization.cs.hlsl | 12 +- Shaders/Source/REBLUR_Diffuse_Blur.cs.hlsl | 12 +- ...BLUR_Diffuse_CopyStabilizedHistory.cs.hlsl | 10 +- .../Source/REBLUR_Diffuse_HistoryFix.cs.hlsl | 12 +- ...BLUR_Diffuse_HitDistReconstruction.cs.hlsl | 12 +- ..._Diffuse_HitDistReconstruction_5x5.cs.hlsl | 12 +- .../Source/REBLUR_Diffuse_PostBlur.cs.hlsl | 12 +- ...e_PostBlur_NoTemporalStabilization.cs.hlsl | 12 +- Shaders/Source/REBLUR_Diffuse_PrePass.cs.hlsl | 12 +- .../Source/REBLUR_Diffuse_SplitScreen.cs.hlsl | 12 +- ...EBLUR_Diffuse_TemporalAccumulation.cs.hlsl | 12 +- ...BLUR_Diffuse_TemporalStabilization.cs.hlsl | 12 +- ...f_DiffuseDirectionalOcclusion_Blur.cs.hlsl | 12 +- ...useDirectionalOcclusion_HistoryFix.cs.hlsl | 12 +- ...ffuseDirectionalOcclusion_PostBlur.cs.hlsl | 12 +- ...n_PostBlur_NoTemporalStabilization.cs.hlsl | 12 +- ...iffuseDirectionalOcclusion_PrePass.cs.hlsl | 12 +- ...onalOcclusion_TemporalAccumulation.cs.hlsl | 12 +- ...nalOcclusion_TemporalStabilization.cs.hlsl | 12 +- .../REBLUR_Perf_DiffuseOcclusion_Blur.cs.hlsl | 12 +- ...R_Perf_DiffuseOcclusion_HistoryFix.cs.hlsl | 12 +- ...useOcclusion_HitDistReconstruction.cs.hlsl | 12 +- ...cclusion_HitDistReconstruction_5x5.cs.hlsl | 12 +- ...n_PostBlur_NoTemporalStabilization.cs.hlsl | 12 +- ...BLUR_Perf_DiffuseOcclusion_PrePass.cs.hlsl | 12 +- ...fuseOcclusion_TemporalAccumulation.cs.hlsl | 12 +- .../Source/REBLUR_Perf_DiffuseSh_Blur.cs.hlsl | 12 +- .../REBLUR_Perf_DiffuseSh_HistoryFix.cs.hlsl | 12 +- .../REBLUR_Perf_DiffuseSh_PostBlur.cs.hlsl | 12 +- ...h_PostBlur_NoTemporalStabilization.cs.hlsl | 12 +- .../REBLUR_Perf_DiffuseSh_PrePass.cs.hlsl | 12 +- ...erf_DiffuseSh_TemporalAccumulation.cs.hlsl | 12 +- ...rf_DiffuseSh_TemporalStabilization.cs.hlsl | 12 +- ...Perf_DiffuseSpecularOcclusion_Blur.cs.hlsl | 12 +- ...iffuseSpecularOcclusion_HistoryFix.cs.hlsl | 12 +- ...larOcclusion_HitDistReconstruction.cs.hlsl | 12 +- ...cclusion_HitDistReconstruction_5x5.cs.hlsl | 12 +- ...n_PostBlur_NoTemporalStabilization.cs.hlsl | 12 +- ...f_DiffuseSpecularOcclusion_PrePass.cs.hlsl | 12 +- ...ularOcclusion_TemporalAccumulation.cs.hlsl | 12 +- ...REBLUR_Perf_DiffuseSpecularSh_Blur.cs.hlsl | 12 +- ..._Perf_DiffuseSpecularSh_HistoryFix.cs.hlsl | 12 +- ...UR_Perf_DiffuseSpecularSh_PostBlur.cs.hlsl | 12 +- ...h_PostBlur_NoTemporalStabilization.cs.hlsl | 12 +- ...LUR_Perf_DiffuseSpecularSh_PrePass.cs.hlsl | 12 +- ...useSpecularSh_TemporalAccumulation.cs.hlsl | 12 +- ...seSpecularSh_TemporalStabilization.cs.hlsl | 12 +- .../REBLUR_Perf_DiffuseSpecular_Blur.cs.hlsl | 12 +- ...UR_Perf_DiffuseSpecular_HistoryFix.cs.hlsl | 12 +- ...fuseSpecular_HitDistReconstruction.cs.hlsl | 12 +- ...Specular_HitDistReconstruction_5x5.cs.hlsl | 12 +- ...BLUR_Perf_DiffuseSpecular_PostBlur.cs.hlsl | 12 +- ...r_PostBlur_NoTemporalStabilization.cs.hlsl | 12 +- ...EBLUR_Perf_DiffuseSpecular_PrePass.cs.hlsl | 12 +- ...ffuseSpecular_TemporalAccumulation.cs.hlsl | 12 +- ...fuseSpecular_TemporalStabilization.cs.hlsl | 12 +- .../Source/REBLUR_Perf_Diffuse_Blur.cs.hlsl | 12 +- .../REBLUR_Perf_Diffuse_HistoryFix.cs.hlsl | 12 +- ...Perf_Diffuse_HitDistReconstruction.cs.hlsl | 12 +- ..._Diffuse_HitDistReconstruction_5x5.cs.hlsl | 12 +- .../REBLUR_Perf_Diffuse_PostBlur.cs.hlsl | 12 +- ...e_PostBlur_NoTemporalStabilization.cs.hlsl | 12 +- .../REBLUR_Perf_Diffuse_PrePass.cs.hlsl | 12 +- ..._Perf_Diffuse_TemporalAccumulation.cs.hlsl | 12 +- ...Perf_Diffuse_TemporalStabilization.cs.hlsl | 12 +- ...REBLUR_Perf_SpecularOcclusion_Blur.cs.hlsl | 12 +- ..._Perf_SpecularOcclusion_HistoryFix.cs.hlsl | 12 +- ...larOcclusion_HitDistReconstruction.cs.hlsl | 12 +- ...cclusion_HitDistReconstruction_5x5.cs.hlsl | 12 +- ...n_PostBlur_NoTemporalStabilization.cs.hlsl | 12 +- ...LUR_Perf_SpecularOcclusion_PrePass.cs.hlsl | 12 +- ...ularOcclusion_TemporalAccumulation.cs.hlsl | 12 +- .../REBLUR_Perf_SpecularSh_Blur.cs.hlsl | 12 +- .../REBLUR_Perf_SpecularSh_HistoryFix.cs.hlsl | 12 +- .../REBLUR_Perf_SpecularSh_PostBlur.cs.hlsl | 12 +- ...h_PostBlur_NoTemporalStabilization.cs.hlsl | 12 +- .../REBLUR_Perf_SpecularSh_PrePass.cs.hlsl | 12 +- ...rf_SpecularSh_TemporalAccumulation.cs.hlsl | 12 +- ...f_SpecularSh_TemporalStabilization.cs.hlsl | 12 +- .../Source/REBLUR_Perf_Specular_Blur.cs.hlsl | 12 +- .../REBLUR_Perf_Specular_HistoryFix.cs.hlsl | 12 +- ...erf_Specular_HitDistReconstruction.cs.hlsl | 12 +- ...Specular_HitDistReconstruction_5x5.cs.hlsl | 12 +- .../REBLUR_Perf_Specular_PostBlur.cs.hlsl | 12 +- ...r_PostBlur_NoTemporalStabilization.cs.hlsl | 12 +- .../REBLUR_Perf_Specular_PrePass.cs.hlsl | 12 +- ...Perf_Specular_TemporalAccumulation.cs.hlsl | 12 +- ...erf_Specular_TemporalStabilization.cs.hlsl | 12 +- .../REBLUR_SpecularOcclusion_Blur.cs.hlsl | 12 +- ...EBLUR_SpecularOcclusion_HistoryFix.cs.hlsl | 12 +- ...larOcclusion_HitDistReconstruction.cs.hlsl | 12 +- ...cclusion_HitDistReconstruction_5x5.cs.hlsl | 12 +- ...n_PostBlur_NoTemporalStabilization.cs.hlsl | 12 +- .../REBLUR_SpecularOcclusion_PrePass.cs.hlsl | 12 +- ...ularOcclusion_TemporalAccumulation.cs.hlsl | 12 +- Shaders/Source/REBLUR_SpecularSh_Blur.cs.hlsl | 12 +- ...R_SpecularSh_CopyStabilizedHistory.cs.hlsl | 10 +- .../REBLUR_SpecularSh_HistoryFix.cs.hlsl | 12 +- .../Source/REBLUR_SpecularSh_PostBlur.cs.hlsl | 12 +- ...h_PostBlur_NoTemporalStabilization.cs.hlsl | 12 +- .../Source/REBLUR_SpecularSh_PrePass.cs.hlsl | 12 +- .../REBLUR_SpecularSh_SplitScreen.cs.hlsl | 12 +- ...UR_SpecularSh_TemporalAccumulation.cs.hlsl | 12 +- ...R_SpecularSh_TemporalStabilization.cs.hlsl | 12 +- Shaders/Source/REBLUR_Specular_Blur.cs.hlsl | 12 +- ...LUR_Specular_CopyStabilizedHistory.cs.hlsl | 10 +- .../Source/REBLUR_Specular_HistoryFix.cs.hlsl | 12 +- ...LUR_Specular_HitDistReconstruction.cs.hlsl | 12 +- ...Specular_HitDistReconstruction_5x5.cs.hlsl | 12 +- .../Source/REBLUR_Specular_PostBlur.cs.hlsl | 12 +- ...r_PostBlur_NoTemporalStabilization.cs.hlsl | 12 +- .../Source/REBLUR_Specular_PrePass.cs.hlsl | 12 +- .../REBLUR_Specular_SplitScreen.cs.hlsl | 12 +- ...BLUR_Specular_TemporalAccumulation.cs.hlsl | 12 +- ...LUR_Specular_TemporalStabilization.cs.hlsl | 12 +- Shaders/Source/REBLUR_Validation.cs.hlsl | 10 +- Shaders/Source/REFERENCE_SplitScreen.cs.hlsl | 6 +- .../REFERENCE_TemporalAccumulation.cs.hlsl | 6 +- .../RELAX_DiffuseSh_AntiFirefly.cs.hlsl | 22 + Shaders/Source/RELAX_DiffuseSh_Atrous.cs.hlsl | 22 + .../Source/RELAX_DiffuseSh_AtrousSmem.cs.hlsl | 22 + .../RELAX_DiffuseSh_HistoryClamping.cs.hlsl | 22 + .../Source/RELAX_DiffuseSh_HistoryFix.cs.hlsl | 22 + ...AX_DiffuseSh_HitDistReconstruction.cs.hlsl | 21 + .../Source/RELAX_DiffuseSh_PrePass.cs.hlsl | 22 + .../RELAX_DiffuseSh_SplitScreen.cs.hlsl | 21 + ...LAX_DiffuseSh_TemporalAccumulation.cs.hlsl | 22 + ...ELAX_DiffuseSpecularSh_AntiFirefly.cs.hlsl | 19 + .../RELAX_DiffuseSpecularSh_Atrous.cs.hlsl | 21 + ...RELAX_DiffuseSpecularSh_AtrousSmem.cs.hlsl | 21 + ..._DiffuseSpecularSh_HistoryClamping.cs.hlsl | 21 + ...RELAX_DiffuseSpecularSh_HistoryFix.cs.hlsl | 21 + .../RELAX_DiffuseSpecularSh_PrePass.cs.hlsl | 21 + ...ELAX_DiffuseSpecularSh_SplitScreen.cs.hlsl | 19 + ...useSpecularSh_TemporalAccumulation.cs.hlsl | 21 + .../RELAX_DiffuseSpecular_AntiFirefly.cs.hlsl | 12 +- .../RELAX_DiffuseSpecular_Atrous.cs.hlsl | 12 +- .../RELAX_DiffuseSpecular_AtrousSmem.cs.hlsl | 12 +- ...AX_DiffuseSpecular_HistoryClamping.cs.hlsl | 12 +- .../RELAX_DiffuseSpecular_HistoryFix.cs.hlsl | 12 +- ...fuseSpecular_HitDistReconstruction.cs.hlsl | 12 +- ...Specular_HitDistReconstruction_5x5.cs.hlsl | 12 +- .../RELAX_DiffuseSpecular_PrePass.cs.hlsl | 12 +- .../RELAX_DiffuseSpecular_SplitScreen.cs.hlsl | 12 +- ...ffuseSpecular_TemporalAccumulation.cs.hlsl | 12 +- .../Source/RELAX_Diffuse_AntiFirefly.cs.hlsl | 12 +- Shaders/Source/RELAX_Diffuse_Atrous.cs.hlsl | 12 +- .../Source/RELAX_Diffuse_AtrousSmem.cs.hlsl | 12 +- .../RELAX_Diffuse_HistoryClamping.cs.hlsl | 12 +- .../Source/RELAX_Diffuse_HistoryFix.cs.hlsl | 12 +- ...ELAX_Diffuse_HitDistReconstruction.cs.hlsl | 12 +- ..._Diffuse_HitDistReconstruction_5x5.cs.hlsl | 12 +- Shaders/Source/RELAX_Diffuse_PrePass.cs.hlsl | 12 +- .../Source/RELAX_Diffuse_SplitScreen.cs.hlsl | 12 +- ...RELAX_Diffuse_TemporalAccumulation.cs.hlsl | 12 +- .../RELAX_SpecularSh_AntiFirefly.cs.hlsl | 22 + .../Source/RELAX_SpecularSh_Atrous.cs.hlsl | 22 + .../RELAX_SpecularSh_AtrousSmem.cs.hlsl | 22 + .../RELAX_SpecularSh_HistoryClamping.cs.hlsl | 22 + .../RELAX_SpecularSh_HistoryFix.cs.hlsl | 22 + .../Source/RELAX_SpecularSh_PrePass.cs.hlsl | 22 + .../RELAX_SpecularSh_SplitScreen.cs.hlsl | 21 + ...AX_SpecularSh_TemporalAccumulation.cs.hlsl | 22 + .../Source/RELAX_Specular_AntiFirefly.cs.hlsl | 12 +- Shaders/Source/RELAX_Specular_Atrous.cs.hlsl | 12 +- .../Source/RELAX_Specular_AtrousSmem.cs.hlsl | 12 +- .../RELAX_Specular_HistoryClamping.cs.hlsl | 12 +- .../Source/RELAX_Specular_HistoryFix.cs.hlsl | 12 +- ...LAX_Specular_HitDistReconstruction.cs.hlsl | 12 +- ...Specular_HitDistReconstruction_5x5.cs.hlsl | 12 +- Shaders/Source/RELAX_Specular_PrePass.cs.hlsl | 12 +- .../Source/RELAX_Specular_SplitScreen.cs.hlsl | 12 +- ...ELAX_Specular_TemporalAccumulation.cs.hlsl | 12 +- Shaders/Source/RELAX_Validation.cs.hlsl | 10 +- .../SIGMA_ShadowTranslucency_Blur.cs.hlsl | 12 +- ...A_ShadowTranslucency_ClassifyTiles.cs.hlsl | 12 +- .../SIGMA_ShadowTranslucency_PostBlur.cs.hlsl | 12 +- ...GMA_ShadowTranslucency_SplitScreen.cs.hlsl | 12 +- ...Translucency_TemporalStabilization.cs.hlsl | 12 +- Shaders/Source/SIGMA_Shadow_Blur.cs.hlsl | 12 +- .../Source/SIGMA_Shadow_ClassifyTiles.cs.hlsl | 12 +- Shaders/Source/SIGMA_Shadow_PostBlur.cs.hlsl | 12 +- .../Source/SIGMA_Shadow_SmoothTiles.cs.hlsl | 10 +- .../Source/SIGMA_Shadow_SplitScreen.cs.hlsl | 12 +- ...SIGMA_Shadow_TemporalStabilization.cs.hlsl | 12 +- .../Source/SpecularDeltaMv_Compute.cs.hlsl | 6 +- .../SpecularReflectionMv_Compute.cs.hlsl | 6 +- Source/DenoiserImpl.cpp | 820 +------------ Source/DenoiserImpl.h | 52 +- Source/Methods/Reblur_Diffuse.hpp | 354 ------ Source/Methods/Reblur_DiffuseOcclusion.hpp | 130 -- Source/Methods/Relax_Diffuse.hpp | 114 -- Source/Methods/Relax_DiffuseSh.hpp | 576 +++++++++ Source/Methods/Relax_DiffuseSpecularSh.hpp | 716 +++++++++++ Source/Methods/Relax_SpecularSh.hpp | 603 ++++++++++ Source/Methods/Sigma_Shadow.hpp | 124 -- Source/Other.cpp | 46 + Source/Reblur.cpp | 1063 +++++++++++++++++ Source/Relax.cpp | 335 ++++++ Source/Sigma.cpp | 185 +++ Source/Wrapper.cpp | 18 +- UPDATE.md | 14 +- 296 files changed, 7010 insertions(+), 3444 deletions(-) create mode 160000 External/ShaderMake create mode 100644 Images/Resolve.jpg delete mode 100644 ShaderCompilation.cmake create mode 100644 Shaders.cfg create mode 100644 Shaders/Source/RELAX_DiffuseSh_AntiFirefly.cs.hlsl create mode 100644 Shaders/Source/RELAX_DiffuseSh_Atrous.cs.hlsl create mode 100644 Shaders/Source/RELAX_DiffuseSh_AtrousSmem.cs.hlsl create mode 100644 Shaders/Source/RELAX_DiffuseSh_HistoryClamping.cs.hlsl create mode 100644 Shaders/Source/RELAX_DiffuseSh_HistoryFix.cs.hlsl create mode 100644 Shaders/Source/RELAX_DiffuseSh_HitDistReconstruction.cs.hlsl create mode 100644 Shaders/Source/RELAX_DiffuseSh_PrePass.cs.hlsl create mode 100644 Shaders/Source/RELAX_DiffuseSh_SplitScreen.cs.hlsl create mode 100644 Shaders/Source/RELAX_DiffuseSh_TemporalAccumulation.cs.hlsl create mode 100644 Shaders/Source/RELAX_DiffuseSpecularSh_AntiFirefly.cs.hlsl create mode 100644 Shaders/Source/RELAX_DiffuseSpecularSh_Atrous.cs.hlsl create mode 100644 Shaders/Source/RELAX_DiffuseSpecularSh_AtrousSmem.cs.hlsl create mode 100644 Shaders/Source/RELAX_DiffuseSpecularSh_HistoryClamping.cs.hlsl create mode 100644 Shaders/Source/RELAX_DiffuseSpecularSh_HistoryFix.cs.hlsl create mode 100644 Shaders/Source/RELAX_DiffuseSpecularSh_PrePass.cs.hlsl create mode 100644 Shaders/Source/RELAX_DiffuseSpecularSh_SplitScreen.cs.hlsl create mode 100644 Shaders/Source/RELAX_DiffuseSpecularSh_TemporalAccumulation.cs.hlsl create mode 100644 Shaders/Source/RELAX_SpecularSh_AntiFirefly.cs.hlsl create mode 100644 Shaders/Source/RELAX_SpecularSh_Atrous.cs.hlsl create mode 100644 Shaders/Source/RELAX_SpecularSh_AtrousSmem.cs.hlsl create mode 100644 Shaders/Source/RELAX_SpecularSh_HistoryClamping.cs.hlsl create mode 100644 Shaders/Source/RELAX_SpecularSh_HistoryFix.cs.hlsl create mode 100644 Shaders/Source/RELAX_SpecularSh_PrePass.cs.hlsl create mode 100644 Shaders/Source/RELAX_SpecularSh_SplitScreen.cs.hlsl create mode 100644 Shaders/Source/RELAX_SpecularSh_TemporalAccumulation.cs.hlsl create mode 100644 Source/Methods/Relax_DiffuseSh.hpp create mode 100644 Source/Methods/Relax_DiffuseSpecularSh.hpp create mode 100644 Source/Methods/Relax_SpecularSh.hpp create mode 100644 Source/Other.cpp create mode 100644 Source/Reblur.cpp create mode 100644 Source/Relax.cpp create mode 100644 Source/Sigma.cpp diff --git a/.gitmodules b/.gitmodules index 833db6f5..497a1a63 100644 --- a/.gitmodules +++ b/.gitmodules @@ -3,3 +3,8 @@ url = https://github.com/NVIDIAGameWorks/MathLib.git branch = main update = merge +[submodule "External/ShaderMake"] + path = External/ShaderMake + url = https://github.com/NVIDIAGameWorks/ShaderMake.git + branch = main + update = merge \ No newline at end of file diff --git a/1-Deploy.sh b/1-Deploy.sh index 0642a574..9445ad57 100644 --- a/1-Deploy.sh +++ b/1-Deploy.sh @@ -9,5 +9,5 @@ git submodule update --init --recursive mkdir -p "_Compiler" cd "_Compiler" -cmake .. -A x64 +cmake .. cd .. diff --git a/2-Build.bat b/2-Build.bat index 41301063..b160ec3c 100644 --- a/2-Build.bat +++ b/2-Build.bat @@ -1,6 +1,6 @@ @echo off cd "_Compiler" -cmake --build . --config Release -cmake --build . --config Debug +cmake --build . --config Release -j 4 +cmake --build . --config Debug -j 4 cd .. diff --git a/2-Build.sh b/2-Build.sh index 079e5297..ae972c48 100644 --- a/2-Build.sh +++ b/2-Build.sh @@ -4,6 +4,6 @@ mkdir -p "_Compiler" cd "_Compiler" cmake .. -cmake --build . --config Release -cmake --build . --config Debug +cmake --build . --config Release -j 4 +cmake --build . --config Debug -j 4 cd .. diff --git a/4-Clean.bat b/4-Clean.bat index 6ee8cc09..d01f7533 100644 --- a/4-Clean.bat +++ b/4-Clean.bat @@ -4,4 +4,5 @@ if exist "build" rd /q /s "build" if exist "_Build" rd /q /s "_Build" if exist "_Compiler" rd /q /s "_Compiler" +if exist "_Shaders" rd /q /s "_Shaders" if exist "_NRD_SDK" rd /q /s "_NRD_SDK" diff --git a/4-Clean.sh b/4-Clean.sh index 21f054c1..ce455c0e 100644 --- a/4-Clean.sh +++ b/4-Clean.sh @@ -4,4 +4,5 @@ rm -rf "build" rm -rf "_Build" rm -rf "_Compiler" +rm -rf "_Shaders" rm -rf "_NRD_SDK" diff --git a/CMakeLists.txt b/CMakeLists.txt index a9ed6cb7..9bb544f7 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,160 +1,212 @@ -cmake_minimum_required(VERSION 3.15) +cmake_minimum_required (VERSION 3.15) # Options -option(NRD_DISABLE_SHADER_COMPILATION "Disable shader compilation" OFF) -option(NRD_USE_PRECOMPILED_SHADERS "Use precompiled (embedded) shaders" ON) -option(NRD_STATIC_LIBRARY "Build static library" OFF) +option (NRD_DISABLE_SHADER_COMPILATION "Disable shader compilation" OFF) +option (NRD_USE_PRECOMPILED_SHADERS "Use precompiled (embedded) shaders" ON) +option (NRD_STATIC_LIBRARY "Build static library" OFF) -# Cached -set(NRD_DXC_CUSTOM_PATH "custom/path/to/dxc" CACHE STRING "Custom DXC to use if Vulkan SDK is not installed") -set(NRD_SHADERS_PATH "" CACHE STRING "Shader output path override") -set(NRD_NORMAL_ENCODING "2" CACHE STRING "Normal encoding variant (0-4, matches nrd::NormalEncoding)") -set(NRD_ROUGHNESS_ENCODING "1" CACHE STRING "Roughness encoding variant (0-2, matches nrd::RoughnessEncoding)") -set(GLOBAL_BIN_OUTPUT_PATH "${CMAKE_SOURCE_DIR}/_Build" CACHE STRING "") -set(CMAKE_CONFIGURATION_TYPES "Debug;Release" CACHE STRING "") - -# Create project -file(READ "Include/NRD.h" ver_h) -string(REGEX MATCH "VERSION_MAJOR ([0-9]*)" _ ${ver_h}) -set(VERSION_MAJOR ${CMAKE_MATCH_1}) -string(REGEX MATCH "VERSION_MINOR ([0-9]*)" _ ${ver_h}) -set(VERSION_MINOR ${CMAKE_MATCH_1}) -string(REGEX MATCH "VERSION_BUILD ([0-9]*)" _ ${ver_h}) -set(VERSION_BUILD ${CMAKE_MATCH_1}) - -message("NRD v${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_BUILD}") -project(NRD LANGUAGES CXX) - -# Generate "NRDEncoding.hlsli" -file(WRITE Shaders/Include/NRDEncoding.hlsli -"// This file is auto-generated during project deployment. Do not modify!\n" -"#define NRD_NORMAL_ENCODING ${NRD_NORMAL_ENCODING}\n" -"#define NRD_ROUGHNESS_ENCODING ${NRD_ROUGHNESS_ENCODING}\n") - -message("NRD encoding: NRD_NORMAL_ENCODING = ${NRD_NORMAL_ENCODING}; NRD_ROUGHNESS_ENCODING = ${NRD_ROUGHNESS_ENCODING}") - -# Globals? -set_property(GLOBAL PROPERTY USE_FOLDERS ON) - -set(CMAKE_CXX_STANDARD 17) -set(CMAKE_CXX_STANDARD_REQUIRED ON) -set(CMAKE_CXX_VISIBILITY_PRESET hidden) -set(CMAKE_CXX_EXTENSIONS OFF) -set(CMAKE_POSITION_INDEPENDENT_CODE ON) -set(CMAKE_POSITION_INDEPENDENT_BINARIES ON) -set(CMAKE_VISIBILITY_INLINES_HIDDEN ON) - -if(MSVC) - set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$:Debug>") +# Is submodule? +if (${CMAKE_SOURCE_DIR} STREQUAL ${CMAKE_CURRENT_SOURCE_DIR}) + set(IS_SUBMODULE OFF) else() - set(CMAKE_STATIC_LINKER_FLAGS "${CMAKE_STATIC_LINKER_FLAGS} -static-libstdc++ -static-libgcc") - set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -static-libstdc++ -static-libgcc") - set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static-libstdc++ -static-libgcc") + set(IS_SUBMODULE ON) endif() -# Compile options -if(CMAKE_CXX_COMPILER_ID MATCHES "Clang") - set(COMPILE_OPTIONS -Wextra -msse4.1) -elseif(CMAKE_CXX_COMPILER_ID MATCHES "GNU") - set(COMPILE_OPTIONS -Wextra -msse4.1) -elseif(MSVC) - set(COMPILE_OPTIONS /W4 /WX) -else() - message(WARNING "Unknown compiler!") +# Cached +if (NOT IS_SUBMODULE) + set (CMAKE_CONFIGURATION_TYPES "Debug;Release" CACHE STRING "") endif() -# Compile definitions -set(COMPILE_DEFINITIONS NRD_NORMAL_ENCODING=${NRD_NORMAL_ENCODING} NRD_ROUGHNESS_ENCODING=${NRD_ROUGHNESS_ENCODING}) -if(WIN32) - set(COMPILE_DEFINITIONS ${COMPILE_DEFINITIONS} WIN32_LEAN_AND_MEAN NOMINMAX _CRT_SECURE_NO_WARNINGS _UNICODE UNICODE _ENFORCE_MATCHING_ALLOCATORS=0) -else() - set(COMPILE_DEFINITIONS ${COMPILE_DEFINITIONS} NRD_ONLY_SPIRV_SHADERS_AVAILABLE=1) -endif() +set (NRD_DXC_CUSTOM_PATH "custom/path/to/dxc" CACHE STRING "Custom DXC to use if Vulkan SDK is not installed") +set (NRD_SHADERS_PATH "" CACHE STRING "Shader output path override") +set (NRD_NORMAL_ENCODING "2" CACHE STRING "Normal encoding variant (0-4, matches nrd::NormalEncoding)") +set (NRD_ROUGHNESS_ENCODING "1" CACHE STRING "Roughness encoding variant (0-2, matches nrd::RoughnessEncoding)") +set (GLOBAL_BIN_OUTPUT_PATH "${CMAKE_SOURCE_DIR}/_Build" CACHE STRING "") -# Shaders -if("${NRD_SHADERS_PATH}" STREQUAL "") - set(NRD_SHADERS_PATH "${PROJECT_BINARY_DIR}/Shaders") -endif() -message("NRD shaders output path: '${NRD_SHADERS_PATH}'") +# Create project +file (READ "Include/NRD.h" ver_h) +string (REGEX MATCH "VERSION_MAJOR ([0-9]*)" _ ${ver_h}) +set (VERSION_MAJOR ${CMAKE_MATCH_1}) +string (REGEX MATCH "VERSION_MINOR ([0-9]*)" _ ${ver_h}) +set (VERSION_MINOR ${CMAKE_MATCH_1}) +string (REGEX MATCH "VERSION_BUILD ([0-9]*)" _ ${ver_h}) +set (VERSION_BUILD ${CMAKE_MATCH_1}) +message ("NRD v${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_BUILD}") + +project (NRD LANGUAGES C CXX) +message ("NRD encoding: NRD_NORMAL_ENCODING = ${NRD_NORMAL_ENCODING}; NRD_ROUGHNESS_ENCODING = ${NRD_ROUGHNESS_ENCODING}") -if(NOT NRD_DISABLE_SHADER_COMPILATION) - # Create output directory - file(MAKE_DIRECTORY ${NRD_SHADERS_PATH}) +# Generate "NRDEncoding.hlsli" +file (WRITE Shaders/Include/NRDEncoding.hlsli + "// This file is auto-generated during project deployment. Do not modify!\n" + "#define NRD_NORMAL_ENCODING ${NRD_NORMAL_ENCODING}\n" + "#define NRD_ROUGHNESS_ENCODING ${NRD_ROUGHNESS_ENCODING}\n") - # External include needed for ShaderCompilation.cmake - set(MATHLIB_INCLUDE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/External/MathLib") +# Globals? +set_property (GLOBAL PROPERTY USE_FOLDERS ON) - # Gather "hlsl/hlsli" files - file(GLOB MATHLIB_HLSLI "${MATHLIB_INCLUDE_PATH}/*.hlsli") - file(GLOB_RECURSE HLSLI "Shaders/*.hlsli" ) - file(GLOB_RECURSE HLSL "Shaders/*.hlsl") - file(GLOB_RECURSE RESOURCES_HLSLI "Shaders/*.resources.hlsli") +set (CMAKE_CXX_STANDARD 17) +set (CMAKE_CXX_STANDARD_REQUIRED ON) +set (CMAKE_C_STANDARD 99) - # Define build rules - include(ShaderCompilation.cmake) +if (MSVC) + set (CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$:Debug>") +endif () - list_hlsl_headers("${HLSL}" HEADER_FILES) - list_hlsl_headers("${MATHLIB_HLSLI}" HEADER_FILES) - list_hlsl_headers("${HLSLI}" HEADER_FILES) - list_hlsl_shaders("${HLSL}" "${HEADER_FILES}" SHADER_FILES) +# Compile options +if (CMAKE_CXX_COMPILER_ID MATCHES "Clang") + set (COMPILE_OPTIONS -msse4.1 -Wextra) +elseif (CMAKE_CXX_COMPILER_ID MATCHES "GNU") + set (COMPILE_OPTIONS -msse4.1 -Wextra) +elseif (MSVC) + set (COMPILE_OPTIONS /W4 /WX /wd4324) +else () + message (WARNING "Unknown compiler!") +endif () - source_group("MathLib" FILES ${MATHLIB_HLSLI}) - source_group("Source" FILES ${HLSL}) - source_group("Resources" FILES ${RESOURCES_HLSLI}) +# Compile definitions +set (COMPILE_DEFINITIONS NRD_NORMAL_ENCODING=${NRD_NORMAL_ENCODING} NRD_ROUGHNESS_ENCODING=${NRD_ROUGHNESS_ENCODING}) - add_custom_target(${PROJECT_NAME}_Shaders ALL DEPENDS ${SHADER_FILES} SOURCES "${HEADER_FILES}") - set_property(TARGET ${PROJECT_NAME}_Shaders PROPERTY FOLDER "${PROJECT_NAME}") -endif() +if (WIN32) + set (COMPILE_DEFINITIONS ${COMPILE_DEFINITIONS} WIN32_LEAN_AND_MEAN NOMINMAX _CRT_SECURE_NO_WARNINGS _UNICODE UNICODE _ENFORCE_MATCHING_ALLOCATORS=0) +else () + set (COMPILE_DEFINITIONS ${COMPILE_DEFINITIONS} NRD_ONLY_SPIRV_SHADERS_AVAILABLE=1) +endif () # External/MathLib -file(READ "External/MathLib/MathLib.h" ver_h) -string(REGEX MATCH "MATHLIB_VERSION_MAJOR ([0-9]*)" _ ${ver_h}) -set(MATHLIB_VERSION_MAJOR ${CMAKE_MATCH_1}) -string(REGEX MATCH "MATHLIB_VERSION_MINOR ([0-9]*)" _ ${ver_h}) -set(MATHLIB_VERSION_MINOR ${CMAKE_MATCH_1}) -message("MathLib v${MATHLIB_VERSION_MAJOR}.${MATHLIB_VERSION_MINOR}") +file (READ "External/MathLib/MathLib.h" ver_h) +string (REGEX MATCH "MATHLIB_VERSION_MAJOR ([0-9]*)" _ ${ver_h}) +set (MATHLIB_VERSION_MAJOR ${CMAKE_MATCH_1}) +string (REGEX MATCH "MATHLIB_VERSION_MINOR ([0-9]*)" _ ${ver_h}) +set (MATHLIB_VERSION_MINOR ${CMAKE_MATCH_1}) +message ("MathLib v${MATHLIB_VERSION_MAJOR}.${MATHLIB_VERSION_MINOR}") -file(GLOB MATHLIB_FILES "External/MathLib/*.h" "External/MathLib/*.hpp") -source_group("MathLib" FILES ${MATHLIB_FILES}) +file (GLOB MATHLIB_FILES "External/MathLib/*.h" "External/MathLib/*.hpp") +source_group ("MathLib" FILES ${MATHLIB_FILES}) # NRD -file(GLOB GLOB_INCUDE "Include/*") -source_group("Include" FILES ${GLOB_INCUDE}) -file(GLOB GLOB_SOURCE "Source/*.cpp" "Source/*.h" "Source/*.hpp") -source_group("Source" FILES ${GLOB_SOURCE}) -file(GLOB GLOB_METHODS "Source/Methods/*.cpp" "Source/Methods/*.h" "Source/Methods/*.hpp") -source_group("Methods" FILES ${GLOB_METHODS}) -file(GLOB GLOB_RESOURCES "Resources/*") -source_group("Resources" FILES ${GLOB_RESOURCES}) - -if(NRD_STATIC_LIBRARY) - add_library(${PROJECT_NAME} STATIC ${GLOB_SOURCE} ${GLOB_METHODS} ${MATHLIB_FILES} ${GLOB_RESOURCES} ${GLOB_INCUDE}) -else() - add_library(${PROJECT_NAME} SHARED ${GLOB_SOURCE} ${GLOB_METHODS} ${MATHLIB_FILES} ${GLOB_RESOURCES} ${GLOB_INCUDE}) - - if(WIN32) - target_compile_definitions(${PROJECT_NAME} PRIVATE "NRD_API=extern \"C\" __declspec(dllexport)") - else() - target_compile_definitions(${PROJECT_NAME} PRIVATE "NRD_API=extern \"C\" __attribute__((visibility(\"default\")))") - endif() -endif() - -target_include_directories(${PROJECT_NAME} PRIVATE "Include" "External") -if(NRD_USE_PRECOMPILED_SHADERS) - target_include_directories(${PROJECT_NAME} PRIVATE "${NRD_SHADERS_PATH}") - target_compile_definitions(${PROJECT_NAME} PRIVATE NRD_USE_PRECOMPILED_SHADERS) -endif() - -target_compile_definitions(${PROJECT_NAME} PRIVATE ${COMPILE_DEFINITIONS}) -target_compile_options(${PROJECT_NAME} PRIVATE ${COMPILE_OPTIONS}) +file (GLOB GLOB_INCUDE "Include/*") +source_group ("Include" FILES ${GLOB_INCUDE}) +file (GLOB GLOB_SOURCE "Source/*.cpp" "Source/*.h" "Source/*.hpp") +source_group ("Source" FILES ${GLOB_SOURCE}) +file (GLOB GLOB_METHODS "Source/Methods/*.cpp" "Source/Methods/*.h" "Source/Methods/*.hpp") +source_group ("Methods" FILES ${GLOB_METHODS}) +file (GLOB GLOB_RESOURCES "Resources/*") +source_group ("Resources" FILES ${GLOB_RESOURCES}) + +if (NRD_STATIC_LIBRARY) + add_library (${PROJECT_NAME} STATIC ${GLOB_SOURCE} ${GLOB_METHODS} ${MATHLIB_FILES} ${GLOB_RESOURCES} ${GLOB_INCUDE}) +else () + add_library (${PROJECT_NAME} SHARED ${GLOB_SOURCE} ${GLOB_METHODS} ${MATHLIB_FILES} ${GLOB_RESOURCES} ${GLOB_INCUDE}) + + if (WIN32) + target_compile_definitions (${PROJECT_NAME} PRIVATE "NRD_API=extern \"C\" __declspec(dllexport)") + else () + target_compile_definitions (${PROJECT_NAME} PRIVATE "NRD_API=extern \"C\" __attribute__((visibility(\"default\")))") + endif () +endif () + +if ("${NRD_SHADERS_PATH}" STREQUAL "") + set (NRD_SHADERS_PATH "${CMAKE_CURRENT_SOURCE_DIR}/_Shaders") +else () + set (NRD_SHADER_BINARIES "--binary") +endif () + +message ("NRD shaders output path: '${NRD_SHADERS_PATH}'") + +if (NRD_USE_PRECOMPILED_SHADERS) + target_include_directories (${PROJECT_NAME} PRIVATE "${NRD_SHADERS_PATH}") + target_compile_definitions (${PROJECT_NAME} PRIVATE NRD_USE_PRECOMPILED_SHADERS) +endif () + +target_include_directories (${PROJECT_NAME} PRIVATE "Include" "External") +target_compile_definitions (${PROJECT_NAME} PRIVATE ${COMPILE_DEFINITIONS}) +target_compile_options (${PROJECT_NAME} PRIVATE ${COMPILE_OPTIONS}) + +set_property (TARGET ${PROJECT_NAME} PROPERTY FOLDER "${PROJECT_NAME}") + +set_target_properties (${PROJECT_NAME} PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${GLOBAL_BIN_OUTPUT_PATH}/$") +set_target_properties (${PROJECT_NAME} PROPERTIES LIBRARY_OUTPUT_DIRECTORY "${GLOBAL_BIN_OUTPUT_PATH}/$") +set_target_properties (${PROJECT_NAME} PROPERTIES ARCHIVE_OUTPUT_DIRECTORY "${GLOBAL_BIN_OUTPUT_PATH}/$") +message ("NRD output path: '${GLOBAL_BIN_OUTPUT_PATH}'") + +# External/ShaderMake +if (NOT TARGET ShaderMake) + set (SHADERMAKE_BIN_OUTPUT_PATH ${GLOBAL_BIN_OUTPUT_PATH} CACHE STRING "") + add_subdirectory (External/ShaderMake) +endif () -set_property(TARGET ${PROJECT_NAME} PROPERTY FOLDER "${PROJECT_NAME}") - -if(NOT NRD_DISABLE_SHADER_COMPILATION) - add_dependencies(${PROJECT_NAME} ${PROJECT_NAME}_Shaders) -endif() - -set_target_properties(${PROJECT_NAME} PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${GLOBAL_BIN_OUTPUT_PATH}/$") -set_target_properties(${PROJECT_NAME} PROPERTIES LIBRARY_OUTPUT_DIRECTORY "${GLOBAL_BIN_OUTPUT_PATH}/$") -set_target_properties(${PROJECT_NAME} PROPERTIES ARCHIVE_OUTPUT_DIRECTORY "${GLOBAL_BIN_OUTPUT_PATH}/$") -message("NRD output path: '${GLOBAL_BIN_OUTPUT_PATH}'") +# Shaders +file (GLOB_RECURSE SHADERS "Shaders/*.hlsl" "Shaders/*.hlsli" "External/MathLib/*.hlsli") +set_source_files_properties (${SHADERS} PROPERTIES VS_TOOL_OVERRIDE "None") + +if (WIN32) + add_custom_target (${PROJECT_NAME}_Shaders ALL + COMMAND ShaderMake + --header ${NRD_SHADER_BINARIES} --flatten --stripReflection --compiler "${DXC_PATH}" + --sourceDir "Shaders/Source" + --allResourcesBound + -p DXIL --WX + -c Shaders.cfg + -o "${NRD_SHADERS_PATH}" + -I "External/MathLib" + -I "Shaders/Include" + -I "Shaders/Resources" + -D NRD_NORMAL_ENCODING=${NRD_NORMAL_ENCODING} + -D NRD_ROUGHNESS_ENCODING=${NRD_ROUGHNESS_ENCODING} + -D NRD_INTERNAL + COMMAND ShaderMake + --header ${NRD_SHADER_BINARIES} --flatten --stripReflection --compiler "${DXC_SPIRV_PATH}" + --sourceDir "Shaders/Source" + --allResourcesBound + -p SPIRV --WX + -c Shaders.cfg + -o "${NRD_SHADERS_PATH}" + -I "External/MathLib" + -I "Shaders/Include" + -I "Shaders/Resources" + -D NRD_NORMAL_ENCODING=${NRD_NORMAL_ENCODING} + -D NRD_ROUGHNESS_ENCODING=${NRD_ROUGHNESS_ENCODING} + -D NRD_INTERNAL + COMMAND ShaderMake + --header ${NRD_SHADER_BINARIES} --flatten --stripReflection --compiler "${FXC_PATH}" + --sourceDir "Shaders/Source" + --allResourcesBound + -p DXBC --WX + -c Shaders.cfg + -o "${NRD_SHADERS_PATH}" + -I "External/MathLib" + -I "Shaders/Include" + -I "Shaders/Resources" + -D NRD_NORMAL_ENCODING=${NRD_NORMAL_ENCODING} + -D NRD_ROUGHNESS_ENCODING=${NRD_ROUGHNESS_ENCODING} + -D NRD_INTERNAL + DEPENDS ShaderMake + WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" + VERBATIM + SOURCES ${SHADERS} + ) +else () + add_custom_target (${PROJECT_NAME}_Shaders ALL + COMMAND ShaderMake + --header ${NRD_SHADER_BINARIES} --flatten --stripReflection --compiler "${DXC_SPIRV_PATH}" + --sourceDir "Shaders/Source" + --allResourcesBound + -p SPIRV --WX + -c Shaders.cfg + -o "${NRD_SHADERS_PATH}" + -I "External/MathLib" + -I "Shaders/Include" + -I "Shaders/Resources" + -D NRD_NORMAL_ENCODING=${NRD_NORMAL_ENCODING} + -D NRD_ROUGHNESS_ENCODING=${NRD_ROUGHNESS_ENCODING} + -D NRD_INTERNAL + DEPENDS ShaderMake + WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" + VERBATIM + SOURCES ${SHADERS} + ) +endif () + +set_property (TARGET ${PROJECT_NAME}_Shaders PROPERTY FOLDER ${PROJECT_NAME}) +add_dependencies (${PROJECT_NAME} ${PROJECT_NAME}_Shaders) diff --git a/External/MathLib b/External/MathLib index 33763bcb..e6765b3f 160000 --- a/External/MathLib +++ b/External/MathLib @@ -1 +1 @@ -Subproject commit 33763bcbcfe5bc830b427b7cdc9f555bf7f9a01c +Subproject commit e6765b3fae9c0471f3e88c0c88d08ace82fcca56 diff --git a/External/ShaderMake b/External/ShaderMake new file mode 160000 index 00000000..d6b1d48a --- /dev/null +++ b/External/ShaderMake @@ -0,0 +1 @@ +Subproject commit d6b1d48af8fa4d2075beababffc2cd2c0f03080f diff --git a/Images/Resolve.jpg b/Images/Resolve.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e07a7831ceb0449cc716cac551c34a3f450e9e7b GIT binary patch literal 191475 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%0AH<>;jN6+{jwpC>%6VMx6c68U*r{eUIbHN( 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 #define NRD_VERSION_MAJOR 4 -#define NRD_VERSION_MINOR 0 -#define NRD_VERSION_BUILD 2 -#define NRD_VERSION_DATE "23 January 2023" +#define NRD_VERSION_MINOR 1 +#define NRD_VERSION_BUILD 0 +#define NRD_VERSION_DATE "23 March 2023" #if defined(_MSC_VER) #define NRD_CALL __fastcall diff --git a/Include/NRDDescs.h b/Include/NRDDescs.h index f592fe07..295ee051 100644 --- a/Include/NRDDescs.h +++ b/Include/NRDDescs.h @@ -11,7 +11,7 @@ license agreement from NVIDIA CORPORATION is strictly prohibited. #pragma once #define NRD_DESCS_VERSION_MAJOR 4 -#define NRD_DESCS_VERSION_MINOR 0 +#define NRD_DESCS_VERSION_MINOR 1 static_assert (NRD_VERSION_MAJOR == NRD_DESCS_VERSION_MAJOR && NRD_VERSION_MINOR == NRD_DESCS_VERSION_MINOR, "Please, update all NRD SDK files"); @@ -98,17 +98,35 @@ namespace nrd // ============================================================================================================================= // INPUTS - IN_MV, IN_NORMAL_ROUGHNESS, IN_VIEWZ, IN_DIFF_RADIANCE_HITDIST + // OPTIONAL INPUTS - IN_DIFF_CONFIDENCE // OUTPUTS - OUT_DIFF_RADIANCE_HITDIST RELAX_DIFFUSE, + // INPUTS - IN_MV, IN_NORMAL_ROUGHNESS, IN_VIEWZ, IN_DIFF_SH0, IN_DIFF_SH1 + // OPTIONAL INPUTS - IN_DIFF_CONFIDENCE + // OUTPUTS - OUT_DIFF_SH0, OUT_DIFF_SH1 + RELAX_DIFFUSE_SH, + // INPUTS - IN_MV, IN_NORMAL_ROUGHNESS, IN_VIEWZ, IN_SPEC_RADIANCE_HITDIST + // OPTIONAL INPUTS - IN_SPEC_CONFIDENCE // OUTPUTS - OUT_SPEC_RADIANCE_HITDIST RELAX_SPECULAR, + // INPUTS - IN_MV, IN_NORMAL_ROUGHNESS, IN_VIEWZ, IN_SPEC_SH0, IN_SPEC_SH1 + // OPTIONAL INPUTS - IN_SPEC_CONFIDENCE + // OUTPUTS - OUT_SPEC_SH0, OUT_SPEC_SH1 + RELAX_SPECULAR_SH, + // INPUTS - IN_MV, IN_NORMAL_ROUGHNESS, IN_VIEWZ, IN_DIFF_RADIANCE_HITDIST, IN_SPEC_RADIANCE_HITDIST + // OPTIONAL INPUTS - IN_DIFF_CONFIDENCE, IN_SPEC_CONFIDENCE // OUTPUTS - OUT_DIFF_RADIANCE_HITDIST, OUT_SPEC_RADIANCE_HITDIST RELAX_DIFFUSE_SPECULAR, + // INPUTS - IN_MV, IN_NORMAL_ROUGHNESS, IN_VIEWZ, IN_DIFF_SH0, IN_DIFF_SH1, IN_SPEC_SH0, IN_SPEC_SH1 + // OPTIONAL INPUTS - IN_DIFF_CONFIDENCE, IN_SPEC_CONFIDENCE + // OUTPUTS - OUT_DIFF_SH0, OUT_DIFF_SH1, OUT_SPEC_SH0, OUT_SPEC_SH1 + RELAX_DIFFUSE_SPECULAR_SH, + // ============================================================================================================================= // REFERENCE // ============================================================================================================================= @@ -169,6 +187,7 @@ namespace nrd // Noisy SH data (2x RGBA16f+) // REBLUR: use "REBLUR_FrontEnd_PackSh" for encoding + // RELAX: use "RELAX_FrontEnd_PackSh" for encoding IN_DIFF_SH0, IN_DIFF_SH1, IN_SPEC_SH0, @@ -214,6 +233,7 @@ namespace nrd // Denoised SH data // REBLUR: use "REBLUR_BackEnd_UnpackSh" for decoding (2x RGBA16f+) + // RELAX: use "RELAX_BackEnd_UnpackSh" for decoding (2x RGBA16f+) OUT_DIFF_SH0, OUT_DIFF_SH1, OUT_SPEC_SH0, diff --git a/Include/NRDSettings.h b/Include/NRDSettings.h index feb0e613..1c9566bb 100644 --- a/Include/NRDSettings.h +++ b/Include/NRDSettings.h @@ -11,7 +11,7 @@ license agreement from NVIDIA CORPORATION is strictly prohibited. #pragma once #define NRD_SETTINGS_VERSION_MAJOR 4 -#define NRD_SETTINGS_VERSION_MINOR 0 +#define NRD_SETTINGS_VERSION_MINOR 1 static_assert (NRD_VERSION_MAJOR == NRD_SETTINGS_VERSION_MAJOR && NRD_VERSION_MINOR == NRD_SETTINGS_VERSION_MINOR, "Please, update all NRD SDK files"); @@ -236,7 +236,7 @@ namespace nrd float historyFixStrideBetweenSamples = 14.0f; // (normalized %) - base fraction of diffuse or specular lobe angle used to drive normal based rejection - float lobeAngleFraction = 0.13f; + float lobeAngleFraction = 0.15f; // (normalized %) - base fraction of center roughness used to drive roughness based rejection float roughnessFraction = 0.15f; diff --git a/Integration/NRDIntegration.h b/Integration/NRDIntegration.h index 466080d5..21e24f60 100644 --- a/Integration/NRDIntegration.h +++ b/Integration/NRDIntegration.h @@ -23,8 +23,8 @@ license agreement from NVIDIA CORPORATION is strictly prohibited. #include #define NRD_INTEGRATION_MAJOR 1 -#define NRD_INTEGRATION_MINOR 4 -#define NRD_INTEGRATION_DATE "20 December 2022" +#define NRD_INTEGRATION_MINOR 5 +#define NRD_INTEGRATION_DATE "23 March 2022" #define NRD_INTEGRATION 1 #define NRD_INTEGRATION_DEBUG_LOGGING 0 diff --git a/Integration/NRDIntegration.hpp b/Integration/NRDIntegration.hpp index e096b3c4..b3aef942 100644 --- a/Integration/NRDIntegration.hpp +++ b/Integration/NRDIntegration.hpp @@ -11,7 +11,7 @@ license agreement from NVIDIA CORPORATION is strictly prohibited. #include "NRDIntegration.h" static_assert(NRD_VERSION_MAJOR >= 4 && NRD_VERSION_MINOR >= 0, "Unsupported NRD version!"); -static_assert(NRI_VERSION_MAJOR >= 1 && NRI_VERSION_MINOR >= 90, "Unsupported NRI version!"); +static_assert(NRI_VERSION_MAJOR >= 1 && NRI_VERSION_MINOR >= 93, "Unsupported NRI version!"); #if _WIN32 #define NRD_INTEGRATION_ALLOCA _alloca diff --git a/README.md b/README.md index 2d3cd7df..0b335e53 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,4 @@ -# NVIDIA Real-time Denoisers v4.0.2 (NRD) +# NVIDIA Real-time Denoisers v4.1.0 (NRD) [![Build NRD SDK](https://github.com/NVIDIAGameWorks/RayTracingDenoiser/actions/workflows/build.yml/badge.svg)](https://github.com/NVIDIAGameWorks/RayTracingDenoiser/actions/workflows/build.yml) @@ -22,7 +22,7 @@ Supported signal types: - Diffuse & specular radiance - Diffuse (ambient) & specular occlusion (OCCLUSION variants) - Diffuse (ambient) directional occlusion (DIRECTIONAL_OCCLUSION variant) - - Diffuse & specular radiance in spherical harmonics (SH variants) + - Diffuse & specular radiance in spherical harmonics (spherical gaussians) (SH variants) - *SIGMA*: - Shadows from an infinite light source (sun, moon) - Shadows from a local light source (omni, spot) @@ -185,6 +185,67 @@ NRD sample is a good start to familiarize yourself with input requirements and b See `NRDDescs.h` for more details and descriptions of other inputs and outputs. +# IMPROVING OUTPUT QUALITY + +The temporal part of *NRD* naturally suppresses jitter, which is essential for upscaling techniques. If an *SH* denoiser is in use, a high quality resolve can be applied to the final output to regain back macro details, micro details and per-pixel jittering. As an example, the image below demonstrates the results *after* and *before* resolve with active *DLSS* (quality mode). + +![Resolve](Images/Resolve.jpg) + +The resolve process takes place on the application side and has the following modular structure: +- construct an SG (spherical gaussian) light +- apply diffuse or specular resolve function to reconstruct macro details +- apply re-jittering to reconstruct micro details +- (optionally) or just extract unresolved color (fully matches the output of a corresponding non-SH denoiser) + +Shader code: +```cpp +// Diffuse +float4 diff = gIn_Diff.SampleLevel( gLinearSampler, pixelUv, 0 ); +float4 diff1 = gIn_DiffSh.SampleLevel( gLinearSampler, pixelUv, 0 ); +NRD_SG diffSg = REBLUR_BackEnd_UnpackSh( diff, diff1 ); + +// Specular +float4 spec = gIn_Spec.SampleLevel( gLinearSampler, pixelUv, 0 ); +float4 spec1 = gIn_SpecSh.SampleLevel( gLinearSampler, pixelUv, 0 ); +NRD_SG specSg = REBLUR_BackEnd_UnpackSh( spec, spec1 ); + +// ( Optional ) AO / SO ( available only for REBLUR ) +diff.w = diffSg.normHitDist; +spec.w = specSg.normHitDist; + +if( gResolve ) +{ + // ( Optional ) replace "roughness" with "roughnessAA" + roughness = NRD_SG_ExtractRoughnessAA( specSg ); + + // Regain macro-details + diff.xyz = NRD_SG_ResolveDiffuse( diffSg, N ); // or NRD_SH_ResolveDiffuse( sg, N ) + spec.xyz = NRD_SG_ResolveSpecular( specSg, N, V, roughness ); + + // Regain micro-details & jittering // TODO: preload N and Z into SMEM + float3 Ne = NRD_FrontEnd_UnpackNormalAndRoughness( gIn_Normal_Roughness[ pixelPos + int2( 1, 0 ) ] ).xyz; + float3 Nw = NRD_FrontEnd_UnpackNormalAndRoughness( gIn_Normal_Roughness[ pixelPos + int2( -1, 0 ) ] ).xyz; + float3 Nn = NRD_FrontEnd_UnpackNormalAndRoughness( gIn_Normal_Roughness[ pixelPos + int2( 0, 1 ) ] ).xyz; + float3 Ns = NRD_FrontEnd_UnpackNormalAndRoughness( gIn_Normal_Roughness[ pixelPos + int2( 0, -1 ) ] ).xyz; + + float Ze = gIn_ViewZ[ pixelPos + int2( 1, 0 ) ]; + float Zw = gIn_ViewZ[ pixelPos + int2( -1, 0 ) ]; + float Zn = gIn_ViewZ[ pixelPos + int2( 0, 1 ) ]; + float Zs = gIn_ViewZ[ pixelPos + int2( 0, -1 ) ]; + + float2 scale = NRD_SG_ReJitter( diffSg, specSg, Rf0, V, roughness, viewZ, Ze, Zw, Zn, Zs, N, Ne, Nw, Nn, Ns ); + + diff.xyz *= scale.x; + spec.xyz *= scale.y; +} +else +{ + // ( Optional ) Unresolved color matching the non-SH version of the denoiser + diff.xyz = NRD_SG_ExtractColor( diffSg ); + spec.xyz = NRD_SG_ExtractColor( specSg ); +} +``` + # VALIDATION LAYER ![Validation](Images/Validation.png) @@ -239,8 +300,11 @@ The *Persistent* column (matches *NRD Permanent pool*) indicates how much of the | | SIGMA_SHADOW | 23.38 | 0.00 | 23.38 | | | SIGMA_SHADOW_TRANSLUCENCY | 42.31 | 0.00 | 42.31 | | | RELAX_DIFFUSE | 120.31 | 65.44 | 54.88 | +| | RELAX_DIFFUSE_SH | 204.69 | 99.19 | 105.50 | | | RELAX_SPECULAR | 130.94 | 73.94 | 57.00 | +| | RELAX_SPECULAR_SH | 215.31 | 107.69 | 107.62 | | | RELAX_DIFFUSE_SPECULAR | 215.31 | 107.69 | 107.62 | +| | RELAX_DIFFUSE_SPECULAR_SH | 384.06 | 175.19 | 208.88 | | | REFERENCE | 33.75 | 33.75 | 0.00 | | | | | | | | 1440p | REBLUR_DIFFUSE | 153.75 | 82.50 | 71.25 | @@ -256,8 +320,11 @@ The *Persistent* column (matches *NRD Permanent pool*) indicates how much of the | | SIGMA_SHADOW | 41.38 | 0.00 | 41.38 | | | SIGMA_SHADOW_TRANSLUCENCY | 75.12 | 0.00 | 75.12 | | | RELAX_DIFFUSE | 213.75 | 116.25 | 97.50 | +| | RELAX_DIFFUSE_SH | 363.75 | 176.25 | 187.50 | | | RELAX_SPECULAR | 232.50 | 131.25 | 101.25 | +| | RELAX_SPECULAR_SH | 382.50 | 191.25 | 191.25 | | | RELAX_DIFFUSE_SPECULAR | 382.50 | 191.25 | 191.25 | +| | RELAX_DIFFUSE_SPECULAR_SH | 682.50 | 311.25 | 371.25 | | | REFERENCE | 60.00 | 60.00 | 0.00 | | | | | | | | 2160p | REBLUR_DIFFUSE | 326.75 | 175.31 | 151.44 | @@ -273,8 +340,11 @@ The *Persistent* column (matches *NRD Permanent pool*) indicates how much of the | | SIGMA_SHADOW | 87.94 | 0.00 | 87.94 | | | SIGMA_SHADOW_TRANSLUCENCY | 159.56 | 0.00 | 159.56 | | | RELAX_DIFFUSE | 454.31 | 247.12 | 207.19 | +| | RELAX_DIFFUSE_SH | 773.06 | 374.62 | 398.44 | | | RELAX_SPECULAR | 494.19 | 279.00 | 215.19 | +| | RELAX_SPECULAR_SH | 812.94 | 406.50 | 406.44 | | | RELAX_DIFFUSE_SPECULAR | 812.94 | 406.50 | 406.44 | +| | RELAX_DIFFUSE_SPECULAR_SH | 1450.44 | 661.50 | 788.94 | | | REFERENCE | 127.50 | 127.50 | 0.00 | # INTEGRATION VARIANTS @@ -467,7 +537,6 @@ Shader part: // Or define NRD encoding in Cmake and deliver macro definitions to shader compilation command line #endif -#define NRD_HEADER_ONLY #include "NRD.hlsli" // Call corresponding "front end" function to encode data for NRD (NRD.hlsli indicates which function @@ -613,6 +682,8 @@ maxAccumulatedFrameNum > maxFastAccumulatedFrameNum > historyFixFrameNum **[NRD]** In case of quarter resolution tracing and denoising use `pixelPos / 2` as texture coordinates. Using a "rotated grid" approach (when a pixel gets selected from 2x2 footprint one by one) is not recommended because it significantly bumps entropy of non-noisy inputs, leading to more disocclusions. In case of *REBLUR* it's recommended to increase `sigmaScale` in antilag settings. "Nearest Z" upsampling works best for upscaling of the denoised output. Code, as well as upsampling function, can be found in *NRD sample* releases before 3.10. +**[NRD]** *SH* denoisers can use more relaxed `lobeAngleFraction`. It can help to improve stability, while details will be reconstructed back by *SG* resolve. + **[REBLUR]** In case of *REBLUR* ensure that `enableReferenceAccumulation = true` works properly first. It's not mandatory, but will help to simplify debugging of potential issues by implicitly disabling spatial filtering entirely. **[REBLUR]** If more performance is needed, consider using `enablePerformanceMode = true`. diff --git a/Resources/Version.h b/Resources/Version.h index 4a7e90e0..218c9e66 100644 --- a/Resources/Version.h +++ b/Resources/Version.h @@ -22,8 +22,8 @@ Versioning rules: */ #define VERSION_MAJOR 4 -#define VERSION_MINOR 0 -#define VERSION_BUILD 2 +#define VERSION_MINOR 1 +#define VERSION_BUILD 0 #define VERSION_REVISION 0 #define VERSION_STRING STR(VERSION_MAJOR.VERSION_MINOR.VERSION_BUILD.VERSION_REVISION) diff --git a/ShaderCompilation.cmake b/ShaderCompilation.cmake deleted file mode 100644 index 4d45e789..00000000 --- a/ShaderCompilation.cmake +++ /dev/null @@ -1,149 +0,0 @@ -# DXC on Windows does not like forward slashes -if(WIN32) - string(REPLACE "/" "\\" SHADER_INCLUDE_PATH "${SHADER_FILES}/Include") - - # Needed only for WinSDK before 22000 - string(REPLACE "/" "\\" MATHLIB_INCLUDE_PATH "${MATHLIB_INCLUDE_PATH}") -endif() - -# Find FXC and DXC -if(WIN32) - if(DEFINED CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION) - set(WINDOWS_SDK_VERSION ${CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION}) - elseif(DEFINED ENV{WindowsSDKLibVersion}) - string(REGEX REPLACE "\\\\$" "" WINDOWS_SDK_VERSION "$ENV{WindowsSDKLibVersion}") - else() - message(FATAL_ERROR "WindowsSDK is not installed.(CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION is not defined; WindowsSDKLibVersion is '$ENV{WindowsSDKLibVersion}')") - endif() - - get_filename_component(WINDOWS_SDK_ROOT - "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows Kits\\Installed Roots;KitsRoot10]" ABSOLUTE) - - set(WINDOWS_SDK_BIN "${WINDOWS_SDK_ROOT}/bin/${WINDOWS_SDK_VERSION}/x64") - - # On Windows, FXC and DXC are part of WindowsSDK and there's also DXC in VulkanSDK which supports SPIR-V - find_program(FXC_PATH "${WINDOWS_SDK_BIN}/fxc") - if(NOT FXC_PATH) - message(FATAL_ERROR "Can't find FXC: '${WINDOWS_SDK_BIN}/fxc'") - endif() - - find_program(DXC_PATH "${WINDOWS_SDK_BIN}/dxc") - if(NOT DXC_PATH) - message(FATAL_ERROR "Can't find DXC: '${WINDOWS_SDK_BIN}/dxc'") - endif() - - find_program(DXC_SPIRV_PATH "$ENV{VULKAN_SDK}/Bin/dxc") - if(NOT DXC_SPIRV_PATH) - message("Can't find VulkanSDK DXC: '$ENV{VULKAN_SDK}/Bin/dxc'") - find_program(DXC_SPIRV_PATH "dxc" "${NRD_DXC_CUSTOM_PATH}") - if(NOT DXC_SPIRV_PATH) - message(FATAL_ERROR "Can't find DXC: Specify custom path using 'NRD_DXC_CUSTOM_PATH' parameter or install VulkanSDK") - endif() - endif() -else() - # On Linux, VulkanSDK does not set VULKAN_SDK, but DXC can be called directly - find_program(DXC_SPIRV_PATH "dxc") - if(NOT DXC_SPIRV_PATH) - find_program(DXC_SPIRV_PATH "${NRD_DXC_CUSTOM_PATH}") - if(NOT DXC_SPIRV_PATH) - message(FATAL_ERROR "Can't find DXC: Specify custom path using 'NRD_DXC_CUSTOM_PATH' parameter or install VulkanSDK") - endif() - endif() -endif() - -message("Using FXC path: '${FXC_PATH}'") -message("Using DXC path: '${DXC_PATH}'") -message("Using DXC(for SPIRV) path: '${DXC_SPIRV_PATH}'") - -function(get_shader_profile_from_name FILE_NAME DXC_PROFILE FXC_PROFILE) - get_filename_component(EXTENSION ${FILE_NAME} EXT) - if("${EXTENSION}" STREQUAL ".cs.hlsl") - set(DXC_PROFILE "cs_6_3" PARENT_SCOPE) - set(FXC_PROFILE "cs_5_0" PARENT_SCOPE) - endif() -endfunction() - -macro(list_hlsl_headers HLSL_FILES HEADER_FILES) - foreach(FILE_NAME ${HLSL_FILES}) - set(DXC_PROFILE "") - set(FXC_PROFILE "") - get_shader_profile_from_name(${FILE_NAME} DXC_PROFILE FXC_PROFILE) - if("${DXC_PROFILE}" STREQUAL "" AND "${FXC_PROFILE}" STREQUAL "") - list(APPEND HEADER_FILES ${FILE_NAME}) - set_source_files_properties(${FILE_NAME} PROPERTIES VS_TOOL_OVERRIDE "None") - endif() - endforeach() -endmacro() - -set(VK_S_SHIFT 100) -set(VK_T_SHIFT 200) -set(VK_B_SHIFT 300) -set(VK_U_SHIFT 400) -set(DXC_VK_SHIFTS - -fvk-s-shift ${VK_S_SHIFT} 0 -fvk-s-shift ${VK_S_SHIFT} 1 -fvk-s-shift ${VK_S_SHIFT} 2 - -fvk-t-shift ${VK_T_SHIFT} 0 -fvk-t-shift ${VK_T_SHIFT} 1 -fvk-t-shift ${VK_T_SHIFT} 2 - -fvk-b-shift ${VK_B_SHIFT} 0 -fvk-b-shift ${VK_B_SHIFT} 1 -fvk-b-shift ${VK_B_SHIFT} 2 - -fvk-u-shift ${VK_U_SHIFT} 0 -fvk-u-shift ${VK_U_SHIFT} 1 -fvk-u-shift ${VK_U_SHIFT} 2) - -macro(list_hlsl_shaders HLSL_FILES HEADER_FILES SHADER_FILES) - foreach(FILE_NAME ${HLSL_FILES}) - get_filename_component(NAME_ONLY ${FILE_NAME} NAME) - string(REGEX REPLACE "\\.[^.]*$" "" NAME_ONLY ${NAME_ONLY}) - string(REPLACE "." "_" BYTECODE_ARRAY_NAME "${NAME_ONLY}") - set(DXC_PROFILE "") - set(FXC_PROFILE "") - set(OUTPUT_PATH_DXBC "${NRD_SHADERS_PATH}/${NAME_ONLY}.dxbc") - set(OUTPUT_PATH_DXIL "${NRD_SHADERS_PATH}/${NAME_ONLY}.dxil") - set(OUTPUT_PATH_SPIRV "${NRD_SHADERS_PATH}/${NAME_ONLY}.spirv") - get_shader_profile_from_name(${FILE_NAME} DXC_PROFILE FXC_PROFILE) - - # DXBC - if(NOT "${FXC_PROFILE}" STREQUAL "" AND NOT "${FXC_PATH}" STREQUAL "") - add_custom_command( - OUTPUT ${OUTPUT_PATH_DXBC} ${OUTPUT_PATH_DXBC}.h - COMMAND ${FXC_PATH} /nologo /E main /T ${FXC_PROFILE} /WX /O3 /all_resources_bound - /DNRD_COMPILER_FXC=1 /DNRD_NORMAL_ENCODING=${NRD_NORMAL_ENCODING} /DNRD_ROUGHNESS_ENCODING=${NRD_ROUGHNESS_ENCODING} - /I "${MATHLIB_INCLUDE_PATH}" /I "${SHADER_INCLUDE_PATH}" - "${FILE_NAME}" /Vn g_${BYTECODE_ARRAY_NAME}_dxbc /Fh ${OUTPUT_PATH_DXBC}.h /Fo ${OUTPUT_PATH_DXBC} - MAIN_DEPENDENCY ${FILE_NAME} - DEPENDS ${HEADER_FILES} - WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/Shaders" - VERBATIM - ) - list(APPEND SHADER_FILES ${OUTPUT_PATH_DXBC} ${OUTPUT_PATH_DXBC}.h) - endif() - - # DXIL - if(NOT "${DXC_PROFILE}" STREQUAL "" AND NOT "${DXC_PATH}" STREQUAL "") - add_custom_command( - OUTPUT ${OUTPUT_PATH_DXIL} ${OUTPUT_PATH_DXIL}.h - COMMAND ${DXC_PATH} -E main -T ${DXC_PROFILE} -WX -O3 -enable-16bit-types -all_resources_bound - -DNRD_COMPILER_DXC=1 -DNRD_NORMAL_ENCODING=${NRD_NORMAL_ENCODING} -DNRD_ROUGHNESS_ENCODING=${NRD_ROUGHNESS_ENCODING} - -I "${MATHLIB_INCLUDE_PATH}" -I "${SHADER_INCLUDE_PATH}" - "${FILE_NAME}" -Vn g_${BYTECODE_ARRAY_NAME}_dxil -Fh ${OUTPUT_PATH_DXIL}.h -Fo ${OUTPUT_PATH_DXIL} - MAIN_DEPENDENCY ${FILE_NAME} - DEPENDS ${HEADER_FILES} - WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/Shaders" - VERBATIM - ) - list(APPEND SHADER_FILES ${OUTPUT_PATH_DXIL} ${OUTPUT_PATH_DXIL}.h) - endif() - - # SPIRV - if(NOT "${DXC_PROFILE}" STREQUAL "" AND NOT "${DXC_SPIRV_PATH}" STREQUAL "") - add_custom_command( - OUTPUT ${OUTPUT_PATH_SPIRV} ${OUTPUT_PATH_SPIRV}.h - COMMAND ${DXC_SPIRV_PATH} -E main -T ${DXC_PROFILE} -WX -O3 -enable-16bit-types -all_resources_bound - -DNRD_COMPILER_DXC=1 -DVULKAN=1 -DNRD_NORMAL_ENCODING=${NRD_NORMAL_ENCODING} -DNRD_ROUGHNESS_ENCODING=${NRD_ROUGHNESS_ENCODING} - -I "${MATHLIB_INCLUDE_PATH}" -I "${SHADER_INCLUDE_PATH}" - "${FILE_NAME}" -Vn g_${BYTECODE_ARRAY_NAME}_spirv -Fh ${OUTPUT_PATH_SPIRV}.h -Fo ${OUTPUT_PATH_SPIRV} ${DXC_VK_SHIFTS} - -spirv - MAIN_DEPENDENCY ${FILE_NAME} - DEPENDS ${HEADER_FILES} - WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/Shaders" - VERBATIM - ) - list(APPEND SHADER_FILES ${OUTPUT_PATH_SPIRV} ${OUTPUT_PATH_SPIRV}.h) - endif() - endforeach() -endmacro() \ No newline at end of file diff --git a/Shaders.cfg b/Shaders.cfg new file mode 100644 index 00000000..d60c2d83 --- /dev/null +++ b/Shaders.cfg @@ -0,0 +1,237 @@ +Clear_f.cs.hlsl -T cs +Clear_ui.cs.hlsl -T cs +REBLUR_DiffuseDirectionalOcclusion_Blur.cs.hlsl -T cs +REBLUR_DiffuseDirectionalOcclusion_HistoryFix.cs.hlsl -T cs +REBLUR_DiffuseDirectionalOcclusion_PostBlur.cs.hlsl -T cs +REBLUR_DiffuseDirectionalOcclusion_PostBlur_NoTemporalStabilization.cs.hlsl -T cs +REBLUR_DiffuseDirectionalOcclusion_PrePass.cs.hlsl -T cs +REBLUR_DiffuseDirectionalOcclusion_TemporalAccumulation.cs.hlsl -T cs +REBLUR_DiffuseDirectionalOcclusion_TemporalStabilization.cs.hlsl -T cs +REBLUR_DiffuseOcclusion_Blur.cs.hlsl -T cs +REBLUR_DiffuseOcclusion_HistoryFix.cs.hlsl -T cs +REBLUR_DiffuseOcclusion_HitDistReconstruction.cs.hlsl -T cs +REBLUR_DiffuseOcclusion_HitDistReconstruction_5x5.cs.hlsl -T cs +REBLUR_DiffuseOcclusion_PostBlur_NoTemporalStabilization.cs.hlsl -T cs +REBLUR_DiffuseOcclusion_PrePass.cs.hlsl -T cs +REBLUR_DiffuseOcclusion_TemporalAccumulation.cs.hlsl -T cs +REBLUR_DiffuseSh_Blur.cs.hlsl -T cs +REBLUR_DiffuseSh_CopyStabilizedHistory.cs.hlsl -T cs +REBLUR_DiffuseSh_HistoryFix.cs.hlsl -T cs +REBLUR_DiffuseSh_PostBlur.cs.hlsl -T cs +REBLUR_DiffuseSh_PostBlur_NoTemporalStabilization.cs.hlsl -T cs +REBLUR_DiffuseSh_PrePass.cs.hlsl -T cs +REBLUR_DiffuseSh_SplitScreen.cs.hlsl -T cs +REBLUR_DiffuseSh_TemporalAccumulation.cs.hlsl -T cs +REBLUR_DiffuseSh_TemporalStabilization.cs.hlsl -T cs +REBLUR_DiffuseSpecularOcclusion_Blur.cs.hlsl -T cs +REBLUR_DiffuseSpecularOcclusion_HistoryFix.cs.hlsl -T cs +REBLUR_DiffuseSpecularOcclusion_HitDistReconstruction.cs.hlsl -T cs +REBLUR_DiffuseSpecularOcclusion_HitDistReconstruction_5x5.cs.hlsl -T cs +REBLUR_DiffuseSpecularOcclusion_PostBlur_NoTemporalStabilization.cs.hlsl -T cs +REBLUR_DiffuseSpecularOcclusion_PrePass.cs.hlsl -T cs +REBLUR_DiffuseSpecularOcclusion_TemporalAccumulation.cs.hlsl -T cs +REBLUR_DiffuseSpecularSh_Blur.cs.hlsl -T cs +REBLUR_DiffuseSpecularSh_CopyStabilizedHistory.cs.hlsl -T cs +REBLUR_DiffuseSpecularSh_HistoryFix.cs.hlsl -T cs +REBLUR_DiffuseSpecularSh_PostBlur.cs.hlsl -T cs +REBLUR_DiffuseSpecularSh_PostBlur_NoTemporalStabilization.cs.hlsl -T cs +REBLUR_DiffuseSpecularSh_PrePass.cs.hlsl -T cs +REBLUR_DiffuseSpecularSh_SplitScreen.cs.hlsl -T cs +REBLUR_DiffuseSpecularSh_TemporalAccumulation.cs.hlsl -T cs +REBLUR_DiffuseSpecularSh_TemporalStabilization.cs.hlsl -T cs +REBLUR_DiffuseSpecular_Blur.cs.hlsl -T cs +REBLUR_DiffuseSpecular_CopyStabilizedHistory.cs.hlsl -T cs +REBLUR_DiffuseSpecular_HistoryFix.cs.hlsl -T cs +REBLUR_DiffuseSpecular_HitDistReconstruction.cs.hlsl -T cs +REBLUR_DiffuseSpecular_HitDistReconstruction_5x5.cs.hlsl -T cs +REBLUR_DiffuseSpecular_PostBlur.cs.hlsl -T cs +REBLUR_DiffuseSpecular_PostBlur_NoTemporalStabilization.cs.hlsl -T cs +REBLUR_DiffuseSpecular_PrePass.cs.hlsl -T cs +REBLUR_DiffuseSpecular_SplitScreen.cs.hlsl -T cs +REBLUR_DiffuseSpecular_TemporalAccumulation.cs.hlsl -T cs +REBLUR_DiffuseSpecular_TemporalStabilization.cs.hlsl -T cs +REBLUR_Diffuse_Blur.cs.hlsl -T cs +REBLUR_Diffuse_CopyStabilizedHistory.cs.hlsl -T cs +REBLUR_Diffuse_HistoryFix.cs.hlsl -T cs +REBLUR_Diffuse_HitDistReconstruction.cs.hlsl -T cs +REBLUR_Diffuse_HitDistReconstruction_5x5.cs.hlsl -T cs +REBLUR_Diffuse_PostBlur.cs.hlsl -T cs +REBLUR_Diffuse_PostBlur_NoTemporalStabilization.cs.hlsl -T cs +REBLUR_Diffuse_PrePass.cs.hlsl -T cs +REBLUR_Diffuse_SplitScreen.cs.hlsl -T cs +REBLUR_Diffuse_TemporalAccumulation.cs.hlsl -T cs +REBLUR_Diffuse_TemporalStabilization.cs.hlsl -T cs +REBLUR_Perf_DiffuseDirectionalOcclusion_Blur.cs.hlsl -T cs +REBLUR_Perf_DiffuseDirectionalOcclusion_HistoryFix.cs.hlsl -T cs +REBLUR_Perf_DiffuseDirectionalOcclusion_PostBlur.cs.hlsl -T cs +REBLUR_Perf_DiffuseDirectionalOcclusion_PostBlur_NoTemporalStabilization.cs.hlsl -T cs +REBLUR_Perf_DiffuseDirectionalOcclusion_PrePass.cs.hlsl -T cs +REBLUR_Perf_DiffuseDirectionalOcclusion_TemporalAccumulation.cs.hlsl -T cs +REBLUR_Perf_DiffuseDirectionalOcclusion_TemporalStabilization.cs.hlsl -T cs +REBLUR_Perf_DiffuseOcclusion_Blur.cs.hlsl -T cs +REBLUR_Perf_DiffuseOcclusion_HistoryFix.cs.hlsl -T cs +REBLUR_Perf_DiffuseOcclusion_HitDistReconstruction.cs.hlsl -T cs +REBLUR_Perf_DiffuseOcclusion_HitDistReconstruction_5x5.cs.hlsl -T cs +REBLUR_Perf_DiffuseOcclusion_PostBlur_NoTemporalStabilization.cs.hlsl -T cs +REBLUR_Perf_DiffuseOcclusion_PrePass.cs.hlsl -T cs +REBLUR_Perf_DiffuseOcclusion_TemporalAccumulation.cs.hlsl -T cs +REBLUR_Perf_DiffuseSh_Blur.cs.hlsl -T cs +REBLUR_Perf_DiffuseSh_HistoryFix.cs.hlsl -T cs +REBLUR_Perf_DiffuseSh_PostBlur.cs.hlsl -T cs +REBLUR_Perf_DiffuseSh_PostBlur_NoTemporalStabilization.cs.hlsl -T cs +REBLUR_Perf_DiffuseSh_PrePass.cs.hlsl -T cs +REBLUR_Perf_DiffuseSh_TemporalAccumulation.cs.hlsl -T cs +REBLUR_Perf_DiffuseSh_TemporalStabilization.cs.hlsl -T cs +REBLUR_Perf_DiffuseSpecularOcclusion_Blur.cs.hlsl -T cs +REBLUR_Perf_DiffuseSpecularOcclusion_HistoryFix.cs.hlsl -T cs +REBLUR_Perf_DiffuseSpecularOcclusion_HitDistReconstruction.cs.hlsl -T cs +REBLUR_Perf_DiffuseSpecularOcclusion_HitDistReconstruction_5x5.cs.hlsl -T cs +REBLUR_Perf_DiffuseSpecularOcclusion_PostBlur_NoTemporalStabilization.cs.hlsl -T cs +REBLUR_Perf_DiffuseSpecularOcclusion_PrePass.cs.hlsl -T cs +REBLUR_Perf_DiffuseSpecularOcclusion_TemporalAccumulation.cs.hlsl -T cs +REBLUR_Perf_DiffuseSpecularSh_Blur.cs.hlsl -T cs +REBLUR_Perf_DiffuseSpecularSh_HistoryFix.cs.hlsl -T cs +REBLUR_Perf_DiffuseSpecularSh_PostBlur.cs.hlsl -T cs +REBLUR_Perf_DiffuseSpecularSh_PostBlur_NoTemporalStabilization.cs.hlsl -T cs +REBLUR_Perf_DiffuseSpecularSh_PrePass.cs.hlsl -T cs +REBLUR_Perf_DiffuseSpecularSh_TemporalAccumulation.cs.hlsl -T cs +REBLUR_Perf_DiffuseSpecularSh_TemporalStabilization.cs.hlsl -T cs +REBLUR_Perf_DiffuseSpecular_Blur.cs.hlsl -T cs +REBLUR_Perf_DiffuseSpecular_HistoryFix.cs.hlsl -T cs +REBLUR_Perf_DiffuseSpecular_HitDistReconstruction.cs.hlsl -T cs +REBLUR_Perf_DiffuseSpecular_HitDistReconstruction_5x5.cs.hlsl -T cs +REBLUR_Perf_DiffuseSpecular_PostBlur.cs.hlsl -T cs +REBLUR_Perf_DiffuseSpecular_PostBlur_NoTemporalStabilization.cs.hlsl -T cs +REBLUR_Perf_DiffuseSpecular_PrePass.cs.hlsl -T cs +REBLUR_Perf_DiffuseSpecular_TemporalAccumulation.cs.hlsl -T cs +REBLUR_Perf_DiffuseSpecular_TemporalStabilization.cs.hlsl -T cs +REBLUR_Perf_Diffuse_Blur.cs.hlsl -T cs +REBLUR_Perf_Diffuse_HistoryFix.cs.hlsl -T cs +REBLUR_Perf_Diffuse_HitDistReconstruction.cs.hlsl -T cs +REBLUR_Perf_Diffuse_HitDistReconstruction_5x5.cs.hlsl -T cs +REBLUR_Perf_Diffuse_PostBlur.cs.hlsl -T cs +REBLUR_Perf_Diffuse_PostBlur_NoTemporalStabilization.cs.hlsl -T cs +REBLUR_Perf_Diffuse_PrePass.cs.hlsl -T cs +REBLUR_Perf_Diffuse_TemporalAccumulation.cs.hlsl -T cs +REBLUR_Perf_Diffuse_TemporalStabilization.cs.hlsl -T cs +REBLUR_Perf_SpecularOcclusion_Blur.cs.hlsl -T cs +REBLUR_Perf_SpecularOcclusion_HistoryFix.cs.hlsl -T cs +REBLUR_Perf_SpecularOcclusion_HitDistReconstruction.cs.hlsl -T cs +REBLUR_Perf_SpecularOcclusion_HitDistReconstruction_5x5.cs.hlsl -T cs +REBLUR_Perf_SpecularOcclusion_PostBlur_NoTemporalStabilization.cs.hlsl -T cs +REBLUR_Perf_SpecularOcclusion_PrePass.cs.hlsl -T cs +REBLUR_Perf_SpecularOcclusion_TemporalAccumulation.cs.hlsl -T cs +REBLUR_Perf_SpecularSh_Blur.cs.hlsl -T cs +REBLUR_Perf_SpecularSh_HistoryFix.cs.hlsl -T cs +REBLUR_Perf_SpecularSh_PostBlur.cs.hlsl -T cs +REBLUR_Perf_SpecularSh_PostBlur_NoTemporalStabilization.cs.hlsl -T cs +REBLUR_Perf_SpecularSh_PrePass.cs.hlsl -T cs +REBLUR_Perf_SpecularSh_TemporalAccumulation.cs.hlsl -T cs +REBLUR_Perf_SpecularSh_TemporalStabilization.cs.hlsl -T cs +REBLUR_Perf_Specular_Blur.cs.hlsl -T cs +REBLUR_Perf_Specular_HistoryFix.cs.hlsl -T cs +REBLUR_Perf_Specular_HitDistReconstruction.cs.hlsl -T cs +REBLUR_Perf_Specular_HitDistReconstruction_5x5.cs.hlsl -T cs +REBLUR_Perf_Specular_PostBlur.cs.hlsl -T cs +REBLUR_Perf_Specular_PostBlur_NoTemporalStabilization.cs.hlsl -T cs +REBLUR_Perf_Specular_PrePass.cs.hlsl -T cs +REBLUR_Perf_Specular_TemporalAccumulation.cs.hlsl -T cs +REBLUR_Perf_Specular_TemporalStabilization.cs.hlsl -T cs +REBLUR_SpecularOcclusion_Blur.cs.hlsl -T cs +REBLUR_SpecularOcclusion_HistoryFix.cs.hlsl -T cs +REBLUR_SpecularOcclusion_HitDistReconstruction.cs.hlsl -T cs +REBLUR_SpecularOcclusion_HitDistReconstruction_5x5.cs.hlsl -T cs +REBLUR_SpecularOcclusion_PostBlur_NoTemporalStabilization.cs.hlsl -T cs +REBLUR_SpecularOcclusion_PrePass.cs.hlsl -T cs +REBLUR_SpecularOcclusion_TemporalAccumulation.cs.hlsl -T cs +REBLUR_SpecularSh_Blur.cs.hlsl -T cs +REBLUR_SpecularSh_CopyStabilizedHistory.cs.hlsl -T cs +REBLUR_SpecularSh_HistoryFix.cs.hlsl -T cs +REBLUR_SpecularSh_PostBlur.cs.hlsl -T cs +REBLUR_SpecularSh_PostBlur_NoTemporalStabilization.cs.hlsl -T cs +REBLUR_SpecularSh_PrePass.cs.hlsl -T cs +REBLUR_SpecularSh_SplitScreen.cs.hlsl -T cs +REBLUR_SpecularSh_TemporalAccumulation.cs.hlsl -T cs +REBLUR_SpecularSh_TemporalStabilization.cs.hlsl -T cs +REBLUR_Specular_Blur.cs.hlsl -T cs +REBLUR_Specular_CopyStabilizedHistory.cs.hlsl -T cs +REBLUR_Specular_HistoryFix.cs.hlsl -T cs +REBLUR_Specular_HitDistReconstruction.cs.hlsl -T cs +REBLUR_Specular_HitDistReconstruction_5x5.cs.hlsl -T cs +REBLUR_Specular_PostBlur.cs.hlsl -T cs +REBLUR_Specular_PostBlur_NoTemporalStabilization.cs.hlsl -T cs +REBLUR_Specular_PrePass.cs.hlsl -T cs +REBLUR_Specular_SplitScreen.cs.hlsl -T cs +REBLUR_Specular_TemporalAccumulation.cs.hlsl -T cs +REBLUR_Specular_TemporalStabilization.cs.hlsl -T cs +REBLUR_Validation.cs.hlsl -T cs +REFERENCE_SplitScreen.cs.hlsl -T cs +REFERENCE_TemporalAccumulation.cs.hlsl -T cs +RELAX_Diffuse_AntiFirefly.cs.hlsl -T cs +RELAX_Diffuse_Atrous.cs.hlsl -T cs +RELAX_Diffuse_AtrousSmem.cs.hlsl -T cs +RELAX_Diffuse_HistoryClamping.cs.hlsl -T cs +RELAX_Diffuse_HistoryFix.cs.hlsl -T cs +RELAX_Diffuse_HitDistReconstruction.cs.hlsl -T cs +RELAX_Diffuse_HitDistReconstruction_5x5.cs.hlsl -T cs +RELAX_Diffuse_PrePass.cs.hlsl -T cs +RELAX_Diffuse_SplitScreen.cs.hlsl -T cs +RELAX_Diffuse_TemporalAccumulation.cs.hlsl -T cs +RELAX_DiffuseSh_AntiFirefly.cs.hlsl -T cs +RELAX_DiffuseSh_Atrous.cs.hlsl -T cs +RELAX_DiffuseSh_AtrousSmem.cs.hlsl -T cs +RELAX_DiffuseSh_HistoryClamping.cs.hlsl -T cs +RELAX_DiffuseSh_HistoryFix.cs.hlsl -T cs +RELAX_DiffuseSh_PrePass.cs.hlsl -T cs +RELAX_DiffuseSh_SplitScreen.cs.hlsl -T cs +RELAX_DiffuseSh_TemporalAccumulation.cs.hlsl -T cs +RELAX_Specular_AntiFirefly.cs.hlsl -T cs +RELAX_Specular_Atrous.cs.hlsl -T cs +RELAX_Specular_AtrousSmem.cs.hlsl -T cs +RELAX_Specular_HistoryClamping.cs.hlsl -T cs +RELAX_Specular_HistoryFix.cs.hlsl -T cs +RELAX_Specular_HitDistReconstruction.cs.hlsl -T cs +RELAX_Specular_HitDistReconstruction_5x5.cs.hlsl -T cs +RELAX_Specular_PrePass.cs.hlsl -T cs +RELAX_Specular_SplitScreen.cs.hlsl -T cs +RELAX_Specular_TemporalAccumulation.cs.hlsl -T cs +RELAX_SpecularSh_AntiFirefly.cs.hlsl -T cs +RELAX_SpecularSh_Atrous.cs.hlsl -T cs +RELAX_SpecularSh_AtrousSmem.cs.hlsl -T cs +RELAX_SpecularSh_HistoryClamping.cs.hlsl -T cs +RELAX_SpecularSh_HistoryFix.cs.hlsl -T cs +RELAX_SpecularSh_PrePass.cs.hlsl -T cs +RELAX_SpecularSh_SplitScreen.cs.hlsl -T cs +RELAX_SpecularSh_TemporalAccumulation.cs.hlsl -T cs +RELAX_DiffuseSpecular_AntiFirefly.cs.hlsl -T cs +RELAX_DiffuseSpecular_Atrous.cs.hlsl -T cs +RELAX_DiffuseSpecular_AtrousSmem.cs.hlsl -T cs +RELAX_DiffuseSpecular_HistoryClamping.cs.hlsl -T cs +RELAX_DiffuseSpecular_HistoryFix.cs.hlsl -T cs +RELAX_DiffuseSpecular_HitDistReconstruction.cs.hlsl -T cs +RELAX_DiffuseSpecular_HitDistReconstruction_5x5.cs.hlsl -T cs +RELAX_DiffuseSpecular_PrePass.cs.hlsl -T cs +RELAX_DiffuseSpecular_SplitScreen.cs.hlsl -T cs +RELAX_DiffuseSpecular_TemporalAccumulation.cs.hlsl -T cs +RELAX_DiffuseSpecularSh_AntiFirefly.cs.hlsl -T cs +RELAX_DiffuseSpecularSh_Atrous.cs.hlsl -T cs +RELAX_DiffuseSpecularSh_AtrousSmem.cs.hlsl -T cs +RELAX_DiffuseSpecularSh_HistoryClamping.cs.hlsl -T cs +RELAX_DiffuseSpecularSh_HistoryFix.cs.hlsl -T cs +RELAX_DiffuseSpecularSh_PrePass.cs.hlsl -T cs +RELAX_DiffuseSpecularSh_SplitScreen.cs.hlsl -T cs +RELAX_DiffuseSpecularSh_TemporalAccumulation.cs.hlsl -T cs +RELAX_Validation.cs.hlsl -T cs +SIGMA_ShadowTranslucency_Blur.cs.hlsl -T cs +SIGMA_ShadowTranslucency_ClassifyTiles.cs.hlsl -T cs +SIGMA_ShadowTranslucency_PostBlur.cs.hlsl -T cs +SIGMA_ShadowTranslucency_SplitScreen.cs.hlsl -T cs +SIGMA_ShadowTranslucency_TemporalStabilization.cs.hlsl -T cs +SIGMA_Shadow_Blur.cs.hlsl -T cs +SIGMA_Shadow_ClassifyTiles.cs.hlsl -T cs +SIGMA_Shadow_PostBlur.cs.hlsl -T cs +SIGMA_Shadow_SmoothTiles.cs.hlsl -T cs +SIGMA_Shadow_SplitScreen.cs.hlsl -T cs +SIGMA_Shadow_TemporalStabilization.cs.hlsl -T cs +SpecularDeltaMv_Compute.cs.hlsl -T cs +SpecularReflectionMv_Compute.cs.hlsl -T cs diff --git a/Shaders/Include/Common.hlsli b/Shaders/Include/Common.hlsli index f54ac89e..35ab07fa 100644 --- a/Shaders/Include/Common.hlsli +++ b/Shaders/Include/Common.hlsli @@ -332,6 +332,26 @@ float2 GetHitDistanceWeightParams( float hitDist, float nonLinearAccumSpeed, flo return float2( a, -b ); } +// Weights params + +float2 GetRoughnessWeightParams( float roughness, float fraction ) +{ + float a = rcp( lerp( 0.01, 1.0, saturate( roughness * fraction ) ) ); + float b = roughness * a; + + return float2( a, -b ); +} + +float2 GetRoughnessWeightParamsSq( float roughness, float fraction ) +{ + return GetRoughnessWeightParams( roughness * roughness, fraction ); +} + +float2 GetCoarseRoughnessWeightParams( float roughness ) +{ + return float2( 1.0, -roughness ); +} + // Weights // IMPORTANT: @@ -365,6 +385,11 @@ float GetRoughnessWeight( float2 params, float roughness ) return _ComputeWeight( roughness, params.x, params.y ); } +float GetRoughnessWeightSq( float2 params, float roughness ) +{ + return GetRoughnessWeight( params, roughness * roughness ); +} + float GetHitDistanceWeight( float2 params, float hitDist ) { return _ComputeExponentialWeight( hitDist, params.x, params.y ); diff --git a/Shaders/Include/NRD.hlsli b/Shaders/Include/NRD.hlsli index 9b214041..237be6f4 100644 --- a/Shaders/Include/NRD.hlsli +++ b/Shaders/Include/NRD.hlsli @@ -8,7 +8,7 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -// NRD v4.0 +// NRD v4.1 //================================================================================================================================= // INPUT PARAMETERS @@ -58,85 +58,41 @@ float normHitDist: NOTE: if "roughness" is needed as an input parameter use is as "isDiffuse ? 1 : roughness" */ - // IMPORTANT: DO NOT MODIFY THIS FILE WITHOUT FULL RECOMPILATION OF NRD LIBRARY! +// IMPORTANT: DO NOT MODIFY THIS FILE WITHOUT FULL RECOMPILATION OF NRD LIBRARY! - #ifndef NRD_INCLUDED - #define NRD_INCLUDED - -#if( !defined( NRD_NORMAL_ENCODING ) || !defined( NRD_ROUGHNESS_ENCODING ) ) - #ifdef NRD_HEADER_ONLY - #error "Include 'NRDEncoding.hlsli' file beforehand to get a match with the settings NRD has been compiled with. Or define encoding variants using Cmake parameters." - #else - #error "For NRD project compilation, encoding variants must be set using Cmake parameters." - #endif -#endif +#ifndef NRD_INCLUDED +#define NRD_INCLUDED //================================================================================================================================= -// BINDINGS +// SETTINGS //================================================================================================================================= +// ( Optional ) Register spaces #define NRD_CONSTANT_BUFFER_SPACE_INDEX 0 #define NRD_SAMPLERS_SPACE_INDEX 0 #define NRD_RESOURCES_SPACE_INDEX 0 -#define NRD_MERGE_TOKENS_( _0, _1 ) _0 ## _1 -#define NRD_MERGE_TOKENS( _0, _1 ) NRD_MERGE_TOKENS_( _0, _1 ) - -#if( defined NRD_COMPILER_UNREAL_ENGINE ) - - #ifndef NRD_CS_MAIN - #define NRD_CS_MAIN main - #endif - - #define NRD_EXPORT - - #define NRD_CONSTANTS_START - #define NRD_CONSTANT( constantType, constantName ) constantType constantName; - #define NRD_CONSTANTS_END - - #define NRD_INPUT_TEXTURE_START - #define NRD_INPUT_TEXTURE( resourceType, resourceName, regName, bindingIndex ) resourceType resourceName; - #define NRD_INPUT_TEXTURE_END +// ( Optional ) Entry point +#ifndef NRD_CS_MAIN + #define NRD_CS_MAIN main +#endif - #define NRD_OUTPUT_TEXTURE_START - #define NRD_OUTPUT_TEXTURE( resourceType, resourceName, regName, bindingIndex ) resourceType resourceName; - #define NRD_OUTPUT_TEXTURE_END +//================================================================================================================================= +// BINDINGS +//================================================================================================================================= - #define NRD_SAMPLER_START - #define NRD_SAMPLER( resourceType, resourceName, regName, bindingIndex ) resourceType resourceName; - #define NRD_SAMPLER_END +#ifndef __cplusplus -#elif( defined NRD_COMPILER_FXC ) +#define NRD_MERGE_TOKENS_( _0, _1 ) _0 ## _1 +#define NRD_MERGE_TOKENS( _0, _1 ) NRD_MERGE_TOKENS_( _0, _1 ) - #ifndef NRD_CS_MAIN - #define NRD_CS_MAIN main - #endif +// Custom engine that has already defined all the macros +#if( defined( NRD_INPUT_TEXTURE ) && defined( NRD_OUTPUT_TEXTURE ) && defined( NRD_CONSTANTS_START ) && defined( NRD_CONSTANT ) && defined( NRD_CONSTANTS_END ) ) #define NRD_EXPORT - #define NRD_CONSTANTS_START cbuffer globalConstants : register( b0 ) { - #define NRD_CONSTANT( constantType, constantName ) constantType constantName; - #define NRD_CONSTANTS_END }; - - #define NRD_INPUT_TEXTURE_START - #define NRD_INPUT_TEXTURE( resourceType, resourceName, regName, bindingIndex ) resourceType resourceName : register( regName ## bindingIndex ); - #define NRD_INPUT_TEXTURE_END - - #define NRD_OUTPUT_TEXTURE_START - #define NRD_OUTPUT_TEXTURE( resourceType, resourceName, regName, bindingIndex ) resourceType resourceName : register( regName ## bindingIndex ); - #define NRD_OUTPUT_TEXTURE_END - - #define NRD_SAMPLER_START - #define NRD_SAMPLER( resourceType, resourceName, regName, bindingIndex ) resourceType resourceName : register( regName ## bindingIndex ); - #define NRD_SAMPLER_END - -#elif( defined NRD_COMPILER_DXC ) - - #ifndef NRD_CS_MAIN - #define NRD_CS_MAIN main - #endif - - #define NRD_EXPORT +// DXC +#elif( defined( NRD_COMPILER_DXC ) || defined( __hlsl_dx_compiler ) ) #define NRD_CONSTANTS_START cbuffer globalConstants : register( b0, NRD_MERGE_TOKENS( space, NRD_CONSTANT_BUFFER_SPACE_INDEX ) ) { #define NRD_CONSTANT( constantType, constantName ) constantType constantName; @@ -154,9 +110,11 @@ NOTE: if "roughness" is needed as an input parameter use is as "isDiffuse ? 1 : #define NRD_SAMPLER( resourceType, resourceName, regName, bindingIndex ) resourceType resourceName : register( regName ## bindingIndex, NRD_MERGE_TOKENS( space, NRD_SAMPLERS_SPACE_INDEX ) ); #define NRD_SAMPLER_END -#elif( defined NRD_COMPILER_PSSLC ) + #define NRD_EXPORT + +// PlayStation +#elif( defined( NRD_COMPILER_PSSLC ) || defined( __PSSL__ ) ) - // Helpers #define EXPAND( x ) x #define GET_NTH_MACRO_4_arg( a, b, c, d, NAME, ... ) NAME #define GET_NTH_MACRO_3_arg( a, b, c, NAME, ... ) NAME @@ -167,16 +125,6 @@ NOTE: if "roughness" is needed as an input parameter use is as "isDiffuse ? 1 : #define GatherGreen3( a, b, c ) GatherGreen( ( a ), ( b ), int2( c ) ) #define GatherGreen2( a, b ) GatherGreen( ( a ), ( b ) ) - #ifndef NRD_CS_MAIN - #define NRD_CS_MAIN main - #endif - - #ifdef EXPORT_NAME - #define NRD_EXPORT [ CxxSymbol( EXPORT_NAME ) ] - #else - #define NRD_EXPORT - #endif - #define NRD_CONSTANTS_START ConstantBuffer globalConstants : register( b0 ) { #define NRD_CONSTANT( constantType, constantName ) constantType constantName; #define NRD_CONSTANTS_END }; @@ -211,25 +159,71 @@ NOTE: if "roughness" is needed as an input parameter use is as "isDiffuse ? 1 : #define InterlockedMax( ... ) AtomicMax( __VA_ARGS__ ) #define unorm -#elif( defined( NRD_INPUT_TEXTURE ) && defined( NRD_OUTPUT_TEXTURE ) && defined( NRD_CONSTANTS_START ) && defined( NRD_CONSTANT ) && defined( NRD_CONSTANTS_END ) ) - - #ifndef NRD_CS_MAIN - #define NRD_CS_MAIN main + #ifdef EXPORT_NAME + #define NRD_EXPORT [ CxxSymbol( EXPORT_NAME ) ] + #else + #define NRD_EXPORT #endif +// Unreal Engine +#elif( defined( NRD_COMPILER_UNREAL_ENGINE ) ) // TODO: is there a predefined macro in UE? + + #define NRD_CONSTANTS_START + #define NRD_CONSTANT( constantType, constantName ) constantType constantName; + #define NRD_CONSTANTS_END + + #define NRD_INPUT_TEXTURE_START + #define NRD_INPUT_TEXTURE( resourceType, resourceName, regName, bindingIndex ) resourceType resourceName; + #define NRD_INPUT_TEXTURE_END + + #define NRD_OUTPUT_TEXTURE_START + #define NRD_OUTPUT_TEXTURE( resourceType, resourceName, regName, bindingIndex ) resourceType resourceName; + #define NRD_OUTPUT_TEXTURE_END + + #define NRD_SAMPLER_START + #define NRD_SAMPLER( resourceType, resourceName, regName, bindingIndex ) resourceType resourceName; + #define NRD_SAMPLER_END + #define NRD_EXPORT - // Custom engine that has already defined all the macros +// FXC +#else // TODO: is there a predefined macro in FXC? + + #define NRD_CONSTANTS_START cbuffer globalConstants : register( b0 ) { + #define NRD_CONSTANT( constantType, constantName ) constantType constantName; + #define NRD_CONSTANTS_END }; + + #define NRD_INPUT_TEXTURE_START + #define NRD_INPUT_TEXTURE( resourceType, resourceName, regName, bindingIndex ) resourceType resourceName : register( regName ## bindingIndex ); + #define NRD_INPUT_TEXTURE_END + + #define NRD_OUTPUT_TEXTURE_START + #define NRD_OUTPUT_TEXTURE( resourceType, resourceName, regName, bindingIndex ) resourceType resourceName : register( regName ## bindingIndex ); + #define NRD_OUTPUT_TEXTURE_END + + #define NRD_SAMPLER_START + #define NRD_SAMPLER( resourceType, resourceName, regName, bindingIndex ) resourceType resourceName : register( regName ## bindingIndex ); + #define NRD_SAMPLER_END + + #define NRD_EXPORT -#elif( !defined( NRD_HEADER_ONLY ) ) - #error "Define one of NRD_COMPILER_[FXC/DXC/PSSLC/UNREAL_ENGINE] or add custom bindings (use already defined platforms as a reference). Or define NRD_HEADER_ONLY to use this file as a header file only." #endif //================================================================================================================================= // PRIVATE //================================================================================================================================= -#if !defined(__cplusplus) +#ifdef NRD_INTERNAL + #pragma pack_matrix( column_major ) +#endif + +#if( !defined( NRD_NORMAL_ENCODING ) || !defined( NRD_ROUGHNESS_ENCODING ) ) + #ifdef NRD_INTERNAL + #error "For NRD project compilation, encoding variants must be set using Cmake parameters." + #else + #error "Include 'NRDEncoding.hlsli' file beforehand to get a match with the settings NRD has been compiled with. Or define encoding variants using Cmake parameters." + #endif +#endif // Normal encoding variants ( match NormalEncoding ) #define NRD_NORMAL_ENCODING_RGBA8_UNORM 0 @@ -248,6 +242,8 @@ NOTE: if "roughness" is needed as an input parameter use is as "isDiffuse ? 1 : #define NRD_FP16_VIEWZ_SCALE 0.125 // TODO: tuned for meters, needs to be scaled down for cm and mm #define NRD_PI 3.14159265358979323846 #define NRD_EPS 1e-6 +#define NRD_REJITTER_VIEWZ_THRESHOLD 0.01 // normalized % +#define NRD_ROUGHNESS_EPS sqrt( sqrt( NRD_EPS ) ) // "m2" fitting in FP32 to "linear roughness" // ViewZ packing into FP16 float _NRD_PackViewZ( float z ) @@ -305,84 +301,187 @@ float3 _NRD_YCoCgToLinear( float3 color ) return max( r, 0.0 ); } -// Hit distance normalization -float _REBLUR_GetHitDistanceNormalization( float viewZ, float4 hitDistParams, float roughness = 1.0 ) +float3 _NRD_YCoCgToLinear_Corrected( float Y, float Y0, float2 CoCg ) { - return ( hitDistParams.x + abs( viewZ ) * hitDistParams.y ) * lerp( 1.0, hitDistParams.z, saturate( exp2( hitDistParams.w * roughness * roughness ) ) ); + Y = max( Y, 0.0 ); + CoCg *= ( Y + NRD_EPS ) / ( Y0 + NRD_EPS ); + + return _NRD_YCoCgToLinear( float3( Y, CoCg ) ); } -//================================================================================================================================= -// SPHERICAL HARMONICS -//================================================================================================================================= +// GGX dominant direction +float _NRD_GetSpecularDominantFactor( float NoV, float roughness ) +{ + float a = 0.298475 * log( 39.4115 - 39.0029 * roughness ); + float dominantFactor = pow( saturate( 1.0 - NoV ), 10.8649 ) * ( 1.0 - a ) + a; -// Spherical harmonics -// https://media.contentapi.ea.com/content/dam/eacom/frostbite/files/gdc2018-precomputedgiobalilluminationinfrostbite.pdf + return saturate( dominantFactor ); +} -struct NRD_SH +float3 _NRD_GetSpecularDominantDirection( float3 N, float3 V, float dominantFactor ) { - float3 c0_chroma; - float3 c1; - float normHitDist; -}; + float3 R = reflect( -V, N ); + float3 D = lerp( N, R, dominantFactor ); -NRD_SH NRD_SH_Create( float3 color, float3 direction, float normHitDist = 1.0 ) + return normalize( D ); +} + +float _NRD_GetSpecMagicCurve( float roughness ) { - float3 YCoCg = _NRD_LinearToYCoCg( color ); + return 1.0 - exp2( -30.0 * roughness * roughness ); +} - NRD_SH sh; - sh.c0_chroma = YCoCg; - sh.c1 = direction * YCoCg.x; - sh.normHitDist = normHitDist; +// BRDF +float _NRD_Pow5( float x ) +{ + return pow( saturate( 1.0 - x ), 5.0 ); +} - return sh; +float _NRD_FresnelTerm( float Rf0, float VoNH ) +{ + return Rf0 + ( 1.0 - Rf0 ) * _NRD_Pow5( VoNH ); } -float3 NRD_SH_ExtractColor( NRD_SH sh ) +float _NRD_DistributionTerm( float roughness, float NoH ) { - return _NRD_YCoCgToLinear( sh.c0_chroma ); + float m = roughness * roughness; + float m2 = m * m; + + float t = ( NoH * m2 - NoH ) * NoH + 1.0; + float a = m / t; + float d = a * a; + + return d / NRD_PI; } -float3 NRD_SH_ExtractDirection( NRD_SH sh ) +float _NRD_GeometryTerm( float roughness, float NoL, float NoV ) { - return sh.c1 / max( length( sh.c1 ), NRD_EPS ); + float m = roughness * roughness; + float m2 = m * m; + + float a = NoL + sqrt( saturate( ( NoL - m2 * NoL ) * NoL + m2 ) ); + float b = NoV + sqrt( saturate( ( NoV - m2 * NoV ) * NoV + m2 ) ); + + return 1.0 / ( a * b ); } -void NRD_SH_Add( inout NRD_SH result, NRD_SH x ) +float _NRD_DiffuseTerm( float roughness, float NoL, float NoV, float VoH ) { - result.c0_chroma += x.c0_chroma; - result.c1 += x.c1; + float m = roughness * roughness; + + float f = 2.0 * VoH * VoH * m - 0.5; + float FdV = f * _NRD_Pow5( NoV ) + 1.0; + float FdL = f * _NRD_Pow5( NoL ) + 1.0; + float d = FdV * FdL; + + return d / NRD_PI; } -void NRD_SH_Mul( inout NRD_SH result, float x ) +float2 _NRD_ComputeBrdfs( float3 Ld, float3 Ls, float3 N, float3 V, float Rf0, float roughness ) { - result.c0_chroma *= x; - result.c1 *= x; + float2 result; + float NoV = abs( dot( N, V ) ); + + // Diffuse + { + float3 H = normalize( Ld + V ); + + float NoL = saturate( dot( N, Ld ) ); + float VoH = saturate( dot( V, H ) ); + + float F = _NRD_FresnelTerm( Rf0, VoH ); + float Kdiff = _NRD_DiffuseTerm( roughness, NoL, NoV, VoH ); + + result.x = ( 1.0 - F ) * Kdiff * NoL; + } + + // Specular + { + float3 H = normalize( Ls + V ); + H = normalize( lerp( N, H, roughness ) ); // Fixed H // TODO: roughness => smc? + + float NoL = saturate( dot( N, Ls ) ); + float NoH = saturate( dot( N, H ) ); + float VoH = saturate( dot( V, H ) ); + + float F = _NRD_FresnelTerm( Rf0, VoH ); + float D = _NRD_DistributionTerm( roughness, NoH ); + float G = _NRD_GeometryTerm( roughness, NoL, NoV ); + + result.y = F * D * G * NoL; + } + + return result; } -float3 NRD_SH_ResolveColor( NRD_SH sh, float3 N ) +// Hit distance normalization +float _REBLUR_GetHitDistanceNormalization( float viewZ, float4 hitDistParams, float roughness = 1.0 ) { - float Y = 0.5 * dot( N, sh.c1 ) + 0.25 * sh.c0_chroma.x; + return ( hitDistParams.x + abs( viewZ ) * hitDistParams.y ) * lerp( 1.0, hitDistParams.z, saturate( exp2( hitDistParams.w * roughness * roughness ) ) ); +} - // 2 - hemisphere, 4 - sphere - Y *= 2.0; +//============================================================================================================================================== +// SPHERICAL HARMONICS: https://media.contentapi.ea.com/content/dam/eacom/frostbite/files/gdc2018-precomputedgiobalilluminationinfrostbite.pdf +// SPHERICAL GAUSSIAN: https://therealmjp.github.io/posts/sg-series-part-1-a-brief-and-incomplete-history-of-baked-lighting-representations/ +//============================================================================================================================================== - // Corrected color reproduction - Y = max( Y, 0.0 ); +struct NRD_SG +{ + float c0; + float2 chroma; + float normHitDist; - float modifier = ( Y + NRD_EPS ) / ( sh.c0_chroma.x + NRD_EPS ); - float2 CoCg = sh.c0_chroma.yz * modifier; + float3 c1; + float sharpness; +}; - return _NRD_YCoCgToLinear( float3( Y, CoCg ) ); +NRD_SG _NRD_SG_Create( float3 radiance, float3 direction, float normHitDist ) +{ + float3 YCoCg = _NRD_LinearToYCoCg( radiance ); + + NRD_SG sg; + sg.c0 = YCoCg.x; + sg.chroma = YCoCg.yz; + sg.c1 = direction * YCoCg.x; + sg.normHitDist = normHitDist; + sg.sharpness = 0.0; // TODO: currently not used + + return sg; +} + +float3 _NRD_SG_ExtractDirection( NRD_SG sg ) +{ + return sg.c1 / max( length( sg.c1 ), NRD_EPS ); +} + +float _NRD_SG_IntegralApprox( NRD_SG sg ) +{ + return 2.0 * NRD_PI * ( sg.c0 / sg.sharpness ); +} + +float _NRD_SG_Integral( NRD_SG sg ) +{ + float expTerm = 1.0 - exp( -2.0 * sg.sharpness ); + + return _NRD_SG_IntegralApprox( sg ) * expTerm; +} + +float _NRD_SG_InnerProduct( NRD_SG a, NRD_SG b ) +{ + // Integral of the product of two SGs + float d = length( a.sharpness * _NRD_SG_ExtractDirection( a ) + b.sharpness * _NRD_SG_ExtractDirection( b ) ); + float c = exp( d - a.sharpness - b.sharpness ); + c *= 1.0 - exp( -2.0 * d ); + c /= d; + + // Original version is without "saturate" ( needed to avoid rare fireflies in our case, energy is already preserved ) + return NRD_PI * saturate( 2.0 * c * a.c0 ) * b.c0; } //================================================================================================================================= -// FRONT-END +// FRONT-END - GENERAL //================================================================================================================================= -//======== -// NRD -//======== - // This function is used in all denoisers to decode normal, roughness and optional materialID // IN_NORMAL_ROUGHNESS => X float4 NRD_FrontEnd_UnpackNormalAndRoughness( float4 p, out float materialID ) @@ -454,9 +553,9 @@ float4 NRD_FrontEnd_PackNormalAndRoughness( float3 N, float roughness, uint mate return p; } -//======== -// REBLUR -//======== +//================================================================================================================================= +// FRONT-END - REBLUR +//================================================================================================================================= // This function returns AO / SO which REBLUR can decode back to "hit distance" internally float REBLUR_FrontEnd_GetNormHitDist( float hitDist, float viewZ, float4 hitDistParams, float roughness = 1.0 ) @@ -501,13 +600,13 @@ float4 REBLUR_FrontEnd_PackSh( float3 radiance, float normHitDist, float3 direct if( normHitDist != 0 ) normHitDist = max( normHitDist, NRD_FP16_MIN ); - NRD_SH sh = NRD_SH_Create( radiance, direction, normHitDist ); + NRD_SG sg = _NRD_SG_Create( radiance, direction, normHitDist ); // IN_DIFF_SH0 / IN_SPEC_SH0 - float4 out0 = float4( sh.c0_chroma, sh.normHitDist ); + float4 out0 = float4( sg.c0, sg.chroma, sg.normHitDist ); // IN_DIFF_SH1 / IN_SPEC_SH1 - out1 = float4( sh.c1, 0.0 ); + out1 = float4( sg.c1, sg.sharpness ); return out0; } @@ -526,14 +625,14 @@ float4 REBLUR_FrontEnd_PackDirectionalOcclusion( float3 direction, float normHit if( normHitDist != 0 ) normHitDist = max( normHitDist, NRD_FP16_MIN ); - NRD_SH sh = NRD_SH_Create( normHitDist, direction ); + NRD_SG sg = _NRD_SG_Create( normHitDist, direction, normHitDist ); - return float4( sh.c1, sh.c0_chroma.x ); + return float4( sg.c1, sg.c0 ); } -//======== -// RELAX -//======== +//================================================================================================================================= +// FRONT-END - RELAX +//================================================================================================================================= // X => IN_DIFF_RADIANCE_HITDIST // X => IN_SPEC_RADIANCE_HITDIST @@ -552,9 +651,32 @@ float4 RELAX_FrontEnd_PackRadianceAndHitDist( float3 radiance, float hitDist, bo return float4( radiance, hitDist ); } -//======== -// SIGMA -//======== +// X => IN_DIFF_SH0 and IN_DIFF_SH1 +// X => IN_SPEC_SH0 and IN_SPEC_SH1 +float4 RELAX_FrontEnd_PackSh( float3 radiance, float hitDist, float3 direction, out float4 out1, bool sanitize = true ) +{ + if( sanitize ) + { + radiance = any( isnan( radiance ) | isinf( radiance ) ) ? 0 : clamp( radiance, 0, NRD_FP16_MAX ); + hitDist = ( isnan( hitDist ) | isinf( hitDist ) ) ? 0 : clamp( hitDist, 0, NRD_FP16_MAX ); + } + + // "0" is reserved to mark "no data" samples, skipped due to probabilistic sampling + if( hitDist != 0 ) + hitDist = max( hitDist, NRD_FP16_MIN ); + + // IN_DIFF_SH0 / IN_SPEC_SH0 + float4 out0 = float4( radiance, hitDist ); + + // IN_DIFF_SH1 / IN_SPEC_SH1 + out1 = float4( direction * _NRD_Luminance( radiance ), 0 ); + + return out0; +} + +//================================================================================================================================= +// FRONT-END - SIGMA +//================================================================================================================================= #define SIGMA_MIN_DISTANCE 0.0001 // not 0, because it means "NoL < 0, stop processing" @@ -631,13 +753,9 @@ float2 SIGMA_FrontEnd_MultiLightEnd( float viewZ, SIGMA_MULTILIGHT_DATATYPE mult } //================================================================================================================================= -// BACK-END +// BACK-END - REBLUR //================================================================================================================================= -//======== -// REBLUR -//======== - // OUT_DIFF_RADIANCE_HITDIST => X // OUT_SPEC_RADIANCE_HITDIST => X float4 REBLUR_BackEnd_UnpackRadianceAndNormHitDist( float4 data ) @@ -649,30 +767,34 @@ float4 REBLUR_BackEnd_UnpackRadianceAndNormHitDist( float4 data ) // OUT_DIFF_SH0 and OUT_DIFF_SH1 => X // OUT_SPEC_SH0 and OUT_SPEC_SH1 => X -NRD_SH REBLUR_BackEnd_UnpackSh( float4 sh0, float4 sh1 ) +NRD_SG REBLUR_BackEnd_UnpackSh( float4 sh0, float4 sh1 ) { - NRD_SH sh; - sh.c0_chroma = sh0.xyz; - sh.c1 = sh1.xyz; - sh.normHitDist = sh0.w; - - return sh; + NRD_SG sg; + sg.c0 = sh0.x; + sg.chroma = sh0.yz; + sg.normHitDist = sh0.w; + sg.c1 = sh1.xyz; + sg.sharpness = sh1.w; + + return sg; } // OUT_DIFF_DIRECTION_HITDIST => X -NRD_SH REBLUR_BackEnd_UnpackDirectionalOcclusion( float4 data ) +NRD_SG REBLUR_BackEnd_UnpackDirectionalOcclusion( float4 data ) { - NRD_SH sh; - sh.c0_chroma = float3( data.w, 0.0, 0.0 ); - sh.c1 = data.xyz; - sh.normHitDist = NRD_SH_ExtractColor( sh ).x; - - return sh; + NRD_SG sg; + sg.c0 = data.w; + sg.chroma = float2( 0, 0 ); + sg.normHitDist = data.w; + sg.c1 = data.xyz; + sg.sharpness = 0.0; + + return sg; } -//======== -// RELAX -//======== +//================================================================================================================================= +// BACK-END - RELAX +//================================================================================================================================= // OUT_DIFF_RADIANCE_HITDIST => X // OUT_SPEC_RADIANCE_HITDIST => X @@ -681,9 +803,23 @@ float4 RELAX_BackEnd_UnpackRadiance( float4 color ) return color; } -//======== -// SIGMA -//======== +// OUT_DIFF_SH0 and OUT_DIFF_SH1 => X +// OUT_SPEC_SH0 and OUT_SPEC_SH1 => X +NRD_SG RELAX_BackEnd_UnpackSh( float4 sh0, float4 sh1 ) +{ + NRD_SG sg; + sg.c0 = sh0.x; + sg.chroma = sh0.yz; + sg.normHitDist = sh0.w; + sg.c1 = sh1.xyz; + sg.sharpness = sh1.w; + + return sg; +} + +//================================================================================================================================= +// BACK-END - SIGMA +//================================================================================================================================= // OUT_SHADOW_TRANSLUCENCY => X // SIGMA_SHADOW: @@ -696,6 +832,197 @@ float4 RELAX_BackEnd_UnpackRadiance( float4 color ) // float3 finalShadowMoreExotic = shadowData.yzw; #define SIGMA_BackEnd_UnpackShadow( color ) ( color * color ) +//================================================================================================================================= +// BACK-END - HIGH QUALITY RESOLVE +//================================================================================================================================= + +float3 NRD_SG_ExtractColor( NRD_SG sg ) +{ + return _NRD_YCoCgToLinear( float3( sg.c0, sg.chroma ) ); +} + +float3 NRD_SG_ExtractDirection( NRD_SG sg ) +{ + return _NRD_SG_ExtractDirection( sg ); +} + +float NRD_SG_ExtractRoughnessAA( NRD_SG sg ) +{ + return sg.sharpness; +} + +float3 NRD_SG_ResolveDiffuse( NRD_SG sg, float3 N ) +{ + // https://therealmjp.github.io/posts/sg-series-part-3-diffuse-lighting-from-an-sg-light-source/ + +#if 1 + // Numerical integration of the resulting irradiance from an SG diffuse light source ( with sharpness of 4.0 ) + sg.sharpness = 4.0; + + float c0 = 0.36; + float c1 = 1.0 / ( 4.0 * c0 ); + + float e = exp( -sg.sharpness ); + float e2 = e * e; + float r = rcp( sg.sharpness ); + + float scale = 1.0 + 2.0 * e2 - r; + float bias = ( e - e2 ) * r - e2; + + float NoL = dot( N, _NRD_SG_ExtractDirection( sg ) ); + float x = sqrt( saturate( 1.0 - scale ) ); + float x0 = c0 * NoL; + float x1 = c1 * x; + float n = x0 + x1; + + float y = saturate( NoL ); + if( abs( x0 ) <= x1 ) + y = n * n / x; + + float Y = scale * y + bias; + Y *= _NRD_SG_IntegralApprox( sg ); +#else + // "SG light" sharpness + sg.sharpness = 2.0; // TODO: another sharpness = another normalization needed... + + // Approximate NDF + NRD_SG ndf = ( NRD_SG )0; + ndf.c0 = 1.0; + ndf.c1 = N; + ndf.sharpness = 2.0; + + // Non-magic scale + ndf.c0 *= 0.75; + + // Multiply two SGs and integrate the result + float Y = _NRD_SG_InnerProduct( ndf, sg ); +#endif + + return _NRD_YCoCgToLinear_Corrected( Y, sg.c0, sg.chroma ); +} + +float3 NRD_SG_ResolveSpecular( NRD_SG sg, float3 N, float3 V, float roughness ) +{ + // https://therealmjp.github.io/posts/sg-series-part-4-specular-lighting-from-an-sg-light-source/ + + // Clamp roughness to avoid numerical imprecision + roughness = max( roughness, NRD_ROUGHNESS_EPS ); + + // "SG light" sharpness + sg.sharpness = 2.0; // TODO: another sharpness = another normalization needed... + + // Approximate NDF + float3 H = normalize( _NRD_SG_ExtractDirection( sg ) + V ); + H = normalize( lerp( N, H, roughness ) ); // Fixed H // TODO: roughness => smc? + + float m = roughness * roughness; + float m2 = m * m; + + NRD_SG ndf = ( NRD_SG )0; + ndf.c0 = 1.0 / ( NRD_PI * m2 ); + ndf.c1 = H; + ndf.sharpness = 2.0 / m2; + + // Non-magic scale + ndf.c0 *= lerp( 1.0, 0.75 * 2.0 * NRD_PI, m2 ); + + // Warp NDF + NRD_SG ndfWarped; + ndfWarped.c1 = reflect( -V, ndf.c1 ); + ndfWarped.c0 = ndf.c0; + ndfWarped.sharpness = ndf.sharpness / ( 4.0 * abs( dot( ndf.c1, V ) ) + NRD_EPS ); + + // Cosine term & visibility term evaluated at the center of the warped BRDF lobe + float NoV = abs( dot( N, V ) ); + float NoL = saturate( dot( N, ndfWarped.c1 ) ); + + ndfWarped.c0 *= NoL; + ndfWarped.c0 *= _NRD_GeometryTerm( roughness, NoL, NoV ); + + // Multiply two SGs and integrate the result + float Y = _NRD_SG_InnerProduct( ndfWarped, sg ); + + return _NRD_YCoCgToLinear_Corrected( Y, sg.c0, sg.chroma ); +} + +/* +Offsets: +e = int2( 1, 0 ) +w = int2(-1, 0 ) +n = int2( 0, 1 ) +s = int2( 0, -1 ) +*/ +float2 NRD_SG_ReJitter( + NRD_SG diffSg, NRD_SG specSg, + float3 Rf0, float3 V, float roughness, + float Z, float Ze, float Zw, float Zn, float Zs, + float3 N, float3 Ne, float3 Nw, float3 Nn, float3 Ns +) +{ + // Clamp roughness to avoid numerical imprecision + roughness = max( roughness, NRD_ROUGHNESS_EPS ); + + // Extract Rf0 and diff & spec dominant light directions + float rf0 = _NRD_Luminance( Rf0 ); + float3 Ld = _NRD_SG_ExtractDirection( diffSg ); + float3 Ls = _NRD_SG_ExtractDirection( specSg ); + + // Ls is accumulated, ideally it shouldn't for low roughness, but it's not a bug on the NRD side. + // The hack below is not needed if stochastic per-pixel jittering is used. Otherwise, the best approach + // is to resolve against jittered "view" vector. Despite that this approach looks very biased, it doesn't + // changes the energy of the output signal + float smc = _NRD_GetSpecMagicCurve( roughness ); + Ls = normalize( lerp( V, Ls, smc ) ); + + // BRDF at center + float2 brdfCenter = _NRD_ComputeBrdfs( Ld, Ls, N, V, rf0, roughness ); + + // BRDFs at neighbors + float2 brdfAverage = _NRD_ComputeBrdfs( Ld, Ls, Ne, V, rf0, roughness ); + brdfAverage += _NRD_ComputeBrdfs( Ld, Ls, Nn, V, rf0, roughness ); + brdfAverage += _NRD_ComputeBrdfs( Ld, Ls, Nw, V, rf0, roughness ); + brdfAverage += _NRD_ComputeBrdfs( Ld, Ls, Ns, V, rf0, roughness ); + + // Viewing angle corrected Z threshold + float NoV = abs( dot( N, V ) ); + float zThreshold = NRD_REJITTER_VIEWZ_THRESHOLD * abs( Z ) / ( NoV * 0.95 + 0.05 ); + + // Sum of all weights + // Exploit: out of screen fetches return "0", which auto-disables resolve on screen edges + uint sum = abs( Ze - Z ) < zThreshold && dot( Ne, N ) > 0.0 ? 1 : 0; + sum += abs( Zn - Z ) < zThreshold && dot( Nn, N ) > 0.0 ? 1 : 0; + sum += abs( Zw - Z ) < zThreshold && dot( Nw, N ) > 0.0 ? 1 : 0; + sum += abs( Zs - Z ) < zThreshold && dot( Ns, N ) > 0.0 ? 1 : 0; + + // Jacobian + float2 f = ( brdfCenter * 4.0 + NRD_EPS ) / ( brdfAverage + NRD_EPS ); + + // Use re-jitter only if all samples are valid to minimize ringing + return sum != 4 ? 1.0 : clamp( f, 1.0 / NRD_PI, NRD_PI ); +} + +//================================================================================================================================= +// SPHERICAL HARMONICS ( MEDIUM QUALITY ) +//================================================================================================================================= + +float3 NRD_SH_ResolveDiffuse( NRD_SG sh, float3 N ) +{ + float Y = dot( N, sh.c1 ) + 0.5 * sh.c0; + + return _NRD_YCoCgToLinear_Corrected( Y, sh.c0, sh.chroma ); +} + +float3 NRD_SH_ResolveSpecular( NRD_SG sh, float3 N, float3 V, float roughness ) +{ + float NoV = abs( dot( N, V ) ); + float f = _NRD_GetSpecularDominantFactor( NoV, roughness ); + float3 D = _NRD_GetSpecularDominantDirection( N, V, f ); + + float Y = dot( D, sh.c1 ) + 0.5 * sh.c0; + + return _NRD_YCoCgToLinear_Corrected( Y, sh.c0, sh.chroma ); +} + //================================================================================================================================= // MISC //================================================================================================================================= @@ -714,6 +1041,6 @@ float REBLUR_GetHitDist( float normHitDist, float viewZ, float4 hitDistParams, f return normHitDist * scale; } -#endif +#endif // __cplusplus -#endif +#endif // NRD_INCLUDED diff --git a/Shaders/Include/REBLUR/REBLUR_Common.hlsli b/Shaders/Include/REBLUR/REBLUR_Common.hlsli index 674a8733..3a099338 100644 --- a/Shaders/Include/REBLUR/REBLUR_Common.hlsli +++ b/Shaders/Include/REBLUR/REBLUR_Common.hlsli @@ -386,19 +386,6 @@ float2x3 GetKernelBasis( float3 D, float3 N, float NoD, float roughness = 1.0, f // Encoding precision aware weight functions ( for reprojection ) -float GetEncodingAwareRoughnessWeights( float roughnessCurr, float roughnessPrev, float fraction ) -{ - float a = rcp( lerp( 0.01, 1.0, saturate( roughnessCurr * fraction ) ) ); - float d = abs( roughnessPrev - roughnessCurr ); - - float w = STL::Math::SmoothStep01( 1.0 - ( d - REBLUR_ROUGHNESS_ULP ) * a ); - - // Needed to mitigate imprecision issues - w = STL::Math::SmoothStep( 0.05, 0.95, w ); - - return w; -} - float GetEncodingAwareNormalWeight( float3 Ncurr, float3 Nprev, float maxAngle, float angleThreshold = 0.0 ) { // Anything below "angleThreshold" is ignored @@ -427,19 +414,6 @@ float GetNormalWeightParams( float nonLinearAccumSpeed, float fraction, float ro return 1.0 / max( angle, REBLUR_NORMAL_ULP ); } -float2 GetRoughnessWeightParams( float roughness, float fraction ) -{ - float a = rcp( lerp( 0.01, 1.0, saturate( roughness * fraction ) ) ); - float b = roughness * a; - - return float2( a, -b ); -} - -float2 GetCoarseRoughnessWeightParams( float roughness ) -{ - return float2( 1.0, -roughness ); -} - float2 GetTemporalAccumulationParams( float isInScreenMulFootprintQuality, float accumSpeed ) { float w = isInScreenMulFootprintQuality; diff --git a/Shaders/Include/REBLUR/REBLUR_Common_SpecularSpatialFilter.hlsli b/Shaders/Include/REBLUR/REBLUR_Common_SpecularSpatialFilter.hlsli index 1769edd9..85c423ed 100644 --- a/Shaders/Include/REBLUR/REBLUR_Common_SpecularSpatialFilter.hlsli +++ b/Shaders/Include/REBLUR/REBLUR_Common_SpecularSpatialFilter.hlsli @@ -200,14 +200,14 @@ license agreement from NVIDIA CORPORATION is strictly prohibited. spec += s * w; #ifdef REBLUR_SH float4 sh = gIn_SpecSh.SampleLevel( gNearestClamp, checkerboardUvScaled, 0 ); - specSh += sh * w; + specSh.xyz += sh.xyz * w; #endif } float invSum = STL::Math::PositiveRcp( sum ); spec *= invSum; #ifdef REBLUR_SH - specSh *= invSum; + specSh.xyz *= invSum; #endif #if( REBLUR_SPATIAL_MODE == REBLUR_PRE_BLUR ) diff --git a/Shaders/Include/REBLUR/REBLUR_Config.hlsli b/Shaders/Include/REBLUR/REBLUR_Config.hlsli index 8e51844d..337e4010 100644 --- a/Shaders/Include/REBLUR/REBLUR_Config.hlsli +++ b/Shaders/Include/REBLUR/REBLUR_Config.hlsli @@ -111,10 +111,11 @@ static const float3 g_Special8[ 8 ] = NRD_CONSTANT( float2, gScreenSize ) \ NRD_CONSTANT( float2, gInvRectSize ) \ NRD_CONSTANT( float2, gRectSize ) \ - NRD_CONSTANT( float2, gRectSizePrev ) \ NRD_CONSTANT( float2, gResolutionScale ) \ - NRD_CONSTANT( float2, gRectOffset ) \ + NRD_CONSTANT( float2, gResolutionScalePrev ) \ + NRD_CONSTANT( float2, gRectSizePrev ) \ NRD_CONSTANT( float2, gSensitivityToDarkness ) \ + NRD_CONSTANT( float2, gRectOffset ) \ NRD_CONSTANT( uint2, gRectOrigin ) \ NRD_CONSTANT( float, gNonReferenceAccumulation ) \ NRD_CONSTANT( float, gOrthoMode ) \ @@ -137,7 +138,9 @@ static const float3 g_Special8[ 8 ] = NRD_CONSTANT( uint, gFrameIndex ) \ NRD_CONSTANT( uint, gDiffMaterialMask ) \ NRD_CONSTANT( uint, gSpecMaterialMask ) \ - NRD_CONSTANT( uint, gResetHistory ) // IMPORTANT: used only in validation + NRD_CONSTANT( uint, gResetHistory ) \ + NRD_CONSTANT( uint, gUnused1 ) \ + NRD_CONSTANT( uint, gUnused2 ) // PERFORMANCE MODE: x1.25 perf boost by sacrificing IQ ( DIFFUSE_SPECULAR on RTX 3090 @ 1440p 2.05 vs 2.55 ms ) #ifdef REBLUR_PERFORMANCE_MODE diff --git a/Shaders/Include/REBLUR/REBLUR_DiffuseSpecular_HistoryFix.hlsli b/Shaders/Include/REBLUR/REBLUR_DiffuseSpecular_HistoryFix.hlsli index f1c726f1..75c010e7 100644 --- a/Shaders/Include/REBLUR/REBLUR_DiffuseSpecular_HistoryFix.hlsli +++ b/Shaders/Include/REBLUR/REBLUR_DiffuseSpecular_HistoryFix.hlsli @@ -272,7 +272,7 @@ NRD_EXPORT void NRD_CS_MAIN( int2 threadPos : SV_GroupThreadId, int2 pixelPos : float specNormalWeightParam = 1.0 / max( lobeHalfAngle, REBLUR_NORMAL_ULP ); float2 specGeometryWeightParams = GetGeometryWeightParams( gPlaneDistSensitivity, frustumSize, Xv, Nv, specNonLinearAccumSpeed ); - float2 specRoughnessWeightParams = GetRoughnessWeightParams( roughness, gRoughnessFraction ); + float2 specRoughnessWeightParamsSq = GetRoughnessWeightParamsSq( roughness, gRoughnessFraction ); float hitDistNormAtCenter = ExtractHitDist( spec ); float smc = GetSpecMagicCurve( roughness ); @@ -316,7 +316,7 @@ NRD_EXPORT void NRD_CS_MAIN( int2 threadPos : SV_GroupThreadId, int2 pixelPos : ws *= CompareMaterials( materialID, materialIDs, gSpecMaterialMask ); ws *= _ComputeWeight( NoX, specGeometryWeightParams.x, specGeometryWeightParams.y ); ws *= _ComputeExponentialWeight( angle, specNormalWeightParam, 0.0 ); - ws *= _ComputeExponentialWeight( Ns.w, specRoughnessWeightParams.x, specRoughnessWeightParams.y ); + ws *= _ComputeExponentialWeight( Ns.w * Ns.w, specRoughnessWeightParamsSq.x, specRoughnessWeightParamsSq.y ); REBLUR_TYPE s = gIn_Spec.SampleLevel( gNearestClamp, uvScaled, 0 ); diff --git a/Shaders/Include/REBLUR/REBLUR_DiffuseSpecular_TemporalAccumulation.hlsli b/Shaders/Include/REBLUR/REBLUR_DiffuseSpecular_TemporalAccumulation.hlsli index 84cfbe4f..4c440c22 100644 --- a/Shaders/Include/REBLUR/REBLUR_DiffuseSpecular_TemporalAccumulation.hlsli +++ b/Shaders/Include/REBLUR/REBLUR_DiffuseSpecular_TemporalAccumulation.hlsli @@ -73,7 +73,8 @@ NRD_EXPORT void NRD_CS_MAIN( int2 threadPos : SV_GroupThreadId, int2 pixelPos : int2 pos = threadPos + int2( i, j ); float4 t = s_Normal_MinHitDist[ pos.y ][ pos.x ]; - Navg.xyz += t.xyz; + if( i < 2 && j < 2 ) + Navg.xyz += t.xyz; #ifdef REBLUR_SPECULAR hitDistForTracking = min( hitDistForTracking, t.w ); // just "min" here works better than code from PrePass @@ -81,7 +82,7 @@ NRD_EXPORT void NRD_CS_MAIN( int2 threadPos : SV_GroupThreadId, int2 pixelPos : } } - Navg /= ( BORDER * 2 + 1 ) * ( BORDER * 2 + 1 ); // needs to be unnormalized! + Navg /= 4.0; // needs to be unnormalized! // Normal and roughness float materialID; @@ -535,7 +536,7 @@ NRD_EXPORT void NRD_CS_MAIN( int2 threadPos : SV_GroupThreadId, int2 pixelPos : float angle = lobeHalfAngle + curvatureAngle; // Virtual motion amount - normal - float4 vmbNormalAndRoughness = UnpackNormalAndRoughness( gIn_Prev_Normal_Roughness.SampleLevel( gLinearClamp, vmbPixelUv * gRectSizePrev * gInvScreenSize, 0 ) ); + float4 vmbNormalAndRoughness = UnpackNormalAndRoughness( gIn_Prev_Normal_Roughness.SampleLevel( gLinearClamp, vmbPixelUv * gResolutionScalePrev, 0 ) ); float3 vmbN = STL::Geometry::RotateVector( gWorldPrevToWorld, vmbNormalAndRoughness.xyz ); float virtualHistoryNormalBasedConfidence = GetEncodingAwareNormalWeight( N, vmbN, angle ); @@ -545,7 +546,8 @@ NRD_EXPORT void NRD_CS_MAIN( int2 threadPos : SV_GroupThreadId, int2 pixelPos : virtualHistoryAmount *= float( dot( vmbN, Navg ) > 0.0 ); // TODO: "frontFacing" seems to be not needed, better replace with "in-lobe" check // Virtual motion amount - roughness - float virtualHistoryRoughnessBasedConfidence = GetEncodingAwareRoughnessWeights( roughness, vmbNormalAndRoughness.w, gRoughnessFraction ); + float2 roughnessParamsSq = GetRoughnessWeightParamsSq( roughness, gRoughnessFraction ); + float virtualHistoryRoughnessBasedConfidence = GetRoughnessWeightSq( roughnessParamsSq, vmbNormalAndRoughness.w ); virtualHistoryAmount *= lerp( 1.0 - saturate( vmbPixelsTraveled ), 1.0, virtualHistoryRoughnessBasedConfidence ); // jitter friendly // Sample history - surface motion @@ -612,21 +614,26 @@ NRD_EXPORT void NRD_CS_MAIN( int2 threadPos : SV_GroupThreadId, int2 pixelPos : vmbDelta /= gRectSizePrev; vmbDelta *= saturate( vmbPixelsTraveled / 0.1 ) + vmbPixelsTraveled / REBLUR_VIRTUAL_MOTION_PREV_PREV_WEIGHT_ITERATION_NUM; + roughnessParamsSq = GetRoughnessWeightParamsSq( vmbNormalAndRoughness.w, gRoughnessFraction ); + float wr = 1.0; + [unroll] for( i = 1; i <= REBLUR_VIRTUAL_MOTION_PREV_PREV_WEIGHT_ITERATION_NUM; i++ ) { float2 vmbPixelUvPrev = vmbPixelUv + vmbDelta * i; - float4 vmbNormalAndRoughnessPrev = UnpackNormalAndRoughness( gIn_Prev_Normal_Roughness.SampleLevel( gLinearClamp, vmbPixelUvPrev * gRectSizePrev * gInvScreenSize, 0 ) ); + float4 vmbNormalAndRoughnessPrev = UnpackNormalAndRoughness( gIn_Prev_Normal_Roughness.SampleLevel( gLinearClamp, vmbPixelUvPrev * gResolutionScalePrev, 0 ) ); - float w = GetEncodingAwareNormalWeight( vmbNormalAndRoughness.xyz, vmbNormalAndRoughnessPrev.xyz, angle + curvatureAngle * i, curvatureAngle ); - float wr = GetEncodingAwareRoughnessWeights( vmbNormalAndRoughness.w, vmbNormalAndRoughnessPrev.w, gRoughnessFraction ); - w *= lerp( 0.33 * i, 1.0, lerp( 1.0 - saturate( abs( vmbPixelsTraveled ) ), 1.0, wr ) ); + float w1 = GetEncodingAwareNormalWeight( vmbNormalAndRoughness.xyz, vmbNormalAndRoughnessPrev.xyz, angle + curvatureAngle * i, curvatureAngle ); + float w2 = GetRoughnessWeightSq( roughnessParamsSq, vmbNormalAndRoughnessPrev.w ); - float isOutOfScreen = 1.0 - IsInScreen( vmbPixelUvPrev ); - virtualHistoryConfidence *= saturate( w + isOutOfScreen ); - virtualHistoryRoughnessBasedConfidence *= saturate( wr + isOutOfScreen ); + bool isInScreen = IsInScreen( vmbPixelUvPrev ); + virtualHistoryConfidence *= isInScreen ? w1 : 1.0; + wr *= isInScreen ? w2 : 1.0; } + virtualHistoryRoughnessBasedConfidence *= wr; + virtualHistoryAmount *= 0.1 + wr * 0.9; + // Virtual motion - accumulation acceleration vmbSpecAccumSpeed *= virtualHistoryConfidence; @@ -637,7 +644,7 @@ NRD_EXPORT void NRD_CS_MAIN( int2 threadPos : SV_GroupThreadId, int2 pixelPos : smbSpecAccumSpeedFactor *= gFramerateScale; smbSpecAccumSpeedFactor *= lerp( 0.5 + 0.5 * virtualHistoryRoughnessBasedConfidence, 1.0, virtualHistoryAmount ); - float diffParallaxInPixels = lerp( smbParallaxInPixels, vmbPixelsTraveled, virtualHistoryAmount ); + float diffParallaxInPixels = lerp( smbParallaxInPixels * ( 1.0 - smc ), vmbPixelsTraveled, virtualHistoryAmount ); float smbSpecAccumSpeed = GetSmbAccumSpeed( smbSpecAccumSpeedFactor, diffParallaxInPixels, viewZ, specAccumSpeed, angle ); // Fallback to surface motion if virtual motion doesn't go well ( tests 103, 111, 132, e9, e11 ) @@ -660,7 +667,10 @@ NRD_EXPORT void NRD_CS_MAIN( int2 threadPos : SV_GroupThreadId, int2 pixelPos : REBLUR_TYPE specResult = MixHistoryAndCurrent( specHistory, spec, specNonLinearAccumSpeed, roughnessModified ); #ifdef REBLUR_SH float4 specShHistory = lerp( smbSpecShHistory, vmbSpecShHistory, virtualHistoryAmount ); - float4 specShResult = MixHistoryAndCurrent( specShHistory, specSh, specNonLinearAccumSpeed, roughnessModified ); + float4 specShResult = lerp( specShHistory, specSh, specNonLinearAccumSpeed ); + + // ( Optional ) Output modified roughness to assist AA during SG resolve + specShResult.w = roughnessModified; // IMPORTANT: should not be blurred #endif // Anti-firefly suppressor diff --git a/Shaders/Include/REBLUR/REBLUR_DiffuseSpecular_TemporalStabilization.hlsli b/Shaders/Include/REBLUR/REBLUR_DiffuseSpecular_TemporalStabilization.hlsli index eb1fca40..db4290fd 100644 --- a/Shaders/Include/REBLUR/REBLUR_DiffuseSpecular_TemporalStabilization.hlsli +++ b/Shaders/Include/REBLUR/REBLUR_DiffuseSpecular_TemporalStabilization.hlsli @@ -198,13 +198,13 @@ NRD_EXPORT void NRD_CS_MAIN( int2 threadPos : SV_GroupThreadId, int2 pixelPos : #endif // Previous position and surface motion uv - float3 mv = gInOut_Mv[ pixelPosUser ] * gMvScale; + float4 mv = gInOut_Mv[ pixelPosUser ] * float4( gMvScale, 1.0 ); float3 Xprev = X; float2 smbPixelUv = pixelUv + mv.xy; if( gIsWorldSpaceMotionEnabled ) { - Xprev += mv; + Xprev += mv.xyz; smbPixelUv = STL::Geometry::GetScreenUv( gWorldToClipPrev, Xprev ); } else if( gMvScale.z != 0.0 ) @@ -266,17 +266,14 @@ NRD_EXPORT void NRD_CS_MAIN( int2 threadPos : SV_GroupThreadId, int2 pixelPos : // Clamp history and combine with the current frame float2 diffTemporalAccumulationParams = GetTemporalAccumulationParams( smbIsInScreenMulFootprintQuality, data1.x ); - smbDiffHistory = STL::Color::Clamp( diffM1, diffSigma * diffTemporalAccumulationParams.y, smbDiffHistory ); - #ifdef REBLUR_SH - smbDiffShHistory = STL::Color::Clamp( diffShM1, diffShSigma * diffTemporalAccumulationParams.y, smbDiffShHistory ); - #endif - float diffHistoryWeight = diffTemporalAccumulationParams.x; diffHistoryWeight *= diffAntilag; diffHistoryWeight *= diffStabilizationStrength; + smbDiffHistory = STL::Color::Clamp( diffM1, diffSigma * diffTemporalAccumulationParams.y, smbDiffHistory ); float4 diffResult = lerp( diff, smbDiffHistory, diffHistoryWeight ); #ifdef REBLUR_SH + smbDiffShHistory = STL::Color::Clamp( diffShM1, diffShSigma * diffTemporalAccumulationParams.y, smbDiffShHistory ); float4 diffShResult = lerp( diffSh, smbDiffShHistory, diffHistoryWeight ); #endif @@ -336,11 +333,11 @@ NRD_EXPORT void NRD_CS_MAIN( int2 threadPos : SV_GroupThreadId, int2 pixelPos : gIn_Spec_StabilizedHistory, vmbSpecHistory ); #else - vmbSpecHistory = gIn_Spec_StabilizedHistory.SampleLevel( gLinearClamp, vmbPixelUv, 0 ); + vmbSpecHistory = gIn_Spec_StabilizedHistory.SampleLevel( gLinearClamp, vmbPixelUv * gResolutionScalePrev, 0 ); #endif #ifdef REBLUR_SH - float4 vmbSpecShHistory = gIn_SpecSh_StabilizedHistory.SampleLevel( gLinearClamp, vmbPixelUv, 0 ); + float4 vmbSpecShHistory = gIn_SpecSh_StabilizedHistory.SampleLevel( gLinearClamp, vmbPixelUv * gResolutionScalePrev, 0 ); #endif // Modify MVs if requested @@ -369,7 +366,7 @@ NRD_EXPORT void NRD_CS_MAIN( int2 threadPos : SV_GroupThreadId, int2 pixelPos : specMv.z = 0.0; // TODO: nice to have, but not needed for TAA & upscaling techniques } - mv = lerp( mv, specMv, f ); + mv.xyz = lerp( mv.xyz, specMv, f ); mv.xy /= gMvScale.xy; mv.z /= gMvScale.z == 0.0 ? 1.0 : gMvScale.z; @@ -406,18 +403,21 @@ NRD_EXPORT void NRD_CS_MAIN( int2 threadPos : SV_GroupThreadId, int2 pixelPos : float isInScreenMulFootprintQuality = lerp( smbIsInScreenMulFootprintQuality, 1.0, virtualHistoryAmount ); float2 specTemporalAccumulationParams = GetTemporalAccumulationParams( isInScreenMulFootprintQuality, data1.z ); - specHistory = STL::Color::Clamp( specM1, specSigma * specTemporalAccumulationParams.y, specHistory ); - #ifdef REBLUR_SH - specShHistory = STL::Color::Clamp( specShM1, specShSigma * specTemporalAccumulationParams.y, specShHistory ); - #endif - + // TODO: roughness should affect stabilization: + // - use "virtualHistoryRoughnessBasedConfidence" from TA + // - compute moments for samples with similar roughness float specHistoryWeight = specTemporalAccumulationParams.x; specHistoryWeight *= specAntilag; // this is important specHistoryWeight *= specStabilizationStrength; + specHistory = STL::Color::Clamp( specM1, specSigma * specTemporalAccumulationParams.y, specHistory ); float4 specResult = lerp( spec, specHistory, specHistoryWeight ); #ifdef REBLUR_SH + specShHistory = STL::Color::Clamp( specShM1, specShSigma * specTemporalAccumulationParams.y, specShHistory ); float4 specShResult = lerp( specSh, specShHistory, specHistoryWeight ); + + // ( Optional ) Output modified roughness to assist AA during SG resolve + specShResult.w = specSh.w; #endif // Output diff --git a/Shaders/Include/RELAX/RELAX_Common.hlsli b/Shaders/Include/RELAX/RELAX_Common.hlsli index f0bd90b0..75149d0a 100644 --- a/Shaders/Include/RELAX/RELAX_Common.hlsli +++ b/Shaders/Include/RELAX/RELAX_Common.hlsli @@ -26,36 +26,41 @@ float4 PackPrevNormalRoughness(float4 normalRoughness) return result; } -float BilinearWithBinaryWeightsImmediateFloat(float s00, float s10, float s01, float s11, float2 bilinearWeights, float4 binaryWeights, float interpolatedBinaryWeight) +float BilinearWithCustomWeightsImmediateFloat(float s00, float s10, float s01, float s11, float4 bilinearCustomWeights) { - s00 *= binaryWeights.x; - s10 *= binaryWeights.y; - s01 *= binaryWeights.z; - s11 *= binaryWeights.w; + float output = s00 * bilinearCustomWeights.x; + output += s10 * bilinearCustomWeights.y; + output += s01 * bilinearCustomWeights.z; + output += s11 * bilinearCustomWeights.w; - STL::Filtering::Bilinear bilinear; - bilinear.weights = bilinearWeights; - - float r = STL::Filtering::ApplyBilinearFilter(s00, s10, s01, s11, bilinear); - r /= interpolatedBinaryWeight; - - return r; + float sumWeights = dot(bilinearCustomWeights, 1.0); + output = sumWeights < 0.0001 ? 0 : output * rcp(sumWeights); + return output; } -float4 BilinearWithBinaryWeightsImmediateFloat4(float4 s00, float4 s10, float4 s01, float4 s11, float2 bilinearWeights, float4 binaryWeights, float interpolatedBinaryWeight) + +float4 BilinearWithCustomWeightsImmediateFloat4(float4 s00, float4 s10, float4 s01, float4 s11, float4 bilinearCustomWeights) { - s00 *= binaryWeights.x; - s10 *= binaryWeights.y; - s01 *= binaryWeights.z; - s11 *= binaryWeights.w; + float4 output = s00 * bilinearCustomWeights.x; + output += s10 * bilinearCustomWeights.y; + output += s01 * bilinearCustomWeights.z; + output += s11 * bilinearCustomWeights.w; - STL::Filtering::Bilinear bilinear; - bilinear.weights = bilinearWeights; + float sumWeights = dot(bilinearCustomWeights, 1.0); + output = sumWeights < 0.0001 ? 0 : output * rcp(sumWeights); + return output; +} - float4 r = STL::Filtering::ApplyBilinearFilter(s00, s10, s01, s11, bilinear); - r /= interpolatedBinaryWeight; +float4 BilinearWithCustomWeightsFloat4(Texture2D tex0, int2 position, float4 bilinearCustomWeights) +{ + float4 output = tex0[position] * bilinearCustomWeights.x; + output += tex0[position + int2(1, 0)] * bilinearCustomWeights.y; + output += tex0[position + int2(0, 1)] * bilinearCustomWeights.z; + output += tex0[position + int2(1, 1)] * bilinearCustomWeights.w; - return r; + float sumWeights = dot(bilinearCustomWeights, 1.0); + output = sumWeights < 0.0001 ? 0 : output * rcp(sumWeights); + return output; } float3 GetCurrentWorldPosFromPixelPos(int2 pixelPos, float viewZ) @@ -175,27 +180,6 @@ float GetNormalWeight(float3 Ncurr, float3 Nprev, float maxAngle) return w; } -float2 GetRoughnessWeightParams(float roughness, float fraction = 0.05) -{ - float a = rcp(lerp(0.01, 1.0, saturate(roughness * fraction))); - float b = roughness * a; - - return float2(a, -b); -} - -float2 GetRoughnessWeightParamsSq(float roughness, float fraction = 0.05) -{ - float roughnessSq = roughness * roughness; - float a = rcp(lerp(0.01, 1.0, saturate(roughnessSq * fraction))); - float b = roughnessSq * a; - - return float2(a, -b); -} -float GetRoughnessWeightSq(float2 params, float roughness) -{ - return GetRoughnessWeight(params, roughness * roughness); -} - void BicubicFilterNoCornersWithFallbackToBilinearFilterWithCustomWeights( float2 samplePos, float2 invTextureSize, float4 bilinearCustomWeights, bool useBicubic, diff --git a/Shaders/Include/RELAX/RELAX_DiffuseSpecular_Atrous.hlsli b/Shaders/Include/RELAX/RELAX_DiffuseSpecular_Atrous.hlsli index eb92c998..fe1fc597 100644 --- a/Shaders/Include/RELAX/RELAX_DiffuseSpecular_Atrous.hlsli +++ b/Shaders/Include/RELAX/RELAX_DiffuseSpecular_Atrous.hlsli @@ -37,6 +37,9 @@ NRD_EXPORT void NRD_CS_MAIN(uint2 pixelPos : SV_DispatchThreadId) // Diffuse normal weight is used for diffuse and can be used for specular depending on settings. // Weight strictness is higher as the Atrous step size increases. float diffuseLobeAngleFraction = gDiffuseLobeAngleFraction / sqrt(gStepSize); + #ifdef RELAX_SH + diffuseLobeAngleFraction = 1.0 / sqrt(gStepSize); + #endif diffuseLobeAngleFraction = lerp(0.99, diffuseLobeAngleFraction, saturate(historyLength / 5.0)); #ifdef RELAX_SPECULAR @@ -83,6 +86,11 @@ NRD_EXPORT void NRD_CS_MAIN(uint2 pixelPos : SV_DispatchThreadId) float sumWSpecular = 0.44198 * 0.44198; float4 sumSpecularIlluminationAndVariance = centerSpecularIlluminationAndVariance * float4(sumWSpecular.xxx, sumWSpecular * sumWSpecular); + #ifdef RELAX_SH + float4 centerSpecularSH1 = gSpecularSH1[pixelPos]; + float4 sumSpecularSH1 = centerSpecularSH1 * sumWSpecular; + float roughnessModified = centerSpecularSH1.w; + #endif #endif #ifdef RELAX_DIFFUSE @@ -109,6 +117,10 @@ NRD_EXPORT void NRD_CS_MAIN(uint2 pixelPos : SV_DispatchThreadId) float sumWDiffuse = 0.44198 * 0.44198; float4 sumDiffuseIlluminationAndVariance = centerDiffuseIlluminationAndVariance * float4(sumWDiffuse.xxx, sumWDiffuse * sumWDiffuse); + #ifdef RELAX_SH + float4 centerDiffuseSH1 = gDiffuseSH1[pixelPos]; + float4 sumDiffuseSH1 = centerDiffuseSH1 * sumWDiffuse; + #endif #endif float3 centerWorldPos = GetCurrentWorldPosFromPixelPos(pixelPos, centerViewZ); @@ -178,6 +190,9 @@ NRD_EXPORT void NRD_CS_MAIN(uint2 pixelPos : SV_DispatchThreadId) sumSpecularIlluminationAndVariance += float4(wSpecular.xxx, wSpecular * wSpecular) * sampleSpecularIlluminationAndVariance; sumWSpecular += wSpecular; + #ifdef RELAX_SH + sumSpecularSH1 += gSpecularSH1[p] * wSpecular; + #endif } #endif @@ -202,6 +217,9 @@ NRD_EXPORT void NRD_CS_MAIN(uint2 pixelPos : SV_DispatchThreadId) wDiffuse *= exp(-diffuseLuminanceW); sumDiffuseIlluminationAndVariance += float4(wDiffuse.xxx, wDiffuse * wDiffuse) * sampleDiffuseIlluminationAndVariance; sumWDiffuse += wDiffuse; + #ifdef RELAX_SH + sumDiffuseSH1 += gDiffuseSH1[p] * wDiffuse; + #endif } #endif } @@ -209,11 +227,27 @@ NRD_EXPORT void NRD_CS_MAIN(uint2 pixelPos : SV_DispatchThreadId) #ifdef RELAX_SPECULAR float4 filteredSpecularIlluminationAndVariance = float4(sumSpecularIlluminationAndVariance / float4(sumWSpecular.xxx, sumWSpecular * sumWSpecular)); + #ifdef RELAX_SH + // Luminance output is expected in YCoCg color space in SH mode, converting to YCoCg in last A-Trous pass + if (gIsLastPass == 1) + { + filteredSpecularIlluminationAndVariance.rgb = _NRD_LinearToYCoCg(filteredSpecularIlluminationAndVariance.rgb); + } + gOutSpecularSH1[pixelPos] = float4(sumSpecularSH1.rgb / sumWSpecular, roughnessModified); + #endif gOutSpecularIlluminationAndVariance[pixelPos] = filteredSpecularIlluminationAndVariance; #endif #ifdef RELAX_DIFFUSE float4 filteredDiffuseIlluminationAndVariance = float4(sumDiffuseIlluminationAndVariance / float4(sumWDiffuse.xxx, sumWDiffuse * sumWDiffuse)); + #ifdef RELAX_SH + // Luminance output is expected in YCoCg color space in SH mode, converting to YCoCg in last A-Trous pass + if (gIsLastPass == 1) + { + filteredDiffuseIlluminationAndVariance.rgb = _NRD_LinearToYCoCg(filteredDiffuseIlluminationAndVariance.rgb); + } + gOutDiffuseSH1[pixelPos] = sumDiffuseSH1 / sumWDiffuse; + #endif gOutDiffuseIlluminationAndVariance[pixelPos] = filteredDiffuseIlluminationAndVariance; #endif } diff --git a/Shaders/Include/RELAX/RELAX_DiffuseSpecular_AtrousSmem.hlsli b/Shaders/Include/RELAX/RELAX_DiffuseSpecular_AtrousSmem.hlsli index a7013c8e..be29c6b9 100644 --- a/Shaders/Include/RELAX/RELAX_DiffuseSpecular_AtrousSmem.hlsli +++ b/Shaders/Include/RELAX/RELAX_DiffuseSpecular_AtrousSmem.hlsli @@ -10,10 +10,16 @@ license agreement from NVIDIA CORPORATION is strictly prohibited. #ifdef RELAX_DIFFUSE groupshared float4 sharedDiffuse[BUFFER_X][BUFFER_Y]; + #ifdef RELAX_SH + groupshared float4 sharedDiffuseSH1[BUFFER_X][BUFFER_Y]; + #endif #endif #ifdef RELAX_SPECULAR groupshared float4 sharedSpecular[BUFFER_X][BUFFER_Y]; + #ifdef RELAX_SH + groupshared float4 sharedSpecularSH1[BUFFER_X][BUFFER_Y]; + #endif #endif groupshared float4 sharedNormalRoughness[BUFFER_X][BUFFER_Y]; @@ -83,10 +89,16 @@ void Preload(uint2 sharedPos, int2 globalPos) #ifdef RELAX_SPECULAR sharedSpecular[sharedPos.y][sharedPos.x] = gSpecularIlluminationAnd2ndMoment[globalPos]; + #ifdef RELAX_SH + sharedSpecularSH1[sharedPos.y][sharedPos.x] = gSpecularSH1[globalPos]; + #endif #endif #ifdef RELAX_DIFFUSE sharedDiffuse[sharedPos.y][sharedPos.x] = gDiffuseIlluminationAnd2ndMoment[globalPos]; + #ifdef RELAX_SH + sharedDiffuseSH1[sharedPos.y][sharedPos.x] = gDiffuseSH1[globalPos]; + #endif #endif float materialID; sharedNormalRoughness[sharedPos.y][sharedPos.x] = NRD_FrontEnd_UnpackNormalAndRoughness(gNormalRoughness[globalPos], materialID); @@ -193,6 +205,10 @@ NRD_EXPORT void NRD_CS_MAIN(int2 pixelPos : SV_DispatchThreadId, uint2 threadPos float sumWSpecular = 0; float4 sumSpecularIlluminationAnd2ndMoment = 0; + #ifdef RELAX_SH + float4 sumSpecularSH1 = 0; + float roughnessModified = sharedSpecularSH1[sharedMemoryIndex.y][sharedMemoryIndex.x].w; + #endif float3 centerV = -normalize(centerWorldPos); #endif @@ -218,6 +234,9 @@ NRD_EXPORT void NRD_CS_MAIN(int2 pixelPos : SV_DispatchThreadId, uint2 threadPos float sumWDiffuse = 0; float4 sumDiffuseIlluminationAnd2ndMoment = 0; + #ifdef RELAX_SH + float4 sumDiffuseSH1 = 0; + #endif #endif static const float kernelWeightGaussian3x3[2] = { 0.44198, 0.27901 }; @@ -279,6 +298,9 @@ NRD_EXPORT void NRD_CS_MAIN(int2 pixelPos : SV_DispatchThreadId, uint2 threadPos sumWSpecular += wSpecular; sumSpecularIlluminationAnd2ndMoment += wSpecular * sampleSpecularIlluminationAnd2ndMoment; + #ifdef RELAX_SH + sumSpecularSH1 += wSpecular * sharedSpecularSH1[sharedMemoryIndexP.y][sharedMemoryIndexP.x];; + #endif #endif #ifdef RELAX_DIFFUSE // Calculating weights for diffuse @@ -300,6 +322,9 @@ NRD_EXPORT void NRD_CS_MAIN(int2 pixelPos : SV_DispatchThreadId, uint2 threadPos sumWDiffuse += wDiffuse; sumDiffuseIlluminationAnd2ndMoment += wDiffuse * sampleDiffuseIlluminationAnd2ndMoment; + #ifdef RELAX_SH + sumDiffuseSH1 += wDiffuse * sharedDiffuseSH1[sharedMemoryIndexP.y][sharedMemoryIndexP.x];; + #endif #endif } } @@ -311,6 +336,9 @@ NRD_EXPORT void NRD_CS_MAIN(int2 pixelPos : SV_DispatchThreadId, uint2 threadPos float specularVariance = max(0, specular2ndMoment - specular1stMoment * specular1stMoment); float4 filteredSpecularIlluminationAndVariance = float4(sumSpecularIlluminationAnd2ndMoment.rgb, specularVariance); gOutSpecularIlluminationAndVariance[pixelPos] = filteredSpecularIlluminationAndVariance; + #ifdef RELAX_SH + gOutSpecularSH1[pixelPos] = float4(sumSpecularSH1.rgb / sumWSpecular, roughnessModified); + #endif #endif #ifdef RELAX_DIFFUSE sumWDiffuse = max(sumWDiffuse, 1e-6f); @@ -319,8 +347,10 @@ NRD_EXPORT void NRD_CS_MAIN(int2 pixelPos : SV_DispatchThreadId, uint2 threadPos float diffuse2ndMoment = sumDiffuseIlluminationAnd2ndMoment.a; float diffuseVariance = max(0, diffuse2ndMoment - diffuse1stMoment * diffuse1stMoment); float4 filteredDiffuseIlluminationAndVariance = float4(sumDiffuseIlluminationAnd2ndMoment.rgb, diffuseVariance); - gOutDiffuseIlluminationAndVariance[pixelPos] = filteredDiffuseIlluminationAndVariance; + #ifdef RELAX_SH + gOutDiffuseSH1[pixelPos] = sumDiffuseSH1 / sumWDiffuse; + #endif #endif } else @@ -331,6 +361,9 @@ NRD_EXPORT void NRD_CS_MAIN(int2 pixelPos : SV_DispatchThreadId, uint2 threadPos float3 sumSpecularIllumination = 0; float sumSpecular1stMoment = 0; float sumSpecular2ndMoment = 0; + #ifdef RELAX_SH + float4 sumSpecularSH1 = 0; + #endif #endif #ifdef RELAX_DIFFUSE @@ -338,6 +371,9 @@ NRD_EXPORT void NRD_CS_MAIN(int2 pixelPos : SV_DispatchThreadId, uint2 threadPos float3 sumDiffuseIllumination = 0; float sumDiffuse1stMoment = 0; float sumDiffuse2ndMoment = 0; + #ifdef RELAX_SH + float4 sumDiffuseSH1 = 0; + #endif #endif // Normal weight is same for diffuse and specular during spatial variance estimation @@ -372,6 +408,9 @@ NRD_EXPORT void NRD_CS_MAIN(int2 pixelPos : SV_DispatchThreadId, uint2 threadPos sumSpecularIllumination += sampleSpecularIllumination.rgb * specularW; sumSpecular1stMoment += sampleSpecular1stMoment * specularW; sumSpecular2ndMoment += sampleSpecular2ndMoment * specularW; + #ifdef RELAX_SH + sumSpecularSH1 += sharedSpecularSH1[sharedMemoryIndexP.y][sharedMemoryIndexP.x] * specularW; + #endif #endif #ifdef RELAX_DIFFUSE @@ -386,6 +425,9 @@ NRD_EXPORT void NRD_CS_MAIN(int2 pixelPos : SV_DispatchThreadId, uint2 threadPos sumDiffuseIllumination += sampleDiffuseIllumination.rgb * diffuseW; sumDiffuse1stMoment += sampleDiffuse1stMoment * diffuseW; sumDiffuse2ndMoment += sampleDiffuse2ndMoment * diffuseW; + #ifdef RELAX_SH + sumDiffuseSH1 += sharedDiffuseSH1[sharedMemoryIndexP.y][sharedMemoryIndexP.x] * diffuseW; + #endif #endif } } @@ -400,6 +442,9 @@ NRD_EXPORT void NRD_CS_MAIN(int2 pixelPos : SV_DispatchThreadId, uint2 threadPos float specularVariance = max(0, sumSpecular2ndMoment - sumSpecular1stMoment * sumSpecular1stMoment); specularVariance *= boost; gOutSpecularIlluminationAndVariance[pixelPos] = float4(sumSpecularIllumination, specularVariance); + #ifdef RELAX_SH + gOutSpecularSH1[pixelPos] = sumSpecularSH1 / sumWSpecularIllumination; + #endif #endif #ifdef RELAX_DIFFUSE @@ -410,6 +455,9 @@ NRD_EXPORT void NRD_CS_MAIN(int2 pixelPos : SV_DispatchThreadId, uint2 threadPos float diffuseVariance = max(0, sumDiffuse2ndMoment - sumDiffuse1stMoment * sumDiffuse1stMoment); diffuseVariance *= boost; gOutDiffuseIlluminationAndVariance[pixelPos] = float4(sumDiffuseIllumination, diffuseVariance); + #ifdef RELAX_SH + gOutDiffuseSH1[pixelPos] = sumDiffuseSH1 / sumWDiffuseIllumination; + #endif #endif } diff --git a/Shaders/Include/RELAX/RELAX_DiffuseSpecular_HistoryClamping.hlsli b/Shaders/Include/RELAX/RELAX_DiffuseSpecular_HistoryClamping.hlsli index aa5ea2cb..21f04bae 100644 --- a/Shaders/Include/RELAX/RELAX_DiffuseSpecular_HistoryClamping.hlsli +++ b/Shaders/Include/RELAX/RELAX_DiffuseSpecular_HistoryClamping.hlsli @@ -93,9 +93,9 @@ NRD_EXPORT void NRD_CS_MAIN(uint2 pixelPos : SV_DispatchThreadId, uint2 threadPo specularColorMaxYCoCg = max(specularColorMaxYCoCg, specularCenterYCoCg.rgb); // Color clamping - if (gSpecFastHistory) - specularYCoCg = clamp(specularYCoCg, specularColorMinYCoCg, specularColorMaxYCoCg); - float3 clampedSpecular = STL::Color::YCoCgToLinear(specularYCoCg); + float3 clampedSpecularYCoCg = specularYCoCg; + if (gSpecFastHistory) clampedSpecularYCoCg = clamp(specularYCoCg, specularColorMinYCoCg, specularColorMaxYCoCg); + float3 clampedSpecular = STL::Color::YCoCgToLinear(clampedSpecularYCoCg); // If history length is less than gHistoryFixFrameNum, // then it is the pixel with history fix applied in the previous (history fix) shader, @@ -109,6 +109,24 @@ NRD_EXPORT void NRD_CS_MAIN(uint2 pixelPos : SV_DispatchThreadId, uint2 threadPo // Writing out the results gOutSpecularIllumination[pixelPos.xy] = outSpecular; gOutSpecularIlluminationResponsive[pixelPos.xy] = outSpecularResponsive; + + #ifdef RELAX_SH + float4 specularSH1 = gSpecularSH1[pixelPos.xy]; + float roughnessModified = specularSH1.w; + float4 specularResponsiveSH1 = gSpecularResponsiveSH1[pixelPos.xy]; + + // Clamping factor: (clamped - slow) / (fast - slow) + // The closest clamped is to fast, the closer clamping factor is to 1. + float specClampingFactor = (specularCenterYCoCg.x - specularYCoCg.x) == 0 ? + 1.0 : saturate( (clampedSpecularYCoCg.x - specularYCoCg.x) / (specularCenterYCoCg.x - specularYCoCg.x)); + + if (historyLength <= gHistoryFixFrameNum) + specClampingFactor = 1.0; + + gOutSpecularSH1[pixelPos.xy] = float4(lerp(specularSH1.rgb, specularResponsiveSH1.rgb, specClampingFactor), roughnessModified); + gOutSpecularResponsiveSH1[pixelPos.xy] = specularResponsiveSH1; + #endif + #endif #ifdef RELAX_DIFFUSE @@ -125,9 +143,9 @@ NRD_EXPORT void NRD_CS_MAIN(uint2 pixelPos : SV_DispatchThreadId, uint2 threadPo diffuseColorMaxYCoCg = max(diffuseColorMaxYCoCg, diffuseCenterYCoCg.rgb); // Color clamping - if (gDiffFastHistory) - diffuseYCoCg = clamp(diffuseYCoCg, diffuseColorMinYCoCg, diffuseColorMaxYCoCg); - float3 clampedDiffuse = STL::Color::YCoCgToLinear(diffuseYCoCg); + float3 clampedDiffuseYCoCg = diffuseYCoCg; + if (gDiffFastHistory) clampedDiffuseYCoCg = clamp(diffuseYCoCg, diffuseColorMinYCoCg, diffuseColorMaxYCoCg); + float3 clampedDiffuse = STL::Color::YCoCgToLinear(clampedDiffuseYCoCg); // If history length is less than gHistoryFixFrameNum, // then it is the pixel with history fix applied in the previous (history fix) shader, @@ -141,6 +159,23 @@ NRD_EXPORT void NRD_CS_MAIN(uint2 pixelPos : SV_DispatchThreadId, uint2 threadPo // Writing out the results gOutDiffuseIllumination[pixelPos.xy] = outDiffuse; gOutDiffuseIlluminationResponsive[pixelPos.xy] = outDiffuseResponsive; + + #ifdef RELAX_SH + float4 diffuseSH1 = gDiffuseSH1[pixelPos.xy]; + float4 diffuseResponsiveSH1 = gDiffuseResponsiveSH1[pixelPos.xy]; + + // Clamping factor: (clamped - slow) / (fast - slow) + // The closest clamped is to fast, the closer clamping factor is to 1. + float diffClampingFactor = (diffuseCenterYCoCg.x - diffuseYCoCg.x) == 0 ? + 1.0 : saturate( (clampedDiffuseYCoCg.x - diffuseYCoCg.x) / (diffuseCenterYCoCg.x - diffuseYCoCg.x)); + + if (historyLength <= gHistoryFixFrameNum) + diffClampingFactor = 1.0; + + gOutDiffuseSH1[pixelPos.xy] = lerp(diffuseSH1, diffuseResponsiveSH1, diffClampingFactor); + gOutDiffuseResponsiveSH1[pixelPos.xy] = diffuseResponsiveSH1; + #endif + #endif // Writing out history length for use in the next frame diff --git a/Shaders/Include/RELAX/RELAX_DiffuseSpecular_HistoryFix.hlsli b/Shaders/Include/RELAX/RELAX_DiffuseSpecular_HistoryFix.hlsli index 0d57fade..5996ccae 100644 --- a/Shaders/Include/RELAX/RELAX_DiffuseSpecular_HistoryFix.hlsli +++ b/Shaders/Include/RELAX/RELAX_DiffuseSpecular_HistoryFix.hlsli @@ -33,13 +33,6 @@ NRD_EXPORT void NRD_CS_MAIN(uint2 pixelPos : SV_DispatchThreadId) if ((centerViewZ > gDenoisingRange) || (historyLength > gHistoryFixFrameNum)) return; -#ifdef RELAX_DIFFUSE - float4 diffuseIlluminationAnd2ndMoment = gDiffuseIllumination[pixelPos]; -#endif -#ifdef RELAX_SPECULAR - float4 specularIlluminationAnd2ndMoment = gSpecularIllumination[pixelPos]; -#endif - // Loading center data float centerMaterialID; float4 centerNormalRoughness = NRD_FrontEnd_UnpackNormalAndRoughness(gNormalRoughness[pixelPos], centerMaterialID); @@ -49,13 +42,19 @@ NRD_EXPORT void NRD_CS_MAIN(uint2 pixelPos : SV_DispatchThreadId) float3 centerV = -normalize(centerWorldPos); float depthThreshold = gDepthThreshold * (gOrthoMode == 0 ? centerViewZ : 1.0); - // Running sparse cross-bilateral filter #ifdef RELAX_DIFFUSE - float4 diffuseIlluminationAnd2ndMomentSum = diffuseIlluminationAnd2ndMoment; + float4 diffuseIlluminationAnd2ndMomentSum = gDiffuseIllumination[pixelPos]; + #ifdef RELAX_SH + float4 diffuseSumSH1 = gDiffuseSH1[pixelPos]; + #endif float diffuseWSum = 1; #endif #ifdef RELAX_SPECULAR - float4 specularIlluminationAnd2ndMomentSum = specularIlluminationAnd2ndMoment; + float4 specularIlluminationAnd2ndMomentSum = gSpecularIllumination[pixelPos]; + #ifdef RELAX_SH + float4 specularSumSH1 = gSpecularSH1[pixelPos]; + float roughnessModified = specularSumSH1.w; + #endif float specularWSum = 1; float2 specularNormalWeightParams = GetNormalWeightParams_ATrous( @@ -67,8 +66,8 @@ NRD_EXPORT void NRD_CS_MAIN(uint2 pixelPos : SV_DispatchThreadId) gSpecularLobeAngleSlack); #endif + // Running sparse cross-bilateral filter float r = getRadius(historyLength); - [unroll] for (int j = -2; j <= 2; j++) { @@ -95,7 +94,7 @@ NRD_EXPORT void NRD_CS_MAIN(uint2 pixelPos : SV_DispatchThreadId) sampleWorldPos, depthThreshold); - #ifdef RELAX_DIFFUSE +#ifdef RELAX_DIFFUSE // Summing up diffuse result float diffuseW = geometryWeight; diffuseW *= getDiffuseNormalWeight(centerNormal, sampleNormal); @@ -106,10 +105,14 @@ NRD_EXPORT void NRD_CS_MAIN(uint2 pixelPos : SV_DispatchThreadId) { float4 sampleDiffuseIlluminationAnd2ndMoment = gDiffuseIllumination[samplePosInt]; diffuseIlluminationAnd2ndMomentSum += sampleDiffuseIlluminationAnd2ndMoment * diffuseW; + #ifdef RELAX_SH + float4 sampleDiffuseSH1 = gDiffuseSH1[samplePosInt]; + diffuseSumSH1 += sampleDiffuseSH1 * diffuseW; + #endif diffuseWSum += diffuseW; } - #endif - #ifdef RELAX_SPECULAR +#endif +#ifdef RELAX_SPECULAR // Getting sample view vector closer to center view vector // by adding gRoughnessEdgeStoppingRelaxation * centerWorldPos // relaxes view direction based rejection @@ -126,9 +129,13 @@ NRD_EXPORT void NRD_CS_MAIN(uint2 pixelPos : SV_DispatchThreadId) { float4 sampleSpecularIlluminationAnd2ndMoment = gSpecularIllumination[samplePosInt]; specularIlluminationAnd2ndMomentSum += sampleSpecularIlluminationAnd2ndMoment * specularW; + #ifdef RELAX_SH + float4 sampleSpecularSH1 = gSpecularSH1[samplePosInt]; + specularSumSH1 += sampleSpecularSH1 * specularW; + #endif specularWSum += specularW; } - #endif +#endif } } @@ -137,10 +144,16 @@ NRD_EXPORT void NRD_CS_MAIN(uint2 pixelPos : SV_DispatchThreadId) #ifdef RELAX_DIFFUSE float4 outDiffuseIlluminationAnd2ndMoment = diffuseIlluminationAnd2ndMomentSum / diffuseWSum; gOutDiffuseIllumination[pixelPos] = outDiffuseIlluminationAnd2ndMoment; + #ifdef RELAX_SH + gOutDiffuseSH1[pixelPos] = diffuseSumSH1 / diffuseWSum; + #endif #endif #ifdef RELAX_SPECULAR float4 outSpecularIlluminationAnd2ndMoment = specularIlluminationAnd2ndMomentSum / specularWSum; gOutSpecularIllumination[pixelPos] = outSpecularIlluminationAnd2ndMoment; + #ifdef RELAX_SH + gOutSpecularSH1[pixelPos] = float4(specularSumSH1.rgb / specularWSum, roughnessModified); + #endif #endif } diff --git a/Shaders/Include/RELAX/RELAX_DiffuseSpecular_HitDistReconstruction.hlsli b/Shaders/Include/RELAX/RELAX_DiffuseSpecular_HitDistReconstruction.hlsli index a996ab42..cd9b20be 100644 --- a/Shaders/Include/RELAX/RELAX_DiffuseSpecular_HitDistReconstruction.hlsli +++ b/Shaders/Include/RELAX/RELAX_DiffuseSpecular_HitDistReconstruction.hlsli @@ -11,11 +11,6 @@ license agreement from NVIDIA CORPORATION is strictly prohibited. groupshared float4 sharedNormalRoughness[BUFFER_Y][BUFFER_X]; groupshared float3 sharedHitdistViewZ[BUFFER_Y][BUFFER_X]; -float2 GetCoarseRoughnessWeightParams(float roughness) -{ - return float2(1.0, -roughness); -} - float GetNormalWeightParams(float nonLinearAccumSpeed, float fraction, float roughness = 1.0) { float angle = STL::ImportanceSampling::GetSpecularLobeHalfAngle(roughness); diff --git a/Shaders/Include/RELAX/RELAX_DiffuseSpecular_PrePass.hlsli b/Shaders/Include/RELAX/RELAX_DiffuseSpecular_PrePass.hlsli index 573696ed..5f77a55b 100644 --- a/Shaders/Include/RELAX/RELAX_DiffuseSpecular_PrePass.hlsli +++ b/Shaders/Include/RELAX/RELAX_DiffuseSpecular_PrePass.hlsli @@ -84,6 +84,9 @@ NRD_EXPORT void NRD_CS_MAIN(int2 pixelPos : SV_DispatchThreadId, uint2 threadPos #ifdef RELAX_DIFFUSE // Reading diffuse & resolving diffuse checkerboard float4 diffuseIllumination = gDiffuseIllumination[DiffCheckerboard(pixelPos + gRectOrigin)]; + #ifdef RELAX_SH + float4 diffuseSH1 = gDiffuseSH1[DiffCheckerboard(pixelPos + gRectOrigin)]; + #endif bool diffHasData = true; if (gDiffuseCheckerboard != 2) @@ -94,17 +97,23 @@ NRD_EXPORT void NRD_CS_MAIN(int2 pixelPos : SV_DispatchThreadId, uint2 threadPos float4 d0 = gDiffuseIllumination[DiffCheckerboard(pixelPos + int2(-1, 0) + gRectOrigin)]; float4 d1 = gDiffuseIllumination[DiffCheckerboard(pixelPos + int2(1, 0) + gRectOrigin)]; float2 diffCheckerboardResolveWeights = checkerboardResolveWeights; -#if( NRD_NORMAL_ENCODING == NRD_NORMAL_ENCODING_R10G10B10A2_UNORM ) - float materialID0; - float materialID1; - NRD_FrontEnd_UnpackNormalAndRoughness(gNormalRoughness[pixelPos + int2(-1, 0) + gRectOrigin], materialID0); - NRD_FrontEnd_UnpackNormalAndRoughness(gNormalRoughness[pixelPos + int2(1, 0) + gRectOrigin], materialID1); - diffCheckerboardResolveWeights.x *= CompareMaterials(centerMaterialID, materialID0, gDiffMaterialMask); - diffCheckerboardResolveWeights.y *= CompareMaterials(centerMaterialID, materialID1, gDiffMaterialMask); - diffCheckerboardResolveWeights *= STL::Math::PositiveRcp(diffCheckerboardResolveWeights.x + diffCheckerboardResolveWeights.y + 1.0e-4); -#endif + #if( NRD_NORMAL_ENCODING == NRD_NORMAL_ENCODING_R10G10B10A2_UNORM ) + float materialID0; + float materialID1; + NRD_FrontEnd_UnpackNormalAndRoughness(gNormalRoughness[pixelPos + int2(-1, 0) + gRectOrigin], materialID0); + NRD_FrontEnd_UnpackNormalAndRoughness(gNormalRoughness[pixelPos + int2(1, 0) + gRectOrigin], materialID1); + diffCheckerboardResolveWeights.x *= CompareMaterials(centerMaterialID, materialID0, gDiffMaterialMask); + diffCheckerboardResolveWeights.y *= CompareMaterials(centerMaterialID, materialID1, gDiffMaterialMask); + diffCheckerboardResolveWeights *= STL::Math::PositiveRcp(diffCheckerboardResolveWeights.x + diffCheckerboardResolveWeights.y + 1.0e-4); + #endif diffuseIllumination *= saturate(1.0 - diffCheckerboardResolveWeights.x - diffCheckerboardResolveWeights.y); diffuseIllumination += d0 * diffCheckerboardResolveWeights.x + d1 * diffCheckerboardResolveWeights.y; + #ifdef RELAX_SH + float4 d0SH1 = gDiffuseSH1[DiffCheckerboard(pixelPos + int2(-1, 0) + gRectOrigin)]; + float4 d1SH1 = gDiffuseSH1[DiffCheckerboard(pixelPos + int2(1, 0) + gRectOrigin)]; + diffuseSH1 *= saturate(1.0 - diffCheckerboardResolveWeights.x - diffCheckerboardResolveWeights.y); + diffuseSH1 += d0SH1 * diffCheckerboardResolveWeights.x + d1SH1 * diffCheckerboardResolveWeights.y; + #endif } // Pre-blur for diffuse @@ -145,11 +154,9 @@ NRD_EXPORT void NRD_CS_MAIN(int2 pixelPos : SV_DispatchThreadId, uint2 threadPos float sampleMaterialID; float3 sampleNormal = NRD_FrontEnd_UnpackNormalAndRoughness(gNormalRoughness.SampleLevel(gNearestClamp, uvScaled, 0), sampleMaterialID).rgb; - - float4 sampleDiffuseIllumination = gDiffuseIllumination.SampleLevel(gNearestClamp, checkerboardUvScaled, 0); float sampleViewZ = abs(gViewZ.SampleLevel(gNearestClamp, uvScaled, 0)); - float3 sampleWorldPos = GetCurrentWorldPosFromClipSpaceXY(uv * 2.0 - 1.0, sampleViewZ); + float4 sampleDiffuseIllumination = gDiffuseIllumination.SampleLevel(gNearestClamp, checkerboardUvScaled, 0); // Sample weight float sampleWeight = IsInScreen(uv); @@ -167,19 +174,33 @@ NRD_EXPORT void NRD_CS_MAIN(int2 pixelPos : SV_DispatchThreadId, uint2 threadPos sampleWeight *= lerp(diffMinHitDistanceWeight, 1.0, GetHitDistanceWeight(hitDistanceWeightParams, sampleDiffuseIllumination.a)); diffuseIllumination += (sampleWeight > 0) ? sampleDiffuseIllumination * sampleWeight : 0; + + #ifdef RELAX_SH + float4 sampleDiffuseSH1 = gDiffuseSH1.SampleLevel(gNearestClamp, checkerboardUvScaled, 0); + diffuseSH1 += (sampleWeight > 0) ? sampleDiffuseSH1 * sampleWeight : 0; + #endif weightSum += sampleWeight; } diffuseIllumination /= weightSum; + #ifdef RELAX_SH + diffuseSH1 /= weightSum; + #endif } gOutDiffuseIllumination[pixelPos] = clamp(diffuseIllumination, 0, NRD_FP16_MAX); + #ifdef RELAX_SH + gOutDiffuseSH1[pixelPos] = clamp(diffuseSH1, -NRD_FP16_MAX, NRD_FP16_MAX); + #endif #endif #ifdef RELAX_SPECULAR // Reading specular & resolving specular checkerboard float4 specularIllumination = gSpecularIllumination[SpecCheckerboard(pixelPos + gRectOrigin)]; + #ifdef RELAX_SH + float4 specularSH1 = gSpecularSH1[SpecCheckerboard(pixelPos + gRectOrigin)]; + #endif bool specHasData = true; if (gSpecularCheckerboard != 2) @@ -201,6 +222,12 @@ NRD_EXPORT void NRD_CS_MAIN(int2 pixelPos : SV_DispatchThreadId, uint2 threadPos #endif specularIllumination *= saturate(1.0 - specCheckerboardResolveWeights.x - specCheckerboardResolveWeights.y); specularIllumination += s0 * specCheckerboardResolveWeights.x + s1 * specCheckerboardResolveWeights.y; + #ifdef RELAX_SH + float4 s0SH1 = gSpecularSH1[SpecCheckerboard(pixelPos + int2(-1, 0) + gRectOrigin)]; + float4 s1SH1 = gSpecularSH1[SpecCheckerboard(pixelPos + int2(1, 0) + gRectOrigin)]; + specularSH1 *= saturate(1.0 - specCheckerboardResolveWeights.x - specCheckerboardResolveWeights.y); + specularSH1 += s0SH1 * specCheckerboardResolveWeights.x + s1SH1 * specCheckerboardResolveWeights.y; + #endif } specularIllumination.a = max(0, min(gDenoisingRange, specularIllumination.a)); @@ -289,7 +316,10 @@ NRD_EXPORT void NRD_CS_MAIN(int2 pixelPos : SV_DispatchThreadId, uint2 threadPos sampleWeight *= lerp(saturate(t), 1.0, STL::Math::LinearStep(0.5, 1.0, centerRoughness)); specularIllumination.rgb += (sampleWeight > 0) ? sampleSpecularIllumination.rgb * sampleWeight : 0; - + #ifdef RELAX_SH + float4 sampleSpecularSH1 = gSpecularSH1.SampleLevel(gNearestClamp, checkerboardUvScaled, 0); + specularSH1 += (sampleWeight > 0) ? sampleSpecularSH1 * sampleWeight : 0; + #endif weightSum += sampleWeight; if (sampleWeight > 0) @@ -300,8 +330,14 @@ NRD_EXPORT void NRD_CS_MAIN(int2 pixelPos : SV_DispatchThreadId, uint2 threadPos } specularIllumination.rgb /= weightSum; specularIllumination.a = minHitT; + #ifdef RELAX_SH + specularSH1 /= weightSum; + #endif } gOutSpecularIllumination[pixelPos] = clamp(specularIllumination, 0, NRD_FP16_MAX); + #ifdef RELAX_SH + gOutSpecularSH1[pixelPos] = clamp(specularSH1, -NRD_FP16_MAX, NRD_FP16_MAX); + #endif #endif } \ No newline at end of file diff --git a/Shaders/Include/RELAX/RELAX_DiffuseSpecular_TemporalAccumulation.hlsli b/Shaders/Include/RELAX/RELAX_DiffuseSpecular_TemporalAccumulation.hlsli index ad723bed..b7902aa8 100644 --- a/Shaders/Include/RELAX/RELAX_DiffuseSpecular_TemporalAccumulation.hlsli +++ b/Shaders/Include/RELAX/RELAX_DiffuseSpecular_TemporalAccumulation.hlsli @@ -47,11 +47,19 @@ float loadSurfaceMotionBasedPrevData( #ifdef RELAX_DIFFUSE , out float4 prevDiffuseIllumAnd2ndMoment , out float3 prevDiffuseResponsiveIllum + #ifdef RELAX_SH + , out float4 prevDiffuseSH1 + , out float4 prevDiffuseResponsiveSH1 + #endif #endif #ifdef RELAX_SPECULAR , out float4 prevSpecularIllumAnd2ndMoment , out float3 prevSpecularResponsiveIllum , out float prevReflectionHitT + #ifdef RELAX_SH + , out float4 prevSpecularSH1 + , out float4 prevSpecularResponsiveSH1 + #endif #endif ) { @@ -143,14 +151,14 @@ float loadSurfaceMotionBasedPrevData( // Calculating bilinear weights in advance STL::Filtering::Bilinear bilinear; bilinear.weights = bilinearWeights; - float4 bilinearWeightsWithValidity = STL::Filtering::GetBilinearCustomWeights(bilinear, float4(bilinearTapsValid.x, bilinearTapsValid.y, bilinearTapsValid.z, bilinearTapsValid.w)); + float4 bilinearCustomWeights = STL::Filtering::GetBilinearCustomWeights(bilinear, float4(bilinearTapsValid.x, bilinearTapsValid.y, bilinearTapsValid.z, bilinearTapsValid.w)); bool useBicubic = (bicubicFootprintValid > 0); // Fetching normal history BicubicFilterNoCornersWithFallbackToBilinearFilterWithCustomWeights( prevPixelPosFloat, gInvResourceSize, - bilinearWeightsWithValidity, useBicubic + bilinearCustomWeights, useBicubic #ifdef RELAX_DIFFUSE , gPrevDiffuseIllumination, prevDiffuseIllumAnd2ndMoment #endif @@ -164,7 +172,7 @@ float loadSurfaceMotionBasedPrevData( float4 diff; BicubicFilterNoCornersWithFallbackToBilinearFilterWithCustomWeights( prevPixelPosFloat, gInvResourceSize, - bilinearWeightsWithValidity, useBicubic + bilinearCustomWeights, useBicubic #ifdef RELAX_DIFFUSE , gPrevDiffuseIlluminationResponsive, diff #endif @@ -174,7 +182,7 @@ float loadSurfaceMotionBasedPrevData( ); #ifdef RELAX_DIFFUSE - prevDiffuseIllumAnd2ndMoment = max(prevDiffuseIllumAnd2ndMoment, 0.0); + prevDiffuseIllumAnd2ndMoment = max(prevDiffuseIllumAnd2ndMoment, 0); prevDiffuseResponsiveIllum = max(diff.rgb, 0); #endif #ifdef RELAX_SPECULAR @@ -182,33 +190,41 @@ float loadSurfaceMotionBasedPrevData( prevSpecularResponsiveIllum = max(spec.rgb, 0); #endif - // Fitering previous data that does not need bicubic - float interpolatedBinaryWeight = STL::Filtering::ApplyBilinearFilter(bilinearTapsValid.x, bilinearTapsValid.y, bilinearTapsValid.z, bilinearTapsValid.w, bilinear); - interpolatedBinaryWeight = max(1e-6, interpolatedBinaryWeight); - - float2 gatherOrigin = (float2(bilinearOrigin)+1.0) * gInvResourceSize; - + // Fitering previous SH data + #ifdef RELAX_SH + #ifdef RELAX_DIFFUSE + prevDiffuseSH1 = BilinearWithCustomWeightsFloat4(gPrevDiffuseSH1, bilinearOrigin, bilinearCustomWeights); + prevDiffuseResponsiveSH1 = BilinearWithCustomWeightsFloat4(gPrevDiffuseResponsiveSH1, bilinearOrigin, bilinearCustomWeights); + #endif + #ifdef RELAX_SPECULAR + prevSpecularSH1 = BilinearWithCustomWeightsFloat4(gPrevSpecularSH1, bilinearOrigin, bilinearCustomWeights); + prevSpecularResponsiveSH1 = BilinearWithCustomWeightsFloat4(gPrevSpecularResponsiveSH1, bilinearOrigin, bilinearCustomWeights); + #endif + #endif + + // Fitering more previous data that does not need bicubic + float2 gatherOrigin = (float2(bilinearOrigin) + 1.0) * gInvResourceSize; float4 prevHistoryLengths = gPrevHistoryLength.GatherRed(gNearestClamp, gatherOrigin).wzxy; - historyLength = 255.0 * BilinearWithBinaryWeightsImmediateFloat( + historyLength = 255.0 * BilinearWithCustomWeightsImmediateFloat( prevHistoryLengths.x, prevHistoryLengths.y, prevHistoryLengths.z, prevHistoryLengths.w, - bilinearWeights, bilinearTapsValid, interpolatedBinaryWeight); + bilinearCustomWeights); #ifdef RELAX_SPECULAR float4 prevReflectionHitTs = gPrevReflectionHitT.GatherRed(gNearestClamp, gatherOrigin).wzxy; - prevReflectionHitT = BilinearWithBinaryWeightsImmediateFloat( + prevReflectionHitT = BilinearWithCustomWeightsImmediateFloat( prevReflectionHitTs.x, prevReflectionHitTs.y, prevReflectionHitTs.z, prevReflectionHitTs.w, - bilinearWeights, bilinearTapsValid, interpolatedBinaryWeight); + bilinearCustomWeights); prevReflectionHitT = max(0.001, prevReflectionHitT); #endif float reprojectionFound = (bicubicFootprintValid > 0) ? 2.0 : 1.0; - footprintQuality = (bicubicFootprintValid > 0) ? 1.0 : interpolatedBinaryWeight; + footprintQuality = (bicubicFootprintValid > 0) ? 1.0 : dot(bilinearCustomWeights, 1.0); [flatten] if (!any(bilinearTapsValid)) @@ -243,7 +259,12 @@ float loadVirtualMotionBasedPrevData( out float3 prevNormal, out float prevRoughness, out float prevReflectionHitT, - out float2 prevUVVMB) + out float2 prevUVVMB + #ifdef RELAX_SH + , out float4 prevSpecularSH1 + , out float4 prevSpecularResponsiveSH1 + #endif + ) { // Calculating previous worldspace virtual position based on reflection hitT float3 virtualViewVector = normalize(currentViewVector) * hitDistFocused; @@ -315,6 +336,10 @@ float loadVirtualMotionBasedPrevData( prevNormal = currentNormal; prevRoughness = 0; prevReflectionHitT = gDenoisingRange; + #ifdef RELAX_SH + prevSpecularSH1 = 0; + prevSpecularResponsiveSH1 = 0; + #endif // Weighted bilinear (or bicubic optionally) for prev specular data based on virtual motion. if (any(bilinearTapsValid)) @@ -322,14 +347,14 @@ float loadVirtualMotionBasedPrevData( // Calculating bilinear weights in advance STL::Filtering::Bilinear bilinear; bilinear.weights = bilinearWeights; - float4 bilinearWeightsWithValidity = STL::Filtering::GetBilinearCustomWeights(bilinear, float4(bilinearTapsValid.x, bilinearTapsValid.y, bilinearTapsValid.z, bilinearTapsValid.w)); + float4 bilinearCustomWeights = STL::Filtering::GetBilinearCustomWeights(bilinear, float4(bilinearTapsValid.x, bilinearTapsValid.y, bilinearTapsValid.z, bilinearTapsValid.w)); bool useBicubic = (surfaceBicubicValid > 0) & all(bilinearTapsValid); // Fetching normal virtual motion based specular history BicubicFilterNoCornersWithFallbackToBilinearFilterWithCustomWeights( prevVirtualPixelPosFloat, gInvResourceSize, - bilinearWeightsWithValidity, useBicubic, + bilinearCustomWeights, useBicubic, gPrevSpecularIllumination, prevSpecularIllumAnd2ndMoment); prevSpecularIllumAnd2ndMoment = max(prevSpecularIllumAnd2ndMoment, 0.0); @@ -337,11 +362,17 @@ float loadVirtualMotionBasedPrevData( // Fetching fast virtual motion based specular history BicubicFilterNoCornersWithFallbackToBilinearFilterWithCustomWeights( prevVirtualPixelPosFloat, gInvResourceSize, - bilinearWeightsWithValidity, useBicubic, + bilinearCustomWeights, useBicubic, gPrevSpecularIlluminationResponsive, prevSpecularResponsiveIllum); prevSpecularResponsiveIllum = max(prevSpecularResponsiveIllum, 0.0); + // Fitering previous SH data + #ifdef RELAX_SH + prevSpecularSH1 = BilinearWithCustomWeightsFloat4(gPrevSpecularSH1, bilinearOrigin, bilinearCustomWeights); + prevSpecularResponsiveSH1 = BilinearWithCustomWeightsFloat4(gPrevSpecularResponsiveSH1, bilinearOrigin, bilinearCustomWeights); + #endif + // Fitering previous data that does not need bicubic prevReflectionHitT = gPrevReflectionHitT.SampleLevel(gLinearClamp, prevUVVMB, 0).x; prevReflectionHitT = max(0.001, prevReflectionHitT); @@ -441,10 +472,16 @@ NRD_EXPORT void NRD_CS_MAIN(uint2 pixelPos : SV_DispatchThreadId, uint2 threadPo // Input noisy data #ifdef RELAX_DIFFUSE float3 diffuseIllumination = gDiffuseIllumination[pixelPos.xy + gRectOrigin].rgb; + #ifdef RELAX_SH + float4 diffuseSH1 = gDiffuseSH1[pixelPos.xy + gRectOrigin]; + #endif #endif #ifdef RELAX_SPECULAR float4 specularIllumination = gSpecularIllumination[pixelPos.xy + gRectOrigin]; + #ifdef RELAX_SH + float4 specularSH1 = gSpecularSH1[pixelPos.xy + gRectOrigin]; + #endif #endif // Calculating average normal, minHitDist and specular sigma @@ -550,11 +587,20 @@ NRD_EXPORT void NRD_CS_MAIN(uint2 pixelPos : SV_DispatchThreadId, uint2 threadPo #ifdef RELAX_DIFFUSE float4 prevDiffuseIlluminationAnd2ndMomentSMB; float3 prevDiffuseIlluminationAnd2ndMomentSMBResponsive; + #ifdef RELAX_SH + float4 prevDiffuseSH1; + float4 prevDiffuseResponsiveSH1; + #endif + #endif #ifdef RELAX_SPECULAR float4 prevSpecularIlluminationAnd2ndMomentSMB; float3 prevSpecularIlluminationAnd2ndMomentSMBResponsive; float prevReflectionHitTSMB; + #ifdef RELAX_SH + float4 prevSpecularSMBSH1; + float4 prevSpecularSMBResponsiveSH1; + #endif #endif float historyLength; @@ -564,9 +610,9 @@ NRD_EXPORT void NRD_CS_MAIN(uint2 pixelPos : SV_DispatchThreadId, uint2 threadPo prevUVSMB, currentLinearZ, normalize(currentNormalAveraged), -#ifdef RELAX_SPECULAR - specularIllumination.a, -#endif + #ifdef RELAX_SPECULAR + specularIllumination.a, + #endif NoV, parallaxInPixels, currentMaterialID, @@ -574,15 +620,23 @@ NRD_EXPORT void NRD_CS_MAIN(uint2 pixelPos : SV_DispatchThreadId, uint2 threadPo mixedDisocclusionDepthThreshold, footprintQuality, historyLength -#ifdef RELAX_DIFFUSE - , prevDiffuseIlluminationAnd2ndMomentSMB - , prevDiffuseIlluminationAnd2ndMomentSMBResponsive -#endif -#ifdef RELAX_SPECULAR - , prevSpecularIlluminationAnd2ndMomentSMB - , prevSpecularIlluminationAnd2ndMomentSMBResponsive - , prevReflectionHitTSMB -#endif + #ifdef RELAX_DIFFUSE + , prevDiffuseIlluminationAnd2ndMomentSMB + , prevDiffuseIlluminationAnd2ndMomentSMBResponsive + #ifdef RELAX_SH + , prevDiffuseSH1 + , prevDiffuseResponsiveSH1 + #endif + #endif + #ifdef RELAX_SPECULAR + , prevSpecularIlluminationAnd2ndMomentSMB + , prevSpecularIlluminationAnd2ndMomentSMBResponsive + , prevReflectionHitTSMB + #ifdef RELAX_SH + , prevSpecularSMBSH1 + , prevSpecularSMBResponsiveSH1 + #endif + #endif ); // History length is based on surface motion based disocclusion @@ -642,6 +696,13 @@ NRD_EXPORT void NRD_CS_MAIN(uint2 pixelPos : SV_DispatchThreadId, uint2 threadPo // Write out the diffuse results gOutDiffuseIllumination[pixelPos] = accumulatedDiffuseIlluminationAnd2ndMoment; gOutDiffuseIlluminationResponsive[pixelPos] = float4(accumulatedDiffuseIlluminationResponsive, 0); + + #ifdef RELAX_SH + float4 accumulatedDiffuseSH1 = lerp(prevDiffuseSH1, diffuseSH1, diffuseAlpha); + float4 accumulatedDiffuseResponsiveSH1 = lerp(prevDiffuseResponsiveSH1, diffuseSH1, diffuseAlphaResponsive); + gOutDiffuseSH1[pixelPos] = accumulatedDiffuseSH1; + gOutDiffuseResponsiveSH1[pixelPos] = float4(accumulatedDiffuseResponsiveSH1); + #endif #endif gOutHistoryLength[pixelPos] = historyLength / 255.0; @@ -681,6 +742,10 @@ NRD_EXPORT void NRD_CS_MAIN(uint2 pixelPos : SV_DispatchThreadId, uint2 threadPo float prevRoughnessVMB; float prevReflectionHitTVMB; float2 prevUVVMB; + #ifdef RELAX_SH + float4 prevSpecularVMBSH1; + float4 prevSpecularVMBResponsiveSH1; + #endif float VMBReprojectionFound = loadVirtualMotionBasedPrevData( pixelPos, @@ -704,6 +769,10 @@ NRD_EXPORT void NRD_CS_MAIN(uint2 pixelPos : SV_DispatchThreadId, uint2 threadPo prevRoughnessVMB, prevReflectionHitTVMB, prevUVVMB + #ifdef RELAX_SH + , prevSpecularVMBSH1 + , prevSpecularVMBResponsiveSH1 + #endif ); // Amount of virtual motion - dominant factor @@ -794,7 +863,7 @@ NRD_EXPORT void NRD_CS_MAIN(uint2 pixelPos : SV_DispatchThreadId, uint2 threadPo // Current specular signal ( surface motion ) float smcFactor = lerp(0.25, 0.001, SMC); // TODO: tune better? smcFactor *= lerp(1.0, lerp(1.0, 0.25, SMC), NoV); - float specSMBConfidence = 1.0 / (1.0 + smcFactor * parallaxInPixels); + float specSMBConfidence = (SMBReprojectionFound > 0 ? 1.0 : 0.0) / (1.0 + smcFactor * parallaxInPixels); specSMBConfidence *= GetNormalWeight(V, Vprev, lobeHalfAngle * NoV / gFramerateScale); float specSMBAlpha = 1.0 - specSMBConfidence; @@ -851,6 +920,19 @@ NRD_EXPORT void NRD_CS_MAIN(uint2 pixelPos : SV_DispatchThreadId, uint2 threadPo float3 accumulatedSpecularIlluminationResponsive = lerp(accumulatedSpecularSMBResponsive.xyz, accumulatedSpecularVMBResponsive.xyz, virtualHistoryAmount); float accumulatedSpecular2ndMoment = lerp(accumulatedSpecularM2SMB, accumulatedSpecularM2VMB, virtualHistoryAmount); + #ifdef RELAX_SH + float4 accumulatedSpecularSMBSH1 = lerp(prevSpecularSMBSH1, specularSH1, specSMBAlpha); + float4 accumulatedSpecularSMBResponsiveSH1 = lerp(prevSpecularSMBResponsiveSH1, specularSH1, specSMBResponsiveAlpha); + + float4 accumulatedSpecularVMBSH1 = lerp(prevSpecularVMBSH1, specularSH1, specVMBAlpha); + float4 accumulatedSpecularVMBResponsiveSH1 = lerp(prevSpecularVMBResponsiveSH1, specularSH1, specVMBResponsiveAlpha); + + float4 accumulatedSpecularSH1 = lerp(accumulatedSpecularSMBSH1, accumulatedSpecularVMBSH1, virtualHistoryAmount); + float4 accumulatedSpecularResponsiveSH1 = lerp(accumulatedSpecularSMBResponsiveSH1, accumulatedSpecularVMBResponsiveSH1, virtualHistoryAmount); + gOutSpecularSH1[pixelPos] = float4(accumulatedSpecularSH1.rgb, currentRoughnessModified); + gOutSpecularResponsiveSH1[pixelPos] = accumulatedSpecularResponsiveSH1; + #endif + // If zero specular sample (color = 0), artificially adding variance for pixels with low reprojection confidence float specularHistoryConfidence = lerp(specSMBConfidence, specVMBConfidence, virtualHistoryAmount); if (accumulatedSpecular2ndMoment == 0) accumulatedSpecular2ndMoment = gSpecularVarianceBoost * (1.0 - specularHistoryConfidence); diff --git a/Shaders/Include/SIGMA/SIGMA_Common.hlsli b/Shaders/Include/SIGMA/SIGMA_Common.hlsli index 1007e1ae..53dc5a7e 100644 --- a/Shaders/Include/SIGMA/SIGMA_Common.hlsli +++ b/Shaders/Include/SIGMA/SIGMA_Common.hlsli @@ -19,7 +19,7 @@ license agreement from NVIDIA CORPORATION is strictly prohibited. #define UnpackShadow( s ) ( s * s ) // TODO: shadow unpacking is less trivial -// 2.0 - closer to reference (dictated by encoding) +// 2.0 - closer to reference ( dictated by encoding ) // 2.0 - s.x - looks better #if 0 #define UnpackShadowSpecial( s ) STL::Math::Pow01( s, 2.0 - s.x * ( 1 - SIGMA_REFERENCE ) ) diff --git a/Shaders/Resources/REBLUR_DiffuseSpecular_TemporalStabilization.resources.hlsli b/Shaders/Resources/REBLUR_DiffuseSpecular_TemporalStabilization.resources.hlsli index 4fbc7a15..5350d2bd 100644 --- a/Shaders/Resources/REBLUR_DiffuseSpecular_TemporalStabilization.resources.hlsli +++ b/Shaders/Resources/REBLUR_DiffuseSpecular_TemporalStabilization.resources.hlsli @@ -51,7 +51,7 @@ NRD_CONSTANTS_END NRD_INPUT_TEXTURE_END NRD_OUTPUT_TEXTURE_START - NRD_OUTPUT_TEXTURE( RWTexture2D, gInOut_Mv, u, 0 ) + NRD_OUTPUT_TEXTURE( RWTexture2D, gInOut_Mv, u, 0 ) NRD_OUTPUT_TEXTURE( RWTexture2D, gOut_InternalData, u, 1 ) NRD_OUTPUT_TEXTURE( RWTexture2D, gOut_Diff, u, 2 ) NRD_OUTPUT_TEXTURE( RWTexture2D, gOut_Spec, u, 3 ) @@ -77,7 +77,7 @@ NRD_CONSTANTS_END NRD_INPUT_TEXTURE_END NRD_OUTPUT_TEXTURE_START - NRD_OUTPUT_TEXTURE( RWTexture2D, gInOut_Mv, u, 0 ) + NRD_OUTPUT_TEXTURE( RWTexture2D, gInOut_Mv, u, 0 ) NRD_OUTPUT_TEXTURE( RWTexture2D, gOut_InternalData, u, 1 ) NRD_OUTPUT_TEXTURE( RWTexture2D, gOut_Diff, u, 2 ) #ifdef REBLUR_SH @@ -103,7 +103,7 @@ NRD_CONSTANTS_END NRD_INPUT_TEXTURE_END NRD_OUTPUT_TEXTURE_START - NRD_OUTPUT_TEXTURE( RWTexture2D, gInOut_Mv, u, 0 ) + NRD_OUTPUT_TEXTURE( RWTexture2D, gInOut_Mv, u, 0 ) NRD_OUTPUT_TEXTURE( RWTexture2D, gOut_InternalData, u, 1 ) NRD_OUTPUT_TEXTURE( RWTexture2D, gOut_Spec, u, 2 ) #ifdef REBLUR_SH diff --git a/Shaders/Resources/RELAX_DiffuseSpecular_Atrous.resources.hlsli b/Shaders/Resources/RELAX_DiffuseSpecular_Atrous.resources.hlsli index 38bcc7d4..3aaf7f63 100644 --- a/Shaders/Resources/RELAX_DiffuseSpecular_Atrous.resources.hlsli +++ b/Shaders/Resources/RELAX_DiffuseSpecular_Atrous.resources.hlsli @@ -37,6 +37,9 @@ NRD_SAMPLER_END NRD_CONSTANT( float, gConfidenceDrivenRelaxationMultiplier ) NRD_CONSTANT( float, gConfidenceDrivenLuminanceEdgeStoppingRelaxation ) NRD_CONSTANT( float, gConfidenceDrivenNormalEdgeStoppingRelaxation ) + #ifdef RELAX_SH + NRD_CONSTANT( uint, gIsLastPass ) + #endif NRD_CONSTANTS_END NRD_INPUT_TEXTURE_START @@ -48,11 +51,19 @@ NRD_SAMPLER_END NRD_INPUT_TEXTURE( Texture2D, gViewZFP16, t, 5 ) NRD_INPUT_TEXTURE( Texture2D, gSpecConfidence, t, 6 ) NRD_INPUT_TEXTURE( Texture2D, gDiffConfidence, t, 7 ) + #ifdef RELAX_SH + NRD_INPUT_TEXTURE( Texture2D, gSpecularSH1, t, 8 ) + NRD_INPUT_TEXTURE( Texture2D, gDiffuseSH1, t, 9 ) + #endif NRD_INPUT_TEXTURE_END NRD_OUTPUT_TEXTURE_START NRD_OUTPUT_TEXTURE( RWTexture2D, gOutSpecularIlluminationAndVariance, u, 0 ) NRD_OUTPUT_TEXTURE( RWTexture2D, gOutDiffuseIlluminationAndVariance, u, 1 ) + #ifdef RELAX_SH + NRD_OUTPUT_TEXTURE( RWTexture2D, gOutSpecularSH1, u, 2 ) + NRD_OUTPUT_TEXTURE( RWTexture2D, gOutDiffuseSH1, u, 3 ) + #endif NRD_OUTPUT_TEXTURE_END #elif( defined RELAX_DIFFUSE ) @@ -68,6 +79,9 @@ NRD_SAMPLER_END NRD_CONSTANT( float, gConfidenceDrivenRelaxationMultiplier ) NRD_CONSTANT( float, gConfidenceDrivenLuminanceEdgeStoppingRelaxation ) NRD_CONSTANT( float, gConfidenceDrivenNormalEdgeStoppingRelaxation ) + #ifdef RELAX_SH + NRD_CONSTANT( uint, gIsLastPass ) + #endif NRD_CONSTANTS_END NRD_INPUT_TEXTURE_START @@ -76,10 +90,16 @@ NRD_SAMPLER_END NRD_INPUT_TEXTURE( Texture2D, gNormalRoughness, t, 2 ) NRD_INPUT_TEXTURE( Texture2D, gViewZFP16, t, 3 ) NRD_INPUT_TEXTURE( Texture2D, gDiffConfidence, t, 4 ) + #ifdef RELAX_SH + NRD_INPUT_TEXTURE( Texture2D, gDiffuseSH1, t, 5 ) + #endif NRD_INPUT_TEXTURE_END NRD_OUTPUT_TEXTURE_START NRD_OUTPUT_TEXTURE( RWTexture2D, gOutDiffuseIlluminationAndVariance, u, 0 ) + #ifdef RELAX_SH + NRD_OUTPUT_TEXTURE( RWTexture2D, gOutDiffuseSH1, u, 1 ) + #endif NRD_OUTPUT_TEXTURE_END #elif( defined RELAX_SPECULAR ) @@ -102,6 +122,9 @@ NRD_SAMPLER_END NRD_CONSTANT( float, gConfidenceDrivenRelaxationMultiplier ) NRD_CONSTANT( float, gConfidenceDrivenLuminanceEdgeStoppingRelaxation ) NRD_CONSTANT( float, gConfidenceDrivenNormalEdgeStoppingRelaxation ) + #ifdef RELAX_SH + NRD_CONSTANT( uint, gIsLastPass ) + #endif NRD_CONSTANTS_END NRD_INPUT_TEXTURE_START @@ -111,10 +134,16 @@ NRD_SAMPLER_END NRD_INPUT_TEXTURE( Texture2D, gNormalRoughness, t, 3 ) NRD_INPUT_TEXTURE( Texture2D, gViewZFP16, t, 4 ) NRD_INPUT_TEXTURE( Texture2D, gSpecConfidence, t, 5 ) + #ifdef RELAX_SH + NRD_INPUT_TEXTURE( Texture2D, gSpecularSH1, t, 6 ) + #endif NRD_INPUT_TEXTURE_END NRD_OUTPUT_TEXTURE_START NRD_OUTPUT_TEXTURE( RWTexture2D, gOutSpecularIlluminationAndVariance, u, 0 ) + #ifdef RELAX_SH + NRD_OUTPUT_TEXTURE( RWTexture2D, gOutSpecularSH1, u, 1 ) + #endif NRD_OUTPUT_TEXTURE_END #endif diff --git a/Shaders/Resources/RELAX_DiffuseSpecular_AtrousSmem.resources.hlsli b/Shaders/Resources/RELAX_DiffuseSpecular_AtrousSmem.resources.hlsli index 47222642..e1f25768 100644 --- a/Shaders/Resources/RELAX_DiffuseSpecular_AtrousSmem.resources.hlsli +++ b/Shaders/Resources/RELAX_DiffuseSpecular_AtrousSmem.resources.hlsli @@ -51,6 +51,10 @@ NRD_SAMPLER_END NRD_INPUT_TEXTURE( Texture2D, gViewZFP16, t, 5 ) NRD_INPUT_TEXTURE( Texture2D, gSpecConfidence, t, 6 ) NRD_INPUT_TEXTURE( Texture2D, gDiffConfidence, t, 7 ) + #ifdef RELAX_SH + NRD_INPUT_TEXTURE( Texture2D, gSpecularSH1, t, 8 ) + NRD_INPUT_TEXTURE( Texture2D, gDiffuseSH1, t, 9 ) + #endif NRD_INPUT_TEXTURE_END NRD_OUTPUT_TEXTURE_START @@ -58,6 +62,11 @@ NRD_SAMPLER_END NRD_OUTPUT_TEXTURE( RWTexture2D, gOutDiffuseIlluminationAndVariance, u, 1 ) NRD_OUTPUT_TEXTURE( RWTexture2D, gOutNormalRoughness, u, 2 ) NRD_OUTPUT_TEXTURE( RWTexture2D, gOutMaterialID, u, 3 ) + #ifdef RELAX_SH + NRD_OUTPUT_TEXTURE( RWTexture2D, gOutSpecularSH1, u, 4 ) + NRD_OUTPUT_TEXTURE( RWTexture2D, gOutDiffuseSH1, u, 5 ) + #endif + NRD_OUTPUT_TEXTURE_END #elif( defined RELAX_DIFFUSE ) @@ -83,12 +92,18 @@ NRD_SAMPLER_END NRD_INPUT_TEXTURE( Texture2D, gNormalRoughness, t, 2 ) NRD_INPUT_TEXTURE( Texture2D, gViewZFP16, t, 3 ) NRD_INPUT_TEXTURE( Texture2D, gDiffConfidence, t, 4 ) + #ifdef RELAX_SH + NRD_INPUT_TEXTURE( Texture2D, gDiffuseSH1, t, 5 ) + #endif NRD_INPUT_TEXTURE_END NRD_OUTPUT_TEXTURE_START NRD_OUTPUT_TEXTURE( RWTexture2D, gOutDiffuseIlluminationAndVariance, u, 0 ) NRD_OUTPUT_TEXTURE( RWTexture2D, gOutNormalRoughness, u, 1 ) NRD_OUTPUT_TEXTURE( RWTexture2D, gOutMaterialID, u, 2 ) + #ifdef RELAX_SH + NRD_OUTPUT_TEXTURE( RWTexture2D, gOutDiffuseSH1, u, 3 ) + #endif NRD_OUTPUT_TEXTURE_END #elif( defined RELAX_SPECULAR ) @@ -122,12 +137,18 @@ NRD_SAMPLER_END NRD_INPUT_TEXTURE( Texture2D, gNormalRoughness, t, 3 ) NRD_INPUT_TEXTURE( Texture2D, gViewZFP16, t, 4 ) NRD_INPUT_TEXTURE( Texture2D, gSpecConfidence, t, 5 ) + #ifdef RELAX_SH + NRD_INPUT_TEXTURE( Texture2D, gSpecularSH1, t, 6 ) + #endif NRD_INPUT_TEXTURE_END NRD_OUTPUT_TEXTURE_START NRD_OUTPUT_TEXTURE( RWTexture2D, gOutSpecularIlluminationAndVariance, u, 0 ) NRD_OUTPUT_TEXTURE( RWTexture2D, gOutNormalRoughness, u, 1 ) NRD_OUTPUT_TEXTURE( RWTexture2D, gOutMaterialID, u, 2 ) + #ifdef RELAX_SH + NRD_OUTPUT_TEXTURE( RWTexture2D, gOutSpecularSH1, u, 3 ) + #endif NRD_OUTPUT_TEXTURE_END #endif diff --git a/Shaders/Resources/RELAX_DiffuseSpecular_HistoryClamping.resources.hlsli b/Shaders/Resources/RELAX_DiffuseSpecular_HistoryClamping.resources.hlsli index bc065291..0ccb6d6c 100644 --- a/Shaders/Resources/RELAX_DiffuseSpecular_HistoryClamping.resources.hlsli +++ b/Shaders/Resources/RELAX_DiffuseSpecular_HistoryClamping.resources.hlsli @@ -35,6 +35,12 @@ NRD_CONSTANTS_END NRD_INPUT_TEXTURE( Texture2D, gSpecularIlluminationResponsive, t, 2 ) NRD_INPUT_TEXTURE( Texture2D, gDiffuseIlluminationResponsive, t, 3 ) NRD_INPUT_TEXTURE( Texture2D, gHistoryLength, t, 4 ) + #ifdef RELAX_SH + NRD_INPUT_TEXTURE( Texture2D, gSpecularSH1, t, 5 ) + NRD_INPUT_TEXTURE( Texture2D, gDiffuseSH1, t, 6 ) + NRD_INPUT_TEXTURE( Texture2D, gSpecularResponsiveSH1, t, 7 ) + NRD_INPUT_TEXTURE( Texture2D, gDiffuseResponsiveSH1, t, 8 ) + #endif NRD_INPUT_TEXTURE_END NRD_OUTPUT_TEXTURE_START @@ -43,6 +49,12 @@ NRD_CONSTANTS_END NRD_OUTPUT_TEXTURE( RWTexture2D, gOutSpecularIlluminationResponsive, u, 2 ) NRD_OUTPUT_TEXTURE( RWTexture2D, gOutDiffuseIlluminationResponsive, u, 3 ) NRD_OUTPUT_TEXTURE( RWTexture2D, gOutHistoryLength, u, 4 ) + #ifdef RELAX_SH + NRD_OUTPUT_TEXTURE( RWTexture2D, gOutSpecularSH1, u, 5 ) + NRD_OUTPUT_TEXTURE( RWTexture2D, gOutDiffuseSH1, u, 6 ) + NRD_OUTPUT_TEXTURE( RWTexture2D, gOutSpecularResponsiveSH1, u, 7 ) + NRD_OUTPUT_TEXTURE( RWTexture2D, gOutDiffuseResponsiveSH1, u, 8 ) + #endif NRD_OUTPUT_TEXTURE_END #elif( defined RELAX_DIFFUSE ) @@ -51,12 +63,20 @@ NRD_CONSTANTS_END NRD_INPUT_TEXTURE( Texture2D, gDiffuseIllumination, t, 0 ) NRD_INPUT_TEXTURE( Texture2D, gDiffuseIlluminationResponsive, t, 1 ) NRD_INPUT_TEXTURE( Texture2D, gHistoryLength, t, 2 ) + #ifdef RELAX_SH + NRD_INPUT_TEXTURE( Texture2D, gDiffuseSH1, t, 3 ) + NRD_INPUT_TEXTURE( Texture2D, gDiffuseResponsiveSH1, t, 4 ) + #endif NRD_INPUT_TEXTURE_END NRD_OUTPUT_TEXTURE_START NRD_OUTPUT_TEXTURE( RWTexture2D, gOutDiffuseIllumination, u, 0 ) NRD_OUTPUT_TEXTURE( RWTexture2D, gOutDiffuseIlluminationResponsive, u, 1 ) NRD_OUTPUT_TEXTURE( RWTexture2D, gOutHistoryLength, u, 2 ) + #ifdef RELAX_SH + NRD_OUTPUT_TEXTURE( RWTexture2D, gOutDiffuseSH1, u, 3 ) + NRD_OUTPUT_TEXTURE( RWTexture2D, gOutDiffuseResponsiveSH1, u, 4 ) + #endif NRD_OUTPUT_TEXTURE_END #elif( defined RELAX_SPECULAR ) @@ -65,12 +85,20 @@ NRD_CONSTANTS_END NRD_INPUT_TEXTURE( Texture2D, gSpecularIllumination, t, 0 ) NRD_INPUT_TEXTURE( Texture2D, gSpecularIlluminationResponsive, t, 1 ) NRD_INPUT_TEXTURE( Texture2D, gHistoryLength, t, 2 ) + #ifdef RELAX_SH + NRD_INPUT_TEXTURE( Texture2D, gSpecularSH1, t, 3 ) + NRD_INPUT_TEXTURE( Texture2D, gSpecularResponsiveSH1, t, 4 ) + #endif NRD_INPUT_TEXTURE_END NRD_OUTPUT_TEXTURE_START NRD_OUTPUT_TEXTURE( RWTexture2D, gOutSpecularIllumination, u, 0 ) NRD_OUTPUT_TEXTURE( RWTexture2D, gOutSpecularIlluminationResponsive, u, 1 ) NRD_OUTPUT_TEXTURE( RWTexture2D, gOutHistoryLength, u, 2 ) + #ifdef RELAX_SH + NRD_OUTPUT_TEXTURE( RWTexture2D, gOutSpecularSH1, u, 3 ) + NRD_OUTPUT_TEXTURE( RWTexture2D, gOutSpecularResponsiveSH1, u, 4 ) + #endif NRD_OUTPUT_TEXTURE_END #endif diff --git a/Shaders/Resources/RELAX_DiffuseSpecular_HistoryFix.resources.hlsli b/Shaders/Resources/RELAX_DiffuseSpecular_HistoryFix.resources.hlsli index da8ccb7e..4bb83836 100644 --- a/Shaders/Resources/RELAX_DiffuseSpecular_HistoryFix.resources.hlsli +++ b/Shaders/Resources/RELAX_DiffuseSpecular_HistoryFix.resources.hlsli @@ -37,11 +37,19 @@ NRD_CONSTANTS_END NRD_INPUT_TEXTURE( Texture2D, gHistoryLength, t, 2 ) NRD_INPUT_TEXTURE( Texture2D, gNormalRoughness, t, 3 ) NRD_INPUT_TEXTURE( Texture2D, gViewZFP16, t, 4 ) + #ifdef RELAX_SH + NRD_INPUT_TEXTURE( Texture2D, gSpecularSH1, t, 5 ) + NRD_INPUT_TEXTURE( Texture2D, gDiffuseSH1, t, 6 ) + #endif NRD_INPUT_TEXTURE_END NRD_OUTPUT_TEXTURE_START NRD_OUTPUT_TEXTURE( RWTexture2D, gOutSpecularIllumination, u, 0 ) NRD_OUTPUT_TEXTURE( RWTexture2D, gOutDiffuseIllumination, u, 1 ) + #ifdef RELAX_SH + NRD_OUTPUT_TEXTURE( RWTexture2D, gOutSpecularSH1, u, 2 ) + NRD_OUTPUT_TEXTURE( RWTexture2D, gOutDiffuseSH1, u, 3 ) + #endif NRD_OUTPUT_TEXTURE_END #elif( defined RELAX_DIFFUSE ) @@ -51,10 +59,16 @@ NRD_CONSTANTS_END NRD_INPUT_TEXTURE( Texture2D, gHistoryLength, t, 1 ) NRD_INPUT_TEXTURE( Texture2D, gNormalRoughness, t, 2 ) NRD_INPUT_TEXTURE( Texture2D, gViewZFP16, t, 3 ) + #ifdef RELAX_SH + NRD_INPUT_TEXTURE( Texture2D, gDiffuseSH1, t, 4 ) + #endif NRD_INPUT_TEXTURE_END NRD_OUTPUT_TEXTURE_START NRD_OUTPUT_TEXTURE( RWTexture2D, gOutDiffuseIllumination, u, 0 ) + #ifdef RELAX_SH + NRD_OUTPUT_TEXTURE( RWTexture2D, gOutDiffuseSH1, u, 1 ) + #endif NRD_OUTPUT_TEXTURE_END #elif( defined RELAX_SPECULAR ) @@ -64,10 +78,16 @@ NRD_CONSTANTS_END NRD_INPUT_TEXTURE( Texture2D, gHistoryLength, t, 1 ) NRD_INPUT_TEXTURE( Texture2D, gNormalRoughness, t, 2 ) NRD_INPUT_TEXTURE( Texture2D, gViewZFP16, t, 3 ) + #ifdef RELAX_SH + NRD_INPUT_TEXTURE( Texture2D, gSpecularSH1, t, 4 ) + #endif NRD_INPUT_TEXTURE_END NRD_OUTPUT_TEXTURE_START NRD_OUTPUT_TEXTURE( RWTexture2D, gOutSpecularIllumination, u, 0 ) + #ifdef RELAX_SH + NRD_OUTPUT_TEXTURE( RWTexture2D, gOutSpecularSH1, u, 1 ) + #endif NRD_OUTPUT_TEXTURE_END #endif diff --git a/Shaders/Resources/RELAX_DiffuseSpecular_PrePass.resources.hlsli b/Shaders/Resources/RELAX_DiffuseSpecular_PrePass.resources.hlsli index 916c104f..c39f5225 100644 --- a/Shaders/Resources/RELAX_DiffuseSpecular_PrePass.resources.hlsli +++ b/Shaders/Resources/RELAX_DiffuseSpecular_PrePass.resources.hlsli @@ -37,6 +37,10 @@ NRD_SAMPLER_END NRD_INPUT_TEXTURE( Texture2D, gDiffuseIllumination, t, 1 ) NRD_INPUT_TEXTURE( Texture2D, gNormalRoughness, t, 2 ) NRD_INPUT_TEXTURE( Texture2D, gViewZ, t, 3 ) + #ifdef RELAX_SH + NRD_INPUT_TEXTURE( Texture2D, gSpecularSH1, t, 4 ) + NRD_INPUT_TEXTURE( Texture2D, gDiffuseSH1, t, 5 ) + #endif NRD_INPUT_TEXTURE_END NRD_OUTPUT_TEXTURE_START @@ -44,6 +48,10 @@ NRD_SAMPLER_END NRD_OUTPUT_TEXTURE( RWTexture2D, gOutDiffuseIllumination, u, 1 ) NRD_OUTPUT_TEXTURE( RWTexture2D, gOutViewZ, u, 2) NRD_OUTPUT_TEXTURE( RWTexture2D, gOutScaledViewZ, u, 3 ) + #ifdef RELAX_SH + NRD_OUTPUT_TEXTURE( RWTexture2D, gOutSpecularSH1, u, 4 ) + NRD_OUTPUT_TEXTURE( RWTexture2D, gOutDiffuseSH1, u, 5 ) + #endif NRD_OUTPUT_TEXTURE_END #elif( defined RELAX_DIFFUSE ) @@ -62,12 +70,18 @@ NRD_SAMPLER_END NRD_INPUT_TEXTURE( Texture2D, gDiffuseIllumination, t, 0 ) NRD_INPUT_TEXTURE( Texture2D, gNormalRoughness, t, 1 ) NRD_INPUT_TEXTURE( Texture2D, gViewZ, t, 2 ) + #ifdef RELAX_SH + NRD_INPUT_TEXTURE( Texture2D, gDiffuseSH1, t, 3 ) + #endif NRD_INPUT_TEXTURE_END NRD_OUTPUT_TEXTURE_START NRD_OUTPUT_TEXTURE( RWTexture2D, gOutDiffuseIllumination, u, 0 ) NRD_OUTPUT_TEXTURE( RWTexture2D, gOutViewZ, u, 1) NRD_OUTPUT_TEXTURE( RWTexture2D, gOutScaledViewZ, u, 2 ) + #ifdef RELAX_SH + NRD_OUTPUT_TEXTURE( RWTexture2D, gOutDiffuseSH1, u, 3 ) + #endif NRD_OUTPUT_TEXTURE_END #elif( defined RELAX_SPECULAR ) @@ -88,12 +102,18 @@ NRD_SAMPLER_END NRD_INPUT_TEXTURE( Texture2D, gSpecularIllumination, t, 0 ) NRD_INPUT_TEXTURE( Texture2D, gNormalRoughness, t, 1 ) NRD_INPUT_TEXTURE( Texture2D, gViewZ, t, 2 ) + #ifdef RELAX_SH + NRD_INPUT_TEXTURE( Texture2D, gSpecularSH1, t, 3 ) + #endif NRD_INPUT_TEXTURE_END NRD_OUTPUT_TEXTURE_START NRD_OUTPUT_TEXTURE( RWTexture2D, gOutSpecularIllumination, u, 0 ) NRD_OUTPUT_TEXTURE( RWTexture2D, gOutViewZ, u, 1) NRD_OUTPUT_TEXTURE( RWTexture2D, gOutScaledViewZ, u, 2 ) + #ifdef RELAX_SH + NRD_OUTPUT_TEXTURE( RWTexture2D, gOutSpecularSH1, u, 3 ) + #endif NRD_OUTPUT_TEXTURE_END #endif diff --git a/Shaders/Resources/RELAX_DiffuseSpecular_TemporalAccumulation.resources.hlsli b/Shaders/Resources/RELAX_DiffuseSpecular_TemporalAccumulation.resources.hlsli index 39f1f739..06da7c41 100644 --- a/Shaders/Resources/RELAX_DiffuseSpecular_TemporalAccumulation.resources.hlsli +++ b/Shaders/Resources/RELAX_DiffuseSpecular_TemporalAccumulation.resources.hlsli @@ -52,6 +52,14 @@ NRD_SAMPLER_END NRD_INPUT_TEXTURE( Texture2D, gSpecConfidence, t, 14 ) NRD_INPUT_TEXTURE( Texture2D, gDiffConfidence, t, 15 ) NRD_INPUT_TEXTURE( Texture2D, gDisocclusionThresholdMix, t, 16) + #ifdef RELAX_SH + NRD_INPUT_TEXTURE( Texture2D, gSpecularSH1, t, 17 ) + NRD_INPUT_TEXTURE( Texture2D, gDiffuseSH1, t, 18 ) + NRD_INPUT_TEXTURE( Texture2D, gPrevSpecularResponsiveSH1, t, 19 ) + NRD_INPUT_TEXTURE( Texture2D, gPrevDiffuseResponsiveSH1, t, 20 ) + NRD_INPUT_TEXTURE( Texture2D, gPrevSpecularSH1, t, 21 ) + NRD_INPUT_TEXTURE( Texture2D, gPrevDiffuseSH1, t, 22 ) + #endif NRD_INPUT_TEXTURE_END NRD_OUTPUT_TEXTURE_START @@ -62,6 +70,12 @@ NRD_SAMPLER_END NRD_OUTPUT_TEXTURE( RWTexture2D, gOutReflectionHitT, u, 4 ) NRD_OUTPUT_TEXTURE( RWTexture2D, gOutHistoryLength, u, 5 ) NRD_OUTPUT_TEXTURE( RWTexture2D, gOutSpecularReprojectionConfidence, u, 6 ) + #ifdef RELAX_SH + NRD_OUTPUT_TEXTURE( RWTexture2D, gOutSpecularSH1, u, 7 ) + NRD_OUTPUT_TEXTURE( RWTexture2D, gOutDiffuseSH1, u, 8 ) + NRD_OUTPUT_TEXTURE( RWTexture2D, gOutSpecularResponsiveSH1, u, 9 ) + NRD_OUTPUT_TEXTURE( RWTexture2D, gOutDiffuseResponsiveSH1, u, 10 ) + #endif NRD_OUTPUT_TEXTURE_END #elif( defined RELAX_DIFFUSE ) @@ -91,12 +105,21 @@ NRD_SAMPLER_END NRD_INPUT_TEXTURE( Texture2D, gPrevMaterialID, t, 9 ) NRD_INPUT_TEXTURE( Texture2D, gDiffConfidence, t, 10 ) NRD_INPUT_TEXTURE( Texture2D, gDisocclusionThresholdMix, t, 11) + #ifdef RELAX_SH + NRD_INPUT_TEXTURE( Texture2D, gDiffuseSH1, t, 12 ) + NRD_INPUT_TEXTURE( Texture2D, gPrevDiffuseResponsiveSH1, t, 13 ) + NRD_INPUT_TEXTURE( Texture2D, gPrevDiffuseSH1, t, 14 ) + #endif NRD_INPUT_TEXTURE_END NRD_OUTPUT_TEXTURE_START NRD_OUTPUT_TEXTURE( RWTexture2D, gOutDiffuseIllumination, u, 0 ) NRD_OUTPUT_TEXTURE( RWTexture2D, gOutDiffuseIlluminationResponsive, u, 1 ) NRD_OUTPUT_TEXTURE( RWTexture2D, gOutHistoryLength, u, 2 ) + #ifdef RELAX_SH + NRD_OUTPUT_TEXTURE( RWTexture2D, gOutDiffuseSH1, u, 3 ) + NRD_OUTPUT_TEXTURE( RWTexture2D, gOutDiffuseResponsiveSH1, u, 4 ) + #endif NRD_OUTPUT_TEXTURE_END #elif( defined RELAX_SPECULAR ) @@ -129,6 +152,11 @@ NRD_SAMPLER_END NRD_INPUT_TEXTURE( Texture2D, gPrevMaterialID, t, 10 ) NRD_INPUT_TEXTURE( Texture2D, gSpecConfidence, t, 11 ) NRD_INPUT_TEXTURE( Texture2D, gDisocclusionThresholdMix, t, 12) + #ifdef RELAX_SH + NRD_INPUT_TEXTURE( Texture2D, gSpecularSH1, t, 13 ) + NRD_INPUT_TEXTURE( Texture2D, gPrevSpecularResponsiveSH1, t, 14 ) + NRD_INPUT_TEXTURE( Texture2D, gPrevSpecularSH1, t, 15 ) + #endif NRD_INPUT_TEXTURE_END NRD_OUTPUT_TEXTURE_START @@ -137,6 +165,10 @@ NRD_SAMPLER_END NRD_OUTPUT_TEXTURE( RWTexture2D, gOutReflectionHitT, u, 2 ) NRD_OUTPUT_TEXTURE( RWTexture2D, gOutHistoryLength, u, 3 ) NRD_OUTPUT_TEXTURE( RWTexture2D, gOutSpecularReprojectionConfidence, u, 4 ) + #ifdef RELAX_SH + NRD_OUTPUT_TEXTURE( RWTexture2D, gOutSpecularSH1, u, 5 ) + NRD_OUTPUT_TEXTURE( RWTexture2D, gOutSpecularResponsiveSH1, u, 6 ) + #endif NRD_OUTPUT_TEXTURE_END #endif diff --git a/Shaders/Source/Clear_f.cs.hlsl b/Shaders/Source/Clear_f.cs.hlsl index 1a567b2e..7c766c83 100644 --- a/Shaders/Source/Clear_f.cs.hlsl +++ b/Shaders/Source/Clear_f.cs.hlsl @@ -8,12 +8,12 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" -#include "../Resources/Clear_f.resources.hlsli" +#include "Clear_f.resources.hlsli" -#include "../Include/Common.hlsli" +#include "Common.hlsli" [numthreads( 16, 16, 1 )] NRD_EXPORT void NRD_CS_MAIN( uint2 pixelPos : SV_DispatchThreadId ) diff --git a/Shaders/Source/Clear_ui.cs.hlsl b/Shaders/Source/Clear_ui.cs.hlsl index c1c26370..af6ddc4e 100644 --- a/Shaders/Source/Clear_ui.cs.hlsl +++ b/Shaders/Source/Clear_ui.cs.hlsl @@ -8,12 +8,12 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" -#include "../Resources/Clear_ui.resources.hlsli" +#include "Clear_ui.resources.hlsli" -#include "../Include/Common.hlsli" +#include "Common.hlsli" [numthreads( 16, 16, 1 )] NRD_EXPORT void NRD_CS_MAIN( uint2 pixelPos : SV_DispatchThreadId ) diff --git a/Shaders/Source/REBLUR_DiffuseDirectionalOcclusion_Blur.cs.hlsl b/Shaders/Source/REBLUR_DiffuseDirectionalOcclusion_Blur.cs.hlsl index e60609ad..9a251abd 100644 --- a/Shaders/Source/REBLUR_DiffuseDirectionalOcclusion_Blur.cs.hlsl +++ b/Shaders/Source/REBLUR_DiffuseDirectionalOcclusion_Blur.cs.hlsl @@ -8,15 +8,15 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_DIFFUSE #define REBLUR_DIRECTIONAL_OCCLUSION -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_Blur.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_Blur.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_Blur.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_Blur.hlsli" diff --git a/Shaders/Source/REBLUR_DiffuseDirectionalOcclusion_HistoryFix.cs.hlsl b/Shaders/Source/REBLUR_DiffuseDirectionalOcclusion_HistoryFix.cs.hlsl index c80ccd83..d591157e 100644 --- a/Shaders/Source/REBLUR_DiffuseDirectionalOcclusion_HistoryFix.cs.hlsl +++ b/Shaders/Source/REBLUR_DiffuseDirectionalOcclusion_HistoryFix.cs.hlsl @@ -8,15 +8,15 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_DIFFUSE #define REBLUR_DIRECTIONAL_OCCLUSION -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_HistoryFix.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_HistoryFix.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_HistoryFix.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_HistoryFix.hlsli" diff --git a/Shaders/Source/REBLUR_DiffuseDirectionalOcclusion_PostBlur.cs.hlsl b/Shaders/Source/REBLUR_DiffuseDirectionalOcclusion_PostBlur.cs.hlsl index 89ac0ea4..613332d8 100644 --- a/Shaders/Source/REBLUR_DiffuseDirectionalOcclusion_PostBlur.cs.hlsl +++ b/Shaders/Source/REBLUR_DiffuseDirectionalOcclusion_PostBlur.cs.hlsl @@ -8,15 +8,15 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_DIFFUSE #define REBLUR_DIRECTIONAL_OCCLUSION -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" diff --git a/Shaders/Source/REBLUR_DiffuseDirectionalOcclusion_PostBlur_NoTemporalStabilization.cs.hlsl b/Shaders/Source/REBLUR_DiffuseDirectionalOcclusion_PostBlur_NoTemporalStabilization.cs.hlsl index 8baa5fd7..6c7cf79c 100644 --- a/Shaders/Source/REBLUR_DiffuseDirectionalOcclusion_PostBlur_NoTemporalStabilization.cs.hlsl +++ b/Shaders/Source/REBLUR_DiffuseDirectionalOcclusion_PostBlur_NoTemporalStabilization.cs.hlsl @@ -8,16 +8,16 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_DIFFUSE #define REBLUR_DIRECTIONAL_OCCLUSION #define REBLUR_NO_TEMPORAL_STABILIZATION -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" diff --git a/Shaders/Source/REBLUR_DiffuseDirectionalOcclusion_PrePass.cs.hlsl b/Shaders/Source/REBLUR_DiffuseDirectionalOcclusion_PrePass.cs.hlsl index 4f178e5c..79e2c6a3 100644 --- a/Shaders/Source/REBLUR_DiffuseDirectionalOcclusion_PrePass.cs.hlsl +++ b/Shaders/Source/REBLUR_DiffuseDirectionalOcclusion_PrePass.cs.hlsl @@ -8,15 +8,15 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_DIFFUSE #define REBLUR_DIRECTIONAL_OCCLUSION -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_PrePass.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_PrePass.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_PrePass.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_PrePass.hlsli" diff --git a/Shaders/Source/REBLUR_DiffuseDirectionalOcclusion_TemporalAccumulation.cs.hlsl b/Shaders/Source/REBLUR_DiffuseDirectionalOcclusion_TemporalAccumulation.cs.hlsl index d6f832f3..662a4971 100644 --- a/Shaders/Source/REBLUR_DiffuseDirectionalOcclusion_TemporalAccumulation.cs.hlsl +++ b/Shaders/Source/REBLUR_DiffuseDirectionalOcclusion_TemporalAccumulation.cs.hlsl @@ -8,15 +8,15 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_DIFFUSE #define REBLUR_DIRECTIONAL_OCCLUSION -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_TemporalAccumulation.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_TemporalAccumulation.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_TemporalAccumulation.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_TemporalAccumulation.hlsli" diff --git a/Shaders/Source/REBLUR_DiffuseDirectionalOcclusion_TemporalStabilization.cs.hlsl b/Shaders/Source/REBLUR_DiffuseDirectionalOcclusion_TemporalStabilization.cs.hlsl index bf8c6e62..5a600fd8 100644 --- a/Shaders/Source/REBLUR_DiffuseDirectionalOcclusion_TemporalStabilization.cs.hlsl +++ b/Shaders/Source/REBLUR_DiffuseDirectionalOcclusion_TemporalStabilization.cs.hlsl @@ -8,15 +8,15 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_DIFFUSE #define REBLUR_DIRECTIONAL_OCCLUSION -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_TemporalStabilization.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_TemporalStabilization.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_TemporalStabilization.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_TemporalStabilization.hlsli" diff --git a/Shaders/Source/REBLUR_DiffuseOcclusion_Blur.cs.hlsl b/Shaders/Source/REBLUR_DiffuseOcclusion_Blur.cs.hlsl index 70748f66..e12aca94 100644 --- a/Shaders/Source/REBLUR_DiffuseOcclusion_Blur.cs.hlsl +++ b/Shaders/Source/REBLUR_DiffuseOcclusion_Blur.cs.hlsl @@ -8,15 +8,15 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_DIFFUSE #define REBLUR_OCCLUSION -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_Blur.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_Blur.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_Blur.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_Blur.hlsli" diff --git a/Shaders/Source/REBLUR_DiffuseOcclusion_HistoryFix.cs.hlsl b/Shaders/Source/REBLUR_DiffuseOcclusion_HistoryFix.cs.hlsl index 2c545daf..b1884ab4 100644 --- a/Shaders/Source/REBLUR_DiffuseOcclusion_HistoryFix.cs.hlsl +++ b/Shaders/Source/REBLUR_DiffuseOcclusion_HistoryFix.cs.hlsl @@ -8,15 +8,15 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_DIFFUSE #define REBLUR_OCCLUSION -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_HistoryFix.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_HistoryFix.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_HistoryFix.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_HistoryFix.hlsli" diff --git a/Shaders/Source/REBLUR_DiffuseOcclusion_HitDistReconstruction.cs.hlsl b/Shaders/Source/REBLUR_DiffuseOcclusion_HitDistReconstruction.cs.hlsl index dda10740..e9826a0e 100644 --- a/Shaders/Source/REBLUR_DiffuseOcclusion_HitDistReconstruction.cs.hlsl +++ b/Shaders/Source/REBLUR_DiffuseOcclusion_HitDistReconstruction.cs.hlsl @@ -8,15 +8,15 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_DIFFUSE #define REBLUR_OCCLUSION -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_HitDistReconstruction.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_HitDistReconstruction.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_HitDistReconstruction.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_HitDistReconstruction.hlsli" diff --git a/Shaders/Source/REBLUR_DiffuseOcclusion_HitDistReconstruction_5x5.cs.hlsl b/Shaders/Source/REBLUR_DiffuseOcclusion_HitDistReconstruction_5x5.cs.hlsl index 66200b42..45d9d658 100644 --- a/Shaders/Source/REBLUR_DiffuseOcclusion_HitDistReconstruction_5x5.cs.hlsl +++ b/Shaders/Source/REBLUR_DiffuseOcclusion_HitDistReconstruction_5x5.cs.hlsl @@ -8,16 +8,16 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_DIFFUSE #define REBLUR_OCCLUSION #define REBLUR_HITDIST_RECONSTRUCTION_5X5 -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_HitDistReconstruction.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_HitDistReconstruction.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_HitDistReconstruction.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_HitDistReconstruction.hlsli" diff --git a/Shaders/Source/REBLUR_DiffuseOcclusion_PostBlur_NoTemporalStabilization.cs.hlsl b/Shaders/Source/REBLUR_DiffuseOcclusion_PostBlur_NoTemporalStabilization.cs.hlsl index d3f9eeb0..60ed8706 100644 --- a/Shaders/Source/REBLUR_DiffuseOcclusion_PostBlur_NoTemporalStabilization.cs.hlsl +++ b/Shaders/Source/REBLUR_DiffuseOcclusion_PostBlur_NoTemporalStabilization.cs.hlsl @@ -8,16 +8,16 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_DIFFUSE #define REBLUR_OCCLUSION #define REBLUR_NO_TEMPORAL_STABILIZATION -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" diff --git a/Shaders/Source/REBLUR_DiffuseOcclusion_PrePass.cs.hlsl b/Shaders/Source/REBLUR_DiffuseOcclusion_PrePass.cs.hlsl index 8404ea28..637ca50e 100644 --- a/Shaders/Source/REBLUR_DiffuseOcclusion_PrePass.cs.hlsl +++ b/Shaders/Source/REBLUR_DiffuseOcclusion_PrePass.cs.hlsl @@ -8,15 +8,15 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_DIFFUSE #define REBLUR_OCCLUSION -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_PrePass.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_PrePass.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_PrePass.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_PrePass.hlsli" diff --git a/Shaders/Source/REBLUR_DiffuseOcclusion_TemporalAccumulation.cs.hlsl b/Shaders/Source/REBLUR_DiffuseOcclusion_TemporalAccumulation.cs.hlsl index 9e89e8d4..76c0776b 100644 --- a/Shaders/Source/REBLUR_DiffuseOcclusion_TemporalAccumulation.cs.hlsl +++ b/Shaders/Source/REBLUR_DiffuseOcclusion_TemporalAccumulation.cs.hlsl @@ -8,15 +8,15 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_DIFFUSE #define REBLUR_OCCLUSION -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_TemporalAccumulation.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_TemporalAccumulation.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_TemporalAccumulation.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_TemporalAccumulation.hlsli" diff --git a/Shaders/Source/REBLUR_DiffuseSh_Blur.cs.hlsl b/Shaders/Source/REBLUR_DiffuseSh_Blur.cs.hlsl index 38584760..cc32855c 100644 --- a/Shaders/Source/REBLUR_DiffuseSh_Blur.cs.hlsl +++ b/Shaders/Source/REBLUR_DiffuseSh_Blur.cs.hlsl @@ -8,15 +8,15 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_DIFFUSE #define REBLUR_SH -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_Blur.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_Blur.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_Blur.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_Blur.hlsli" diff --git a/Shaders/Source/REBLUR_DiffuseSh_CopyStabilizedHistory.cs.hlsl b/Shaders/Source/REBLUR_DiffuseSh_CopyStabilizedHistory.cs.hlsl index 7b432438..2828fc84 100644 --- a/Shaders/Source/REBLUR_DiffuseSh_CopyStabilizedHistory.cs.hlsl +++ b/Shaders/Source/REBLUR_DiffuseSh_CopyStabilizedHistory.cs.hlsl @@ -8,14 +8,14 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_DIFFUSE #define REBLUR_SH -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_CopyStabilizedHistory.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_CopyStabilizedHistory.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_CopyStabilizedHistory.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_CopyStabilizedHistory.hlsli" diff --git a/Shaders/Source/REBLUR_DiffuseSh_HistoryFix.cs.hlsl b/Shaders/Source/REBLUR_DiffuseSh_HistoryFix.cs.hlsl index 6cf23e12..d73c2ea2 100644 --- a/Shaders/Source/REBLUR_DiffuseSh_HistoryFix.cs.hlsl +++ b/Shaders/Source/REBLUR_DiffuseSh_HistoryFix.cs.hlsl @@ -8,15 +8,15 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_DIFFUSE #define REBLUR_SH -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_HistoryFix.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_HistoryFix.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_HistoryFix.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_HistoryFix.hlsli" diff --git a/Shaders/Source/REBLUR_DiffuseSh_PostBlur.cs.hlsl b/Shaders/Source/REBLUR_DiffuseSh_PostBlur.cs.hlsl index 0b005482..718b56f2 100644 --- a/Shaders/Source/REBLUR_DiffuseSh_PostBlur.cs.hlsl +++ b/Shaders/Source/REBLUR_DiffuseSh_PostBlur.cs.hlsl @@ -8,15 +8,15 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_DIFFUSE #define REBLUR_SH -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" diff --git a/Shaders/Source/REBLUR_DiffuseSh_PostBlur_NoTemporalStabilization.cs.hlsl b/Shaders/Source/REBLUR_DiffuseSh_PostBlur_NoTemporalStabilization.cs.hlsl index 3cf568ed..e57bbee5 100644 --- a/Shaders/Source/REBLUR_DiffuseSh_PostBlur_NoTemporalStabilization.cs.hlsl +++ b/Shaders/Source/REBLUR_DiffuseSh_PostBlur_NoTemporalStabilization.cs.hlsl @@ -8,16 +8,16 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_DIFFUSE #define REBLUR_SH #define REBLUR_NO_TEMPORAL_STABILIZATION -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" diff --git a/Shaders/Source/REBLUR_DiffuseSh_PrePass.cs.hlsl b/Shaders/Source/REBLUR_DiffuseSh_PrePass.cs.hlsl index 99410b66..5b220498 100644 --- a/Shaders/Source/REBLUR_DiffuseSh_PrePass.cs.hlsl +++ b/Shaders/Source/REBLUR_DiffuseSh_PrePass.cs.hlsl @@ -8,15 +8,15 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_DIFFUSE #define REBLUR_SH -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_PrePass.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_PrePass.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_PrePass.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_PrePass.hlsli" diff --git a/Shaders/Source/REBLUR_DiffuseSh_SplitScreen.cs.hlsl b/Shaders/Source/REBLUR_DiffuseSh_SplitScreen.cs.hlsl index a6bb62c9..3823701e 100644 --- a/Shaders/Source/REBLUR_DiffuseSh_SplitScreen.cs.hlsl +++ b/Shaders/Source/REBLUR_DiffuseSh_SplitScreen.cs.hlsl @@ -8,15 +8,15 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_DIFFUSE #define REBLUR_SH -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_SplitScreen.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_SplitScreen.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_SplitScreen.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_SplitScreen.hlsli" diff --git a/Shaders/Source/REBLUR_DiffuseSh_TemporalAccumulation.cs.hlsl b/Shaders/Source/REBLUR_DiffuseSh_TemporalAccumulation.cs.hlsl index 03ade65d..4ff65a69 100644 --- a/Shaders/Source/REBLUR_DiffuseSh_TemporalAccumulation.cs.hlsl +++ b/Shaders/Source/REBLUR_DiffuseSh_TemporalAccumulation.cs.hlsl @@ -8,15 +8,15 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_DIFFUSE #define REBLUR_SH -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_TemporalAccumulation.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_TemporalAccumulation.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_TemporalAccumulation.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_TemporalAccumulation.hlsli" diff --git a/Shaders/Source/REBLUR_DiffuseSh_TemporalStabilization.cs.hlsl b/Shaders/Source/REBLUR_DiffuseSh_TemporalStabilization.cs.hlsl index 55140dd4..eddec30d 100644 --- a/Shaders/Source/REBLUR_DiffuseSh_TemporalStabilization.cs.hlsl +++ b/Shaders/Source/REBLUR_DiffuseSh_TemporalStabilization.cs.hlsl @@ -8,15 +8,15 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_DIFFUSE #define REBLUR_SH -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_TemporalStabilization.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_TemporalStabilization.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_TemporalStabilization.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_TemporalStabilization.hlsli" diff --git a/Shaders/Source/REBLUR_DiffuseSpecularOcclusion_Blur.cs.hlsl b/Shaders/Source/REBLUR_DiffuseSpecularOcclusion_Blur.cs.hlsl index 31e17f00..5b48a2cf 100644 --- a/Shaders/Source/REBLUR_DiffuseSpecularOcclusion_Blur.cs.hlsl +++ b/Shaders/Source/REBLUR_DiffuseSpecularOcclusion_Blur.cs.hlsl @@ -8,16 +8,16 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_DIFFUSE #define REBLUR_SPECULAR #define REBLUR_OCCLUSION -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_Blur.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_Blur.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_Blur.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_Blur.hlsli" diff --git a/Shaders/Source/REBLUR_DiffuseSpecularOcclusion_HistoryFix.cs.hlsl b/Shaders/Source/REBLUR_DiffuseSpecularOcclusion_HistoryFix.cs.hlsl index 5b570a73..ab079686 100644 --- a/Shaders/Source/REBLUR_DiffuseSpecularOcclusion_HistoryFix.cs.hlsl +++ b/Shaders/Source/REBLUR_DiffuseSpecularOcclusion_HistoryFix.cs.hlsl @@ -8,16 +8,16 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_DIFFUSE #define REBLUR_SPECULAR #define REBLUR_OCCLUSION -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_HistoryFix.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_HistoryFix.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_HistoryFix.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_HistoryFix.hlsli" diff --git a/Shaders/Source/REBLUR_DiffuseSpecularOcclusion_HitDistReconstruction.cs.hlsl b/Shaders/Source/REBLUR_DiffuseSpecularOcclusion_HitDistReconstruction.cs.hlsl index ce19b07f..485fac06 100644 --- a/Shaders/Source/REBLUR_DiffuseSpecularOcclusion_HitDistReconstruction.cs.hlsl +++ b/Shaders/Source/REBLUR_DiffuseSpecularOcclusion_HitDistReconstruction.cs.hlsl @@ -8,16 +8,16 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_DIFFUSE #define REBLUR_SPECULAR #define REBLUR_OCCLUSION -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_HitDistReconstruction.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_HitDistReconstruction.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_HitDistReconstruction.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_HitDistReconstruction.hlsli" diff --git a/Shaders/Source/REBLUR_DiffuseSpecularOcclusion_HitDistReconstruction_5x5.cs.hlsl b/Shaders/Source/REBLUR_DiffuseSpecularOcclusion_HitDistReconstruction_5x5.cs.hlsl index f38e5906..cc5d8529 100644 --- a/Shaders/Source/REBLUR_DiffuseSpecularOcclusion_HitDistReconstruction_5x5.cs.hlsl +++ b/Shaders/Source/REBLUR_DiffuseSpecularOcclusion_HitDistReconstruction_5x5.cs.hlsl @@ -8,7 +8,7 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_DIFFUSE @@ -16,9 +16,9 @@ license agreement from NVIDIA CORPORATION is strictly prohibited. #define REBLUR_OCCLUSION #define REBLUR_HITDIST_RECONSTRUCTION_5X5 -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_HitDistReconstruction.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_HitDistReconstruction.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_HitDistReconstruction.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_HitDistReconstruction.hlsli" diff --git a/Shaders/Source/REBLUR_DiffuseSpecularOcclusion_PostBlur_NoTemporalStabilization.cs.hlsl b/Shaders/Source/REBLUR_DiffuseSpecularOcclusion_PostBlur_NoTemporalStabilization.cs.hlsl index e72c827d..d49e98d0 100644 --- a/Shaders/Source/REBLUR_DiffuseSpecularOcclusion_PostBlur_NoTemporalStabilization.cs.hlsl +++ b/Shaders/Source/REBLUR_DiffuseSpecularOcclusion_PostBlur_NoTemporalStabilization.cs.hlsl @@ -8,7 +8,7 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_DIFFUSE @@ -16,9 +16,9 @@ license agreement from NVIDIA CORPORATION is strictly prohibited. #define REBLUR_OCCLUSION #define REBLUR_NO_TEMPORAL_STABILIZATION -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" diff --git a/Shaders/Source/REBLUR_DiffuseSpecularOcclusion_PrePass.cs.hlsl b/Shaders/Source/REBLUR_DiffuseSpecularOcclusion_PrePass.cs.hlsl index 9844baae..b82e9a45 100644 --- a/Shaders/Source/REBLUR_DiffuseSpecularOcclusion_PrePass.cs.hlsl +++ b/Shaders/Source/REBLUR_DiffuseSpecularOcclusion_PrePass.cs.hlsl @@ -8,16 +8,16 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_DIFFUSE #define REBLUR_SPECULAR #define REBLUR_OCCLUSION -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_PrePass.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_PrePass.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_PrePass.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_PrePass.hlsli" diff --git a/Shaders/Source/REBLUR_DiffuseSpecularOcclusion_TemporalAccumulation.cs.hlsl b/Shaders/Source/REBLUR_DiffuseSpecularOcclusion_TemporalAccumulation.cs.hlsl index 996f0b52..25710942 100644 --- a/Shaders/Source/REBLUR_DiffuseSpecularOcclusion_TemporalAccumulation.cs.hlsl +++ b/Shaders/Source/REBLUR_DiffuseSpecularOcclusion_TemporalAccumulation.cs.hlsl @@ -8,16 +8,16 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_DIFFUSE #define REBLUR_SPECULAR #define REBLUR_OCCLUSION -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_TemporalAccumulation.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_TemporalAccumulation.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_TemporalAccumulation.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_TemporalAccumulation.hlsli" diff --git a/Shaders/Source/REBLUR_DiffuseSpecularSh_Blur.cs.hlsl b/Shaders/Source/REBLUR_DiffuseSpecularSh_Blur.cs.hlsl index 094087fa..afd9667b 100644 --- a/Shaders/Source/REBLUR_DiffuseSpecularSh_Blur.cs.hlsl +++ b/Shaders/Source/REBLUR_DiffuseSpecularSh_Blur.cs.hlsl @@ -8,16 +8,16 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_DIFFUSE #define REBLUR_SPECULAR #define REBLUR_SH -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_Blur.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_Blur.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_Blur.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_Blur.hlsli" diff --git a/Shaders/Source/REBLUR_DiffuseSpecularSh_CopyStabilizedHistory.cs.hlsl b/Shaders/Source/REBLUR_DiffuseSpecularSh_CopyStabilizedHistory.cs.hlsl index 1ebfecc1..5ac814d7 100644 --- a/Shaders/Source/REBLUR_DiffuseSpecularSh_CopyStabilizedHistory.cs.hlsl +++ b/Shaders/Source/REBLUR_DiffuseSpecularSh_CopyStabilizedHistory.cs.hlsl @@ -8,15 +8,15 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_DIFFUSE #define REBLUR_SPECULAR #define REBLUR_SH -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_CopyStabilizedHistory.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_CopyStabilizedHistory.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_CopyStabilizedHistory.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_CopyStabilizedHistory.hlsli" diff --git a/Shaders/Source/REBLUR_DiffuseSpecularSh_HistoryFix.cs.hlsl b/Shaders/Source/REBLUR_DiffuseSpecularSh_HistoryFix.cs.hlsl index f3421364..033022e4 100644 --- a/Shaders/Source/REBLUR_DiffuseSpecularSh_HistoryFix.cs.hlsl +++ b/Shaders/Source/REBLUR_DiffuseSpecularSh_HistoryFix.cs.hlsl @@ -8,16 +8,16 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_DIFFUSE #define REBLUR_SPECULAR #define REBLUR_SH -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_HistoryFix.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_HistoryFix.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_HistoryFix.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_HistoryFix.hlsli" diff --git a/Shaders/Source/REBLUR_DiffuseSpecularSh_PostBlur.cs.hlsl b/Shaders/Source/REBLUR_DiffuseSpecularSh_PostBlur.cs.hlsl index 918ad5f5..50a6bc0c 100644 --- a/Shaders/Source/REBLUR_DiffuseSpecularSh_PostBlur.cs.hlsl +++ b/Shaders/Source/REBLUR_DiffuseSpecularSh_PostBlur.cs.hlsl @@ -8,16 +8,16 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_DIFFUSE #define REBLUR_SPECULAR #define REBLUR_SH -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" diff --git a/Shaders/Source/REBLUR_DiffuseSpecularSh_PostBlur_NoTemporalStabilization.cs.hlsl b/Shaders/Source/REBLUR_DiffuseSpecularSh_PostBlur_NoTemporalStabilization.cs.hlsl index 58ece88f..b68f2319 100644 --- a/Shaders/Source/REBLUR_DiffuseSpecularSh_PostBlur_NoTemporalStabilization.cs.hlsl +++ b/Shaders/Source/REBLUR_DiffuseSpecularSh_PostBlur_NoTemporalStabilization.cs.hlsl @@ -8,7 +8,7 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_DIFFUSE @@ -16,9 +16,9 @@ license agreement from NVIDIA CORPORATION is strictly prohibited. #define REBLUR_SH #define REBLUR_NO_TEMPORAL_STABILIZATION -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" diff --git a/Shaders/Source/REBLUR_DiffuseSpecularSh_PrePass.cs.hlsl b/Shaders/Source/REBLUR_DiffuseSpecularSh_PrePass.cs.hlsl index 825eb449..46fbd347 100644 --- a/Shaders/Source/REBLUR_DiffuseSpecularSh_PrePass.cs.hlsl +++ b/Shaders/Source/REBLUR_DiffuseSpecularSh_PrePass.cs.hlsl @@ -8,16 +8,16 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_DIFFUSE #define REBLUR_SPECULAR #define REBLUR_SH -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_PrePass.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_PrePass.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_PrePass.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_PrePass.hlsli" diff --git a/Shaders/Source/REBLUR_DiffuseSpecularSh_SplitScreen.cs.hlsl b/Shaders/Source/REBLUR_DiffuseSpecularSh_SplitScreen.cs.hlsl index ec8c4749..8a6c1161 100644 --- a/Shaders/Source/REBLUR_DiffuseSpecularSh_SplitScreen.cs.hlsl +++ b/Shaders/Source/REBLUR_DiffuseSpecularSh_SplitScreen.cs.hlsl @@ -8,16 +8,16 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_DIFFUSE #define REBLUR_SPECULAR #define REBLUR_SH -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_SplitScreen.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_SplitScreen.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_SplitScreen.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_SplitScreen.hlsli" diff --git a/Shaders/Source/REBLUR_DiffuseSpecularSh_TemporalAccumulation.cs.hlsl b/Shaders/Source/REBLUR_DiffuseSpecularSh_TemporalAccumulation.cs.hlsl index a324c3ba..82be2a32 100644 --- a/Shaders/Source/REBLUR_DiffuseSpecularSh_TemporalAccumulation.cs.hlsl +++ b/Shaders/Source/REBLUR_DiffuseSpecularSh_TemporalAccumulation.cs.hlsl @@ -8,16 +8,16 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_DIFFUSE #define REBLUR_SPECULAR #define REBLUR_SH -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_TemporalAccumulation.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_TemporalAccumulation.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_TemporalAccumulation.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_TemporalAccumulation.hlsli" diff --git a/Shaders/Source/REBLUR_DiffuseSpecularSh_TemporalStabilization.cs.hlsl b/Shaders/Source/REBLUR_DiffuseSpecularSh_TemporalStabilization.cs.hlsl index cdf6456b..c51bf021 100644 --- a/Shaders/Source/REBLUR_DiffuseSpecularSh_TemporalStabilization.cs.hlsl +++ b/Shaders/Source/REBLUR_DiffuseSpecularSh_TemporalStabilization.cs.hlsl @@ -8,16 +8,16 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_DIFFUSE #define REBLUR_SPECULAR #define REBLUR_SH -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_TemporalStabilization.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_TemporalStabilization.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_TemporalStabilization.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_TemporalStabilization.hlsli" diff --git a/Shaders/Source/REBLUR_DiffuseSpecular_Blur.cs.hlsl b/Shaders/Source/REBLUR_DiffuseSpecular_Blur.cs.hlsl index e9950dd5..15a203f0 100644 --- a/Shaders/Source/REBLUR_DiffuseSpecular_Blur.cs.hlsl +++ b/Shaders/Source/REBLUR_DiffuseSpecular_Blur.cs.hlsl @@ -8,15 +8,15 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_DIFFUSE #define REBLUR_SPECULAR -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_Blur.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_Blur.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_Blur.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_Blur.hlsli" diff --git a/Shaders/Source/REBLUR_DiffuseSpecular_CopyStabilizedHistory.cs.hlsl b/Shaders/Source/REBLUR_DiffuseSpecular_CopyStabilizedHistory.cs.hlsl index a8cda158..f273011c 100644 --- a/Shaders/Source/REBLUR_DiffuseSpecular_CopyStabilizedHistory.cs.hlsl +++ b/Shaders/Source/REBLUR_DiffuseSpecular_CopyStabilizedHistory.cs.hlsl @@ -8,14 +8,14 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_DIFFUSE #define REBLUR_SPECULAR -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_CopyStabilizedHistory.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_CopyStabilizedHistory.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_CopyStabilizedHistory.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_CopyStabilizedHistory.hlsli" diff --git a/Shaders/Source/REBLUR_DiffuseSpecular_HistoryFix.cs.hlsl b/Shaders/Source/REBLUR_DiffuseSpecular_HistoryFix.cs.hlsl index 00cece2b..030481c2 100644 --- a/Shaders/Source/REBLUR_DiffuseSpecular_HistoryFix.cs.hlsl +++ b/Shaders/Source/REBLUR_DiffuseSpecular_HistoryFix.cs.hlsl @@ -8,15 +8,15 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_DIFFUSE #define REBLUR_SPECULAR -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_HistoryFix.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_HistoryFix.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_HistoryFix.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_HistoryFix.hlsli" diff --git a/Shaders/Source/REBLUR_DiffuseSpecular_HitDistReconstruction.cs.hlsl b/Shaders/Source/REBLUR_DiffuseSpecular_HitDistReconstruction.cs.hlsl index 84959ea7..737d7a9a 100644 --- a/Shaders/Source/REBLUR_DiffuseSpecular_HitDistReconstruction.cs.hlsl +++ b/Shaders/Source/REBLUR_DiffuseSpecular_HitDistReconstruction.cs.hlsl @@ -8,15 +8,15 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_DIFFUSE #define REBLUR_SPECULAR -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_HitDistReconstruction.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_HitDistReconstruction.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_HitDistReconstruction.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_HitDistReconstruction.hlsli" diff --git a/Shaders/Source/REBLUR_DiffuseSpecular_HitDistReconstruction_5x5.cs.hlsl b/Shaders/Source/REBLUR_DiffuseSpecular_HitDistReconstruction_5x5.cs.hlsl index 85c5b7a2..f7b4ae2f 100644 --- a/Shaders/Source/REBLUR_DiffuseSpecular_HitDistReconstruction_5x5.cs.hlsl +++ b/Shaders/Source/REBLUR_DiffuseSpecular_HitDistReconstruction_5x5.cs.hlsl @@ -8,16 +8,16 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_DIFFUSE #define REBLUR_SPECULAR #define REBLUR_HITDIST_RECONSTRUCTION_5X5 -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_HitDistReconstruction.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_HitDistReconstruction.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_HitDistReconstruction.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_HitDistReconstruction.hlsli" diff --git a/Shaders/Source/REBLUR_DiffuseSpecular_PostBlur.cs.hlsl b/Shaders/Source/REBLUR_DiffuseSpecular_PostBlur.cs.hlsl index 6e3958a0..75833218 100644 --- a/Shaders/Source/REBLUR_DiffuseSpecular_PostBlur.cs.hlsl +++ b/Shaders/Source/REBLUR_DiffuseSpecular_PostBlur.cs.hlsl @@ -8,15 +8,15 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_DIFFUSE #define REBLUR_SPECULAR -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" diff --git a/Shaders/Source/REBLUR_DiffuseSpecular_PostBlur_NoTemporalStabilization.cs.hlsl b/Shaders/Source/REBLUR_DiffuseSpecular_PostBlur_NoTemporalStabilization.cs.hlsl index 0711e14c..1b21ada9 100644 --- a/Shaders/Source/REBLUR_DiffuseSpecular_PostBlur_NoTemporalStabilization.cs.hlsl +++ b/Shaders/Source/REBLUR_DiffuseSpecular_PostBlur_NoTemporalStabilization.cs.hlsl @@ -8,16 +8,16 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_DIFFUSE #define REBLUR_SPECULAR #define REBLUR_NO_TEMPORAL_STABILIZATION -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" diff --git a/Shaders/Source/REBLUR_DiffuseSpecular_PrePass.cs.hlsl b/Shaders/Source/REBLUR_DiffuseSpecular_PrePass.cs.hlsl index d3d55890..5cacf675 100644 --- a/Shaders/Source/REBLUR_DiffuseSpecular_PrePass.cs.hlsl +++ b/Shaders/Source/REBLUR_DiffuseSpecular_PrePass.cs.hlsl @@ -8,15 +8,15 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_DIFFUSE #define REBLUR_SPECULAR -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_PrePass.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_PrePass.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_PrePass.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_PrePass.hlsli" diff --git a/Shaders/Source/REBLUR_DiffuseSpecular_SplitScreen.cs.hlsl b/Shaders/Source/REBLUR_DiffuseSpecular_SplitScreen.cs.hlsl index 4dc03cef..f8960973 100644 --- a/Shaders/Source/REBLUR_DiffuseSpecular_SplitScreen.cs.hlsl +++ b/Shaders/Source/REBLUR_DiffuseSpecular_SplitScreen.cs.hlsl @@ -8,15 +8,15 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_DIFFUSE #define REBLUR_SPECULAR -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_SplitScreen.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_SplitScreen.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_SplitScreen.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_SplitScreen.hlsli" diff --git a/Shaders/Source/REBLUR_DiffuseSpecular_TemporalAccumulation.cs.hlsl b/Shaders/Source/REBLUR_DiffuseSpecular_TemporalAccumulation.cs.hlsl index 4a5a115b..6b8a2886 100644 --- a/Shaders/Source/REBLUR_DiffuseSpecular_TemporalAccumulation.cs.hlsl +++ b/Shaders/Source/REBLUR_DiffuseSpecular_TemporalAccumulation.cs.hlsl @@ -8,15 +8,15 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_DIFFUSE #define REBLUR_SPECULAR -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_TemporalAccumulation.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_TemporalAccumulation.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_TemporalAccumulation.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_TemporalAccumulation.hlsli" diff --git a/Shaders/Source/REBLUR_DiffuseSpecular_TemporalStabilization.cs.hlsl b/Shaders/Source/REBLUR_DiffuseSpecular_TemporalStabilization.cs.hlsl index 301aa16c..9064ad58 100644 --- a/Shaders/Source/REBLUR_DiffuseSpecular_TemporalStabilization.cs.hlsl +++ b/Shaders/Source/REBLUR_DiffuseSpecular_TemporalStabilization.cs.hlsl @@ -8,15 +8,15 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_DIFFUSE #define REBLUR_SPECULAR -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_TemporalStabilization.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_TemporalStabilization.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_TemporalStabilization.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_TemporalStabilization.hlsli" diff --git a/Shaders/Source/REBLUR_Diffuse_Blur.cs.hlsl b/Shaders/Source/REBLUR_Diffuse_Blur.cs.hlsl index 8ea2ced9..776a75ec 100644 --- a/Shaders/Source/REBLUR_Diffuse_Blur.cs.hlsl +++ b/Shaders/Source/REBLUR_Diffuse_Blur.cs.hlsl @@ -8,14 +8,14 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_DIFFUSE -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_Blur.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_Blur.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_Blur.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_Blur.hlsli" diff --git a/Shaders/Source/REBLUR_Diffuse_CopyStabilizedHistory.cs.hlsl b/Shaders/Source/REBLUR_Diffuse_CopyStabilizedHistory.cs.hlsl index f09ba428..68bb9e9d 100644 --- a/Shaders/Source/REBLUR_Diffuse_CopyStabilizedHistory.cs.hlsl +++ b/Shaders/Source/REBLUR_Diffuse_CopyStabilizedHistory.cs.hlsl @@ -8,13 +8,13 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_DIFFUSE -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_CopyStabilizedHistory.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_CopyStabilizedHistory.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_CopyStabilizedHistory.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_CopyStabilizedHistory.hlsli" diff --git a/Shaders/Source/REBLUR_Diffuse_HistoryFix.cs.hlsl b/Shaders/Source/REBLUR_Diffuse_HistoryFix.cs.hlsl index 55d4d103..360293e5 100644 --- a/Shaders/Source/REBLUR_Diffuse_HistoryFix.cs.hlsl +++ b/Shaders/Source/REBLUR_Diffuse_HistoryFix.cs.hlsl @@ -8,14 +8,14 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_DIFFUSE -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_HistoryFix.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_HistoryFix.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_HistoryFix.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_HistoryFix.hlsli" diff --git a/Shaders/Source/REBLUR_Diffuse_HitDistReconstruction.cs.hlsl b/Shaders/Source/REBLUR_Diffuse_HitDistReconstruction.cs.hlsl index 876f8943..02561573 100644 --- a/Shaders/Source/REBLUR_Diffuse_HitDistReconstruction.cs.hlsl +++ b/Shaders/Source/REBLUR_Diffuse_HitDistReconstruction.cs.hlsl @@ -8,14 +8,14 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_DIFFUSE -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_HitDistReconstruction.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_HitDistReconstruction.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_HitDistReconstruction.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_HitDistReconstruction.hlsli" diff --git a/Shaders/Source/REBLUR_Diffuse_HitDistReconstruction_5x5.cs.hlsl b/Shaders/Source/REBLUR_Diffuse_HitDistReconstruction_5x5.cs.hlsl index 338d0586..4125b594 100644 --- a/Shaders/Source/REBLUR_Diffuse_HitDistReconstruction_5x5.cs.hlsl +++ b/Shaders/Source/REBLUR_Diffuse_HitDistReconstruction_5x5.cs.hlsl @@ -8,15 +8,15 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_DIFFUSE #define REBLUR_HITDIST_RECONSTRUCTION_5X5 -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_HitDistReconstruction.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_HitDistReconstruction.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_HitDistReconstruction.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_HitDistReconstruction.hlsli" diff --git a/Shaders/Source/REBLUR_Diffuse_PostBlur.cs.hlsl b/Shaders/Source/REBLUR_Diffuse_PostBlur.cs.hlsl index 4b3c119d..ea7469a2 100644 --- a/Shaders/Source/REBLUR_Diffuse_PostBlur.cs.hlsl +++ b/Shaders/Source/REBLUR_Diffuse_PostBlur.cs.hlsl @@ -8,14 +8,14 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_DIFFUSE -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" diff --git a/Shaders/Source/REBLUR_Diffuse_PostBlur_NoTemporalStabilization.cs.hlsl b/Shaders/Source/REBLUR_Diffuse_PostBlur_NoTemporalStabilization.cs.hlsl index 6a639435..490cc2e7 100644 --- a/Shaders/Source/REBLUR_Diffuse_PostBlur_NoTemporalStabilization.cs.hlsl +++ b/Shaders/Source/REBLUR_Diffuse_PostBlur_NoTemporalStabilization.cs.hlsl @@ -8,15 +8,15 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_DIFFUSE #define REBLUR_NO_TEMPORAL_STABILIZATION -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" diff --git a/Shaders/Source/REBLUR_Diffuse_PrePass.cs.hlsl b/Shaders/Source/REBLUR_Diffuse_PrePass.cs.hlsl index eaf00cbc..1fedf35c 100644 --- a/Shaders/Source/REBLUR_Diffuse_PrePass.cs.hlsl +++ b/Shaders/Source/REBLUR_Diffuse_PrePass.cs.hlsl @@ -8,14 +8,14 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_DIFFUSE -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_PrePass.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_PrePass.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_PrePass.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_PrePass.hlsli" diff --git a/Shaders/Source/REBLUR_Diffuse_SplitScreen.cs.hlsl b/Shaders/Source/REBLUR_Diffuse_SplitScreen.cs.hlsl index 3057d9fe..0789a173 100644 --- a/Shaders/Source/REBLUR_Diffuse_SplitScreen.cs.hlsl +++ b/Shaders/Source/REBLUR_Diffuse_SplitScreen.cs.hlsl @@ -8,14 +8,14 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_DIFFUSE -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_SplitScreen.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_SplitScreen.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_SplitScreen.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_SplitScreen.hlsli" diff --git a/Shaders/Source/REBLUR_Diffuse_TemporalAccumulation.cs.hlsl b/Shaders/Source/REBLUR_Diffuse_TemporalAccumulation.cs.hlsl index d8a3635b..e219f4ca 100644 --- a/Shaders/Source/REBLUR_Diffuse_TemporalAccumulation.cs.hlsl +++ b/Shaders/Source/REBLUR_Diffuse_TemporalAccumulation.cs.hlsl @@ -8,14 +8,14 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_DIFFUSE -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_TemporalAccumulation.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_TemporalAccumulation.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_TemporalAccumulation.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_TemporalAccumulation.hlsli" diff --git a/Shaders/Source/REBLUR_Diffuse_TemporalStabilization.cs.hlsl b/Shaders/Source/REBLUR_Diffuse_TemporalStabilization.cs.hlsl index 2b161959..6587fac4 100644 --- a/Shaders/Source/REBLUR_Diffuse_TemporalStabilization.cs.hlsl +++ b/Shaders/Source/REBLUR_Diffuse_TemporalStabilization.cs.hlsl @@ -8,14 +8,14 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_DIFFUSE -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_TemporalStabilization.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_TemporalStabilization.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_TemporalStabilization.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_TemporalStabilization.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_DiffuseDirectionalOcclusion_Blur.cs.hlsl b/Shaders/Source/REBLUR_Perf_DiffuseDirectionalOcclusion_Blur.cs.hlsl index b8f49540..49f2db83 100644 --- a/Shaders/Source/REBLUR_Perf_DiffuseDirectionalOcclusion_Blur.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_DiffuseDirectionalOcclusion_Blur.cs.hlsl @@ -8,16 +8,16 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE #define REBLUR_DIFFUSE #define REBLUR_DIRECTIONAL_OCCLUSION -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_Blur.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_Blur.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_Blur.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_Blur.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_DiffuseDirectionalOcclusion_HistoryFix.cs.hlsl b/Shaders/Source/REBLUR_Perf_DiffuseDirectionalOcclusion_HistoryFix.cs.hlsl index 80d210f0..c838eb6b 100644 --- a/Shaders/Source/REBLUR_Perf_DiffuseDirectionalOcclusion_HistoryFix.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_DiffuseDirectionalOcclusion_HistoryFix.cs.hlsl @@ -8,16 +8,16 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE #define REBLUR_DIFFUSE #define REBLUR_DIRECTIONAL_OCCLUSION -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_HistoryFix.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_HistoryFix.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_HistoryFix.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_HistoryFix.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_DiffuseDirectionalOcclusion_PostBlur.cs.hlsl b/Shaders/Source/REBLUR_Perf_DiffuseDirectionalOcclusion_PostBlur.cs.hlsl index 63e6aff6..74290c21 100644 --- a/Shaders/Source/REBLUR_Perf_DiffuseDirectionalOcclusion_PostBlur.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_DiffuseDirectionalOcclusion_PostBlur.cs.hlsl @@ -8,16 +8,16 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE #define REBLUR_DIFFUSE #define REBLUR_DIRECTIONAL_OCCLUSION -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_DiffuseDirectionalOcclusion_PostBlur_NoTemporalStabilization.cs.hlsl b/Shaders/Source/REBLUR_Perf_DiffuseDirectionalOcclusion_PostBlur_NoTemporalStabilization.cs.hlsl index b18bacbc..78e391af 100644 --- a/Shaders/Source/REBLUR_Perf_DiffuseDirectionalOcclusion_PostBlur_NoTemporalStabilization.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_DiffuseDirectionalOcclusion_PostBlur_NoTemporalStabilization.cs.hlsl @@ -8,7 +8,7 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE @@ -16,9 +16,9 @@ license agreement from NVIDIA CORPORATION is strictly prohibited. #define REBLUR_DIRECTIONAL_OCCLUSION #define REBLUR_NO_TEMPORAL_STABILIZATION -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_DiffuseDirectionalOcclusion_PrePass.cs.hlsl b/Shaders/Source/REBLUR_Perf_DiffuseDirectionalOcclusion_PrePass.cs.hlsl index c9a57f21..366aa610 100644 --- a/Shaders/Source/REBLUR_Perf_DiffuseDirectionalOcclusion_PrePass.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_DiffuseDirectionalOcclusion_PrePass.cs.hlsl @@ -8,16 +8,16 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE #define REBLUR_DIFFUSE #define REBLUR_DIRECTIONAL_OCCLUSION -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_PrePass.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_PrePass.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_PrePass.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_PrePass.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_DiffuseDirectionalOcclusion_TemporalAccumulation.cs.hlsl b/Shaders/Source/REBLUR_Perf_DiffuseDirectionalOcclusion_TemporalAccumulation.cs.hlsl index f0f9250e..1d0a6ac9 100644 --- a/Shaders/Source/REBLUR_Perf_DiffuseDirectionalOcclusion_TemporalAccumulation.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_DiffuseDirectionalOcclusion_TemporalAccumulation.cs.hlsl @@ -8,16 +8,16 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE #define REBLUR_DIFFUSE #define REBLUR_DIRECTIONAL_OCCLUSION -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_TemporalAccumulation.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_TemporalAccumulation.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_TemporalAccumulation.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_TemporalAccumulation.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_DiffuseDirectionalOcclusion_TemporalStabilization.cs.hlsl b/Shaders/Source/REBLUR_Perf_DiffuseDirectionalOcclusion_TemporalStabilization.cs.hlsl index 7b84a31c..4c455a46 100644 --- a/Shaders/Source/REBLUR_Perf_DiffuseDirectionalOcclusion_TemporalStabilization.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_DiffuseDirectionalOcclusion_TemporalStabilization.cs.hlsl @@ -8,16 +8,16 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE #define REBLUR_DIFFUSE #define REBLUR_DIRECTIONAL_OCCLUSION -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_TemporalStabilization.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_TemporalStabilization.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_TemporalStabilization.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_TemporalStabilization.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_DiffuseOcclusion_Blur.cs.hlsl b/Shaders/Source/REBLUR_Perf_DiffuseOcclusion_Blur.cs.hlsl index 3f32cb9e..704bab50 100644 --- a/Shaders/Source/REBLUR_Perf_DiffuseOcclusion_Blur.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_DiffuseOcclusion_Blur.cs.hlsl @@ -8,16 +8,16 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE #define REBLUR_DIFFUSE #define REBLUR_OCCLUSION -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_Blur.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_Blur.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_Blur.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_Blur.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_DiffuseOcclusion_HistoryFix.cs.hlsl b/Shaders/Source/REBLUR_Perf_DiffuseOcclusion_HistoryFix.cs.hlsl index 99da34ba..cc8956b1 100644 --- a/Shaders/Source/REBLUR_Perf_DiffuseOcclusion_HistoryFix.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_DiffuseOcclusion_HistoryFix.cs.hlsl @@ -8,16 +8,16 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE #define REBLUR_DIFFUSE #define REBLUR_OCCLUSION -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_HistoryFix.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_HistoryFix.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_HistoryFix.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_HistoryFix.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_DiffuseOcclusion_HitDistReconstruction.cs.hlsl b/Shaders/Source/REBLUR_Perf_DiffuseOcclusion_HitDistReconstruction.cs.hlsl index aff6ff91..95a6ecb0 100644 --- a/Shaders/Source/REBLUR_Perf_DiffuseOcclusion_HitDistReconstruction.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_DiffuseOcclusion_HitDistReconstruction.cs.hlsl @@ -8,16 +8,16 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE #define REBLUR_DIFFUSE #define REBLUR_OCCLUSION -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_HitDistReconstruction.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_HitDistReconstruction.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_HitDistReconstruction.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_HitDistReconstruction.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_DiffuseOcclusion_HitDistReconstruction_5x5.cs.hlsl b/Shaders/Source/REBLUR_Perf_DiffuseOcclusion_HitDistReconstruction_5x5.cs.hlsl index f035f598..233cddd1 100644 --- a/Shaders/Source/REBLUR_Perf_DiffuseOcclusion_HitDistReconstruction_5x5.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_DiffuseOcclusion_HitDistReconstruction_5x5.cs.hlsl @@ -8,7 +8,7 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE @@ -16,9 +16,9 @@ license agreement from NVIDIA CORPORATION is strictly prohibited. #define REBLUR_OCCLUSION #define REBLUR_HITDIST_RECONSTRUCTION_5X5 -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_HitDistReconstruction.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_HitDistReconstruction.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_HitDistReconstruction.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_HitDistReconstruction.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_DiffuseOcclusion_PostBlur_NoTemporalStabilization.cs.hlsl b/Shaders/Source/REBLUR_Perf_DiffuseOcclusion_PostBlur_NoTemporalStabilization.cs.hlsl index 5727f70c..03914b37 100644 --- a/Shaders/Source/REBLUR_Perf_DiffuseOcclusion_PostBlur_NoTemporalStabilization.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_DiffuseOcclusion_PostBlur_NoTemporalStabilization.cs.hlsl @@ -8,7 +8,7 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE @@ -16,9 +16,9 @@ license agreement from NVIDIA CORPORATION is strictly prohibited. #define REBLUR_OCCLUSION #define REBLUR_NO_TEMPORAL_STABILIZATION -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_DiffuseOcclusion_PrePass.cs.hlsl b/Shaders/Source/REBLUR_Perf_DiffuseOcclusion_PrePass.cs.hlsl index 6bcbb602..e159d662 100644 --- a/Shaders/Source/REBLUR_Perf_DiffuseOcclusion_PrePass.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_DiffuseOcclusion_PrePass.cs.hlsl @@ -8,16 +8,16 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE #define REBLUR_DIFFUSE #define REBLUR_OCCLUSION -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_PrePass.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_PrePass.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_PrePass.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_PrePass.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_DiffuseOcclusion_TemporalAccumulation.cs.hlsl b/Shaders/Source/REBLUR_Perf_DiffuseOcclusion_TemporalAccumulation.cs.hlsl index 5b9b49e4..d6a293b5 100644 --- a/Shaders/Source/REBLUR_Perf_DiffuseOcclusion_TemporalAccumulation.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_DiffuseOcclusion_TemporalAccumulation.cs.hlsl @@ -8,16 +8,16 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE #define REBLUR_DIFFUSE #define REBLUR_OCCLUSION -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_TemporalAccumulation.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_TemporalAccumulation.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_TemporalAccumulation.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_TemporalAccumulation.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_DiffuseSh_Blur.cs.hlsl b/Shaders/Source/REBLUR_Perf_DiffuseSh_Blur.cs.hlsl index bbbb75fd..d0d749e2 100644 --- a/Shaders/Source/REBLUR_Perf_DiffuseSh_Blur.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_DiffuseSh_Blur.cs.hlsl @@ -8,16 +8,16 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE #define REBLUR_DIFFUSE #define REBLUR_SH -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_Blur.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_Blur.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_Blur.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_Blur.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_DiffuseSh_HistoryFix.cs.hlsl b/Shaders/Source/REBLUR_Perf_DiffuseSh_HistoryFix.cs.hlsl index 6338d2bf..ad5febc2 100644 --- a/Shaders/Source/REBLUR_Perf_DiffuseSh_HistoryFix.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_DiffuseSh_HistoryFix.cs.hlsl @@ -8,16 +8,16 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE #define REBLUR_DIFFUSE #define REBLUR_SH -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_HistoryFix.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_HistoryFix.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_HistoryFix.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_HistoryFix.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_DiffuseSh_PostBlur.cs.hlsl b/Shaders/Source/REBLUR_Perf_DiffuseSh_PostBlur.cs.hlsl index 4424e9e2..83777349 100644 --- a/Shaders/Source/REBLUR_Perf_DiffuseSh_PostBlur.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_DiffuseSh_PostBlur.cs.hlsl @@ -8,16 +8,16 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE #define REBLUR_DIFFUSE #define REBLUR_SH -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_DiffuseSh_PostBlur_NoTemporalStabilization.cs.hlsl b/Shaders/Source/REBLUR_Perf_DiffuseSh_PostBlur_NoTemporalStabilization.cs.hlsl index 6f9eb0b9..d75c706a 100644 --- a/Shaders/Source/REBLUR_Perf_DiffuseSh_PostBlur_NoTemporalStabilization.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_DiffuseSh_PostBlur_NoTemporalStabilization.cs.hlsl @@ -8,7 +8,7 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE @@ -16,9 +16,9 @@ license agreement from NVIDIA CORPORATION is strictly prohibited. #define REBLUR_SH #define REBLUR_NO_TEMPORAL_STABILIZATION -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_DiffuseSh_PrePass.cs.hlsl b/Shaders/Source/REBLUR_Perf_DiffuseSh_PrePass.cs.hlsl index 2f4e7c0e..99879266 100644 --- a/Shaders/Source/REBLUR_Perf_DiffuseSh_PrePass.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_DiffuseSh_PrePass.cs.hlsl @@ -8,16 +8,16 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE #define REBLUR_DIFFUSE #define REBLUR_SH -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_PrePass.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_PrePass.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_PrePass.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_PrePass.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_DiffuseSh_TemporalAccumulation.cs.hlsl b/Shaders/Source/REBLUR_Perf_DiffuseSh_TemporalAccumulation.cs.hlsl index 714b496d..89cfa379 100644 --- a/Shaders/Source/REBLUR_Perf_DiffuseSh_TemporalAccumulation.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_DiffuseSh_TemporalAccumulation.cs.hlsl @@ -8,16 +8,16 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE #define REBLUR_DIFFUSE #define REBLUR_SH -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_TemporalAccumulation.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_TemporalAccumulation.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_TemporalAccumulation.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_TemporalAccumulation.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_DiffuseSh_TemporalStabilization.cs.hlsl b/Shaders/Source/REBLUR_Perf_DiffuseSh_TemporalStabilization.cs.hlsl index baeb6b6a..064609d2 100644 --- a/Shaders/Source/REBLUR_Perf_DiffuseSh_TemporalStabilization.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_DiffuseSh_TemporalStabilization.cs.hlsl @@ -8,16 +8,16 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE #define REBLUR_DIFFUSE #define REBLUR_SH -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_TemporalStabilization.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_TemporalStabilization.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_TemporalStabilization.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_TemporalStabilization.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_DiffuseSpecularOcclusion_Blur.cs.hlsl b/Shaders/Source/REBLUR_Perf_DiffuseSpecularOcclusion_Blur.cs.hlsl index 3dd83564..9416f8f8 100644 --- a/Shaders/Source/REBLUR_Perf_DiffuseSpecularOcclusion_Blur.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_DiffuseSpecularOcclusion_Blur.cs.hlsl @@ -8,7 +8,7 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE @@ -16,9 +16,9 @@ license agreement from NVIDIA CORPORATION is strictly prohibited. #define REBLUR_SPECULAR #define REBLUR_OCCLUSION -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_Blur.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_Blur.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_Blur.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_Blur.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_DiffuseSpecularOcclusion_HistoryFix.cs.hlsl b/Shaders/Source/REBLUR_Perf_DiffuseSpecularOcclusion_HistoryFix.cs.hlsl index e7e5e170..932f994b 100644 --- a/Shaders/Source/REBLUR_Perf_DiffuseSpecularOcclusion_HistoryFix.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_DiffuseSpecularOcclusion_HistoryFix.cs.hlsl @@ -8,7 +8,7 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE @@ -16,9 +16,9 @@ license agreement from NVIDIA CORPORATION is strictly prohibited. #define REBLUR_SPECULAR #define REBLUR_OCCLUSION -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_HistoryFix.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_HistoryFix.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_HistoryFix.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_HistoryFix.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_DiffuseSpecularOcclusion_HitDistReconstruction.cs.hlsl b/Shaders/Source/REBLUR_Perf_DiffuseSpecularOcclusion_HitDistReconstruction.cs.hlsl index 3c08f763..01094d41 100644 --- a/Shaders/Source/REBLUR_Perf_DiffuseSpecularOcclusion_HitDistReconstruction.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_DiffuseSpecularOcclusion_HitDistReconstruction.cs.hlsl @@ -8,7 +8,7 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE @@ -16,9 +16,9 @@ license agreement from NVIDIA CORPORATION is strictly prohibited. #define REBLUR_SPECULAR #define REBLUR_OCCLUSION -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_HitDistReconstruction.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_HitDistReconstruction.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_HitDistReconstruction.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_HitDistReconstruction.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_DiffuseSpecularOcclusion_HitDistReconstruction_5x5.cs.hlsl b/Shaders/Source/REBLUR_Perf_DiffuseSpecularOcclusion_HitDistReconstruction_5x5.cs.hlsl index 490d6fca..c17b1338 100644 --- a/Shaders/Source/REBLUR_Perf_DiffuseSpecularOcclusion_HitDistReconstruction_5x5.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_DiffuseSpecularOcclusion_HitDistReconstruction_5x5.cs.hlsl @@ -8,7 +8,7 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE @@ -17,9 +17,9 @@ license agreement from NVIDIA CORPORATION is strictly prohibited. #define REBLUR_OCCLUSION #define REBLUR_HITDIST_RECONSTRUCTION_5X5 -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_HitDistReconstruction.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_HitDistReconstruction.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_HitDistReconstruction.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_HitDistReconstruction.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_DiffuseSpecularOcclusion_PostBlur_NoTemporalStabilization.cs.hlsl b/Shaders/Source/REBLUR_Perf_DiffuseSpecularOcclusion_PostBlur_NoTemporalStabilization.cs.hlsl index 92d8e6c6..b3b91a43 100644 --- a/Shaders/Source/REBLUR_Perf_DiffuseSpecularOcclusion_PostBlur_NoTemporalStabilization.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_DiffuseSpecularOcclusion_PostBlur_NoTemporalStabilization.cs.hlsl @@ -8,7 +8,7 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE @@ -17,9 +17,9 @@ license agreement from NVIDIA CORPORATION is strictly prohibited. #define REBLUR_OCCLUSION #define REBLUR_NO_TEMPORAL_STABILIZATION -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_DiffuseSpecularOcclusion_PrePass.cs.hlsl b/Shaders/Source/REBLUR_Perf_DiffuseSpecularOcclusion_PrePass.cs.hlsl index 29898146..73701889 100644 --- a/Shaders/Source/REBLUR_Perf_DiffuseSpecularOcclusion_PrePass.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_DiffuseSpecularOcclusion_PrePass.cs.hlsl @@ -8,7 +8,7 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE @@ -16,9 +16,9 @@ license agreement from NVIDIA CORPORATION is strictly prohibited. #define REBLUR_SPECULAR #define REBLUR_OCCLUSION -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_PrePass.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_PrePass.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_PrePass.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_PrePass.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_DiffuseSpecularOcclusion_TemporalAccumulation.cs.hlsl b/Shaders/Source/REBLUR_Perf_DiffuseSpecularOcclusion_TemporalAccumulation.cs.hlsl index 9c2791d0..6b244466 100644 --- a/Shaders/Source/REBLUR_Perf_DiffuseSpecularOcclusion_TemporalAccumulation.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_DiffuseSpecularOcclusion_TemporalAccumulation.cs.hlsl @@ -8,7 +8,7 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE @@ -16,9 +16,9 @@ license agreement from NVIDIA CORPORATION is strictly prohibited. #define REBLUR_SPECULAR #define REBLUR_OCCLUSION -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_TemporalAccumulation.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_TemporalAccumulation.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_TemporalAccumulation.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_TemporalAccumulation.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_DiffuseSpecularSh_Blur.cs.hlsl b/Shaders/Source/REBLUR_Perf_DiffuseSpecularSh_Blur.cs.hlsl index 51996667..3f22802e 100644 --- a/Shaders/Source/REBLUR_Perf_DiffuseSpecularSh_Blur.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_DiffuseSpecularSh_Blur.cs.hlsl @@ -8,7 +8,7 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE @@ -16,9 +16,9 @@ license agreement from NVIDIA CORPORATION is strictly prohibited. #define REBLUR_SPECULAR #define REBLUR_SH -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_Blur.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_Blur.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_Blur.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_Blur.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_DiffuseSpecularSh_HistoryFix.cs.hlsl b/Shaders/Source/REBLUR_Perf_DiffuseSpecularSh_HistoryFix.cs.hlsl index 87ece34a..8d6129c4 100644 --- a/Shaders/Source/REBLUR_Perf_DiffuseSpecularSh_HistoryFix.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_DiffuseSpecularSh_HistoryFix.cs.hlsl @@ -8,7 +8,7 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE @@ -16,9 +16,9 @@ license agreement from NVIDIA CORPORATION is strictly prohibited. #define REBLUR_SPECULAR #define REBLUR_SH -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_HistoryFix.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_HistoryFix.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_HistoryFix.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_HistoryFix.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_DiffuseSpecularSh_PostBlur.cs.hlsl b/Shaders/Source/REBLUR_Perf_DiffuseSpecularSh_PostBlur.cs.hlsl index a8c9b84b..b44538ce 100644 --- a/Shaders/Source/REBLUR_Perf_DiffuseSpecularSh_PostBlur.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_DiffuseSpecularSh_PostBlur.cs.hlsl @@ -8,7 +8,7 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE @@ -16,9 +16,9 @@ license agreement from NVIDIA CORPORATION is strictly prohibited. #define REBLUR_SPECULAR #define REBLUR_SH -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_DiffuseSpecularSh_PostBlur_NoTemporalStabilization.cs.hlsl b/Shaders/Source/REBLUR_Perf_DiffuseSpecularSh_PostBlur_NoTemporalStabilization.cs.hlsl index ccac06ae..077ec6ee 100644 --- a/Shaders/Source/REBLUR_Perf_DiffuseSpecularSh_PostBlur_NoTemporalStabilization.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_DiffuseSpecularSh_PostBlur_NoTemporalStabilization.cs.hlsl @@ -8,7 +8,7 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE @@ -17,9 +17,9 @@ license agreement from NVIDIA CORPORATION is strictly prohibited. #define REBLUR_SH #define REBLUR_NO_TEMPORAL_STABILIZATION -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_DiffuseSpecularSh_PrePass.cs.hlsl b/Shaders/Source/REBLUR_Perf_DiffuseSpecularSh_PrePass.cs.hlsl index 52c10985..23dbe0bd 100644 --- a/Shaders/Source/REBLUR_Perf_DiffuseSpecularSh_PrePass.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_DiffuseSpecularSh_PrePass.cs.hlsl @@ -8,7 +8,7 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE @@ -16,9 +16,9 @@ license agreement from NVIDIA CORPORATION is strictly prohibited. #define REBLUR_SPECULAR #define REBLUR_SH -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_PrePass.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_PrePass.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_PrePass.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_PrePass.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_DiffuseSpecularSh_TemporalAccumulation.cs.hlsl b/Shaders/Source/REBLUR_Perf_DiffuseSpecularSh_TemporalAccumulation.cs.hlsl index 9cedf4b1..65ef5ef2 100644 --- a/Shaders/Source/REBLUR_Perf_DiffuseSpecularSh_TemporalAccumulation.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_DiffuseSpecularSh_TemporalAccumulation.cs.hlsl @@ -8,7 +8,7 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE @@ -16,9 +16,9 @@ license agreement from NVIDIA CORPORATION is strictly prohibited. #define REBLUR_SPECULAR #define REBLUR_SH -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_TemporalAccumulation.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_TemporalAccumulation.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_TemporalAccumulation.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_TemporalAccumulation.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_DiffuseSpecularSh_TemporalStabilization.cs.hlsl b/Shaders/Source/REBLUR_Perf_DiffuseSpecularSh_TemporalStabilization.cs.hlsl index b9e767f9..431b9b4b 100644 --- a/Shaders/Source/REBLUR_Perf_DiffuseSpecularSh_TemporalStabilization.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_DiffuseSpecularSh_TemporalStabilization.cs.hlsl @@ -8,7 +8,7 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE @@ -16,9 +16,9 @@ license agreement from NVIDIA CORPORATION is strictly prohibited. #define REBLUR_SPECULAR #define REBLUR_SH -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_TemporalStabilization.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_TemporalStabilization.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_TemporalStabilization.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_TemporalStabilization.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_DiffuseSpecular_Blur.cs.hlsl b/Shaders/Source/REBLUR_Perf_DiffuseSpecular_Blur.cs.hlsl index a6bacfea..d01786ba 100644 --- a/Shaders/Source/REBLUR_Perf_DiffuseSpecular_Blur.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_DiffuseSpecular_Blur.cs.hlsl @@ -8,16 +8,16 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE #define REBLUR_DIFFUSE #define REBLUR_SPECULAR -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_Blur.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_Blur.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_Blur.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_Blur.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_DiffuseSpecular_HistoryFix.cs.hlsl b/Shaders/Source/REBLUR_Perf_DiffuseSpecular_HistoryFix.cs.hlsl index c7891820..fe627962 100644 --- a/Shaders/Source/REBLUR_Perf_DiffuseSpecular_HistoryFix.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_DiffuseSpecular_HistoryFix.cs.hlsl @@ -8,16 +8,16 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE #define REBLUR_DIFFUSE #define REBLUR_SPECULAR -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_HistoryFix.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_HistoryFix.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_HistoryFix.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_HistoryFix.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_DiffuseSpecular_HitDistReconstruction.cs.hlsl b/Shaders/Source/REBLUR_Perf_DiffuseSpecular_HitDistReconstruction.cs.hlsl index 300c9147..155e3459 100644 --- a/Shaders/Source/REBLUR_Perf_DiffuseSpecular_HitDistReconstruction.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_DiffuseSpecular_HitDistReconstruction.cs.hlsl @@ -8,16 +8,16 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE #define REBLUR_DIFFUSE #define REBLUR_SPECULAR -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_HitDistReconstruction.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_HitDistReconstruction.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_HitDistReconstruction.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_HitDistReconstruction.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_DiffuseSpecular_HitDistReconstruction_5x5.cs.hlsl b/Shaders/Source/REBLUR_Perf_DiffuseSpecular_HitDistReconstruction_5x5.cs.hlsl index 45d554f3..d5b86dd9 100644 --- a/Shaders/Source/REBLUR_Perf_DiffuseSpecular_HitDistReconstruction_5x5.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_DiffuseSpecular_HitDistReconstruction_5x5.cs.hlsl @@ -8,7 +8,7 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE @@ -16,9 +16,9 @@ license agreement from NVIDIA CORPORATION is strictly prohibited. #define REBLUR_SPECULAR #define REBLUR_HITDIST_RECONSTRUCTION_5X5 -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_HitDistReconstruction.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_HitDistReconstruction.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_HitDistReconstruction.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_HitDistReconstruction.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_DiffuseSpecular_PostBlur.cs.hlsl b/Shaders/Source/REBLUR_Perf_DiffuseSpecular_PostBlur.cs.hlsl index b1b2ff27..c80fd6c1 100644 --- a/Shaders/Source/REBLUR_Perf_DiffuseSpecular_PostBlur.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_DiffuseSpecular_PostBlur.cs.hlsl @@ -8,16 +8,16 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE #define REBLUR_DIFFUSE #define REBLUR_SPECULAR -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_DiffuseSpecular_PostBlur_NoTemporalStabilization.cs.hlsl b/Shaders/Source/REBLUR_Perf_DiffuseSpecular_PostBlur_NoTemporalStabilization.cs.hlsl index 1efda52d..325a3adf 100644 --- a/Shaders/Source/REBLUR_Perf_DiffuseSpecular_PostBlur_NoTemporalStabilization.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_DiffuseSpecular_PostBlur_NoTemporalStabilization.cs.hlsl @@ -8,7 +8,7 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE @@ -16,9 +16,9 @@ license agreement from NVIDIA CORPORATION is strictly prohibited. #define REBLUR_SPECULAR #define REBLUR_NO_TEMPORAL_STABILIZATION -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_DiffuseSpecular_PrePass.cs.hlsl b/Shaders/Source/REBLUR_Perf_DiffuseSpecular_PrePass.cs.hlsl index 71e64a11..cef069ac 100644 --- a/Shaders/Source/REBLUR_Perf_DiffuseSpecular_PrePass.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_DiffuseSpecular_PrePass.cs.hlsl @@ -8,16 +8,16 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE #define REBLUR_DIFFUSE #define REBLUR_SPECULAR -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_PrePass.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_PrePass.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_PrePass.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_PrePass.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_DiffuseSpecular_TemporalAccumulation.cs.hlsl b/Shaders/Source/REBLUR_Perf_DiffuseSpecular_TemporalAccumulation.cs.hlsl index 95247a47..9ff24956 100644 --- a/Shaders/Source/REBLUR_Perf_DiffuseSpecular_TemporalAccumulation.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_DiffuseSpecular_TemporalAccumulation.cs.hlsl @@ -8,16 +8,16 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE #define REBLUR_DIFFUSE #define REBLUR_SPECULAR -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_TemporalAccumulation.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_TemporalAccumulation.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_TemporalAccumulation.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_TemporalAccumulation.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_DiffuseSpecular_TemporalStabilization.cs.hlsl b/Shaders/Source/REBLUR_Perf_DiffuseSpecular_TemporalStabilization.cs.hlsl index 2f293716..8c79ddb8 100644 --- a/Shaders/Source/REBLUR_Perf_DiffuseSpecular_TemporalStabilization.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_DiffuseSpecular_TemporalStabilization.cs.hlsl @@ -8,16 +8,16 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE #define REBLUR_DIFFUSE #define REBLUR_SPECULAR -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_TemporalStabilization.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_TemporalStabilization.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_TemporalStabilization.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_TemporalStabilization.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_Diffuse_Blur.cs.hlsl b/Shaders/Source/REBLUR_Perf_Diffuse_Blur.cs.hlsl index 166987bc..4f2d75a0 100644 --- a/Shaders/Source/REBLUR_Perf_Diffuse_Blur.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_Diffuse_Blur.cs.hlsl @@ -8,15 +8,15 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE #define REBLUR_DIFFUSE -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_Blur.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_Blur.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_Blur.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_Blur.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_Diffuse_HistoryFix.cs.hlsl b/Shaders/Source/REBLUR_Perf_Diffuse_HistoryFix.cs.hlsl index 1059ea77..6cd5e4d1 100644 --- a/Shaders/Source/REBLUR_Perf_Diffuse_HistoryFix.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_Diffuse_HistoryFix.cs.hlsl @@ -8,15 +8,15 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE #define REBLUR_DIFFUSE -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_HistoryFix.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_HistoryFix.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_HistoryFix.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_HistoryFix.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_Diffuse_HitDistReconstruction.cs.hlsl b/Shaders/Source/REBLUR_Perf_Diffuse_HitDistReconstruction.cs.hlsl index b76be61c..ee3e1a88 100644 --- a/Shaders/Source/REBLUR_Perf_Diffuse_HitDistReconstruction.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_Diffuse_HitDistReconstruction.cs.hlsl @@ -8,15 +8,15 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE #define REBLUR_DIFFUSE -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_HitDistReconstruction.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_HitDistReconstruction.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_HitDistReconstruction.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_HitDistReconstruction.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_Diffuse_HitDistReconstruction_5x5.cs.hlsl b/Shaders/Source/REBLUR_Perf_Diffuse_HitDistReconstruction_5x5.cs.hlsl index d5bb196c..e09ffc9d 100644 --- a/Shaders/Source/REBLUR_Perf_Diffuse_HitDistReconstruction_5x5.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_Diffuse_HitDistReconstruction_5x5.cs.hlsl @@ -8,16 +8,16 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE #define REBLUR_DIFFUSE #define REBLUR_HITDIST_RECONSTRUCTION_5X5 -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_HitDistReconstruction.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_HitDistReconstruction.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_HitDistReconstruction.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_HitDistReconstruction.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_Diffuse_PostBlur.cs.hlsl b/Shaders/Source/REBLUR_Perf_Diffuse_PostBlur.cs.hlsl index 69b8034c..7f305c05 100644 --- a/Shaders/Source/REBLUR_Perf_Diffuse_PostBlur.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_Diffuse_PostBlur.cs.hlsl @@ -8,15 +8,15 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE #define REBLUR_DIFFUSE -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_Diffuse_PostBlur_NoTemporalStabilization.cs.hlsl b/Shaders/Source/REBLUR_Perf_Diffuse_PostBlur_NoTemporalStabilization.cs.hlsl index f9d5e8ca..b9c1c90e 100644 --- a/Shaders/Source/REBLUR_Perf_Diffuse_PostBlur_NoTemporalStabilization.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_Diffuse_PostBlur_NoTemporalStabilization.cs.hlsl @@ -8,16 +8,16 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE #define REBLUR_DIFFUSE #define REBLUR_NO_TEMPORAL_STABILIZATION -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_Diffuse_PrePass.cs.hlsl b/Shaders/Source/REBLUR_Perf_Diffuse_PrePass.cs.hlsl index ab26e2a3..c1f6db8e 100644 --- a/Shaders/Source/REBLUR_Perf_Diffuse_PrePass.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_Diffuse_PrePass.cs.hlsl @@ -8,15 +8,15 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE #define REBLUR_DIFFUSE -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_PrePass.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_PrePass.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_PrePass.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_PrePass.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_Diffuse_TemporalAccumulation.cs.hlsl b/Shaders/Source/REBLUR_Perf_Diffuse_TemporalAccumulation.cs.hlsl index 82c24c12..43b13480 100644 --- a/Shaders/Source/REBLUR_Perf_Diffuse_TemporalAccumulation.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_Diffuse_TemporalAccumulation.cs.hlsl @@ -8,15 +8,15 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE #define REBLUR_DIFFUSE -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_TemporalAccumulation.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_TemporalAccumulation.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_TemporalAccumulation.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_TemporalAccumulation.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_Diffuse_TemporalStabilization.cs.hlsl b/Shaders/Source/REBLUR_Perf_Diffuse_TemporalStabilization.cs.hlsl index e9e27846..bd8f1faf 100644 --- a/Shaders/Source/REBLUR_Perf_Diffuse_TemporalStabilization.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_Diffuse_TemporalStabilization.cs.hlsl @@ -8,15 +8,15 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE #define REBLUR_DIFFUSE -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_TemporalStabilization.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_TemporalStabilization.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_TemporalStabilization.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_TemporalStabilization.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_SpecularOcclusion_Blur.cs.hlsl b/Shaders/Source/REBLUR_Perf_SpecularOcclusion_Blur.cs.hlsl index 8f908148..e1d459b4 100644 --- a/Shaders/Source/REBLUR_Perf_SpecularOcclusion_Blur.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_SpecularOcclusion_Blur.cs.hlsl @@ -8,16 +8,16 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE #define REBLUR_SPECULAR #define REBLUR_OCCLUSION -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_Blur.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_Blur.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_Blur.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_Blur.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_SpecularOcclusion_HistoryFix.cs.hlsl b/Shaders/Source/REBLUR_Perf_SpecularOcclusion_HistoryFix.cs.hlsl index 0b768223..cfb7f6f6 100644 --- a/Shaders/Source/REBLUR_Perf_SpecularOcclusion_HistoryFix.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_SpecularOcclusion_HistoryFix.cs.hlsl @@ -8,16 +8,16 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE #define REBLUR_SPECULAR #define REBLUR_OCCLUSION -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_HistoryFix.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_HistoryFix.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_HistoryFix.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_HistoryFix.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_SpecularOcclusion_HitDistReconstruction.cs.hlsl b/Shaders/Source/REBLUR_Perf_SpecularOcclusion_HitDistReconstruction.cs.hlsl index 9a1655c7..3624e214 100644 --- a/Shaders/Source/REBLUR_Perf_SpecularOcclusion_HitDistReconstruction.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_SpecularOcclusion_HitDistReconstruction.cs.hlsl @@ -8,16 +8,16 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE #define REBLUR_SPECULAR #define REBLUR_OCCLUSION -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_HitDistReconstruction.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_HitDistReconstruction.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_HitDistReconstruction.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_HitDistReconstruction.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_SpecularOcclusion_HitDistReconstruction_5x5.cs.hlsl b/Shaders/Source/REBLUR_Perf_SpecularOcclusion_HitDistReconstruction_5x5.cs.hlsl index 6c406f70..71637350 100644 --- a/Shaders/Source/REBLUR_Perf_SpecularOcclusion_HitDistReconstruction_5x5.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_SpecularOcclusion_HitDistReconstruction_5x5.cs.hlsl @@ -8,7 +8,7 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE @@ -16,9 +16,9 @@ license agreement from NVIDIA CORPORATION is strictly prohibited. #define REBLUR_OCCLUSION #define REBLUR_HITDIST_RECONSTRUCTION_5X5 -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_HitDistReconstruction.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_HitDistReconstruction.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_HitDistReconstruction.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_HitDistReconstruction.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_SpecularOcclusion_PostBlur_NoTemporalStabilization.cs.hlsl b/Shaders/Source/REBLUR_Perf_SpecularOcclusion_PostBlur_NoTemporalStabilization.cs.hlsl index 47932325..fb3440e7 100644 --- a/Shaders/Source/REBLUR_Perf_SpecularOcclusion_PostBlur_NoTemporalStabilization.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_SpecularOcclusion_PostBlur_NoTemporalStabilization.cs.hlsl @@ -8,7 +8,7 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE @@ -16,9 +16,9 @@ license agreement from NVIDIA CORPORATION is strictly prohibited. #define REBLUR_OCCLUSION #define REBLUR_NO_TEMPORAL_STABILIZATION -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_SpecularOcclusion_PrePass.cs.hlsl b/Shaders/Source/REBLUR_Perf_SpecularOcclusion_PrePass.cs.hlsl index d18d17ac..84c9c278 100644 --- a/Shaders/Source/REBLUR_Perf_SpecularOcclusion_PrePass.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_SpecularOcclusion_PrePass.cs.hlsl @@ -8,16 +8,16 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE #define REBLUR_SPECULAR #define REBLUR_OCCLUSION -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_PrePass.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_PrePass.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_PrePass.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_PrePass.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_SpecularOcclusion_TemporalAccumulation.cs.hlsl b/Shaders/Source/REBLUR_Perf_SpecularOcclusion_TemporalAccumulation.cs.hlsl index 9c0ea7af..23756b30 100644 --- a/Shaders/Source/REBLUR_Perf_SpecularOcclusion_TemporalAccumulation.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_SpecularOcclusion_TemporalAccumulation.cs.hlsl @@ -8,16 +8,16 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE #define REBLUR_SPECULAR #define REBLUR_OCCLUSION -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_TemporalAccumulation.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_TemporalAccumulation.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_TemporalAccumulation.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_TemporalAccumulation.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_SpecularSh_Blur.cs.hlsl b/Shaders/Source/REBLUR_Perf_SpecularSh_Blur.cs.hlsl index 556561ca..4e9f2d04 100644 --- a/Shaders/Source/REBLUR_Perf_SpecularSh_Blur.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_SpecularSh_Blur.cs.hlsl @@ -8,16 +8,16 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE #define REBLUR_SPECULAR #define REBLUR_SH -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_Blur.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_Blur.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_Blur.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_Blur.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_SpecularSh_HistoryFix.cs.hlsl b/Shaders/Source/REBLUR_Perf_SpecularSh_HistoryFix.cs.hlsl index 465fe929..999900c4 100644 --- a/Shaders/Source/REBLUR_Perf_SpecularSh_HistoryFix.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_SpecularSh_HistoryFix.cs.hlsl @@ -8,16 +8,16 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE #define REBLUR_SPECULAR #define REBLUR_SH -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_HistoryFix.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_HistoryFix.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_HistoryFix.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_HistoryFix.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_SpecularSh_PostBlur.cs.hlsl b/Shaders/Source/REBLUR_Perf_SpecularSh_PostBlur.cs.hlsl index 368de98c..5ddde9f0 100644 --- a/Shaders/Source/REBLUR_Perf_SpecularSh_PostBlur.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_SpecularSh_PostBlur.cs.hlsl @@ -8,16 +8,16 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE #define REBLUR_SPECULAR #define REBLUR_SH -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_SpecularSh_PostBlur_NoTemporalStabilization.cs.hlsl b/Shaders/Source/REBLUR_Perf_SpecularSh_PostBlur_NoTemporalStabilization.cs.hlsl index 9536f648..9fe57944 100644 --- a/Shaders/Source/REBLUR_Perf_SpecularSh_PostBlur_NoTemporalStabilization.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_SpecularSh_PostBlur_NoTemporalStabilization.cs.hlsl @@ -8,7 +8,7 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE @@ -16,9 +16,9 @@ license agreement from NVIDIA CORPORATION is strictly prohibited. #define REBLUR_SH #define REBLUR_NO_TEMPORAL_STABILIZATION -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_SpecularSh_PrePass.cs.hlsl b/Shaders/Source/REBLUR_Perf_SpecularSh_PrePass.cs.hlsl index 724912a3..d89b7d27 100644 --- a/Shaders/Source/REBLUR_Perf_SpecularSh_PrePass.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_SpecularSh_PrePass.cs.hlsl @@ -8,16 +8,16 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE #define REBLUR_SPECULAR #define REBLUR_SH -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_PrePass.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_PrePass.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_PrePass.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_PrePass.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_SpecularSh_TemporalAccumulation.cs.hlsl b/Shaders/Source/REBLUR_Perf_SpecularSh_TemporalAccumulation.cs.hlsl index 6ea1f049..03dd63ad 100644 --- a/Shaders/Source/REBLUR_Perf_SpecularSh_TemporalAccumulation.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_SpecularSh_TemporalAccumulation.cs.hlsl @@ -8,16 +8,16 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE #define REBLUR_SPECULAR #define REBLUR_SH -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_TemporalAccumulation.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_TemporalAccumulation.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_TemporalAccumulation.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_TemporalAccumulation.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_SpecularSh_TemporalStabilization.cs.hlsl b/Shaders/Source/REBLUR_Perf_SpecularSh_TemporalStabilization.cs.hlsl index 5aa306c6..9c88f328 100644 --- a/Shaders/Source/REBLUR_Perf_SpecularSh_TemporalStabilization.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_SpecularSh_TemporalStabilization.cs.hlsl @@ -8,16 +8,16 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE #define REBLUR_SPECULAR #define REBLUR_SH -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_TemporalStabilization.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_TemporalStabilization.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_TemporalStabilization.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_TemporalStabilization.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_Specular_Blur.cs.hlsl b/Shaders/Source/REBLUR_Perf_Specular_Blur.cs.hlsl index 9aea87a2..68c36830 100644 --- a/Shaders/Source/REBLUR_Perf_Specular_Blur.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_Specular_Blur.cs.hlsl @@ -8,15 +8,15 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE #define REBLUR_SPECULAR -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_Blur.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_Blur.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_Blur.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_Blur.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_Specular_HistoryFix.cs.hlsl b/Shaders/Source/REBLUR_Perf_Specular_HistoryFix.cs.hlsl index 90da1711..9c6bae67 100644 --- a/Shaders/Source/REBLUR_Perf_Specular_HistoryFix.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_Specular_HistoryFix.cs.hlsl @@ -8,15 +8,15 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE #define REBLUR_SPECULAR -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_HistoryFix.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_HistoryFix.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_HistoryFix.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_HistoryFix.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_Specular_HitDistReconstruction.cs.hlsl b/Shaders/Source/REBLUR_Perf_Specular_HitDistReconstruction.cs.hlsl index 25ba1d95..7060aca8 100644 --- a/Shaders/Source/REBLUR_Perf_Specular_HitDistReconstruction.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_Specular_HitDistReconstruction.cs.hlsl @@ -8,15 +8,15 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE #define REBLUR_SPECULAR -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_HitDistReconstruction.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_HitDistReconstruction.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_HitDistReconstruction.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_HitDistReconstruction.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_Specular_HitDistReconstruction_5x5.cs.hlsl b/Shaders/Source/REBLUR_Perf_Specular_HitDistReconstruction_5x5.cs.hlsl index 0efb5233..ac8cd3fa 100644 --- a/Shaders/Source/REBLUR_Perf_Specular_HitDistReconstruction_5x5.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_Specular_HitDistReconstruction_5x5.cs.hlsl @@ -8,16 +8,16 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE #define REBLUR_SPECULAR #define REBLUR_HITDIST_RECONSTRUCTION_5X5 -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_HitDistReconstruction.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_HitDistReconstruction.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_HitDistReconstruction.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_HitDistReconstruction.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_Specular_PostBlur.cs.hlsl b/Shaders/Source/REBLUR_Perf_Specular_PostBlur.cs.hlsl index ce1aef0b..79a6cfe4 100644 --- a/Shaders/Source/REBLUR_Perf_Specular_PostBlur.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_Specular_PostBlur.cs.hlsl @@ -8,15 +8,15 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE #define REBLUR_SPECULAR -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_Specular_PostBlur_NoTemporalStabilization.cs.hlsl b/Shaders/Source/REBLUR_Perf_Specular_PostBlur_NoTemporalStabilization.cs.hlsl index 3fb48b05..5820e03e 100644 --- a/Shaders/Source/REBLUR_Perf_Specular_PostBlur_NoTemporalStabilization.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_Specular_PostBlur_NoTemporalStabilization.cs.hlsl @@ -8,16 +8,16 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE #define REBLUR_SPECULAR #define REBLUR_NO_TEMPORAL_STABILIZATION -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_Specular_PrePass.cs.hlsl b/Shaders/Source/REBLUR_Perf_Specular_PrePass.cs.hlsl index fa092380..0ca42d6b 100644 --- a/Shaders/Source/REBLUR_Perf_Specular_PrePass.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_Specular_PrePass.cs.hlsl @@ -8,15 +8,15 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE #define REBLUR_SPECULAR -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_PrePass.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_PrePass.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_PrePass.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_PrePass.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_Specular_TemporalAccumulation.cs.hlsl b/Shaders/Source/REBLUR_Perf_Specular_TemporalAccumulation.cs.hlsl index b115b015..f5af8f3e 100644 --- a/Shaders/Source/REBLUR_Perf_Specular_TemporalAccumulation.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_Specular_TemporalAccumulation.cs.hlsl @@ -8,15 +8,15 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE #define REBLUR_SPECULAR -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_TemporalAccumulation.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_TemporalAccumulation.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_TemporalAccumulation.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_TemporalAccumulation.hlsli" diff --git a/Shaders/Source/REBLUR_Perf_Specular_TemporalStabilization.cs.hlsl b/Shaders/Source/REBLUR_Perf_Specular_TemporalStabilization.cs.hlsl index 05951e05..f546dae7 100644 --- a/Shaders/Source/REBLUR_Perf_Specular_TemporalStabilization.cs.hlsl +++ b/Shaders/Source/REBLUR_Perf_Specular_TemporalStabilization.cs.hlsl @@ -8,15 +8,15 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_PERFORMANCE_MODE #define REBLUR_SPECULAR -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_TemporalStabilization.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_TemporalStabilization.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_TemporalStabilization.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_TemporalStabilization.hlsli" diff --git a/Shaders/Source/REBLUR_SpecularOcclusion_Blur.cs.hlsl b/Shaders/Source/REBLUR_SpecularOcclusion_Blur.cs.hlsl index b34f2c3f..33854b53 100644 --- a/Shaders/Source/REBLUR_SpecularOcclusion_Blur.cs.hlsl +++ b/Shaders/Source/REBLUR_SpecularOcclusion_Blur.cs.hlsl @@ -8,15 +8,15 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_SPECULAR #define REBLUR_OCCLUSION -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_Blur.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_Blur.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_Blur.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_Blur.hlsli" diff --git a/Shaders/Source/REBLUR_SpecularOcclusion_HistoryFix.cs.hlsl b/Shaders/Source/REBLUR_SpecularOcclusion_HistoryFix.cs.hlsl index a80684f0..e2899f75 100644 --- a/Shaders/Source/REBLUR_SpecularOcclusion_HistoryFix.cs.hlsl +++ b/Shaders/Source/REBLUR_SpecularOcclusion_HistoryFix.cs.hlsl @@ -8,15 +8,15 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_SPECULAR #define REBLUR_OCCLUSION -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_HistoryFix.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_HistoryFix.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_HistoryFix.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_HistoryFix.hlsli" diff --git a/Shaders/Source/REBLUR_SpecularOcclusion_HitDistReconstruction.cs.hlsl b/Shaders/Source/REBLUR_SpecularOcclusion_HitDistReconstruction.cs.hlsl index d52d0efe..03aad448 100644 --- a/Shaders/Source/REBLUR_SpecularOcclusion_HitDistReconstruction.cs.hlsl +++ b/Shaders/Source/REBLUR_SpecularOcclusion_HitDistReconstruction.cs.hlsl @@ -8,15 +8,15 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_SPECULAR #define REBLUR_OCCLUSION -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_HitDistReconstruction.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_HitDistReconstruction.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_HitDistReconstruction.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_HitDistReconstruction.hlsli" diff --git a/Shaders/Source/REBLUR_SpecularOcclusion_HitDistReconstruction_5x5.cs.hlsl b/Shaders/Source/REBLUR_SpecularOcclusion_HitDistReconstruction_5x5.cs.hlsl index 5a4a2d67..5543acc0 100644 --- a/Shaders/Source/REBLUR_SpecularOcclusion_HitDistReconstruction_5x5.cs.hlsl +++ b/Shaders/Source/REBLUR_SpecularOcclusion_HitDistReconstruction_5x5.cs.hlsl @@ -8,16 +8,16 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_SPECULAR #define REBLUR_OCCLUSION #define REBLUR_HITDIST_RECONSTRUCTION_5X5 -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_HitDistReconstruction.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_HitDistReconstruction.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_HitDistReconstruction.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_HitDistReconstruction.hlsli" diff --git a/Shaders/Source/REBLUR_SpecularOcclusion_PostBlur_NoTemporalStabilization.cs.hlsl b/Shaders/Source/REBLUR_SpecularOcclusion_PostBlur_NoTemporalStabilization.cs.hlsl index 4582bdc0..28561217 100644 --- a/Shaders/Source/REBLUR_SpecularOcclusion_PostBlur_NoTemporalStabilization.cs.hlsl +++ b/Shaders/Source/REBLUR_SpecularOcclusion_PostBlur_NoTemporalStabilization.cs.hlsl @@ -8,16 +8,16 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_SPECULAR #define REBLUR_OCCLUSION #define REBLUR_NO_TEMPORAL_STABILIZATION -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" diff --git a/Shaders/Source/REBLUR_SpecularOcclusion_PrePass.cs.hlsl b/Shaders/Source/REBLUR_SpecularOcclusion_PrePass.cs.hlsl index d8d2aee6..614c1fe1 100644 --- a/Shaders/Source/REBLUR_SpecularOcclusion_PrePass.cs.hlsl +++ b/Shaders/Source/REBLUR_SpecularOcclusion_PrePass.cs.hlsl @@ -8,15 +8,15 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_SPECULAR #define REBLUR_OCCLUSION -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_PrePass.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_PrePass.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_PrePass.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_PrePass.hlsli" diff --git a/Shaders/Source/REBLUR_SpecularOcclusion_TemporalAccumulation.cs.hlsl b/Shaders/Source/REBLUR_SpecularOcclusion_TemporalAccumulation.cs.hlsl index f9c0f61d..6bd6e038 100644 --- a/Shaders/Source/REBLUR_SpecularOcclusion_TemporalAccumulation.cs.hlsl +++ b/Shaders/Source/REBLUR_SpecularOcclusion_TemporalAccumulation.cs.hlsl @@ -8,15 +8,15 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_SPECULAR #define REBLUR_OCCLUSION -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_TemporalAccumulation.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_TemporalAccumulation.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_TemporalAccumulation.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_TemporalAccumulation.hlsli" diff --git a/Shaders/Source/REBLUR_SpecularSh_Blur.cs.hlsl b/Shaders/Source/REBLUR_SpecularSh_Blur.cs.hlsl index 3f351d2d..54201347 100644 --- a/Shaders/Source/REBLUR_SpecularSh_Blur.cs.hlsl +++ b/Shaders/Source/REBLUR_SpecularSh_Blur.cs.hlsl @@ -8,15 +8,15 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_SPECULAR #define REBLUR_SH -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_Blur.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_Blur.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_Blur.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_Blur.hlsli" diff --git a/Shaders/Source/REBLUR_SpecularSh_CopyStabilizedHistory.cs.hlsl b/Shaders/Source/REBLUR_SpecularSh_CopyStabilizedHistory.cs.hlsl index 4918cb69..1fb278a8 100644 --- a/Shaders/Source/REBLUR_SpecularSh_CopyStabilizedHistory.cs.hlsl +++ b/Shaders/Source/REBLUR_SpecularSh_CopyStabilizedHistory.cs.hlsl @@ -8,14 +8,14 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_SPECULAR #define REBLUR_SH -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_CopyStabilizedHistory.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_CopyStabilizedHistory.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_CopyStabilizedHistory.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_CopyStabilizedHistory.hlsli" diff --git a/Shaders/Source/REBLUR_SpecularSh_HistoryFix.cs.hlsl b/Shaders/Source/REBLUR_SpecularSh_HistoryFix.cs.hlsl index 1ff34626..823db950 100644 --- a/Shaders/Source/REBLUR_SpecularSh_HistoryFix.cs.hlsl +++ b/Shaders/Source/REBLUR_SpecularSh_HistoryFix.cs.hlsl @@ -8,15 +8,15 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_SPECULAR #define REBLUR_SH -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_HistoryFix.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_HistoryFix.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_HistoryFix.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_HistoryFix.hlsli" diff --git a/Shaders/Source/REBLUR_SpecularSh_PostBlur.cs.hlsl b/Shaders/Source/REBLUR_SpecularSh_PostBlur.cs.hlsl index ee55b836..799fbcbf 100644 --- a/Shaders/Source/REBLUR_SpecularSh_PostBlur.cs.hlsl +++ b/Shaders/Source/REBLUR_SpecularSh_PostBlur.cs.hlsl @@ -8,15 +8,15 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_SPECULAR #define REBLUR_SH -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" diff --git a/Shaders/Source/REBLUR_SpecularSh_PostBlur_NoTemporalStabilization.cs.hlsl b/Shaders/Source/REBLUR_SpecularSh_PostBlur_NoTemporalStabilization.cs.hlsl index d8c27788..97959090 100644 --- a/Shaders/Source/REBLUR_SpecularSh_PostBlur_NoTemporalStabilization.cs.hlsl +++ b/Shaders/Source/REBLUR_SpecularSh_PostBlur_NoTemporalStabilization.cs.hlsl @@ -8,16 +8,16 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_SPECULAR #define REBLUR_SH #define REBLUR_NO_TEMPORAL_STABILIZATION -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" diff --git a/Shaders/Source/REBLUR_SpecularSh_PrePass.cs.hlsl b/Shaders/Source/REBLUR_SpecularSh_PrePass.cs.hlsl index d2f68081..680aa530 100644 --- a/Shaders/Source/REBLUR_SpecularSh_PrePass.cs.hlsl +++ b/Shaders/Source/REBLUR_SpecularSh_PrePass.cs.hlsl @@ -8,15 +8,15 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_SPECULAR #define REBLUR_SH -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_PrePass.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_PrePass.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_PrePass.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_PrePass.hlsli" diff --git a/Shaders/Source/REBLUR_SpecularSh_SplitScreen.cs.hlsl b/Shaders/Source/REBLUR_SpecularSh_SplitScreen.cs.hlsl index c7caa605..e1be4542 100644 --- a/Shaders/Source/REBLUR_SpecularSh_SplitScreen.cs.hlsl +++ b/Shaders/Source/REBLUR_SpecularSh_SplitScreen.cs.hlsl @@ -8,15 +8,15 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_SPECULAR #define REBLUR_SH -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_SplitScreen.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_SplitScreen.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_SplitScreen.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_SplitScreen.hlsli" diff --git a/Shaders/Source/REBLUR_SpecularSh_TemporalAccumulation.cs.hlsl b/Shaders/Source/REBLUR_SpecularSh_TemporalAccumulation.cs.hlsl index b4850907..d41ba17a 100644 --- a/Shaders/Source/REBLUR_SpecularSh_TemporalAccumulation.cs.hlsl +++ b/Shaders/Source/REBLUR_SpecularSh_TemporalAccumulation.cs.hlsl @@ -8,15 +8,15 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_SPECULAR #define REBLUR_SH -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_TemporalAccumulation.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_TemporalAccumulation.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_TemporalAccumulation.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_TemporalAccumulation.hlsli" diff --git a/Shaders/Source/REBLUR_SpecularSh_TemporalStabilization.cs.hlsl b/Shaders/Source/REBLUR_SpecularSh_TemporalStabilization.cs.hlsl index a76cdec0..e36743a6 100644 --- a/Shaders/Source/REBLUR_SpecularSh_TemporalStabilization.cs.hlsl +++ b/Shaders/Source/REBLUR_SpecularSh_TemporalStabilization.cs.hlsl @@ -8,15 +8,15 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_SPECULAR #define REBLUR_SH -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_TemporalStabilization.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_TemporalStabilization.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_TemporalStabilization.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_TemporalStabilization.hlsli" diff --git a/Shaders/Source/REBLUR_Specular_Blur.cs.hlsl b/Shaders/Source/REBLUR_Specular_Blur.cs.hlsl index 00a55eab..501ca484 100644 --- a/Shaders/Source/REBLUR_Specular_Blur.cs.hlsl +++ b/Shaders/Source/REBLUR_Specular_Blur.cs.hlsl @@ -8,14 +8,14 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_SPECULAR -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_Blur.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_Blur.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_Blur.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_Blur.hlsli" diff --git a/Shaders/Source/REBLUR_Specular_CopyStabilizedHistory.cs.hlsl b/Shaders/Source/REBLUR_Specular_CopyStabilizedHistory.cs.hlsl index d5189ac2..77233c0b 100644 --- a/Shaders/Source/REBLUR_Specular_CopyStabilizedHistory.cs.hlsl +++ b/Shaders/Source/REBLUR_Specular_CopyStabilizedHistory.cs.hlsl @@ -8,13 +8,13 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_SPECULAR -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_CopyStabilizedHistory.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_CopyStabilizedHistory.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_CopyStabilizedHistory.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_CopyStabilizedHistory.hlsli" diff --git a/Shaders/Source/REBLUR_Specular_HistoryFix.cs.hlsl b/Shaders/Source/REBLUR_Specular_HistoryFix.cs.hlsl index 1281c15b..c1732fd0 100644 --- a/Shaders/Source/REBLUR_Specular_HistoryFix.cs.hlsl +++ b/Shaders/Source/REBLUR_Specular_HistoryFix.cs.hlsl @@ -8,14 +8,14 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_SPECULAR -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_HistoryFix.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_HistoryFix.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_HistoryFix.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_HistoryFix.hlsli" diff --git a/Shaders/Source/REBLUR_Specular_HitDistReconstruction.cs.hlsl b/Shaders/Source/REBLUR_Specular_HitDistReconstruction.cs.hlsl index c440674d..b13faf92 100644 --- a/Shaders/Source/REBLUR_Specular_HitDistReconstruction.cs.hlsl +++ b/Shaders/Source/REBLUR_Specular_HitDistReconstruction.cs.hlsl @@ -8,14 +8,14 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_SPECULAR -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_HitDistReconstruction.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_HitDistReconstruction.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_HitDistReconstruction.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_HitDistReconstruction.hlsli" diff --git a/Shaders/Source/REBLUR_Specular_HitDistReconstruction_5x5.cs.hlsl b/Shaders/Source/REBLUR_Specular_HitDistReconstruction_5x5.cs.hlsl index b4b8bead..646e5f09 100644 --- a/Shaders/Source/REBLUR_Specular_HitDistReconstruction_5x5.cs.hlsl +++ b/Shaders/Source/REBLUR_Specular_HitDistReconstruction_5x5.cs.hlsl @@ -8,15 +8,15 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_SPECULAR #define REBLUR_HITDIST_RECONSTRUCTION_5X5 -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_HitDistReconstruction.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_HitDistReconstruction.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_HitDistReconstruction.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_HitDistReconstruction.hlsli" diff --git a/Shaders/Source/REBLUR_Specular_PostBlur.cs.hlsl b/Shaders/Source/REBLUR_Specular_PostBlur.cs.hlsl index d8c88271..b575bcc7 100644 --- a/Shaders/Source/REBLUR_Specular_PostBlur.cs.hlsl +++ b/Shaders/Source/REBLUR_Specular_PostBlur.cs.hlsl @@ -8,14 +8,14 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_SPECULAR -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" diff --git a/Shaders/Source/REBLUR_Specular_PostBlur_NoTemporalStabilization.cs.hlsl b/Shaders/Source/REBLUR_Specular_PostBlur_NoTemporalStabilization.cs.hlsl index fe773e7c..0117b69f 100644 --- a/Shaders/Source/REBLUR_Specular_PostBlur_NoTemporalStabilization.cs.hlsl +++ b/Shaders/Source/REBLUR_Specular_PostBlur_NoTemporalStabilization.cs.hlsl @@ -8,15 +8,15 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_SPECULAR #define REBLUR_NO_TEMPORAL_STABILIZATION -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_PostBlur.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_PostBlur.hlsli" diff --git a/Shaders/Source/REBLUR_Specular_PrePass.cs.hlsl b/Shaders/Source/REBLUR_Specular_PrePass.cs.hlsl index 0f081800..e9855c95 100644 --- a/Shaders/Source/REBLUR_Specular_PrePass.cs.hlsl +++ b/Shaders/Source/REBLUR_Specular_PrePass.cs.hlsl @@ -8,14 +8,14 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_SPECULAR -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_PrePass.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_PrePass.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_PrePass.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_PrePass.hlsli" diff --git a/Shaders/Source/REBLUR_Specular_SplitScreen.cs.hlsl b/Shaders/Source/REBLUR_Specular_SplitScreen.cs.hlsl index a1210498..0a7c4634 100644 --- a/Shaders/Source/REBLUR_Specular_SplitScreen.cs.hlsl +++ b/Shaders/Source/REBLUR_Specular_SplitScreen.cs.hlsl @@ -8,14 +8,14 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_SPECULAR -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_SplitScreen.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_SplitScreen.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_SplitScreen.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_SplitScreen.hlsli" diff --git a/Shaders/Source/REBLUR_Specular_TemporalAccumulation.cs.hlsl b/Shaders/Source/REBLUR_Specular_TemporalAccumulation.cs.hlsl index f3bf9cea..0f846116 100644 --- a/Shaders/Source/REBLUR_Specular_TemporalAccumulation.cs.hlsl +++ b/Shaders/Source/REBLUR_Specular_TemporalAccumulation.cs.hlsl @@ -8,14 +8,14 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_SPECULAR -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_TemporalAccumulation.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_TemporalAccumulation.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_TemporalAccumulation.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_TemporalAccumulation.hlsli" diff --git a/Shaders/Source/REBLUR_Specular_TemporalStabilization.cs.hlsl b/Shaders/Source/REBLUR_Specular_TemporalStabilization.cs.hlsl index ce5e3302..d92347cb 100644 --- a/Shaders/Source/REBLUR_Specular_TemporalStabilization.cs.hlsl +++ b/Shaders/Source/REBLUR_Specular_TemporalStabilization.cs.hlsl @@ -8,14 +8,14 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define REBLUR_SPECULAR -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_DiffuseSpecular_TemporalStabilization.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_DiffuseSpecular_TemporalStabilization.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" -#include "../Include/REBLUR/REBLUR_DiffuseSpecular_TemporalStabilization.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" +#include "REBLUR/REBLUR_DiffuseSpecular_TemporalStabilization.hlsli" diff --git a/Shaders/Source/REBLUR_Validation.cs.hlsl b/Shaders/Source/REBLUR_Validation.cs.hlsl index 3207f86f..7f3fc374 100644 --- a/Shaders/Source/REBLUR_Validation.cs.hlsl +++ b/Shaders/Source/REBLUR_Validation.cs.hlsl @@ -8,14 +8,14 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" -#include "../Include/REBLUR/REBLUR_Config.hlsli" -#include "../Resources/REBLUR_Validation.resources.hlsli" +#include "REBLUR/REBLUR_Config.hlsli" +#include "REBLUR_Validation.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/REBLUR/REBLUR_Common.hlsli" +#include "Common.hlsli" +#include "REBLUR/REBLUR_Common.hlsli" #define VIEWPORT_SIZE 0.25 #define OFFSET 5 diff --git a/Shaders/Source/REFERENCE_SplitScreen.cs.hlsl b/Shaders/Source/REFERENCE_SplitScreen.cs.hlsl index 156fc7e9..a0d45a0e 100644 --- a/Shaders/Source/REFERENCE_SplitScreen.cs.hlsl +++ b/Shaders/Source/REFERENCE_SplitScreen.cs.hlsl @@ -8,12 +8,12 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" -#include "../Resources/REFERENCE_SplitScreen.resources.hlsli" +#include "REFERENCE_SplitScreen.resources.hlsli" -#include "../Include/Common.hlsli" +#include "Common.hlsli" [numthreads( GROUP_X, GROUP_Y, 1 )] NRD_EXPORT void NRD_CS_MAIN( uint2 pixelPos : SV_DispatchThreadId ) diff --git a/Shaders/Source/REFERENCE_TemporalAccumulation.cs.hlsl b/Shaders/Source/REFERENCE_TemporalAccumulation.cs.hlsl index c5756e75..9628d829 100644 --- a/Shaders/Source/REFERENCE_TemporalAccumulation.cs.hlsl +++ b/Shaders/Source/REFERENCE_TemporalAccumulation.cs.hlsl @@ -8,12 +8,12 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" -#include "../Resources/REFERENCE_TemporalAccumulation.resources.hlsli" +#include "REFERENCE_TemporalAccumulation.resources.hlsli" -#include "../Include/Common.hlsli" +#include "Common.hlsli" [numthreads( GROUP_X, GROUP_Y, 1 )] NRD_EXPORT void NRD_CS_MAIN( uint2 pixelPos : SV_DispatchThreadId ) diff --git a/Shaders/Source/RELAX_DiffuseSh_AntiFirefly.cs.hlsl b/Shaders/Source/RELAX_DiffuseSh_AntiFirefly.cs.hlsl new file mode 100644 index 00000000..3d5a34f0 --- /dev/null +++ b/Shaders/Source/RELAX_DiffuseSh_AntiFirefly.cs.hlsl @@ -0,0 +1,22 @@ +/* +Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved. + +NVIDIA CORPORATION and its licensors retain all intellectual property +and proprietary rights in and to this software, related documentation +and any modifications thereto. Any use, reproduction, disclosure or +distribution of this software and related documentation without an express +license agreement from NVIDIA CORPORATION is strictly prohibited. +*/ + +#include "NRD.hlsli" +#include "STL.hlsli" + +#define RELAX_DIFFUSE +#define RELAX_SH + +#include "RELAX/RELAX_Config.hlsli" +#include "RELAX_DiffuseSpecular_AntiFirefly.resources.hlsli" + +#include "Common.hlsli" +#include "RELAX/RELAX_Common.hlsli" +#include "RELAX/RELAX_DiffuseSpecular_AntiFirefly.hlsli" diff --git a/Shaders/Source/RELAX_DiffuseSh_Atrous.cs.hlsl b/Shaders/Source/RELAX_DiffuseSh_Atrous.cs.hlsl new file mode 100644 index 00000000..7eb43b46 --- /dev/null +++ b/Shaders/Source/RELAX_DiffuseSh_Atrous.cs.hlsl @@ -0,0 +1,22 @@ +/* +Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved. + +NVIDIA CORPORATION and its licensors retain all intellectual property +and proprietary rights in and to this software, related documentation +and any modifications thereto. Any use, reproduction, disclosure or +distribution of this software and related documentation without an express +license agreement from NVIDIA CORPORATION is strictly prohibited. +*/ + +#include "NRD.hlsli" +#include "STL.hlsli" + +#define RELAX_DIFFUSE +#define RELAX_SH + +#include "RELAX/RELAX_Config.hlsli" +#include "RELAX_DiffuseSpecular_Atrous.resources.hlsli" + +#include "Common.hlsli" +#include "RELAX/RELAX_Common.hlsli" +#include "RELAX/RELAX_DiffuseSpecular_Atrous.hlsli" diff --git a/Shaders/Source/RELAX_DiffuseSh_AtrousSmem.cs.hlsl b/Shaders/Source/RELAX_DiffuseSh_AtrousSmem.cs.hlsl new file mode 100644 index 00000000..c09b9712 --- /dev/null +++ b/Shaders/Source/RELAX_DiffuseSh_AtrousSmem.cs.hlsl @@ -0,0 +1,22 @@ +/* +Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved. + +NVIDIA CORPORATION and its licensors retain all intellectual property +and proprietary rights in and to this software, related documentation +and any modifications thereto. Any use, reproduction, disclosure or +distribution of this software and related documentation without an express +license agreement from NVIDIA CORPORATION is strictly prohibited. +*/ + +#include "NRD.hlsli" +#include "STL.hlsli" + +#define RELAX_DIFFUSE +#define RELAX_SH + +#include "RELAX/RELAX_Config.hlsli" +#include "RELAX_DiffuseSpecular_AtrousSmem.resources.hlsli" + +#include "Common.hlsli" +#include "RELAX/RELAX_Common.hlsli" +#include "RELAX/RELAX_DiffuseSpecular_AtrousSmem.hlsli" diff --git a/Shaders/Source/RELAX_DiffuseSh_HistoryClamping.cs.hlsl b/Shaders/Source/RELAX_DiffuseSh_HistoryClamping.cs.hlsl new file mode 100644 index 00000000..c0ee4bb7 --- /dev/null +++ b/Shaders/Source/RELAX_DiffuseSh_HistoryClamping.cs.hlsl @@ -0,0 +1,22 @@ +/* +Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved. + +NVIDIA CORPORATION and its licensors retain all intellectual property +and proprietary rights in and to this software, related documentation +and any modifications thereto. Any use, reproduction, disclosure or +distribution of this software and related documentation without an express +license agreement from NVIDIA CORPORATION is strictly prohibited. +*/ + +#include "NRD.hlsli" +#include "STL.hlsli" + +#define RELAX_DIFFUSE +#define RELAX_SH + +#include "RELAX/RELAX_Config.hlsli" +#include "RELAX_DiffuseSpecular_HistoryClamping.resources.hlsli" + +#include "Common.hlsli" +#include "RELAX/RELAX_Common.hlsli" +#include "RELAX/RELAX_DiffuseSpecular_HistoryClamping.hlsli" diff --git a/Shaders/Source/RELAX_DiffuseSh_HistoryFix.cs.hlsl b/Shaders/Source/RELAX_DiffuseSh_HistoryFix.cs.hlsl new file mode 100644 index 00000000..0b52f961 --- /dev/null +++ b/Shaders/Source/RELAX_DiffuseSh_HistoryFix.cs.hlsl @@ -0,0 +1,22 @@ +/* +Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved. + +NVIDIA CORPORATION and its licensors retain all intellectual property +and proprietary rights in and to this software, related documentation +and any modifications thereto. Any use, reproduction, disclosure or +distribution of this software and related documentation without an express +license agreement from NVIDIA CORPORATION is strictly prohibited. +*/ + +#include "NRD.hlsli" +#include "STL.hlsli" + +#define RELAX_DIFFUSE +#define RELAX_SH + +#include "RELAX/RELAX_Config.hlsli" +#include "RELAX_DiffuseSpecular_HistoryFix.resources.hlsli" + +#include "Common.hlsli" +#include "RELAX/RELAX_Common.hlsli" +#include "RELAX/RELAX_DiffuseSpecular_HistoryFix.hlsli" diff --git a/Shaders/Source/RELAX_DiffuseSh_HitDistReconstruction.cs.hlsl b/Shaders/Source/RELAX_DiffuseSh_HitDistReconstruction.cs.hlsl new file mode 100644 index 00000000..1dc88818 --- /dev/null +++ b/Shaders/Source/RELAX_DiffuseSh_HitDistReconstruction.cs.hlsl @@ -0,0 +1,21 @@ +/* +Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved. + +NVIDIA CORPORATION and its licensors retain all intellectual property +and proprietary rights in and to this software, related documentation +and any modifications thereto. Any use, reproduction, disclosure or +distribution of this software and related documentation without an express +license agreement from NVIDIA CORPORATION is strictly prohibited. +*/ + +#include "NRD.hlsli" +#include "STL.hlsli" + +#define RELAX_DIFFUSE + +#include "RELAX/RELAX_Config.hlsli" +#include "RELAX_DiffuseSpecular_HitDistReconstruction.resources.hlsli" + +#include "Common.hlsli" +#include "RELAX/RELAX_Common.hlsli" +#include "RELAX/RELAX_DiffuseSpecular_HitDistReconstruction.hlsli" diff --git a/Shaders/Source/RELAX_DiffuseSh_PrePass.cs.hlsl b/Shaders/Source/RELAX_DiffuseSh_PrePass.cs.hlsl new file mode 100644 index 00000000..cffa4ec6 --- /dev/null +++ b/Shaders/Source/RELAX_DiffuseSh_PrePass.cs.hlsl @@ -0,0 +1,22 @@ +/* +Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved. + +NVIDIA CORPORATION and its licensors retain all intellectual property +and proprietary rights in and to this software, related documentation +and any modifications thereto. Any use, reproduction, disclosure or +distribution of this software and related documentation without an express +license agreement from NVIDIA CORPORATION is strictly prohibited. +*/ + +#include "NRD.hlsli" +#include "STL.hlsli" + +#define RELAX_DIFFUSE +#define RELAX_SH + +#include "RELAX/RELAX_Config.hlsli" +#include "RELAX_DiffuseSpecular_PrePass.resources.hlsli" + +#include "Common.hlsli" +#include "RELAX/RELAX_Common.hlsli" +#include "RELAX/RELAX_DiffuseSpecular_PrePass.hlsli" diff --git a/Shaders/Source/RELAX_DiffuseSh_SplitScreen.cs.hlsl b/Shaders/Source/RELAX_DiffuseSh_SplitScreen.cs.hlsl new file mode 100644 index 00000000..9ae30200 --- /dev/null +++ b/Shaders/Source/RELAX_DiffuseSh_SplitScreen.cs.hlsl @@ -0,0 +1,21 @@ +/* +Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved. + +NVIDIA CORPORATION and its licensors retain all intellectual property +and proprietary rights in and to this software, related documentation +and any modifications thereto. Any use, reproduction, disclosure or +distribution of this software and related documentation without an express +license agreement from NVIDIA CORPORATION is strictly prohibited. +*/ + +#include "NRD.hlsli" +#include "STL.hlsli" + +#define RELAX_DIFFUSE + +#include "RELAX/RELAX_Config.hlsli" +#include "RELAX_DiffuseSpecular_SplitScreen.resources.hlsli" + +#include "Common.hlsli" +#include "RELAX/RELAX_Common.hlsli" +#include "RELAX/RELAX_DiffuseSpecular_SplitScreen.hlsli" diff --git a/Shaders/Source/RELAX_DiffuseSh_TemporalAccumulation.cs.hlsl b/Shaders/Source/RELAX_DiffuseSh_TemporalAccumulation.cs.hlsl new file mode 100644 index 00000000..2d84bf5b --- /dev/null +++ b/Shaders/Source/RELAX_DiffuseSh_TemporalAccumulation.cs.hlsl @@ -0,0 +1,22 @@ +/* +Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved. + +NVIDIA CORPORATION and its licensors retain all intellectual property +and proprietary rights in and to this software, related documentation +and any modifications thereto. Any use, reproduction, disclosure or +distribution of this software and related documentation without an express +license agreement from NVIDIA CORPORATION is strictly prohibited. +*/ + +#include "NRD.hlsli" +#include "STL.hlsli" + +#define RELAX_DIFFUSE +#define RELAX_SH + +#include "RELAX/RELAX_Config.hlsli" +#include "RELAX_DiffuseSpecular_TemporalAccumulation.resources.hlsli" + +#include "Common.hlsli" +#include "RELAX/RELAX_Common.hlsli" +#include "RELAX/RELAX_DiffuseSpecular_TemporalAccumulation.hlsli" diff --git a/Shaders/Source/RELAX_DiffuseSpecularSh_AntiFirefly.cs.hlsl b/Shaders/Source/RELAX_DiffuseSpecularSh_AntiFirefly.cs.hlsl new file mode 100644 index 00000000..fa06b66b --- /dev/null +++ b/Shaders/Source/RELAX_DiffuseSpecularSh_AntiFirefly.cs.hlsl @@ -0,0 +1,19 @@ +/* +Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved. + +NVIDIA CORPORATION and its licensors retain all intellectual property +and proprietary rights in and to this software, related documentation +and any modifications thereto. Any use, reproduction, disclosure or +distribution of this software and related documentation without an express +license agreement from NVIDIA CORPORATION is strictly prohibited. +*/ + +#include "NRD.hlsli" +#include "STL.hlsli" + +#include "RELAX/RELAX_Config.hlsli" +#include "RELAX_DiffuseSpecular_AntiFirefly.resources.hlsli" + +#include "Common.hlsli" +#include "RELAX/RELAX_Common.hlsli" +#include "RELAX/RELAX_DiffuseSpecular_AntiFirefly.hlsli" diff --git a/Shaders/Source/RELAX_DiffuseSpecularSh_Atrous.cs.hlsl b/Shaders/Source/RELAX_DiffuseSpecularSh_Atrous.cs.hlsl new file mode 100644 index 00000000..96037e22 --- /dev/null +++ b/Shaders/Source/RELAX_DiffuseSpecularSh_Atrous.cs.hlsl @@ -0,0 +1,21 @@ +/* +Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved. + +NVIDIA CORPORATION and its licensors retain all intellectual property +and proprietary rights in and to this software, related documentation +and any modifications thereto. Any use, reproduction, disclosure or +distribution of this software and related documentation without an express +license agreement from NVIDIA CORPORATION is strictly prohibited. +*/ + +#include "NRD.hlsli" +#include "STL.hlsli" + +#define RELAX_SH + +#include "RELAX/RELAX_Config.hlsli" +#include "RELAX_DiffuseSpecular_Atrous.resources.hlsli" + +#include "Common.hlsli" +#include "RELAX/RELAX_Common.hlsli" +#include "RELAX/RELAX_DiffuseSpecular_Atrous.hlsli" diff --git a/Shaders/Source/RELAX_DiffuseSpecularSh_AtrousSmem.cs.hlsl b/Shaders/Source/RELAX_DiffuseSpecularSh_AtrousSmem.cs.hlsl new file mode 100644 index 00000000..c918aa43 --- /dev/null +++ b/Shaders/Source/RELAX_DiffuseSpecularSh_AtrousSmem.cs.hlsl @@ -0,0 +1,21 @@ +/* +Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved. + +NVIDIA CORPORATION and its licensors retain all intellectual property +and proprietary rights in and to this software, related documentation +and any modifications thereto. Any use, reproduction, disclosure or +distribution of this software and related documentation without an express +license agreement from NVIDIA CORPORATION is strictly prohibited. +*/ + +#include "NRD.hlsli" +#include "STL.hlsli" + +#define RELAX_SH + +#include "RELAX/RELAX_Config.hlsli" +#include "RELAX_DiffuseSpecular_AtrousSmem.resources.hlsli" + +#include "Common.hlsli" +#include "RELAX/RELAX_Common.hlsli" +#include "RELAX/RELAX_DiffuseSpecular_AtrousSmem.hlsli" diff --git a/Shaders/Source/RELAX_DiffuseSpecularSh_HistoryClamping.cs.hlsl b/Shaders/Source/RELAX_DiffuseSpecularSh_HistoryClamping.cs.hlsl new file mode 100644 index 00000000..2be34279 --- /dev/null +++ b/Shaders/Source/RELAX_DiffuseSpecularSh_HistoryClamping.cs.hlsl @@ -0,0 +1,21 @@ +/* +Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved. + +NVIDIA CORPORATION and its licensors retain all intellectual property +and proprietary rights in and to this software, related documentation +and any modifications thereto. Any use, reproduction, disclosure or +distribution of this software and related documentation without an express +license agreement from NVIDIA CORPORATION is strictly prohibited. +*/ + +#include "NRD.hlsli" +#include "STL.hlsli" + +#define RELAX_SH + +#include "RELAX/RELAX_Config.hlsli" +#include "RELAX_DiffuseSpecular_HistoryClamping.resources.hlsli" + +#include "Common.hlsli" +#include "RELAX/RELAX_Common.hlsli" +#include "RELAX/RELAX_DiffuseSpecular_HistoryClamping.hlsli" diff --git a/Shaders/Source/RELAX_DiffuseSpecularSh_HistoryFix.cs.hlsl b/Shaders/Source/RELAX_DiffuseSpecularSh_HistoryFix.cs.hlsl new file mode 100644 index 00000000..35635b49 --- /dev/null +++ b/Shaders/Source/RELAX_DiffuseSpecularSh_HistoryFix.cs.hlsl @@ -0,0 +1,21 @@ +/* +Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved. + +NVIDIA CORPORATION and its licensors retain all intellectual property +and proprietary rights in and to this software, related documentation +and any modifications thereto. Any use, reproduction, disclosure or +distribution of this software and related documentation without an express +license agreement from NVIDIA CORPORATION is strictly prohibited. +*/ + +#include "NRD.hlsli" +#include "STL.hlsli" + +#define RELAX_SH + +#include "RELAX/RELAX_Config.hlsli" +#include "RELAX_DiffuseSpecular_HistoryFix.resources.hlsli" + +#include "Common.hlsli" +#include "RELAX/RELAX_Common.hlsli" +#include "RELAX/RELAX_DiffuseSpecular_HistoryFix.hlsli" diff --git a/Shaders/Source/RELAX_DiffuseSpecularSh_PrePass.cs.hlsl b/Shaders/Source/RELAX_DiffuseSpecularSh_PrePass.cs.hlsl new file mode 100644 index 00000000..06990488 --- /dev/null +++ b/Shaders/Source/RELAX_DiffuseSpecularSh_PrePass.cs.hlsl @@ -0,0 +1,21 @@ +/* +Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved. + +NVIDIA CORPORATION and its licensors retain all intellectual property +and proprietary rights in and to this software, related documentation +and any modifications thereto. Any use, reproduction, disclosure or +distribution of this software and related documentation without an express +license agreement from NVIDIA CORPORATION is strictly prohibited. +*/ + +#include "NRD.hlsli" +#include "STL.hlsli" + +#define RELAX_SH + +#include "RELAX/RELAX_Config.hlsli" +#include "RELAX_DiffuseSpecular_PrePass.resources.hlsli" + +#include "Common.hlsli" +#include "RELAX/RELAX_Common.hlsli" +#include "RELAX/RELAX_DiffuseSpecular_PrePass.hlsli" diff --git a/Shaders/Source/RELAX_DiffuseSpecularSh_SplitScreen.cs.hlsl b/Shaders/Source/RELAX_DiffuseSpecularSh_SplitScreen.cs.hlsl new file mode 100644 index 00000000..2fe628b8 --- /dev/null +++ b/Shaders/Source/RELAX_DiffuseSpecularSh_SplitScreen.cs.hlsl @@ -0,0 +1,19 @@ +/* +Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved. + +NVIDIA CORPORATION and its licensors retain all intellectual property +and proprietary rights in and to this software, related documentation +and any modifications thereto. Any use, reproduction, disclosure or +distribution of this software and related documentation without an express +license agreement from NVIDIA CORPORATION is strictly prohibited. +*/ + +#include "NRD.hlsli" +#include "STL.hlsli" + +#include "RELAX/RELAX_Config.hlsli" +#include "RELAX_DiffuseSpecular_SplitScreen.resources.hlsli" + +#include "Common.hlsli" +#include "RELAX/RELAX_Common.hlsli" +#include "RELAX/RELAX_DiffuseSpecular_SplitScreen.hlsli" diff --git a/Shaders/Source/RELAX_DiffuseSpecularSh_TemporalAccumulation.cs.hlsl b/Shaders/Source/RELAX_DiffuseSpecularSh_TemporalAccumulation.cs.hlsl new file mode 100644 index 00000000..9fb47b95 --- /dev/null +++ b/Shaders/Source/RELAX_DiffuseSpecularSh_TemporalAccumulation.cs.hlsl @@ -0,0 +1,21 @@ +/* +Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved. + +NVIDIA CORPORATION and its licensors retain all intellectual property +and proprietary rights in and to this software, related documentation +and any modifications thereto. Any use, reproduction, disclosure or +distribution of this software and related documentation without an express +license agreement from NVIDIA CORPORATION is strictly prohibited. +*/ + +#include "NRD.hlsli" +#include "STL.hlsli" + +#define RELAX_SH + +#include "RELAX/RELAX_Config.hlsli" +#include "RELAX_DiffuseSpecular_TemporalAccumulation.resources.hlsli" + +#include "Common.hlsli" +#include "RELAX/RELAX_Common.hlsli" +#include "RELAX/RELAX_DiffuseSpecular_TemporalAccumulation.hlsli" diff --git a/Shaders/Source/RELAX_DiffuseSpecular_AntiFirefly.cs.hlsl b/Shaders/Source/RELAX_DiffuseSpecular_AntiFirefly.cs.hlsl index fc9146b9..fa06b66b 100644 --- a/Shaders/Source/RELAX_DiffuseSpecular_AntiFirefly.cs.hlsl +++ b/Shaders/Source/RELAX_DiffuseSpecular_AntiFirefly.cs.hlsl @@ -8,12 +8,12 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" -#include "../Include/RELAX/RELAX_Config.hlsli" -#include "../Resources/RELAX_DiffuseSpecular_AntiFirefly.resources.hlsli" +#include "RELAX/RELAX_Config.hlsli" +#include "RELAX_DiffuseSpecular_AntiFirefly.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/RELAX/RELAX_Common.hlsli" -#include "../Include/RELAX/RELAX_DiffuseSpecular_AntiFirefly.hlsli" +#include "Common.hlsli" +#include "RELAX/RELAX_Common.hlsli" +#include "RELAX/RELAX_DiffuseSpecular_AntiFirefly.hlsli" diff --git a/Shaders/Source/RELAX_DiffuseSpecular_Atrous.cs.hlsl b/Shaders/Source/RELAX_DiffuseSpecular_Atrous.cs.hlsl index 61f95f21..906f04c2 100644 --- a/Shaders/Source/RELAX_DiffuseSpecular_Atrous.cs.hlsl +++ b/Shaders/Source/RELAX_DiffuseSpecular_Atrous.cs.hlsl @@ -8,12 +8,12 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" -#include "../Include/RELAX/RELAX_Config.hlsli" -#include "../Resources/RELAX_DiffuseSpecular_Atrous.resources.hlsli" +#include "RELAX/RELAX_Config.hlsli" +#include "RELAX_DiffuseSpecular_Atrous.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/RELAX/RELAX_Common.hlsli" -#include "../Include/RELAX/RELAX_DiffuseSpecular_Atrous.hlsli" +#include "Common.hlsli" +#include "RELAX/RELAX_Common.hlsli" +#include "RELAX/RELAX_DiffuseSpecular_Atrous.hlsli" diff --git a/Shaders/Source/RELAX_DiffuseSpecular_AtrousSmem.cs.hlsl b/Shaders/Source/RELAX_DiffuseSpecular_AtrousSmem.cs.hlsl index f5f1db4c..09bca68e 100644 --- a/Shaders/Source/RELAX_DiffuseSpecular_AtrousSmem.cs.hlsl +++ b/Shaders/Source/RELAX_DiffuseSpecular_AtrousSmem.cs.hlsl @@ -8,12 +8,12 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" -#include "../Include/RELAX/RELAX_Config.hlsli" -#include "../Resources/RELAX_DiffuseSpecular_AtrousSmem.resources.hlsli" +#include "RELAX/RELAX_Config.hlsli" +#include "RELAX_DiffuseSpecular_AtrousSmem.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/RELAX/RELAX_Common.hlsli" -#include "../Include/RELAX/RELAX_DiffuseSpecular_AtrousSmem.hlsli" +#include "Common.hlsli" +#include "RELAX/RELAX_Common.hlsli" +#include "RELAX/RELAX_DiffuseSpecular_AtrousSmem.hlsli" diff --git a/Shaders/Source/RELAX_DiffuseSpecular_HistoryClamping.cs.hlsl b/Shaders/Source/RELAX_DiffuseSpecular_HistoryClamping.cs.hlsl index 60acabfc..4bbaa4f5 100644 --- a/Shaders/Source/RELAX_DiffuseSpecular_HistoryClamping.cs.hlsl +++ b/Shaders/Source/RELAX_DiffuseSpecular_HistoryClamping.cs.hlsl @@ -8,12 +8,12 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" -#include "../Include/RELAX/RELAX_Config.hlsli" -#include "../Resources/RELAX_DiffuseSpecular_HistoryClamping.resources.hlsli" +#include "RELAX/RELAX_Config.hlsli" +#include "RELAX_DiffuseSpecular_HistoryClamping.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/RELAX/RELAX_Common.hlsli" -#include "../Include/RELAX/RELAX_DiffuseSpecular_HistoryClamping.hlsli" +#include "Common.hlsli" +#include "RELAX/RELAX_Common.hlsli" +#include "RELAX/RELAX_DiffuseSpecular_HistoryClamping.hlsli" diff --git a/Shaders/Source/RELAX_DiffuseSpecular_HistoryFix.cs.hlsl b/Shaders/Source/RELAX_DiffuseSpecular_HistoryFix.cs.hlsl index 99643af5..7c75478e 100644 --- a/Shaders/Source/RELAX_DiffuseSpecular_HistoryFix.cs.hlsl +++ b/Shaders/Source/RELAX_DiffuseSpecular_HistoryFix.cs.hlsl @@ -8,12 +8,12 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" -#include "../Include/RELAX/RELAX_Config.hlsli" -#include "../Resources/RELAX_DiffuseSpecular_HistoryFix.resources.hlsli" +#include "RELAX/RELAX_Config.hlsli" +#include "RELAX_DiffuseSpecular_HistoryFix.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/RELAX/RELAX_Common.hlsli" -#include "../Include/RELAX/RELAX_DiffuseSpecular_HistoryFix.hlsli" +#include "Common.hlsli" +#include "RELAX/RELAX_Common.hlsli" +#include "RELAX/RELAX_DiffuseSpecular_HistoryFix.hlsli" diff --git a/Shaders/Source/RELAX_DiffuseSpecular_HitDistReconstruction.cs.hlsl b/Shaders/Source/RELAX_DiffuseSpecular_HitDistReconstruction.cs.hlsl index 1093a861..025d5368 100644 --- a/Shaders/Source/RELAX_DiffuseSpecular_HitDistReconstruction.cs.hlsl +++ b/Shaders/Source/RELAX_DiffuseSpecular_HitDistReconstruction.cs.hlsl @@ -8,12 +8,12 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" -#include "../Include/RELAX/RELAX_Config.hlsli" -#include "../Resources/RELAX_DiffuseSpecular_HitDistReconstruction.resources.hlsli" +#include "RELAX/RELAX_Config.hlsli" +#include "RELAX_DiffuseSpecular_HitDistReconstruction.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/RELAX/RELAX_Common.hlsli" -#include "../Include/RELAX/RELAX_DiffuseSpecular_HitDistReconstruction.hlsli" +#include "Common.hlsli" +#include "RELAX/RELAX_Common.hlsli" +#include "RELAX/RELAX_DiffuseSpecular_HitDistReconstruction.hlsli" diff --git a/Shaders/Source/RELAX_DiffuseSpecular_HitDistReconstruction_5x5.cs.hlsl b/Shaders/Source/RELAX_DiffuseSpecular_HitDistReconstruction_5x5.cs.hlsl index d4095113..6732c1b4 100644 --- a/Shaders/Source/RELAX_DiffuseSpecular_HitDistReconstruction_5x5.cs.hlsl +++ b/Shaders/Source/RELAX_DiffuseSpecular_HitDistReconstruction_5x5.cs.hlsl @@ -8,14 +8,14 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define RELAX_HITDIST_RECONSTRUCTION_5X5 -#include "../Include/RELAX/RELAX_Config.hlsli" -#include "../Resources/RELAX_DiffuseSpecular_HitDistReconstruction.resources.hlsli" +#include "RELAX/RELAX_Config.hlsli" +#include "RELAX_DiffuseSpecular_HitDistReconstruction.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/RELAX/RELAX_Common.hlsli" -#include "../Include/RELAX/RELAX_DiffuseSpecular_HitDistReconstruction.hlsli" +#include "Common.hlsli" +#include "RELAX/RELAX_Common.hlsli" +#include "RELAX/RELAX_DiffuseSpecular_HitDistReconstruction.hlsli" diff --git a/Shaders/Source/RELAX_DiffuseSpecular_PrePass.cs.hlsl b/Shaders/Source/RELAX_DiffuseSpecular_PrePass.cs.hlsl index 576ca703..ac40b301 100644 --- a/Shaders/Source/RELAX_DiffuseSpecular_PrePass.cs.hlsl +++ b/Shaders/Source/RELAX_DiffuseSpecular_PrePass.cs.hlsl @@ -8,12 +8,12 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" -#include "../Include/RELAX/RELAX_Config.hlsli" -#include "../Resources/RELAX_DiffuseSpecular_PrePass.resources.hlsli" +#include "RELAX/RELAX_Config.hlsli" +#include "RELAX_DiffuseSpecular_PrePass.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/RELAX/RELAX_Common.hlsli" -#include "../Include/RELAX/RELAX_DiffuseSpecular_PrePass.hlsli" +#include "Common.hlsli" +#include "RELAX/RELAX_Common.hlsli" +#include "RELAX/RELAX_DiffuseSpecular_PrePass.hlsli" diff --git a/Shaders/Source/RELAX_DiffuseSpecular_SplitScreen.cs.hlsl b/Shaders/Source/RELAX_DiffuseSpecular_SplitScreen.cs.hlsl index 71844081..2fe628b8 100644 --- a/Shaders/Source/RELAX_DiffuseSpecular_SplitScreen.cs.hlsl +++ b/Shaders/Source/RELAX_DiffuseSpecular_SplitScreen.cs.hlsl @@ -8,12 +8,12 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" -#include "../Include/RELAX/RELAX_Config.hlsli" -#include "../Resources/RELAX_DiffuseSpecular_SplitScreen.resources.hlsli" +#include "RELAX/RELAX_Config.hlsli" +#include "RELAX_DiffuseSpecular_SplitScreen.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/RELAX/RELAX_Common.hlsli" -#include "../Include/RELAX/RELAX_DiffuseSpecular_SplitScreen.hlsli" +#include "Common.hlsli" +#include "RELAX/RELAX_Common.hlsli" +#include "RELAX/RELAX_DiffuseSpecular_SplitScreen.hlsli" diff --git a/Shaders/Source/RELAX_DiffuseSpecular_TemporalAccumulation.cs.hlsl b/Shaders/Source/RELAX_DiffuseSpecular_TemporalAccumulation.cs.hlsl index a374d9cc..abf998c4 100644 --- a/Shaders/Source/RELAX_DiffuseSpecular_TemporalAccumulation.cs.hlsl +++ b/Shaders/Source/RELAX_DiffuseSpecular_TemporalAccumulation.cs.hlsl @@ -8,12 +8,12 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" -#include "../Include/RELAX/RELAX_Config.hlsli" -#include "../Resources/RELAX_DiffuseSpecular_TemporalAccumulation.resources.hlsli" +#include "RELAX/RELAX_Config.hlsli" +#include "RELAX_DiffuseSpecular_TemporalAccumulation.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/RELAX/RELAX_Common.hlsli" -#include "../Include/RELAX/RELAX_DiffuseSpecular_TemporalAccumulation.hlsli" +#include "Common.hlsli" +#include "RELAX/RELAX_Common.hlsli" +#include "RELAX/RELAX_DiffuseSpecular_TemporalAccumulation.hlsli" diff --git a/Shaders/Source/RELAX_Diffuse_AntiFirefly.cs.hlsl b/Shaders/Source/RELAX_Diffuse_AntiFirefly.cs.hlsl index 5cf779bb..61dd3cdc 100644 --- a/Shaders/Source/RELAX_Diffuse_AntiFirefly.cs.hlsl +++ b/Shaders/Source/RELAX_Diffuse_AntiFirefly.cs.hlsl @@ -8,14 +8,14 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define RELAX_DIFFUSE -#include "../Include/RELAX/RELAX_Config.hlsli" -#include "../Resources/RELAX_DiffuseSpecular_AntiFirefly.resources.hlsli" +#include "RELAX/RELAX_Config.hlsli" +#include "RELAX_DiffuseSpecular_AntiFirefly.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/RELAX/RELAX_Common.hlsli" -#include "../Include/RELAX/RELAX_DiffuseSpecular_AntiFirefly.hlsli" +#include "Common.hlsli" +#include "RELAX/RELAX_Common.hlsli" +#include "RELAX/RELAX_DiffuseSpecular_AntiFirefly.hlsli" diff --git a/Shaders/Source/RELAX_Diffuse_Atrous.cs.hlsl b/Shaders/Source/RELAX_Diffuse_Atrous.cs.hlsl index 512a25bc..0f94657a 100644 --- a/Shaders/Source/RELAX_Diffuse_Atrous.cs.hlsl +++ b/Shaders/Source/RELAX_Diffuse_Atrous.cs.hlsl @@ -8,14 +8,14 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define RELAX_DIFFUSE -#include "../Include/RELAX/RELAX_Config.hlsli" -#include "../Resources/RELAX_DiffuseSpecular_Atrous.resources.hlsli" +#include "RELAX/RELAX_Config.hlsli" +#include "RELAX_DiffuseSpecular_Atrous.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/RELAX/RELAX_Common.hlsli" -#include "../Include/RELAX/RELAX_DiffuseSpecular_Atrous.hlsli" +#include "Common.hlsli" +#include "RELAX/RELAX_Common.hlsli" +#include "RELAX/RELAX_DiffuseSpecular_Atrous.hlsli" diff --git a/Shaders/Source/RELAX_Diffuse_AtrousSmem.cs.hlsl b/Shaders/Source/RELAX_Diffuse_AtrousSmem.cs.hlsl index f7e35899..209a125c 100644 --- a/Shaders/Source/RELAX_Diffuse_AtrousSmem.cs.hlsl +++ b/Shaders/Source/RELAX_Diffuse_AtrousSmem.cs.hlsl @@ -8,14 +8,14 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define RELAX_DIFFUSE -#include "../Include/RELAX/RELAX_Config.hlsli" -#include "../Resources/RELAX_DiffuseSpecular_AtrousSmem.resources.hlsli" +#include "RELAX/RELAX_Config.hlsli" +#include "RELAX_DiffuseSpecular_AtrousSmem.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/RELAX/RELAX_Common.hlsli" -#include "../Include/RELAX/RELAX_DiffuseSpecular_AtrousSmem.hlsli" +#include "Common.hlsli" +#include "RELAX/RELAX_Common.hlsli" +#include "RELAX/RELAX_DiffuseSpecular_AtrousSmem.hlsli" diff --git a/Shaders/Source/RELAX_Diffuse_HistoryClamping.cs.hlsl b/Shaders/Source/RELAX_Diffuse_HistoryClamping.cs.hlsl index b6d23a7e..9e16ba80 100644 --- a/Shaders/Source/RELAX_Diffuse_HistoryClamping.cs.hlsl +++ b/Shaders/Source/RELAX_Diffuse_HistoryClamping.cs.hlsl @@ -8,14 +8,14 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define RELAX_DIFFUSE -#include "../Include/RELAX/RELAX_Config.hlsli" -#include "../Resources/RELAX_DiffuseSpecular_HistoryClamping.resources.hlsli" +#include "RELAX/RELAX_Config.hlsli" +#include "RELAX_DiffuseSpecular_HistoryClamping.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/RELAX/RELAX_Common.hlsli" -#include "../Include/RELAX/RELAX_DiffuseSpecular_HistoryClamping.hlsli" +#include "Common.hlsli" +#include "RELAX/RELAX_Common.hlsli" +#include "RELAX/RELAX_DiffuseSpecular_HistoryClamping.hlsli" diff --git a/Shaders/Source/RELAX_Diffuse_HistoryFix.cs.hlsl b/Shaders/Source/RELAX_Diffuse_HistoryFix.cs.hlsl index 67f28f89..48819f17 100644 --- a/Shaders/Source/RELAX_Diffuse_HistoryFix.cs.hlsl +++ b/Shaders/Source/RELAX_Diffuse_HistoryFix.cs.hlsl @@ -8,14 +8,14 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define RELAX_DIFFUSE -#include "../Include/RELAX/RELAX_Config.hlsli" -#include "../Resources/RELAX_DiffuseSpecular_HistoryFix.resources.hlsli" +#include "RELAX/RELAX_Config.hlsli" +#include "RELAX_DiffuseSpecular_HistoryFix.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/RELAX/RELAX_Common.hlsli" -#include "../Include/RELAX/RELAX_DiffuseSpecular_HistoryFix.hlsli" +#include "Common.hlsli" +#include "RELAX/RELAX_Common.hlsli" +#include "RELAX/RELAX_DiffuseSpecular_HistoryFix.hlsli" diff --git a/Shaders/Source/RELAX_Diffuse_HitDistReconstruction.cs.hlsl b/Shaders/Source/RELAX_Diffuse_HitDistReconstruction.cs.hlsl index 30f6c6df..1dc88818 100644 --- a/Shaders/Source/RELAX_Diffuse_HitDistReconstruction.cs.hlsl +++ b/Shaders/Source/RELAX_Diffuse_HitDistReconstruction.cs.hlsl @@ -8,14 +8,14 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define RELAX_DIFFUSE -#include "../Include/RELAX/RELAX_Config.hlsli" -#include "../Resources/RELAX_DiffuseSpecular_HitDistReconstruction.resources.hlsli" +#include "RELAX/RELAX_Config.hlsli" +#include "RELAX_DiffuseSpecular_HitDistReconstruction.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/RELAX/RELAX_Common.hlsli" -#include "../Include/RELAX/RELAX_DiffuseSpecular_HitDistReconstruction.hlsli" +#include "Common.hlsli" +#include "RELAX/RELAX_Common.hlsli" +#include "RELAX/RELAX_DiffuseSpecular_HitDistReconstruction.hlsli" diff --git a/Shaders/Source/RELAX_Diffuse_HitDistReconstruction_5x5.cs.hlsl b/Shaders/Source/RELAX_Diffuse_HitDistReconstruction_5x5.cs.hlsl index f8307a85..ebc228b2 100644 --- a/Shaders/Source/RELAX_Diffuse_HitDistReconstruction_5x5.cs.hlsl +++ b/Shaders/Source/RELAX_Diffuse_HitDistReconstruction_5x5.cs.hlsl @@ -8,15 +8,15 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define RELAX_DIFFUSE #define RELAX_HITDIST_RECONSTRUCTION_5X5 -#include "../Include/RELAX/RELAX_Config.hlsli" -#include "../Resources/RELAX_DiffuseSpecular_HitDistReconstruction.resources.hlsli" +#include "RELAX/RELAX_Config.hlsli" +#include "RELAX_DiffuseSpecular_HitDistReconstruction.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/RELAX/RELAX_Common.hlsli" -#include "../Include/RELAX/RELAX_DiffuseSpecular_HitDistReconstruction.hlsli" +#include "Common.hlsli" +#include "RELAX/RELAX_Common.hlsli" +#include "RELAX/RELAX_DiffuseSpecular_HitDistReconstruction.hlsli" diff --git a/Shaders/Source/RELAX_Diffuse_PrePass.cs.hlsl b/Shaders/Source/RELAX_Diffuse_PrePass.cs.hlsl index d6c22f0e..42aa9c56 100644 --- a/Shaders/Source/RELAX_Diffuse_PrePass.cs.hlsl +++ b/Shaders/Source/RELAX_Diffuse_PrePass.cs.hlsl @@ -8,14 +8,14 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define RELAX_DIFFUSE -#include "../Include/RELAX/RELAX_Config.hlsli" -#include "../Resources/RELAX_DiffuseSpecular_PrePass.resources.hlsli" +#include "RELAX/RELAX_Config.hlsli" +#include "RELAX_DiffuseSpecular_PrePass.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/RELAX/RELAX_Common.hlsli" -#include "../Include/RELAX/RELAX_DiffuseSpecular_PrePass.hlsli" +#include "Common.hlsli" +#include "RELAX/RELAX_Common.hlsli" +#include "RELAX/RELAX_DiffuseSpecular_PrePass.hlsli" diff --git a/Shaders/Source/RELAX_Diffuse_SplitScreen.cs.hlsl b/Shaders/Source/RELAX_Diffuse_SplitScreen.cs.hlsl index e353042c..9ae30200 100644 --- a/Shaders/Source/RELAX_Diffuse_SplitScreen.cs.hlsl +++ b/Shaders/Source/RELAX_Diffuse_SplitScreen.cs.hlsl @@ -8,14 +8,14 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define RELAX_DIFFUSE -#include "../Include/RELAX/RELAX_Config.hlsli" -#include "../Resources/RELAX_DiffuseSpecular_SplitScreen.resources.hlsli" +#include "RELAX/RELAX_Config.hlsli" +#include "RELAX_DiffuseSpecular_SplitScreen.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/RELAX/RELAX_Common.hlsli" -#include "../Include/RELAX/RELAX_DiffuseSpecular_SplitScreen.hlsli" +#include "Common.hlsli" +#include "RELAX/RELAX_Common.hlsli" +#include "RELAX/RELAX_DiffuseSpecular_SplitScreen.hlsli" diff --git a/Shaders/Source/RELAX_Diffuse_TemporalAccumulation.cs.hlsl b/Shaders/Source/RELAX_Diffuse_TemporalAccumulation.cs.hlsl index 06a73cf5..e4a30883 100644 --- a/Shaders/Source/RELAX_Diffuse_TemporalAccumulation.cs.hlsl +++ b/Shaders/Source/RELAX_Diffuse_TemporalAccumulation.cs.hlsl @@ -8,14 +8,14 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define RELAX_DIFFUSE -#include "../Include/RELAX/RELAX_Config.hlsli" -#include "../Resources/RELAX_DiffuseSpecular_TemporalAccumulation.resources.hlsli" +#include "RELAX/RELAX_Config.hlsli" +#include "RELAX_DiffuseSpecular_TemporalAccumulation.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/RELAX/RELAX_Common.hlsli" -#include "../Include/RELAX/RELAX_DiffuseSpecular_TemporalAccumulation.hlsli" +#include "Common.hlsli" +#include "RELAX/RELAX_Common.hlsli" +#include "RELAX/RELAX_DiffuseSpecular_TemporalAccumulation.hlsli" diff --git a/Shaders/Source/RELAX_SpecularSh_AntiFirefly.cs.hlsl b/Shaders/Source/RELAX_SpecularSh_AntiFirefly.cs.hlsl new file mode 100644 index 00000000..36bfe548 --- /dev/null +++ b/Shaders/Source/RELAX_SpecularSh_AntiFirefly.cs.hlsl @@ -0,0 +1,22 @@ +/* +Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved. + +NVIDIA CORPORATION and its licensors retain all intellectual property +and proprietary rights in and to this software, related documentation +and any modifications thereto. Any use, reproduction, disclosure or +distribution of this software and related documentation without an express +license agreement from NVIDIA CORPORATION is strictly prohibited. +*/ + +#include "NRD.hlsli" +#include "STL.hlsli" + +#define RELAX_SPECULAR +#define RELAX_SH + +#include "RELAX/RELAX_Config.hlsli" +#include "RELAX_DiffuseSpecular_AntiFirefly.resources.hlsli" + +#include "Common.hlsli" +#include "RELAX/RELAX_Common.hlsli" +#include "RELAX/RELAX_DiffuseSpecular_AntiFirefly.hlsli" diff --git a/Shaders/Source/RELAX_SpecularSh_Atrous.cs.hlsl b/Shaders/Source/RELAX_SpecularSh_Atrous.cs.hlsl new file mode 100644 index 00000000..3f9c3064 --- /dev/null +++ b/Shaders/Source/RELAX_SpecularSh_Atrous.cs.hlsl @@ -0,0 +1,22 @@ +/* +Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved. + +NVIDIA CORPORATION and its licensors retain all intellectual property +and proprietary rights in and to this software, related documentation +and any modifications thereto. Any use, reproduction, disclosure or +distribution of this software and related documentation without an express +license agreement from NVIDIA CORPORATION is strictly prohibited. +*/ + +#include "NRD.hlsli" +#include "STL.hlsli" + +#define RELAX_SPECULAR +#define RELAX_SH + +#include "RELAX/RELAX_Config.hlsli" +#include "RELAX_DiffuseSpecular_Atrous.resources.hlsli" + +#include "Common.hlsli" +#include "RELAX/RELAX_Common.hlsli" +#include "RELAX/RELAX_DiffuseSpecular_Atrous.hlsli" diff --git a/Shaders/Source/RELAX_SpecularSh_AtrousSmem.cs.hlsl b/Shaders/Source/RELAX_SpecularSh_AtrousSmem.cs.hlsl new file mode 100644 index 00000000..20550d1f --- /dev/null +++ b/Shaders/Source/RELAX_SpecularSh_AtrousSmem.cs.hlsl @@ -0,0 +1,22 @@ +/* +Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved. + +NVIDIA CORPORATION and its licensors retain all intellectual property +and proprietary rights in and to this software, related documentation +and any modifications thereto. Any use, reproduction, disclosure or +distribution of this software and related documentation without an express +license agreement from NVIDIA CORPORATION is strictly prohibited. +*/ + +#include "NRD.hlsli" +#include "STL.hlsli" + +#define RELAX_SPECULAR +#define RELAX_SH + +#include "RELAX/RELAX_Config.hlsli" +#include "RELAX_DiffuseSpecular_AtrousSmem.resources.hlsli" + +#include "Common.hlsli" +#include "RELAX/RELAX_Common.hlsli" +#include "RELAX/RELAX_DiffuseSpecular_AtrousSmem.hlsli" diff --git a/Shaders/Source/RELAX_SpecularSh_HistoryClamping.cs.hlsl b/Shaders/Source/RELAX_SpecularSh_HistoryClamping.cs.hlsl new file mode 100644 index 00000000..587b5b0d --- /dev/null +++ b/Shaders/Source/RELAX_SpecularSh_HistoryClamping.cs.hlsl @@ -0,0 +1,22 @@ +/* +Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved. + +NVIDIA CORPORATION and its licensors retain all intellectual property +and proprietary rights in and to this software, related documentation +and any modifications thereto. Any use, reproduction, disclosure or +distribution of this software and related documentation without an express +license agreement from NVIDIA CORPORATION is strictly prohibited. +*/ + +#include "NRD.hlsli" +#include "STL.hlsli" + +#define RELAX_SPECULAR +#define RELAX_SH + +#include "RELAX/RELAX_Config.hlsli" +#include "RELAX_DiffuseSpecular_HistoryClamping.resources.hlsli" + +#include "Common.hlsli" +#include "RELAX/RELAX_Common.hlsli" +#include "RELAX/RELAX_DiffuseSpecular_HistoryClamping.hlsli" diff --git a/Shaders/Source/RELAX_SpecularSh_HistoryFix.cs.hlsl b/Shaders/Source/RELAX_SpecularSh_HistoryFix.cs.hlsl new file mode 100644 index 00000000..7c0945dd --- /dev/null +++ b/Shaders/Source/RELAX_SpecularSh_HistoryFix.cs.hlsl @@ -0,0 +1,22 @@ +/* +Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved. + +NVIDIA CORPORATION and its licensors retain all intellectual property +and proprietary rights in and to this software, related documentation +and any modifications thereto. Any use, reproduction, disclosure or +distribution of this software and related documentation without an express +license agreement from NVIDIA CORPORATION is strictly prohibited. +*/ + +#include "NRD.hlsli" +#include "STL.hlsli" + +#define RELAX_SPECULAR +#define RELAX_SH + +#include "RELAX/RELAX_Config.hlsli" +#include "RELAX_DiffuseSpecular_HistoryFix.resources.hlsli" + +#include "Common.hlsli" +#include "RELAX/RELAX_Common.hlsli" +#include "RELAX/RELAX_DiffuseSpecular_HistoryFix.hlsli" diff --git a/Shaders/Source/RELAX_SpecularSh_PrePass.cs.hlsl b/Shaders/Source/RELAX_SpecularSh_PrePass.cs.hlsl new file mode 100644 index 00000000..a756f155 --- /dev/null +++ b/Shaders/Source/RELAX_SpecularSh_PrePass.cs.hlsl @@ -0,0 +1,22 @@ +/* +Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved. + +NVIDIA CORPORATION and its licensors retain all intellectual property +and proprietary rights in and to this software, related documentation +and any modifications thereto. Any use, reproduction, disclosure or +distribution of this software and related documentation without an express +license agreement from NVIDIA CORPORATION is strictly prohibited. +*/ + +#include "NRD.hlsli" +#include "STL.hlsli" + +#define RELAX_SPECULAR +#define RELAX_SH + +#include "RELAX/RELAX_Config.hlsli" +#include "RELAX_DiffuseSpecular_PrePass.resources.hlsli" + +#include "Common.hlsli" +#include "RELAX/RELAX_Common.hlsli" +#include "RELAX/RELAX_DiffuseSpecular_PrePass.hlsli" diff --git a/Shaders/Source/RELAX_SpecularSh_SplitScreen.cs.hlsl b/Shaders/Source/RELAX_SpecularSh_SplitScreen.cs.hlsl new file mode 100644 index 00000000..dbac178a --- /dev/null +++ b/Shaders/Source/RELAX_SpecularSh_SplitScreen.cs.hlsl @@ -0,0 +1,21 @@ +/* +Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved. + +NVIDIA CORPORATION and its licensors retain all intellectual property +and proprietary rights in and to this software, related documentation +and any modifications thereto. Any use, reproduction, disclosure or +distribution of this software and related documentation without an express +license agreement from NVIDIA CORPORATION is strictly prohibited. +*/ + +#include "NRD.hlsli" +#include "STL.hlsli" + +#define RELAX_SPECULAR + +#include "RELAX/RELAX_Config.hlsli" +#include "RELAX_DiffuseSpecular_SplitScreen.resources.hlsli" + +#include "Common.hlsli" +#include "RELAX/RELAX_Common.hlsli" +#include "RELAX/RELAX_DiffuseSpecular_SplitScreen.hlsli" diff --git a/Shaders/Source/RELAX_SpecularSh_TemporalAccumulation.cs.hlsl b/Shaders/Source/RELAX_SpecularSh_TemporalAccumulation.cs.hlsl new file mode 100644 index 00000000..209664bd --- /dev/null +++ b/Shaders/Source/RELAX_SpecularSh_TemporalAccumulation.cs.hlsl @@ -0,0 +1,22 @@ +/* +Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved. + +NVIDIA CORPORATION and its licensors retain all intellectual property +and proprietary rights in and to this software, related documentation +and any modifications thereto. Any use, reproduction, disclosure or +distribution of this software and related documentation without an express +license agreement from NVIDIA CORPORATION is strictly prohibited. +*/ + +#include "NRD.hlsli" +#include "STL.hlsli" + +#define RELAX_SPECULAR +#define RELAX_SH + +#include "RELAX/RELAX_Config.hlsli" +#include "RELAX_DiffuseSpecular_TemporalAccumulation.resources.hlsli" + +#include "Common.hlsli" +#include "RELAX/RELAX_Common.hlsli" +#include "RELAX/RELAX_DiffuseSpecular_TemporalAccumulation.hlsli" diff --git a/Shaders/Source/RELAX_Specular_AntiFirefly.cs.hlsl b/Shaders/Source/RELAX_Specular_AntiFirefly.cs.hlsl index 670ad5d7..361ca603 100644 --- a/Shaders/Source/RELAX_Specular_AntiFirefly.cs.hlsl +++ b/Shaders/Source/RELAX_Specular_AntiFirefly.cs.hlsl @@ -8,14 +8,14 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define RELAX_SPECULAR -#include "../Include/RELAX/RELAX_Config.hlsli" -#include "../Resources/RELAX_DiffuseSpecular_AntiFirefly.resources.hlsli" +#include "RELAX/RELAX_Config.hlsli" +#include "RELAX_DiffuseSpecular_AntiFirefly.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/RELAX/RELAX_Common.hlsli" -#include "../Include/RELAX/RELAX_DiffuseSpecular_AntiFirefly.hlsli" +#include "Common.hlsli" +#include "RELAX/RELAX_Common.hlsli" +#include "RELAX/RELAX_DiffuseSpecular_AntiFirefly.hlsli" diff --git a/Shaders/Source/RELAX_Specular_Atrous.cs.hlsl b/Shaders/Source/RELAX_Specular_Atrous.cs.hlsl index efb50a86..1eaa0a83 100644 --- a/Shaders/Source/RELAX_Specular_Atrous.cs.hlsl +++ b/Shaders/Source/RELAX_Specular_Atrous.cs.hlsl @@ -8,14 +8,14 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define RELAX_SPECULAR -#include "../Include/RELAX/RELAX_Config.hlsli" -#include "../Resources/RELAX_DiffuseSpecular_Atrous.resources.hlsli" +#include "RELAX/RELAX_Config.hlsli" +#include "RELAX_DiffuseSpecular_Atrous.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/RELAX/RELAX_Common.hlsli" -#include "../Include/RELAX/RELAX_DiffuseSpecular_Atrous.hlsli" +#include "Common.hlsli" +#include "RELAX/RELAX_Common.hlsli" +#include "RELAX/RELAX_DiffuseSpecular_Atrous.hlsli" diff --git a/Shaders/Source/RELAX_Specular_AtrousSmem.cs.hlsl b/Shaders/Source/RELAX_Specular_AtrousSmem.cs.hlsl index 0be5f34a..01a67637 100644 --- a/Shaders/Source/RELAX_Specular_AtrousSmem.cs.hlsl +++ b/Shaders/Source/RELAX_Specular_AtrousSmem.cs.hlsl @@ -8,14 +8,14 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define RELAX_SPECULAR -#include "../Include/RELAX/RELAX_Config.hlsli" -#include "../Resources/RELAX_DiffuseSpecular_AtrousSmem.resources.hlsli" +#include "RELAX/RELAX_Config.hlsli" +#include "RELAX_DiffuseSpecular_AtrousSmem.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/RELAX/RELAX_Common.hlsli" -#include "../Include/RELAX/RELAX_DiffuseSpecular_AtrousSmem.hlsli" +#include "Common.hlsli" +#include "RELAX/RELAX_Common.hlsli" +#include "RELAX/RELAX_DiffuseSpecular_AtrousSmem.hlsli" diff --git a/Shaders/Source/RELAX_Specular_HistoryClamping.cs.hlsl b/Shaders/Source/RELAX_Specular_HistoryClamping.cs.hlsl index 53bdeecc..ecfa68c8 100644 --- a/Shaders/Source/RELAX_Specular_HistoryClamping.cs.hlsl +++ b/Shaders/Source/RELAX_Specular_HistoryClamping.cs.hlsl @@ -8,14 +8,14 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define RELAX_SPECULAR -#include "../Include/RELAX/RELAX_Config.hlsli" -#include "../Resources/RELAX_DiffuseSpecular_HistoryClamping.resources.hlsli" +#include "RELAX/RELAX_Config.hlsli" +#include "RELAX_DiffuseSpecular_HistoryClamping.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/RELAX/RELAX_Common.hlsli" -#include "../Include/RELAX/RELAX_DiffuseSpecular_HistoryClamping.hlsli" +#include "Common.hlsli" +#include "RELAX/RELAX_Common.hlsli" +#include "RELAX/RELAX_DiffuseSpecular_HistoryClamping.hlsli" diff --git a/Shaders/Source/RELAX_Specular_HistoryFix.cs.hlsl b/Shaders/Source/RELAX_Specular_HistoryFix.cs.hlsl index 647e52ba..d8b111c0 100644 --- a/Shaders/Source/RELAX_Specular_HistoryFix.cs.hlsl +++ b/Shaders/Source/RELAX_Specular_HistoryFix.cs.hlsl @@ -8,14 +8,14 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define RELAX_SPECULAR -#include "../Include/RELAX/RELAX_Config.hlsli" -#include "../Resources/RELAX_DiffuseSpecular_HistoryFix.resources.hlsli" +#include "RELAX/RELAX_Config.hlsli" +#include "RELAX_DiffuseSpecular_HistoryFix.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/RELAX/RELAX_Common.hlsli" -#include "../Include/RELAX/RELAX_DiffuseSpecular_HistoryFix.hlsli" +#include "Common.hlsli" +#include "RELAX/RELAX_Common.hlsli" +#include "RELAX/RELAX_DiffuseSpecular_HistoryFix.hlsli" diff --git a/Shaders/Source/RELAX_Specular_HitDistReconstruction.cs.hlsl b/Shaders/Source/RELAX_Specular_HitDistReconstruction.cs.hlsl index 3be46605..588cce1b 100644 --- a/Shaders/Source/RELAX_Specular_HitDistReconstruction.cs.hlsl +++ b/Shaders/Source/RELAX_Specular_HitDistReconstruction.cs.hlsl @@ -8,14 +8,14 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define RELAX_SPECULAR -#include "../Include/RELAX/RELAX_Config.hlsli" -#include "../Resources/RELAX_DiffuseSpecular_HitDistReconstruction.resources.hlsli" +#include "RELAX/RELAX_Config.hlsli" +#include "RELAX_DiffuseSpecular_HitDistReconstruction.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/RELAX/RELAX_Common.hlsli" -#include "../Include/RELAX/RELAX_DiffuseSpecular_HitDistReconstruction.hlsli" +#include "Common.hlsli" +#include "RELAX/RELAX_Common.hlsli" +#include "RELAX/RELAX_DiffuseSpecular_HitDistReconstruction.hlsli" diff --git a/Shaders/Source/RELAX_Specular_HitDistReconstruction_5x5.cs.hlsl b/Shaders/Source/RELAX_Specular_HitDistReconstruction_5x5.cs.hlsl index 86d3bb3d..539b87b2 100644 --- a/Shaders/Source/RELAX_Specular_HitDistReconstruction_5x5.cs.hlsl +++ b/Shaders/Source/RELAX_Specular_HitDistReconstruction_5x5.cs.hlsl @@ -8,15 +8,15 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define RELAX_SPECULAR #define RELAX_HITDIST_RECONSTRUCTION_5X5 -#include "../Include/RELAX/RELAX_Config.hlsli" -#include "../Resources/RELAX_DiffuseSpecular_HitDistReconstruction.resources.hlsli" +#include "RELAX/RELAX_Config.hlsli" +#include "RELAX_DiffuseSpecular_HitDistReconstruction.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/RELAX/RELAX_Common.hlsli" -#include "../Include/RELAX/RELAX_DiffuseSpecular_HitDistReconstruction.hlsli" +#include "Common.hlsli" +#include "RELAX/RELAX_Common.hlsli" +#include "RELAX/RELAX_DiffuseSpecular_HitDistReconstruction.hlsli" diff --git a/Shaders/Source/RELAX_Specular_PrePass.cs.hlsl b/Shaders/Source/RELAX_Specular_PrePass.cs.hlsl index ad6a3212..adf6a401 100644 --- a/Shaders/Source/RELAX_Specular_PrePass.cs.hlsl +++ b/Shaders/Source/RELAX_Specular_PrePass.cs.hlsl @@ -8,14 +8,14 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define RELAX_SPECULAR -#include "../Include/RELAX/RELAX_Config.hlsli" -#include "../Resources/RELAX_DiffuseSpecular_PrePass.resources.hlsli" +#include "RELAX/RELAX_Config.hlsli" +#include "RELAX_DiffuseSpecular_PrePass.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/RELAX/RELAX_Common.hlsli" -#include "../Include/RELAX/RELAX_DiffuseSpecular_PrePass.hlsli" +#include "Common.hlsli" +#include "RELAX/RELAX_Common.hlsli" +#include "RELAX/RELAX_DiffuseSpecular_PrePass.hlsli" diff --git a/Shaders/Source/RELAX_Specular_SplitScreen.cs.hlsl b/Shaders/Source/RELAX_Specular_SplitScreen.cs.hlsl index e73c53a6..dbac178a 100644 --- a/Shaders/Source/RELAX_Specular_SplitScreen.cs.hlsl +++ b/Shaders/Source/RELAX_Specular_SplitScreen.cs.hlsl @@ -8,14 +8,14 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define RELAX_SPECULAR -#include "../Include/RELAX/RELAX_Config.hlsli" -#include "../Resources/RELAX_DiffuseSpecular_SplitScreen.resources.hlsli" +#include "RELAX/RELAX_Config.hlsli" +#include "RELAX_DiffuseSpecular_SplitScreen.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/RELAX/RELAX_Common.hlsli" -#include "../Include/RELAX/RELAX_DiffuseSpecular_SplitScreen.hlsli" +#include "Common.hlsli" +#include "RELAX/RELAX_Common.hlsli" +#include "RELAX/RELAX_DiffuseSpecular_SplitScreen.hlsli" diff --git a/Shaders/Source/RELAX_Specular_TemporalAccumulation.cs.hlsl b/Shaders/Source/RELAX_Specular_TemporalAccumulation.cs.hlsl index 05114f8e..2dcd2b13 100644 --- a/Shaders/Source/RELAX_Specular_TemporalAccumulation.cs.hlsl +++ b/Shaders/Source/RELAX_Specular_TemporalAccumulation.cs.hlsl @@ -8,14 +8,14 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define RELAX_SPECULAR -#include "../Include/RELAX/RELAX_Config.hlsli" -#include "../Resources/RELAX_DiffuseSpecular_TemporalAccumulation.resources.hlsli" +#include "RELAX/RELAX_Config.hlsli" +#include "RELAX_DiffuseSpecular_TemporalAccumulation.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/RELAX/RELAX_Common.hlsli" -#include "../Include/RELAX/RELAX_DiffuseSpecular_TemporalAccumulation.hlsli" +#include "Common.hlsli" +#include "RELAX/RELAX_Common.hlsli" +#include "RELAX/RELAX_DiffuseSpecular_TemporalAccumulation.hlsli" diff --git a/Shaders/Source/RELAX_Validation.cs.hlsl b/Shaders/Source/RELAX_Validation.cs.hlsl index 650f5c74..7c846216 100644 --- a/Shaders/Source/RELAX_Validation.cs.hlsl +++ b/Shaders/Source/RELAX_Validation.cs.hlsl @@ -8,14 +8,14 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" -#include "../Include/RELAX/RELAX_Config.hlsli" -#include "../Resources/RELAX_Validation.resources.hlsli" +#include "RELAX/RELAX_Config.hlsli" +#include "RELAX_Validation.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/RELAX/RELAX_Common.hlsli" +#include "Common.hlsli" +#include "RELAX/RELAX_Common.hlsli" #define VIEWPORT_SIZE 0.25 #define OFFSET 5 diff --git a/Shaders/Source/SIGMA_ShadowTranslucency_Blur.cs.hlsl b/Shaders/Source/SIGMA_ShadowTranslucency_Blur.cs.hlsl index ab797664..9358e399 100644 --- a/Shaders/Source/SIGMA_ShadowTranslucency_Blur.cs.hlsl +++ b/Shaders/Source/SIGMA_ShadowTranslucency_Blur.cs.hlsl @@ -8,15 +8,15 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define SIGMA_TRANSLUCENT #define SIGMA_FIRST_PASS -#include "../Include/SIGMA/SIGMA_Config.hlsli" -#include "../Resources/SIGMA_Shadow_Blur.resources.hlsli" +#include "SIGMA/SIGMA_Config.hlsli" +#include "SIGMA_Shadow_Blur.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/SIGMA/SIGMA_Common.hlsli" -#include "../Include/SIGMA/SIGMA_Shadow_Blur.hlsli" +#include "Common.hlsli" +#include "SIGMA/SIGMA_Common.hlsli" +#include "SIGMA/SIGMA_Shadow_Blur.hlsli" diff --git a/Shaders/Source/SIGMA_ShadowTranslucency_ClassifyTiles.cs.hlsl b/Shaders/Source/SIGMA_ShadowTranslucency_ClassifyTiles.cs.hlsl index cb45282b..28b86df3 100644 --- a/Shaders/Source/SIGMA_ShadowTranslucency_ClassifyTiles.cs.hlsl +++ b/Shaders/Source/SIGMA_ShadowTranslucency_ClassifyTiles.cs.hlsl @@ -8,14 +8,14 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define SIGMA_TRANSLUCENT -#include "../Include/SIGMA/SIGMA_Config.hlsli" -#include "../Resources/SIGMA_Shadow_ClassifyTiles.resources.hlsli" +#include "SIGMA/SIGMA_Config.hlsli" +#include "SIGMA_Shadow_ClassifyTiles.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/SIGMA/SIGMA_Common.hlsli" -#include "../Include/SIGMA/SIGMA_Shadow_ClassifyTiles.hlsli" +#include "Common.hlsli" +#include "SIGMA/SIGMA_Common.hlsli" +#include "SIGMA/SIGMA_Shadow_ClassifyTiles.hlsli" diff --git a/Shaders/Source/SIGMA_ShadowTranslucency_PostBlur.cs.hlsl b/Shaders/Source/SIGMA_ShadowTranslucency_PostBlur.cs.hlsl index e243dcda..9ba0af31 100644 --- a/Shaders/Source/SIGMA_ShadowTranslucency_PostBlur.cs.hlsl +++ b/Shaders/Source/SIGMA_ShadowTranslucency_PostBlur.cs.hlsl @@ -8,14 +8,14 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define SIGMA_TRANSLUCENT -#include "../Include/SIGMA/SIGMA_Config.hlsli" -#include "../Resources/SIGMA_Shadow_Blur.resources.hlsli" +#include "SIGMA/SIGMA_Config.hlsli" +#include "SIGMA_Shadow_Blur.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/SIGMA/SIGMA_Common.hlsli" -#include "../Include/SIGMA/SIGMA_Shadow_Blur.hlsli" +#include "Common.hlsli" +#include "SIGMA/SIGMA_Common.hlsli" +#include "SIGMA/SIGMA_Shadow_Blur.hlsli" diff --git a/Shaders/Source/SIGMA_ShadowTranslucency_SplitScreen.cs.hlsl b/Shaders/Source/SIGMA_ShadowTranslucency_SplitScreen.cs.hlsl index fabc71bd..fd9451fd 100644 --- a/Shaders/Source/SIGMA_ShadowTranslucency_SplitScreen.cs.hlsl +++ b/Shaders/Source/SIGMA_ShadowTranslucency_SplitScreen.cs.hlsl @@ -8,14 +8,14 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define SIGMA_TRANSLUCENT -#include "../Include/SIGMA/SIGMA_Config.hlsli" -#include "../Resources/SIGMA_Shadow_SplitScreen.resources.hlsli" +#include "SIGMA/SIGMA_Config.hlsli" +#include "SIGMA_Shadow_SplitScreen.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/SIGMA/SIGMA_Common.hlsli" -#include "../Include/SIGMA/SIGMA_Shadow_SplitScreen.hlsli" +#include "Common.hlsli" +#include "SIGMA/SIGMA_Common.hlsli" +#include "SIGMA/SIGMA_Shadow_SplitScreen.hlsli" diff --git a/Shaders/Source/SIGMA_ShadowTranslucency_TemporalStabilization.cs.hlsl b/Shaders/Source/SIGMA_ShadowTranslucency_TemporalStabilization.cs.hlsl index cb3a8e01..9a9f901a 100644 --- a/Shaders/Source/SIGMA_ShadowTranslucency_TemporalStabilization.cs.hlsl +++ b/Shaders/Source/SIGMA_ShadowTranslucency_TemporalStabilization.cs.hlsl @@ -8,14 +8,14 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define SIGMA_TRANSLUCENT -#include "../Include/SIGMA/SIGMA_Config.hlsli" -#include "../Resources/SIGMA_Shadow_TemporalStabilization.resources.hlsli" +#include "SIGMA/SIGMA_Config.hlsli" +#include "SIGMA_Shadow_TemporalStabilization.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/SIGMA/SIGMA_Common.hlsli" -#include "../Include/SIGMA/SIGMA_Shadow_TemporalStabilization.hlsli" +#include "Common.hlsli" +#include "SIGMA/SIGMA_Common.hlsli" +#include "SIGMA/SIGMA_Shadow_TemporalStabilization.hlsli" diff --git a/Shaders/Source/SIGMA_Shadow_Blur.cs.hlsl b/Shaders/Source/SIGMA_Shadow_Blur.cs.hlsl index 68332f14..19d7c625 100644 --- a/Shaders/Source/SIGMA_Shadow_Blur.cs.hlsl +++ b/Shaders/Source/SIGMA_Shadow_Blur.cs.hlsl @@ -8,14 +8,14 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" #define SIGMA_FIRST_PASS -#include "../Include/SIGMA/SIGMA_Config.hlsli" -#include "../Resources/SIGMA_Shadow_Blur.resources.hlsli" +#include "SIGMA/SIGMA_Config.hlsli" +#include "SIGMA_Shadow_Blur.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/SIGMA/SIGMA_Common.hlsli" -#include "../Include/SIGMA/SIGMA_Shadow_Blur.hlsli" +#include "Common.hlsli" +#include "SIGMA/SIGMA_Common.hlsli" +#include "SIGMA/SIGMA_Shadow_Blur.hlsli" diff --git a/Shaders/Source/SIGMA_Shadow_ClassifyTiles.cs.hlsl b/Shaders/Source/SIGMA_Shadow_ClassifyTiles.cs.hlsl index 6a186336..e187711d 100644 --- a/Shaders/Source/SIGMA_Shadow_ClassifyTiles.cs.hlsl +++ b/Shaders/Source/SIGMA_Shadow_ClassifyTiles.cs.hlsl @@ -8,12 +8,12 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" -#include "../Include/SIGMA/SIGMA_Config.hlsli" -#include "../Resources/SIGMA_Shadow_ClassifyTiles.resources.hlsli" +#include "SIGMA/SIGMA_Config.hlsli" +#include "SIGMA_Shadow_ClassifyTiles.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/SIGMA/SIGMA_Common.hlsli" -#include "../Include/SIGMA/SIGMA_Shadow_ClassifyTiles.hlsli" +#include "Common.hlsli" +#include "SIGMA/SIGMA_Common.hlsli" +#include "SIGMA/SIGMA_Shadow_ClassifyTiles.hlsli" diff --git a/Shaders/Source/SIGMA_Shadow_PostBlur.cs.hlsl b/Shaders/Source/SIGMA_Shadow_PostBlur.cs.hlsl index 513d98e7..d75cb8aa 100644 --- a/Shaders/Source/SIGMA_Shadow_PostBlur.cs.hlsl +++ b/Shaders/Source/SIGMA_Shadow_PostBlur.cs.hlsl @@ -8,12 +8,12 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" -#include "../Include/SIGMA/SIGMA_Config.hlsli" -#include "../Resources/SIGMA_Shadow_Blur.resources.hlsli" +#include "SIGMA/SIGMA_Config.hlsli" +#include "SIGMA_Shadow_Blur.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/SIGMA/SIGMA_Common.hlsli" -#include "../Include/SIGMA/SIGMA_Shadow_Blur.hlsli" +#include "Common.hlsli" +#include "SIGMA/SIGMA_Common.hlsli" +#include "SIGMA/SIGMA_Shadow_Blur.hlsli" diff --git a/Shaders/Source/SIGMA_Shadow_SmoothTiles.cs.hlsl b/Shaders/Source/SIGMA_Shadow_SmoothTiles.cs.hlsl index 3f17045e..449bd074 100644 --- a/Shaders/Source/SIGMA_Shadow_SmoothTiles.cs.hlsl +++ b/Shaders/Source/SIGMA_Shadow_SmoothTiles.cs.hlsl @@ -8,14 +8,14 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" -#include "../Include/SIGMA/SIGMA_Config.hlsli" -#include "../Resources/SIGMA_Shadow_SmoothTiles.resources.hlsli" +#include "SIGMA/SIGMA_Config.hlsli" +#include "SIGMA_Shadow_SmoothTiles.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/SIGMA/SIGMA_Common.hlsli" +#include "Common.hlsli" +#include "SIGMA/SIGMA_Common.hlsli" groupshared float2 s_Tile[ BUFFER_Y ][ BUFFER_X ]; diff --git a/Shaders/Source/SIGMA_Shadow_SplitScreen.cs.hlsl b/Shaders/Source/SIGMA_Shadow_SplitScreen.cs.hlsl index 49b520c5..6b334635 100644 --- a/Shaders/Source/SIGMA_Shadow_SplitScreen.cs.hlsl +++ b/Shaders/Source/SIGMA_Shadow_SplitScreen.cs.hlsl @@ -8,12 +8,12 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" -#include "../Include/SIGMA/SIGMA_Config.hlsli" -#include "../Resources/SIGMA_Shadow_SplitScreen.resources.hlsli" +#include "SIGMA/SIGMA_Config.hlsli" +#include "SIGMA_Shadow_SplitScreen.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/SIGMA/SIGMA_Common.hlsli" -#include "../Include/SIGMA/SIGMA_Shadow_SplitScreen.hlsli" +#include "Common.hlsli" +#include "SIGMA/SIGMA_Common.hlsli" +#include "SIGMA/SIGMA_Shadow_SplitScreen.hlsli" diff --git a/Shaders/Source/SIGMA_Shadow_TemporalStabilization.cs.hlsl b/Shaders/Source/SIGMA_Shadow_TemporalStabilization.cs.hlsl index ec4437d9..0c6b91cf 100644 --- a/Shaders/Source/SIGMA_Shadow_TemporalStabilization.cs.hlsl +++ b/Shaders/Source/SIGMA_Shadow_TemporalStabilization.cs.hlsl @@ -8,12 +8,12 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" -#include "../Include/SIGMA/SIGMA_Config.hlsli" -#include "../Resources/SIGMA_Shadow_TemporalStabilization.resources.hlsli" +#include "SIGMA/SIGMA_Config.hlsli" +#include "SIGMA_Shadow_TemporalStabilization.resources.hlsli" -#include "../Include/Common.hlsli" -#include "../Include/SIGMA/SIGMA_Common.hlsli" -#include "../Include/SIGMA/SIGMA_Shadow_TemporalStabilization.hlsli" +#include "Common.hlsli" +#include "SIGMA/SIGMA_Common.hlsli" +#include "SIGMA/SIGMA_Shadow_TemporalStabilization.hlsli" diff --git a/Shaders/Source/SpecularDeltaMv_Compute.cs.hlsl b/Shaders/Source/SpecularDeltaMv_Compute.cs.hlsl index 859fddf4..ce33089b 100644 --- a/Shaders/Source/SpecularDeltaMv_Compute.cs.hlsl +++ b/Shaders/Source/SpecularDeltaMv_Compute.cs.hlsl @@ -8,12 +8,12 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" -#include "../Resources/SpecularDeltaMv_Compute.resources.hlsli" +#include "SpecularDeltaMv_Compute.resources.hlsli" -#include "../Include/Common.hlsli" +#include "Common.hlsli" // acos(dot(a,b)) has severe precision issues for small angles // length(cross(a,b)) == length(a) * length(b) * sin(angle) diff --git a/Shaders/Source/SpecularReflectionMv_Compute.cs.hlsl b/Shaders/Source/SpecularReflectionMv_Compute.cs.hlsl index 534f8b07..40ee1b0b 100644 --- a/Shaders/Source/SpecularReflectionMv_Compute.cs.hlsl +++ b/Shaders/Source/SpecularReflectionMv_Compute.cs.hlsl @@ -8,12 +8,12 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#include "../Include/NRD.hlsli" +#include "NRD.hlsli" #include "STL.hlsli" -#include "../Resources/SpecularReflectionMv_Compute.resources.hlsli" +#include "SpecularReflectionMv_Compute.resources.hlsli" -#include "../Include/Common.hlsli" +#include "Common.hlsli" groupshared float4 s_Normal_Roughness[ BUFFER_Y ][ BUFFER_X ]; diff --git a/Source/DenoiserImpl.cpp b/Source/DenoiserImpl.cpp index 9a1ec6e6..84211eec 100644 --- a/Source/DenoiserImpl.cpp +++ b/Source/DenoiserImpl.cpp @@ -8,17 +8,11 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ +#include "../Shaders/Include/NRD.hlsli" #include "DenoiserImpl.h" #include -#define NRD_HEADER_ONLY -#include "../Shaders/Include/NRD.hlsli" - -#ifndef BYTE - #define BYTE unsigned char -#endif - constexpr std::array g_Samplers = { nrd::Sampler::NEAREST_CLAMP, @@ -75,10 +69,6 @@ constexpr std::array g_IsIntegerFormat = false, // R9_G9_B9_E5_UFLOAT }; -//============================================================================================================================= -// SHADERS -//============================================================================================================================= - #ifdef NRD_USE_PRECOMPILED_SHADERS // NRD @@ -92,736 +82,8 @@ constexpr std::array g_IsIntegerFormat = #include "Clear_f.cs.spirv.h" #include "Clear_ui.cs.spirv.h" - // REBLUR_DIFFUSE - #if !NRD_ONLY_SPIRV_SHADERS_AVAILABLE - #include "REBLUR_Diffuse_HitDistReconstruction.cs.dxbc.h" - #include "REBLUR_Diffuse_HitDistReconstruction.cs.dxil.h" - #include "REBLUR_Diffuse_HitDistReconstruction_5x5.cs.dxbc.h" - #include "REBLUR_Diffuse_HitDistReconstruction_5x5.cs.dxil.h" - #include "REBLUR_Diffuse_PrePass.cs.dxbc.h" - #include "REBLUR_Diffuse_PrePass.cs.dxil.h" - #include "REBLUR_Diffuse_TemporalAccumulation.cs.dxbc.h" - #include "REBLUR_Diffuse_TemporalAccumulation.cs.dxil.h" - #include "REBLUR_Diffuse_HistoryFix.cs.dxbc.h" - #include "REBLUR_Diffuse_HistoryFix.cs.dxil.h" - #include "REBLUR_Diffuse_Blur.cs.dxbc.h" - #include "REBLUR_Diffuse_Blur.cs.dxil.h" - #include "REBLUR_Diffuse_PostBlur.cs.dxbc.h" - #include "REBLUR_Diffuse_PostBlur.cs.dxil.h" - #include "REBLUR_Diffuse_PostBlur_NoTemporalStabilization.cs.dxbc.h" - #include "REBLUR_Diffuse_PostBlur_NoTemporalStabilization.cs.dxil.h" - #include "REBLUR_Diffuse_CopyStabilizedHistory.cs.dxbc.h" - #include "REBLUR_Diffuse_CopyStabilizedHistory.cs.dxil.h" - #include "REBLUR_Diffuse_TemporalStabilization.cs.dxbc.h" - #include "REBLUR_Diffuse_TemporalStabilization.cs.dxil.h" - #include "REBLUR_Diffuse_SplitScreen.cs.dxbc.h" - #include "REBLUR_Diffuse_SplitScreen.cs.dxil.h" - #include "REBLUR_Validation.cs.dxbc.h" - #include "REBLUR_Validation.cs.dxil.h" - - #include "REBLUR_Perf_Diffuse_HitDistReconstruction.cs.dxbc.h" - #include "REBLUR_Perf_Diffuse_HitDistReconstruction.cs.dxil.h" - #include "REBLUR_Perf_Diffuse_HitDistReconstruction_5x5.cs.dxil.h" - #include "REBLUR_Perf_Diffuse_HitDistReconstruction_5x5.cs.dxbc.h" - #include "REBLUR_Perf_Diffuse_PrePass.cs.dxbc.h" - #include "REBLUR_Perf_Diffuse_PrePass.cs.dxil.h" - #include "REBLUR_Perf_Diffuse_TemporalAccumulation.cs.dxbc.h" - #include "REBLUR_Perf_Diffuse_TemporalAccumulation.cs.dxil.h" - #include "REBLUR_Perf_Diffuse_HistoryFix.cs.dxbc.h" - #include "REBLUR_Perf_Diffuse_HistoryFix.cs.dxil.h" - #include "REBLUR_Perf_Diffuse_Blur.cs.dxbc.h" - #include "REBLUR_Perf_Diffuse_Blur.cs.dxil.h" - #include "REBLUR_Perf_Diffuse_PostBlur.cs.dxbc.h" - #include "REBLUR_Perf_Diffuse_PostBlur.cs.dxil.h" - #include "REBLUR_Perf_Diffuse_PostBlur_NoTemporalStabilization.cs.dxbc.h" - #include "REBLUR_Perf_Diffuse_PostBlur_NoTemporalStabilization.cs.dxil.h" - #include "REBLUR_Perf_Diffuse_TemporalStabilization.cs.dxbc.h" - #include "REBLUR_Perf_Diffuse_TemporalStabilization.cs.dxil.h" - #endif - - #include "REBLUR_Diffuse_HitDistReconstruction.cs.spirv.h" - #include "REBLUR_Diffuse_HitDistReconstruction_5x5.cs.spirv.h" - #include "REBLUR_Diffuse_PrePass.cs.spirv.h" - #include "REBLUR_Diffuse_TemporalAccumulation.cs.spirv.h" - #include "REBLUR_Diffuse_HistoryFix.cs.spirv.h" - #include "REBLUR_Diffuse_Blur.cs.spirv.h" - #include "REBLUR_Diffuse_CopyStabilizedHistory.cs.spirv.h" - #include "REBLUR_Diffuse_TemporalStabilization.cs.spirv.h" - #include "REBLUR_Diffuse_PostBlur.cs.spirv.h" - #include "REBLUR_Diffuse_PostBlur_NoTemporalStabilization.cs.spirv.h" - #include "REBLUR_Diffuse_SplitScreen.cs.spirv.h" - #include "REBLUR_Validation.cs.spirv.h" - - #include "REBLUR_Perf_Diffuse_HitDistReconstruction.cs.spirv.h" - #include "REBLUR_Perf_Diffuse_HitDistReconstruction_5x5.cs.spirv.h" - #include "REBLUR_Perf_Diffuse_PrePass.cs.spirv.h" - #include "REBLUR_Perf_Diffuse_TemporalAccumulation.cs.spirv.h" - #include "REBLUR_Perf_Diffuse_HistoryFix.cs.spirv.h" - #include "REBLUR_Perf_Diffuse_Blur.cs.spirv.h" - #include "REBLUR_Perf_Diffuse_TemporalStabilization.cs.spirv.h" - #include "REBLUR_Perf_Diffuse_PostBlur.cs.spirv.h" - #include "REBLUR_Perf_Diffuse_PostBlur_NoTemporalStabilization.cs.spirv.h" - - // REBLUR_DIFFUSE_OCCLUSION - #if !NRD_ONLY_SPIRV_SHADERS_AVAILABLE - #include "REBLUR_DiffuseOcclusion_HitDistReconstruction.cs.dxbc.h" - #include "REBLUR_DiffuseOcclusion_HitDistReconstruction.cs.dxil.h" - #include "REBLUR_DiffuseOcclusion_HitDistReconstruction_5x5.cs.dxbc.h" - #include "REBLUR_DiffuseOcclusion_HitDistReconstruction_5x5.cs.dxil.h" - #include "REBLUR_DiffuseOcclusion_TemporalAccumulation.cs.dxbc.h" - #include "REBLUR_DiffuseOcclusion_TemporalAccumulation.cs.dxil.h" - #include "REBLUR_DiffuseOcclusion_HistoryFix.cs.dxbc.h" - #include "REBLUR_DiffuseOcclusion_HistoryFix.cs.dxil.h" - #include "REBLUR_DiffuseOcclusion_Blur.cs.dxbc.h" - #include "REBLUR_DiffuseOcclusion_Blur.cs.dxil.h" - #include "REBLUR_DiffuseOcclusion_PostBlur_NoTemporalStabilization.cs.dxbc.h" - #include "REBLUR_DiffuseOcclusion_PostBlur_NoTemporalStabilization.cs.dxil.h" - - #include "REBLUR_Perf_DiffuseOcclusion_HitDistReconstruction.cs.dxbc.h" - #include "REBLUR_Perf_DiffuseOcclusion_HitDistReconstruction.cs.dxil.h" - #include "REBLUR_Perf_DiffuseOcclusion_HitDistReconstruction_5x5.cs.dxbc.h" - #include "REBLUR_Perf_DiffuseOcclusion_HitDistReconstruction_5x5.cs.dxil.h" - #include "REBLUR_Perf_DiffuseOcclusion_TemporalAccumulation.cs.dxbc.h" - #include "REBLUR_Perf_DiffuseOcclusion_TemporalAccumulation.cs.dxil.h" - #include "REBLUR_Perf_DiffuseOcclusion_HistoryFix.cs.dxbc.h" - #include "REBLUR_Perf_DiffuseOcclusion_HistoryFix.cs.dxil.h" - #include "REBLUR_Perf_DiffuseOcclusion_Blur.cs.dxbc.h" - #include "REBLUR_Perf_DiffuseOcclusion_Blur.cs.dxil.h" - #include "REBLUR_Perf_DiffuseOcclusion_PostBlur_NoTemporalStabilization.cs.dxbc.h" - #include "REBLUR_Perf_DiffuseOcclusion_PostBlur_NoTemporalStabilization.cs.dxil.h" - #endif - - #include "REBLUR_DiffuseOcclusion_HitDistReconstruction.cs.spirv.h" - #include "REBLUR_DiffuseOcclusion_HitDistReconstruction_5x5.cs.spirv.h" - #include "REBLUR_DiffuseOcclusion_TemporalAccumulation.cs.spirv.h" - #include "REBLUR_DiffuseOcclusion_HistoryFix.cs.spirv.h" - #include "REBLUR_DiffuseOcclusion_Blur.cs.spirv.h" - #include "REBLUR_DiffuseOcclusion_PostBlur_NoTemporalStabilization.cs.spirv.h" - - #include "REBLUR_Perf_DiffuseOcclusion_HitDistReconstruction.cs.spirv.h" - #include "REBLUR_Perf_DiffuseOcclusion_HitDistReconstruction_5x5.cs.spirv.h" - #include "REBLUR_Perf_DiffuseOcclusion_TemporalAccumulation.cs.spirv.h" - #include "REBLUR_Perf_DiffuseOcclusion_HistoryFix.cs.spirv.h" - #include "REBLUR_Perf_DiffuseOcclusion_Blur.cs.spirv.h" - #include "REBLUR_Perf_DiffuseOcclusion_PostBlur_NoTemporalStabilization.cs.spirv.h" - - // REBLUR_DIFFUSE_SH - #if !NRD_ONLY_SPIRV_SHADERS_AVAILABLE - #include "REBLUR_DiffuseSh_PrePass.cs.dxbc.h" - #include "REBLUR_DiffuseSh_PrePass.cs.dxil.h" - #include "REBLUR_DiffuseSh_TemporalAccumulation.cs.dxbc.h" - #include "REBLUR_DiffuseSh_TemporalAccumulation.cs.dxil.h" - #include "REBLUR_DiffuseSh_HistoryFix.cs.dxbc.h" - #include "REBLUR_DiffuseSh_HistoryFix.cs.dxil.h" - #include "REBLUR_DiffuseSh_Blur.cs.dxbc.h" - #include "REBLUR_DiffuseSh_Blur.cs.dxil.h" - #include "REBLUR_DiffuseSh_PostBlur.cs.dxbc.h" - #include "REBLUR_DiffuseSh_PostBlur.cs.dxil.h" - #include "REBLUR_DiffuseSh_PostBlur_NoTemporalStabilization.cs.dxbc.h" - #include "REBLUR_DiffuseSh_PostBlur_NoTemporalStabilization.cs.dxil.h" - #include "REBLUR_DiffuseSh_CopyStabilizedHistory.cs.dxbc.h" - #include "REBLUR_DiffuseSh_CopyStabilizedHistory.cs.dxil.h" - #include "REBLUR_DiffuseSh_TemporalStabilization.cs.dxbc.h" - #include "REBLUR_DiffuseSh_TemporalStabilization.cs.dxil.h" - #include "REBLUR_DiffuseSh_SplitScreen.cs.dxbc.h" - #include "REBLUR_DiffuseSh_SplitScreen.cs.dxil.h" - - #include "REBLUR_Perf_DiffuseSh_PrePass.cs.dxbc.h" - #include "REBLUR_Perf_DiffuseSh_PrePass.cs.dxil.h" - #include "REBLUR_Perf_DiffuseSh_TemporalAccumulation.cs.dxbc.h" - #include "REBLUR_Perf_DiffuseSh_TemporalAccumulation.cs.dxil.h" - #include "REBLUR_Perf_DiffuseSh_HistoryFix.cs.dxbc.h" - #include "REBLUR_Perf_DiffuseSh_HistoryFix.cs.dxil.h" - #include "REBLUR_Perf_DiffuseSh_Blur.cs.dxbc.h" - #include "REBLUR_Perf_DiffuseSh_Blur.cs.dxil.h" - #include "REBLUR_Perf_DiffuseSh_PostBlur.cs.dxbc.h" - #include "REBLUR_Perf_DiffuseSh_PostBlur.cs.dxil.h" - #include "REBLUR_Perf_DiffuseSh_PostBlur_NoTemporalStabilization.cs.dxbc.h" - #include "REBLUR_Perf_DiffuseSh_PostBlur_NoTemporalStabilization.cs.dxil.h" - #include "REBLUR_Perf_DiffuseSh_TemporalStabilization.cs.dxbc.h" - #include "REBLUR_Perf_DiffuseSh_TemporalStabilization.cs.dxil.h" - #endif - - #include "REBLUR_DiffuseSh_PrePass.cs.spirv.h" - #include "REBLUR_DiffuseSh_TemporalAccumulation.cs.spirv.h" - #include "REBLUR_DiffuseSh_HistoryFix.cs.spirv.h" - #include "REBLUR_DiffuseSh_Blur.cs.spirv.h" - #include "REBLUR_DiffuseSh_CopyStabilizedHistory.cs.spirv.h" - #include "REBLUR_DiffuseSh_TemporalStabilization.cs.spirv.h" - #include "REBLUR_DiffuseSh_PostBlur.cs.spirv.h" - #include "REBLUR_DiffuseSh_PostBlur_NoTemporalStabilization.cs.spirv.h" - #include "REBLUR_DiffuseSh_SplitScreen.cs.spirv.h" - - #include "REBLUR_Perf_DiffuseSh_PrePass.cs.spirv.h" - #include "REBLUR_Perf_DiffuseSh_TemporalAccumulation.cs.spirv.h" - #include "REBLUR_Perf_DiffuseSh_HistoryFix.cs.spirv.h" - #include "REBLUR_Perf_DiffuseSh_Blur.cs.spirv.h" - #include "REBLUR_Perf_DiffuseSh_TemporalStabilization.cs.spirv.h" - #include "REBLUR_Perf_DiffuseSh_PostBlur.cs.spirv.h" - #include "REBLUR_Perf_DiffuseSh_PostBlur_NoTemporalStabilization.cs.spirv.h" - - // REBLUR_SPECULAR - #if !NRD_ONLY_SPIRV_SHADERS_AVAILABLE - #include "REBLUR_Specular_HitDistReconstruction.cs.dxbc.h" - #include "REBLUR_Specular_HitDistReconstruction.cs.dxil.h" - #include "REBLUR_Specular_HitDistReconstruction_5x5.cs.dxbc.h" - #include "REBLUR_Specular_HitDistReconstruction_5x5.cs.dxil.h" - #include "REBLUR_Specular_PrePass.cs.dxbc.h" - #include "REBLUR_Specular_PrePass.cs.dxil.h" - #include "REBLUR_Specular_TemporalAccumulation.cs.dxbc.h" - #include "REBLUR_Specular_TemporalAccumulation.cs.dxil.h" - #include "REBLUR_Specular_HistoryFix.cs.dxbc.h" - #include "REBLUR_Specular_HistoryFix.cs.dxil.h" - #include "REBLUR_Specular_Blur.cs.dxbc.h" - #include "REBLUR_Specular_Blur.cs.dxil.h" - #include "REBLUR_Specular_PostBlur.cs.dxbc.h" - #include "REBLUR_Specular_PostBlur.cs.dxil.h" - #include "REBLUR_Specular_PostBlur_NoTemporalStabilization.cs.dxbc.h" - #include "REBLUR_Specular_PostBlur_NoTemporalStabilization.cs.dxil.h" - #include "REBLUR_Specular_CopyStabilizedHistory.cs.dxbc.h" - #include "REBLUR_Specular_CopyStabilizedHistory.cs.dxil.h" - #include "REBLUR_Specular_TemporalStabilization.cs.dxbc.h" - #include "REBLUR_Specular_TemporalStabilization.cs.dxil.h" - #include "REBLUR_Specular_SplitScreen.cs.dxbc.h" - #include "REBLUR_Specular_SplitScreen.cs.dxil.h" - - #include "REBLUR_Perf_Specular_HitDistReconstruction.cs.dxbc.h" - #include "REBLUR_Perf_Specular_HitDistReconstruction.cs.dxil.h" - #include "REBLUR_Perf_Specular_HitDistReconstruction_5x5.cs.dxbc.h" - #include "REBLUR_Perf_Specular_HitDistReconstruction_5x5.cs.dxil.h" - #include "REBLUR_Perf_Specular_PrePass.cs.dxbc.h" - #include "REBLUR_Perf_Specular_PrePass.cs.dxil.h" - #include "REBLUR_Perf_Specular_TemporalAccumulation.cs.dxbc.h" - #include "REBLUR_Perf_Specular_TemporalAccumulation.cs.dxil.h" - #include "REBLUR_Perf_Specular_HistoryFix.cs.dxbc.h" - #include "REBLUR_Perf_Specular_HistoryFix.cs.dxil.h" - #include "REBLUR_Perf_Specular_Blur.cs.dxbc.h" - #include "REBLUR_Perf_Specular_Blur.cs.dxil.h" - #include "REBLUR_Perf_Specular_PostBlur.cs.dxbc.h" - #include "REBLUR_Perf_Specular_PostBlur.cs.dxil.h" - #include "REBLUR_Perf_Specular_PostBlur_NoTemporalStabilization.cs.dxbc.h" - #include "REBLUR_Perf_Specular_PostBlur_NoTemporalStabilization.cs.dxil.h" - #include "REBLUR_Perf_Specular_TemporalStabilization.cs.dxbc.h" - #include "REBLUR_Perf_Specular_TemporalStabilization.cs.dxil.h" - #endif - - #include "REBLUR_Specular_HitDistReconstruction.cs.spirv.h" - #include "REBLUR_Specular_HitDistReconstruction_5x5.cs.spirv.h" - #include "REBLUR_Specular_PrePass.cs.spirv.h" - #include "REBLUR_Specular_TemporalAccumulation.cs.spirv.h" - #include "REBLUR_Specular_HistoryFix.cs.spirv.h" - #include "REBLUR_Specular_Blur.cs.spirv.h" - #include "REBLUR_Specular_PostBlur.cs.spirv.h" - #include "REBLUR_Specular_PostBlur_NoTemporalStabilization.cs.spirv.h" - #include "REBLUR_Specular_CopyStabilizedHistory.cs.spirv.h" - #include "REBLUR_Specular_TemporalStabilization.cs.spirv.h" - #include "REBLUR_Specular_SplitScreen.cs.spirv.h" - - #include "REBLUR_Perf_Specular_HitDistReconstruction.cs.spirv.h" - #include "REBLUR_Perf_Specular_HitDistReconstruction_5x5.cs.spirv.h" - #include "REBLUR_Perf_Specular_PrePass.cs.spirv.h" - #include "REBLUR_Perf_Specular_TemporalAccumulation.cs.spirv.h" - #include "REBLUR_Perf_Specular_HistoryFix.cs.spirv.h" - #include "REBLUR_Perf_Specular_Blur.cs.spirv.h" - #include "REBLUR_Perf_Specular_PostBlur.cs.spirv.h" - #include "REBLUR_Perf_Specular_PostBlur_NoTemporalStabilization.cs.spirv.h" - #include "REBLUR_Perf_Specular_TemporalStabilization.cs.spirv.h" - - // REBLUR_SPECULAR_OCCLUSION - #if !NRD_ONLY_SPIRV_SHADERS_AVAILABLE - #include "REBLUR_SpecularOcclusion_HitDistReconstruction.cs.dxbc.h" - #include "REBLUR_SpecularOcclusion_HitDistReconstruction.cs.dxil.h" - #include "REBLUR_SpecularOcclusion_HitDistReconstruction_5x5.cs.dxbc.h" - #include "REBLUR_SpecularOcclusion_HitDistReconstruction_5x5.cs.dxil.h" - #include "REBLUR_SpecularOcclusion_TemporalAccumulation.cs.dxbc.h" - #include "REBLUR_SpecularOcclusion_TemporalAccumulation.cs.dxil.h" - #include "REBLUR_SpecularOcclusion_HistoryFix.cs.dxbc.h" - #include "REBLUR_SpecularOcclusion_HistoryFix.cs.dxil.h" - #include "REBLUR_SpecularOcclusion_Blur.cs.dxbc.h" - #include "REBLUR_SpecularOcclusion_Blur.cs.dxil.h" - #include "REBLUR_SpecularOcclusion_PostBlur_NoTemporalStabilization.cs.dxbc.h" - #include "REBLUR_SpecularOcclusion_PostBlur_NoTemporalStabilization.cs.dxil.h" - - #include "REBLUR_Perf_SpecularOcclusion_HitDistReconstruction.cs.dxbc.h" - #include "REBLUR_Perf_SpecularOcclusion_HitDistReconstruction.cs.dxil.h" - #include "REBLUR_Perf_SpecularOcclusion_HitDistReconstruction_5x5.cs.dxbc.h" - #include "REBLUR_Perf_SpecularOcclusion_HitDistReconstruction_5x5.cs.dxil.h" - #include "REBLUR_Perf_SpecularOcclusion_TemporalAccumulation.cs.dxbc.h" - #include "REBLUR_Perf_SpecularOcclusion_TemporalAccumulation.cs.dxil.h" - #include "REBLUR_Perf_SpecularOcclusion_HistoryFix.cs.dxbc.h" - #include "REBLUR_Perf_SpecularOcclusion_HistoryFix.cs.dxil.h" - #include "REBLUR_Perf_SpecularOcclusion_Blur.cs.dxbc.h" - #include "REBLUR_Perf_SpecularOcclusion_Blur.cs.dxil.h" - #include "REBLUR_Perf_SpecularOcclusion_PostBlur_NoTemporalStabilization.cs.dxbc.h" - #include "REBLUR_Perf_SpecularOcclusion_PostBlur_NoTemporalStabilization.cs.dxil.h" - #endif - - #include "REBLUR_SpecularOcclusion_HitDistReconstruction.cs.spirv.h" - #include "REBLUR_SpecularOcclusion_HitDistReconstruction_5x5.cs.spirv.h" - #include "REBLUR_SpecularOcclusion_TemporalAccumulation.cs.spirv.h" - #include "REBLUR_SpecularOcclusion_HistoryFix.cs.spirv.h" - #include "REBLUR_SpecularOcclusion_Blur.cs.spirv.h" - #include "REBLUR_SpecularOcclusion_PostBlur_NoTemporalStabilization.cs.spirv.h" - - #include "REBLUR_Perf_SpecularOcclusion_HitDistReconstruction.cs.spirv.h" - #include "REBLUR_Perf_SpecularOcclusion_HitDistReconstruction_5x5.cs.spirv.h" - #include "REBLUR_Perf_SpecularOcclusion_TemporalAccumulation.cs.spirv.h" - #include "REBLUR_Perf_SpecularOcclusion_HistoryFix.cs.spirv.h" - #include "REBLUR_Perf_SpecularOcclusion_Blur.cs.spirv.h" - #include "REBLUR_Perf_SpecularOcclusion_PostBlur_NoTemporalStabilization.cs.spirv.h" - - // REBLUR_SPECULAR_SH - #if !NRD_ONLY_SPIRV_SHADERS_AVAILABLE - #include "REBLUR_SpecularSh_PrePass.cs.dxbc.h" - #include "REBLUR_SpecularSh_PrePass.cs.dxil.h" - #include "REBLUR_SpecularSh_TemporalAccumulation.cs.dxbc.h" - #include "REBLUR_SpecularSh_TemporalAccumulation.cs.dxil.h" - #include "REBLUR_SpecularSh_HistoryFix.cs.dxbc.h" - #include "REBLUR_SpecularSh_HistoryFix.cs.dxil.h" - #include "REBLUR_SpecularSh_Blur.cs.dxbc.h" - #include "REBLUR_SpecularSh_Blur.cs.dxil.h" - #include "REBLUR_SpecularSh_PostBlur.cs.dxbc.h" - #include "REBLUR_SpecularSh_PostBlur.cs.dxil.h" - #include "REBLUR_SpecularSh_PostBlur_NoTemporalStabilization.cs.dxbc.h" - #include "REBLUR_SpecularSh_PostBlur_NoTemporalStabilization.cs.dxil.h" - #include "REBLUR_SpecularSh_CopyStabilizedHistory.cs.dxbc.h" - #include "REBLUR_SpecularSh_CopyStabilizedHistory.cs.dxil.h" - #include "REBLUR_SpecularSh_TemporalStabilization.cs.dxbc.h" - #include "REBLUR_SpecularSh_TemporalStabilization.cs.dxil.h" - #include "REBLUR_SpecularSh_SplitScreen.cs.dxbc.h" - #include "REBLUR_SpecularSh_SplitScreen.cs.dxil.h" - - #include "REBLUR_Perf_SpecularSh_PrePass.cs.dxbc.h" - #include "REBLUR_Perf_SpecularSh_PrePass.cs.dxil.h" - #include "REBLUR_Perf_SpecularSh_TemporalAccumulation.cs.dxbc.h" - #include "REBLUR_Perf_SpecularSh_TemporalAccumulation.cs.dxil.h" - #include "REBLUR_Perf_SpecularSh_HistoryFix.cs.dxbc.h" - #include "REBLUR_Perf_SpecularSh_HistoryFix.cs.dxil.h" - #include "REBLUR_Perf_SpecularSh_Blur.cs.dxbc.h" - #include "REBLUR_Perf_SpecularSh_Blur.cs.dxil.h" - #include "REBLUR_Perf_SpecularSh_PostBlur.cs.dxbc.h" - #include "REBLUR_Perf_SpecularSh_PostBlur.cs.dxil.h" - #include "REBLUR_Perf_SpecularSh_PostBlur_NoTemporalStabilization.cs.dxbc.h" - #include "REBLUR_Perf_SpecularSh_PostBlur_NoTemporalStabilization.cs.dxil.h" - #include "REBLUR_Perf_SpecularSh_TemporalStabilization.cs.dxbc.h" - #include "REBLUR_Perf_SpecularSh_TemporalStabilization.cs.dxil.h" - #endif - - #include "REBLUR_SpecularSh_PrePass.cs.spirv.h" - #include "REBLUR_SpecularSh_TemporalAccumulation.cs.spirv.h" - #include "REBLUR_SpecularSh_HistoryFix.cs.spirv.h" - #include "REBLUR_SpecularSh_Blur.cs.spirv.h" - #include "REBLUR_SpecularSh_PostBlur.cs.spirv.h" - #include "REBLUR_SpecularSh_PostBlur_NoTemporalStabilization.cs.spirv.h" - #include "REBLUR_SpecularSh_CopyStabilizedHistory.cs.spirv.h" - #include "REBLUR_SpecularSh_TemporalStabilization.cs.spirv.h" - #include "REBLUR_SpecularSh_SplitScreen.cs.spirv.h" - - #include "REBLUR_Perf_SpecularSh_PrePass.cs.spirv.h" - #include "REBLUR_Perf_SpecularSh_TemporalAccumulation.cs.spirv.h" - #include "REBLUR_Perf_SpecularSh_HistoryFix.cs.spirv.h" - #include "REBLUR_Perf_SpecularSh_Blur.cs.spirv.h" - #include "REBLUR_Perf_SpecularSh_PostBlur.cs.spirv.h" - #include "REBLUR_Perf_SpecularSh_PostBlur_NoTemporalStabilization.cs.spirv.h" - #include "REBLUR_Perf_SpecularSh_TemporalStabilization.cs.spirv.h" - - // REBLUR_DIFFUSE_SPECULAR - #if !NRD_ONLY_SPIRV_SHADERS_AVAILABLE - #include "REBLUR_DiffuseSpecular_HitDistReconstruction.cs.dxbc.h" - #include "REBLUR_DiffuseSpecular_HitDistReconstruction.cs.dxil.h" - #include "REBLUR_DiffuseSpecular_HitDistReconstruction_5x5.cs.dxbc.h" - #include "REBLUR_DiffuseSpecular_HitDistReconstruction_5x5.cs.dxil.h" - #include "REBLUR_DiffuseSpecular_PrePass.cs.dxbc.h" - #include "REBLUR_DiffuseSpecular_PrePass.cs.dxil.h" - #include "REBLUR_DiffuseSpecular_TemporalAccumulation.cs.dxbc.h" - #include "REBLUR_DiffuseSpecular_TemporalAccumulation.cs.dxil.h" - #include "REBLUR_DiffuseSpecular_HistoryFix.cs.dxbc.h" - #include "REBLUR_DiffuseSpecular_HistoryFix.cs.dxil.h" - #include "REBLUR_DiffuseSpecular_Blur.cs.dxbc.h" - #include "REBLUR_DiffuseSpecular_Blur.cs.dxil.h" - #include "REBLUR_DiffuseSpecular_CopyStabilizedHistory.cs.dxbc.h" - #include "REBLUR_DiffuseSpecular_CopyStabilizedHistory.cs.dxil.h" - #include "REBLUR_DiffuseSpecular_TemporalStabilization.cs.dxbc.h" - #include "REBLUR_DiffuseSpecular_TemporalStabilization.cs.dxil.h" - #include "REBLUR_DiffuseSpecular_PostBlur.cs.dxbc.h" - #include "REBLUR_DiffuseSpecular_PostBlur.cs.dxil.h" - #include "REBLUR_DiffuseSpecular_PostBlur_NoTemporalStabilization.cs.dxbc.h" - #include "REBLUR_DiffuseSpecular_PostBlur_NoTemporalStabilization.cs.dxil.h" - #include "REBLUR_DiffuseSpecular_SplitScreen.cs.dxbc.h" - #include "REBLUR_DiffuseSpecular_SplitScreen.cs.dxil.h" - - #include "REBLUR_Perf_DiffuseSpecular_HitDistReconstruction.cs.dxbc.h" - #include "REBLUR_Perf_DiffuseSpecular_HitDistReconstruction.cs.dxil.h" - #include "REBLUR_Perf_DiffuseSpecular_HitDistReconstruction_5x5.cs.dxbc.h" - #include "REBLUR_Perf_DiffuseSpecular_HitDistReconstruction_5x5.cs.dxil.h" - #include "REBLUR_Perf_DiffuseSpecular_PrePass.cs.dxbc.h" - #include "REBLUR_Perf_DiffuseSpecular_PrePass.cs.dxil.h" - #include "REBLUR_Perf_DiffuseSpecular_TemporalAccumulation.cs.dxbc.h" - #include "REBLUR_Perf_DiffuseSpecular_TemporalAccumulation.cs.dxil.h" - #include "REBLUR_Perf_DiffuseSpecular_HistoryFix.cs.dxbc.h" - #include "REBLUR_Perf_DiffuseSpecular_HistoryFix.cs.dxil.h" - #include "REBLUR_Perf_DiffuseSpecular_Blur.cs.dxbc.h" - #include "REBLUR_Perf_DiffuseSpecular_Blur.cs.dxil.h" - #include "REBLUR_Perf_DiffuseSpecular_TemporalStabilization.cs.dxbc.h" - #include "REBLUR_Perf_DiffuseSpecular_TemporalStabilization.cs.dxil.h" - #include "REBLUR_Perf_DiffuseSpecular_PostBlur.cs.dxbc.h" - #include "REBLUR_Perf_DiffuseSpecular_PostBlur.cs.dxil.h" - #include "REBLUR_Perf_DiffuseSpecular_PostBlur_NoTemporalStabilization.cs.dxbc.h" - #include "REBLUR_Perf_DiffuseSpecular_PostBlur_NoTemporalStabilization.cs.dxil.h" - #endif - - #include "REBLUR_DiffuseSpecular_HitDistReconstruction.cs.spirv.h" - #include "REBLUR_DiffuseSpecular_HitDistReconstruction_5x5.cs.spirv.h" - #include "REBLUR_DiffuseSpecular_PrePass.cs.spirv.h" - #include "REBLUR_DiffuseSpecular_TemporalAccumulation.cs.spirv.h" - #include "REBLUR_DiffuseSpecular_HistoryFix.cs.spirv.h" - #include "REBLUR_DiffuseSpecular_Blur.cs.spirv.h" - #include "REBLUR_DiffuseSpecular_CopyStabilizedHistory.cs.spirv.h" - #include "REBLUR_DiffuseSpecular_TemporalStabilization.cs.spirv.h" - #include "REBLUR_DiffuseSpecular_PostBlur.cs.spirv.h" - #include "REBLUR_DiffuseSpecular_PostBlur_NoTemporalStabilization.cs.spirv.h" - #include "REBLUR_DiffuseSpecular_SplitScreen.cs.spirv.h" - - #include "REBLUR_Perf_DiffuseSpecular_HitDistReconstruction.cs.spirv.h" - #include "REBLUR_Perf_DiffuseSpecular_HitDistReconstruction_5x5.cs.spirv.h" - #include "REBLUR_Perf_DiffuseSpecular_PrePass.cs.spirv.h" - #include "REBLUR_Perf_DiffuseSpecular_TemporalAccumulation.cs.spirv.h" - #include "REBLUR_Perf_DiffuseSpecular_HistoryFix.cs.spirv.h" - #include "REBLUR_Perf_DiffuseSpecular_Blur.cs.spirv.h" - #include "REBLUR_Perf_DiffuseSpecular_TemporalStabilization.cs.spirv.h" - #include "REBLUR_Perf_DiffuseSpecular_PostBlur.cs.spirv.h" - #include "REBLUR_Perf_DiffuseSpecular_PostBlur_NoTemporalStabilization.cs.spirv.h" - - // REBLUR_DIFFUSE_SPECULAR_OCCLUSION - #if !NRD_ONLY_SPIRV_SHADERS_AVAILABLE - #include "REBLUR_DiffuseSpecularOcclusion_HitDistReconstruction.cs.dxbc.h" - #include "REBLUR_DiffuseSpecularOcclusion_HitDistReconstruction.cs.dxil.h" - #include "REBLUR_DiffuseSpecularOcclusion_HitDistReconstruction_5x5.cs.dxbc.h" - #include "REBLUR_DiffuseSpecularOcclusion_HitDistReconstruction_5x5.cs.dxil.h" - #include "REBLUR_DiffuseSpecularOcclusion_TemporalAccumulation.cs.dxbc.h" - #include "REBLUR_DiffuseSpecularOcclusion_TemporalAccumulation.cs.dxil.h" - #include "REBLUR_DiffuseSpecularOcclusion_HistoryFix.cs.dxbc.h" - #include "REBLUR_DiffuseSpecularOcclusion_HistoryFix.cs.dxil.h" - #include "REBLUR_DiffuseSpecularOcclusion_Blur.cs.dxbc.h" - #include "REBLUR_DiffuseSpecularOcclusion_Blur.cs.dxil.h" - #include "REBLUR_DiffuseSpecularOcclusion_PostBlur_NoTemporalStabilization.cs.dxbc.h" - #include "REBLUR_DiffuseSpecularOcclusion_PostBlur_NoTemporalStabilization.cs.dxil.h" - - #include "REBLUR_Perf_DiffuseSpecularOcclusion_HitDistReconstruction.cs.dxbc.h" - #include "REBLUR_Perf_DiffuseSpecularOcclusion_HitDistReconstruction.cs.dxil.h" - #include "REBLUR_Perf_DiffuseSpecularOcclusion_HitDistReconstruction_5x5.cs.dxbc.h" - #include "REBLUR_Perf_DiffuseSpecularOcclusion_HitDistReconstruction_5x5.cs.dxil.h" - #include "REBLUR_Perf_DiffuseSpecularOcclusion_TemporalAccumulation.cs.dxbc.h" - #include "REBLUR_Perf_DiffuseSpecularOcclusion_TemporalAccumulation.cs.dxil.h" - #include "REBLUR_Perf_DiffuseSpecularOcclusion_HistoryFix.cs.dxbc.h" - #include "REBLUR_Perf_DiffuseSpecularOcclusion_HistoryFix.cs.dxil.h" - #include "REBLUR_Perf_DiffuseSpecularOcclusion_Blur.cs.dxbc.h" - #include "REBLUR_Perf_DiffuseSpecularOcclusion_Blur.cs.dxil.h" - #include "REBLUR_Perf_DiffuseSpecularOcclusion_PostBlur_NoTemporalStabilization.cs.dxbc.h" - #include "REBLUR_Perf_DiffuseSpecularOcclusion_PostBlur_NoTemporalStabilization.cs.dxil.h" - #endif - - #include "REBLUR_DiffuseSpecularOcclusion_HitDistReconstruction.cs.spirv.h" - #include "REBLUR_DiffuseSpecularOcclusion_HitDistReconstruction_5x5.cs.spirv.h" - #include "REBLUR_DiffuseSpecularOcclusion_TemporalAccumulation.cs.spirv.h" - #include "REBLUR_DiffuseSpecularOcclusion_HistoryFix.cs.spirv.h" - #include "REBLUR_DiffuseSpecularOcclusion_Blur.cs.spirv.h" - #include "REBLUR_DiffuseSpecularOcclusion_PostBlur_NoTemporalStabilization.cs.spirv.h" - - #include "REBLUR_Perf_DiffuseSpecularOcclusion_HitDistReconstruction.cs.spirv.h" - #include "REBLUR_Perf_DiffuseSpecularOcclusion_HitDistReconstruction_5x5.cs.spirv.h" - #include "REBLUR_Perf_DiffuseSpecularOcclusion_TemporalAccumulation.cs.spirv.h" - #include "REBLUR_Perf_DiffuseSpecularOcclusion_HistoryFix.cs.spirv.h" - #include "REBLUR_Perf_DiffuseSpecularOcclusion_Blur.cs.spirv.h" - #include "REBLUR_Perf_DiffuseSpecularOcclusion_PostBlur_NoTemporalStabilization.cs.spirv.h" - - // REBLUR_DIFFUSE_SPECULAR_SH - #if !NRD_ONLY_SPIRV_SHADERS_AVAILABLE - #include "REBLUR_DiffuseSpecularSh_PrePass.cs.dxbc.h" - #include "REBLUR_DiffuseSpecularSh_PrePass.cs.dxil.h" - #include "REBLUR_DiffuseSpecularSh_TemporalAccumulation.cs.dxbc.h" - #include "REBLUR_DiffuseSpecularSh_TemporalAccumulation.cs.dxil.h" - #include "REBLUR_DiffuseSpecularSh_HistoryFix.cs.dxbc.h" - #include "REBLUR_DiffuseSpecularSh_HistoryFix.cs.dxil.h" - #include "REBLUR_DiffuseSpecularSh_Blur.cs.dxbc.h" - #include "REBLUR_DiffuseSpecularSh_Blur.cs.dxil.h" - #include "REBLUR_DiffuseSpecularSh_CopyStabilizedHistory.cs.dxbc.h" - #include "REBLUR_DiffuseSpecularSh_CopyStabilizedHistory.cs.dxil.h" - #include "REBLUR_DiffuseSpecularSh_TemporalStabilization.cs.dxbc.h" - #include "REBLUR_DiffuseSpecularSh_TemporalStabilization.cs.dxil.h" - #include "REBLUR_DiffuseSpecularSh_PostBlur.cs.dxbc.h" - #include "REBLUR_DiffuseSpecularSh_PostBlur.cs.dxil.h" - #include "REBLUR_DiffuseSpecularSh_PostBlur_NoTemporalStabilization.cs.dxbc.h" - #include "REBLUR_DiffuseSpecularSh_PostBlur_NoTemporalStabilization.cs.dxil.h" - #include "REBLUR_DiffuseSpecularSh_SplitScreen.cs.dxbc.h" - #include "REBLUR_DiffuseSpecularSh_SplitScreen.cs.dxil.h" - - #include "REBLUR_Perf_DiffuseSpecularSh_PrePass.cs.dxbc.h" - #include "REBLUR_Perf_DiffuseSpecularSh_PrePass.cs.dxil.h" - #include "REBLUR_Perf_DiffuseSpecularSh_TemporalAccumulation.cs.dxbc.h" - #include "REBLUR_Perf_DiffuseSpecularSh_TemporalAccumulation.cs.dxil.h" - #include "REBLUR_Perf_DiffuseSpecularSh_HistoryFix.cs.dxbc.h" - #include "REBLUR_Perf_DiffuseSpecularSh_HistoryFix.cs.dxil.h" - #include "REBLUR_Perf_DiffuseSpecularSh_Blur.cs.dxbc.h" - #include "REBLUR_Perf_DiffuseSpecularSh_Blur.cs.dxil.h" - #include "REBLUR_Perf_DiffuseSpecularSh_TemporalStabilization.cs.dxbc.h" - #include "REBLUR_Perf_DiffuseSpecularSh_TemporalStabilization.cs.dxil.h" - #include "REBLUR_Perf_DiffuseSpecularSh_PostBlur.cs.dxbc.h" - #include "REBLUR_Perf_DiffuseSpecularSh_PostBlur.cs.dxil.h" - #include "REBLUR_Perf_DiffuseSpecularSh_PostBlur_NoTemporalStabilization.cs.dxbc.h" - #include "REBLUR_Perf_DiffuseSpecularSh_PostBlur_NoTemporalStabilization.cs.dxil.h" - #endif - - #include "REBLUR_DiffuseSpecularSh_PrePass.cs.spirv.h" - #include "REBLUR_DiffuseSpecularSh_TemporalAccumulation.cs.spirv.h" - #include "REBLUR_DiffuseSpecularSh_HistoryFix.cs.spirv.h" - #include "REBLUR_DiffuseSpecularSh_Blur.cs.spirv.h" - #include "REBLUR_DiffuseSpecularSh_CopyStabilizedHistory.cs.spirv.h" - #include "REBLUR_DiffuseSpecularSh_TemporalStabilization.cs.spirv.h" - #include "REBLUR_DiffuseSpecularSh_PostBlur.cs.spirv.h" - #include "REBLUR_DiffuseSpecularSh_PostBlur_NoTemporalStabilization.cs.spirv.h" - #include "REBLUR_DiffuseSpecularSh_SplitScreen.cs.spirv.h" - - #include "REBLUR_Perf_DiffuseSpecularSh_PrePass.cs.spirv.h" - #include "REBLUR_Perf_DiffuseSpecularSh_TemporalAccumulation.cs.spirv.h" - #include "REBLUR_Perf_DiffuseSpecularSh_HistoryFix.cs.spirv.h" - #include "REBLUR_Perf_DiffuseSpecularSh_Blur.cs.spirv.h" - #include "REBLUR_Perf_DiffuseSpecularSh_TemporalStabilization.cs.spirv.h" - #include "REBLUR_Perf_DiffuseSpecularSh_PostBlur.cs.spirv.h" - #include "REBLUR_Perf_DiffuseSpecularSh_PostBlur_NoTemporalStabilization.cs.spirv.h" - - // REBLUR_DIFFUSE_DIRECTIONAL_OCCLUSION - #if !NRD_ONLY_SPIRV_SHADERS_AVAILABLE - #include "REBLUR_DiffuseDirectionalOcclusion_PrePass.cs.dxbc.h" - #include "REBLUR_DiffuseDirectionalOcclusion_PrePass.cs.dxil.h" - #include "REBLUR_DiffuseDirectionalOcclusion_TemporalAccumulation.cs.dxbc.h" - #include "REBLUR_DiffuseDirectionalOcclusion_TemporalAccumulation.cs.dxil.h" - #include "REBLUR_DiffuseDirectionalOcclusion_HistoryFix.cs.dxbc.h" - #include "REBLUR_DiffuseDirectionalOcclusion_HistoryFix.cs.dxil.h" - #include "REBLUR_DiffuseDirectionalOcclusion_Blur.cs.dxbc.h" - #include "REBLUR_DiffuseDirectionalOcclusion_Blur.cs.dxil.h" - #include "REBLUR_DiffuseDirectionalOcclusion_PostBlur.cs.dxbc.h" - #include "REBLUR_DiffuseDirectionalOcclusion_PostBlur.cs.dxil.h" - #include "REBLUR_DiffuseDirectionalOcclusion_PostBlur_NoTemporalStabilization.cs.dxbc.h" - #include "REBLUR_DiffuseDirectionalOcclusion_PostBlur_NoTemporalStabilization.cs.dxil.h" - #include "REBLUR_DiffuseDirectionalOcclusion_TemporalStabilization.cs.dxbc.h" - #include "REBLUR_DiffuseDirectionalOcclusion_TemporalStabilization.cs.dxil.h" - - #include "REBLUR_Perf_DiffuseDirectionalOcclusion_PrePass.cs.dxbc.h" - #include "REBLUR_Perf_DiffuseDirectionalOcclusion_PrePass.cs.dxil.h" - #include "REBLUR_Perf_DiffuseDirectionalOcclusion_TemporalAccumulation.cs.dxbc.h" - #include "REBLUR_Perf_DiffuseDirectionalOcclusion_TemporalAccumulation.cs.dxil.h" - #include "REBLUR_Perf_DiffuseDirectionalOcclusion_HistoryFix.cs.dxbc.h" - #include "REBLUR_Perf_DiffuseDirectionalOcclusion_HistoryFix.cs.dxil.h" - #include "REBLUR_Perf_DiffuseDirectionalOcclusion_Blur.cs.dxbc.h" - #include "REBLUR_Perf_DiffuseDirectionalOcclusion_Blur.cs.dxil.h" - #include "REBLUR_Perf_DiffuseDirectionalOcclusion_PostBlur.cs.dxbc.h" - #include "REBLUR_Perf_DiffuseDirectionalOcclusion_PostBlur.cs.dxil.h" - #include "REBLUR_Perf_DiffuseDirectionalOcclusion_PostBlur_NoTemporalStabilization.cs.dxbc.h" - #include "REBLUR_Perf_DiffuseDirectionalOcclusion_PostBlur_NoTemporalStabilization.cs.dxil.h" - #include "REBLUR_Perf_DiffuseDirectionalOcclusion_TemporalStabilization.cs.dxbc.h" - #include "REBLUR_Perf_DiffuseDirectionalOcclusion_TemporalStabilization.cs.dxil.h" - #endif - - #include "REBLUR_DiffuseDirectionalOcclusion_PrePass.cs.spirv.h" - #include "REBLUR_DiffuseDirectionalOcclusion_TemporalAccumulation.cs.spirv.h" - #include "REBLUR_DiffuseDirectionalOcclusion_HistoryFix.cs.spirv.h" - #include "REBLUR_DiffuseDirectionalOcclusion_Blur.cs.spirv.h" - #include "REBLUR_DiffuseDirectionalOcclusion_TemporalStabilization.cs.spirv.h" - #include "REBLUR_DiffuseDirectionalOcclusion_PostBlur.cs.spirv.h" - #include "REBLUR_DiffuseDirectionalOcclusion_PostBlur_NoTemporalStabilization.cs.spirv.h" - - #include "REBLUR_Perf_DiffuseDirectionalOcclusion_PrePass.cs.spirv.h" - #include "REBLUR_Perf_DiffuseDirectionalOcclusion_TemporalAccumulation.cs.spirv.h" - #include "REBLUR_Perf_DiffuseDirectionalOcclusion_HistoryFix.cs.spirv.h" - #include "REBLUR_Perf_DiffuseDirectionalOcclusion_Blur.cs.spirv.h" - #include "REBLUR_Perf_DiffuseDirectionalOcclusion_TemporalStabilization.cs.spirv.h" - #include "REBLUR_Perf_DiffuseDirectionalOcclusion_PostBlur.cs.spirv.h" - #include "REBLUR_Perf_DiffuseDirectionalOcclusion_PostBlur_NoTemporalStabilization.cs.spirv.h" - - // SIGMA_SHADOW - #if !NRD_ONLY_SPIRV_SHADERS_AVAILABLE - #include "SIGMA_Shadow_ClassifyTiles.cs.dxbc.h" - #include "SIGMA_Shadow_ClassifyTiles.cs.dxil.h" - #include "SIGMA_Shadow_SmoothTiles.cs.dxbc.h" - #include "SIGMA_Shadow_SmoothTiles.cs.dxil.h" - #include "SIGMA_Shadow_Blur.cs.dxbc.h" - #include "SIGMA_Shadow_Blur.cs.dxil.h" - #include "SIGMA_Shadow_PostBlur.cs.dxbc.h" - #include "SIGMA_Shadow_PostBlur.cs.dxil.h" - #include "SIGMA_Shadow_TemporalStabilization.cs.dxbc.h" - #include "SIGMA_Shadow_TemporalStabilization.cs.dxil.h" - #include "SIGMA_Shadow_SplitScreen.cs.dxbc.h" - #include "SIGMA_Shadow_SplitScreen.cs.dxil.h" - #endif - - #include "SIGMA_Shadow_ClassifyTiles.cs.spirv.h" - #include "SIGMA_Shadow_SmoothTiles.cs.spirv.h" - #include "SIGMA_Shadow_Blur.cs.spirv.h" - #include "SIGMA_Shadow_PostBlur.cs.spirv.h" - #include "SIGMA_Shadow_TemporalStabilization.cs.spirv.h" - #include "SIGMA_Shadow_SplitScreen.cs.spirv.h" - - // SIGMA_SHADOW_TRANSLUCENCY - #if !NRD_ONLY_SPIRV_SHADERS_AVAILABLE - #include "SIGMA_ShadowTranslucency_ClassifyTiles.cs.dxbc.h" - #include "SIGMA_ShadowTranslucency_ClassifyTiles.cs.dxil.h" - #include "SIGMA_ShadowTranslucency_Blur.cs.dxbc.h" - #include "SIGMA_ShadowTranslucency_Blur.cs.dxil.h" - #include "SIGMA_ShadowTranslucency_PostBlur.cs.dxbc.h" - #include "SIGMA_ShadowTranslucency_PostBlur.cs.dxil.h" - #include "SIGMA_ShadowTranslucency_TemporalStabilization.cs.dxbc.h" - #include "SIGMA_ShadowTranslucency_TemporalStabilization.cs.dxil.h" - #include "SIGMA_ShadowTranslucency_SplitScreen.cs.dxbc.h" - #include "SIGMA_ShadowTranslucency_SplitScreen.cs.dxil.h" - #endif - - #include "SIGMA_ShadowTranslucency_ClassifyTiles.cs.spirv.h" - #include "SIGMA_ShadowTranslucency_Blur.cs.spirv.h" - #include "SIGMA_ShadowTranslucency_PostBlur.cs.spirv.h" - #include "SIGMA_ShadowTranslucency_TemporalStabilization.cs.spirv.h" - #include "SIGMA_ShadowTranslucency_SplitScreen.cs.spirv.h" - - // RELAX_DIFFUSE - #if !NRD_ONLY_SPIRV_SHADERS_AVAILABLE - #include "RELAX_Diffuse_HitDistReconstruction.cs.dxbc.h" - #include "RELAX_Diffuse_HitDistReconstruction.cs.dxil.h" - #include "RELAX_Diffuse_HitDistReconstruction_5x5.cs.dxbc.h" - #include "RELAX_Diffuse_HitDistReconstruction_5x5.cs.dxil.h" - #include "RELAX_Diffuse_PrePass.cs.dxbc.h" - #include "RELAX_Diffuse_PrePass.cs.dxil.h" - #include "RELAX_Diffuse_TemporalAccumulation.cs.dxbc.h" - #include "RELAX_Diffuse_TemporalAccumulation.cs.dxil.h" - #include "RELAX_Diffuse_HistoryFix.cs.dxbc.h" - #include "RELAX_Diffuse_HistoryFix.cs.dxil.h" - #include "RELAX_Diffuse_HistoryClamping.cs.dxbc.h" - #include "RELAX_Diffuse_HistoryClamping.cs.dxil.h" - #include "RELAX_Diffuse_AntiFirefly.cs.dxbc.h" - #include "RELAX_Diffuse_AntiFirefly.cs.dxil.h" - #include "RELAX_Diffuse_AtrousSmem.cs.dxbc.h" - #include "RELAX_Diffuse_AtrousSmem.cs.dxil.h" - #include "RELAX_Diffuse_Atrous.cs.dxbc.h" - #include "RELAX_Diffuse_Atrous.cs.dxil.h" - #include "RELAX_Diffuse_SplitScreen.cs.dxbc.h" - #include "RELAX_Diffuse_SplitScreen.cs.dxil.h" - #include "RELAX_Validation.cs.dxbc.h" - #include "RELAX_Validation.cs.dxil.h" - #endif - - #include "RELAX_Diffuse_HitDistReconstruction.cs.spirv.h" - #include "RELAX_Diffuse_HitDistReconstruction_5x5.cs.spirv.h" - #include "RELAX_Diffuse_PrePass.cs.spirv.h" - #include "RELAX_Diffuse_TemporalAccumulation.cs.spirv.h" - #include "RELAX_Diffuse_HistoryFix.cs.spirv.h" - #include "RELAX_Diffuse_HistoryClamping.cs.spirv.h" - #include "RELAX_Diffuse_AntiFirefly.cs.spirv.h" - #include "RELAX_Diffuse_AtrousSmem.cs.spirv.h" - #include "RELAX_Diffuse_Atrous.cs.spirv.h" - #include "RELAX_Diffuse_SplitScreen.cs.spirv.h" - #include "RELAX_Validation.cs.spirv.h" - - // RELAX_SPECULAR - #if !NRD_ONLY_SPIRV_SHADERS_AVAILABLE - #include "RELAX_Specular_HitDistReconstruction.cs.dxbc.h" - #include "RELAX_Specular_HitDistReconstruction.cs.dxil.h" - #include "RELAX_Specular_HitDistReconstruction_5x5.cs.dxbc.h" - #include "RELAX_Specular_HitDistReconstruction_5x5.cs.dxil.h" - #include "RELAX_Specular_PrePass.cs.dxbc.h" - #include "RELAX_Specular_PrePass.cs.dxil.h" - #include "RELAX_Specular_TemporalAccumulation.cs.dxbc.h" - #include "RELAX_Specular_TemporalAccumulation.cs.dxil.h" - #include "RELAX_Specular_HistoryFix.cs.dxbc.h" - #include "RELAX_Specular_HistoryFix.cs.dxil.h" - #include "RELAX_Specular_HistoryClamping.cs.dxbc.h" - #include "RELAX_Specular_HistoryClamping.cs.dxil.h" - #include "RELAX_Specular_AntiFirefly.cs.dxbc.h" - #include "RELAX_Specular_AntiFirefly.cs.dxil.h" - #include "RELAX_Specular_AtrousSmem.cs.dxbc.h" - #include "RELAX_Specular_AtrousSmem.cs.dxil.h" - #include "RELAX_Specular_Atrous.cs.dxbc.h" - #include "RELAX_Specular_Atrous.cs.dxil.h" - #include "RELAX_Specular_SplitScreen.cs.dxbc.h" - #include "RELAX_Specular_SplitScreen.cs.dxil.h" - #endif - - #include "RELAX_Specular_HitDistReconstruction.cs.spirv.h" - #include "RELAX_Specular_HitDistReconstruction_5x5.cs.spirv.h" - #include "RELAX_Specular_PrePass.cs.spirv.h" - #include "RELAX_Specular_TemporalAccumulation.cs.spirv.h" - #include "RELAX_Specular_HistoryFix.cs.spirv.h" - #include "RELAX_Specular_HistoryClamping.cs.spirv.h" - #include "RELAX_Specular_AntiFirefly.cs.spirv.h" - #include "RELAX_Specular_AtrousSmem.cs.spirv.h" - #include "RELAX_Specular_Atrous.cs.spirv.h" - #include "RELAX_Specular_SplitScreen.cs.spirv.h" - - // RELAX_DIFFUSE_SPECULAR - #if !NRD_ONLY_SPIRV_SHADERS_AVAILABLE - #include "RELAX_DiffuseSpecular_HitDistReconstruction.cs.dxbc.h" - #include "RELAX_DiffuseSpecular_HitDistReconstruction.cs.dxil.h" - #include "RELAX_DiffuseSpecular_HitDistReconstruction_5x5.cs.dxbc.h" - #include "RELAX_DiffuseSpecular_HitDistReconstruction_5x5.cs.dxil.h" - #include "RELAX_DiffuseSpecular_PrePass.cs.dxbc.h" - #include "RELAX_DiffuseSpecular_PrePass.cs.dxil.h" - #include "RELAX_DiffuseSpecular_TemporalAccumulation.cs.dxbc.h" - #include "RELAX_DiffuseSpecular_TemporalAccumulation.cs.dxil.h" - #include "RELAX_DiffuseSpecular_HistoryFix.cs.dxbc.h" - #include "RELAX_DiffuseSpecular_HistoryFix.cs.dxil.h" - #include "RELAX_DiffuseSpecular_HistoryClamping.cs.dxbc.h" - #include "RELAX_DiffuseSpecular_HistoryClamping.cs.dxil.h" - #include "RELAX_DiffuseSpecular_AntiFirefly.cs.dxbc.h" - #include "RELAX_DiffuseSpecular_AntiFirefly.cs.dxil.h" - #include "RELAX_DiffuseSpecular_AtrousSmem.cs.dxbc.h" - #include "RELAX_DiffuseSpecular_AtrousSmem.cs.dxil.h" - #include "RELAX_DiffuseSpecular_Atrous.cs.dxbc.h" - #include "RELAX_DiffuseSpecular_Atrous.cs.dxil.h" - #include "RELAX_DiffuseSpecular_SplitScreen.cs.dxbc.h" - #include "RELAX_DiffuseSpecular_SplitScreen.cs.dxil.h" - #endif - - #include "RELAX_DiffuseSpecular_HitDistReconstruction.cs.spirv.h" - #include "RELAX_DiffuseSpecular_HitDistReconstruction_5x5.cs.spirv.h" - #include "RELAX_DiffuseSpecular_PrePass.cs.spirv.h" - #include "RELAX_DiffuseSpecular_TemporalAccumulation.cs.spirv.h" - #include "RELAX_DiffuseSpecular_HistoryFix.cs.spirv.h" - #include "RELAX_DiffuseSpecular_HistoryClamping.cs.spirv.h" - #include "RELAX_DiffuseSpecular_AntiFirefly.cs.spirv.h" - #include "RELAX_DiffuseSpecular_AtrousSmem.cs.spirv.h" - #include "RELAX_DiffuseSpecular_Atrous.cs.spirv.h" - #include "RELAX_DiffuseSpecular_SplitScreen.cs.spirv.h" - - // REFERENCE - #if !NRD_ONLY_SPIRV_SHADERS_AVAILABLE - #include "REFERENCE_TemporalAccumulation.cs.dxbc.h" - #include "REFERENCE_TemporalAccumulation.cs.dxil.h" - #include "REFERENCE_SplitScreen.cs.dxbc.h" - #include "REFERENCE_SplitScreen.cs.dxil.h" - #endif - - #include "REFERENCE_TemporalAccumulation.cs.spirv.h" - #include "REFERENCE_SplitScreen.cs.spirv.h" - - // SPECULAR_REFLECTION_MV - #if !NRD_ONLY_SPIRV_SHADERS_AVAILABLE - #include "SpecularReflectionMv_Compute.cs.dxbc.h" - #include "SpecularReflectionMv_Compute.cs.dxil.h" - #endif - - #include "SpecularReflectionMv_Compute.cs.spirv.h" - - // SPECULAR_DELTA_MV - #if !NRD_ONLY_SPIRV_SHADERS_AVAILABLE - #include "SpecularDeltaMv_Compute.cs.dxbc.h" - #include "SpecularDeltaMv_Compute.cs.dxil.h" - #endif - - #include "SpecularDeltaMv_Compute.cs.spirv.h" #endif -//============================================================================================================================= -// DenoiserImpl -//============================================================================================================================= - nrd::Result nrd::DenoiserImpl::Create(const DenoiserCreationDesc& denoiserCreationDesc) { const LibraryDesc& libraryDesc = GetLibraryDesc(); @@ -876,10 +138,16 @@ nrd::Result nrd::DenoiserImpl::Create(const DenoiserCreationDesc& denoiserCreati AddMethod_SigmaShadowTranslucency(methodData); else if (methodDesc.method == Method::RELAX_DIFFUSE) AddMethod_RelaxDiffuse(methodData); + else if (methodDesc.method == Method::RELAX_DIFFUSE_SH) + AddMethod_RelaxDiffuseSh(methodData); else if (methodDesc.method == Method::RELAX_SPECULAR) AddMethod_RelaxSpecular(methodData); + else if (methodDesc.method == Method::RELAX_SPECULAR_SH) + AddMethod_RelaxSpecularSh(methodData); else if (methodDesc.method == Method::RELAX_DIFFUSE_SPECULAR) AddMethod_RelaxDiffuseSpecular(methodData); + else if (methodDesc.method == Method::RELAX_DIFFUSE_SPECULAR_SH) + AddMethod_RelaxDiffuseSpecularSh(methodData); else if (methodDesc.method == Method::REFERENCE) AddMethod_Reference(methodData); else if (methodDesc.method == Method::SPECULAR_REFLECTION_MV) @@ -1022,10 +290,16 @@ void nrd::DenoiserImpl::GetComputeDispatches(const CommonSettings& commonSetting UpdateMethod_SigmaShadow(methodData); else if (methodData.desc.method == Method::RELAX_DIFFUSE) UpdateMethod_RelaxDiffuse(methodData); + else if (methodData.desc.method == Method::RELAX_DIFFUSE_SH) + UpdateMethod_RelaxDiffuseSh(methodData); else if (methodData.desc.method == Method::RELAX_SPECULAR) UpdateMethod_RelaxSpecular(methodData); + else if (methodData.desc.method == Method::RELAX_SPECULAR_SH) + UpdateMethod_RelaxSpecularSh(methodData); else if (methodData.desc.method == Method::RELAX_DIFFUSE_SPECULAR) UpdateMethod_RelaxDiffuseSpecular(methodData); + else if (methodData.desc.method == Method::RELAX_DIFFUSE_SPECULAR_SH) + UpdateMethod_RelaxDiffuseSpecularSh(methodData); else if (methodData.desc.method == Method::REFERENCE) UpdateMethod_Reference(methodData); else if (methodData.desc.method == Method::SPECULAR_REFLECTION_MV) @@ -1159,7 +433,7 @@ void nrd::DenoiserImpl::AddComputeDispatchDesc { PipelineDesc pipelineDesc = {}; pipelineDesc.shaderFileName = shaderFileName; - pipelineDesc.shaderEntryPointName = NRD_CS_MAIN; + pipelineDesc.shaderEntryPointName = NRD_STRINGIFY(NRD_CS_MAIN); pipelineDesc.computeShaderDXBC = dxbc; pipelineDesc.computeShaderDXIL = dxil; pipelineDesc.computeShaderSPIRV = spirv; @@ -1235,6 +509,49 @@ void nrd::DenoiserImpl::PushTexture(DescriptorType descriptorType, uint16_t inde m_Resources.push_back( {descriptorType, resourceType, indexInPool, mipOffset, mipNum} ); } +nrd::Constant* nrd::DenoiserImpl::PushDispatch(const MethodData& methodData, uint32_t localIndex) +{ + size_t dispatchIndex = methodData.dispatchOffset + localIndex; + const InternalDispatchDesc& internalDispatchDesc = m_Dispatches[dispatchIndex]; + + // Copy data + DispatchDesc dispatchDesc = {}; + dispatchDesc.name = internalDispatchDesc.name; + dispatchDesc.resources = internalDispatchDesc.resources; + dispatchDesc.resourcesNum = internalDispatchDesc.resourcesNum; + dispatchDesc.pipelineIndex = internalDispatchDesc.pipelineIndex; + + // Update constant data + if (m_ConstantDataOffset + internalDispatchDesc.constantBufferDataSize > CONSTANT_DATA_SIZE) + m_ConstantDataOffset = 0; + dispatchDesc.constantBufferData = m_ConstantData + m_ConstantDataOffset; + dispatchDesc.constantBufferDataSize = internalDispatchDesc.constantBufferDataSize; + m_ConstantDataOffset += internalDispatchDesc.constantBufferDataSize; + + // Update grid size + float sx = ml::Max(internalDispatchDesc.downsampleFactor == USE_MAX_DIMS ? m_ResolutionScalePrev.x : 0.0f, m_CommonSettings.resolutionScale[0]); + float sy = ml::Max(internalDispatchDesc.downsampleFactor == USE_MAX_DIMS ? m_ResolutionScalePrev.y : 0.0f, m_CommonSettings.resolutionScale[1]); + uint16_t d = internalDispatchDesc.downsampleFactor == USE_MAX_DIMS ? 1 : internalDispatchDesc.downsampleFactor; + + if (internalDispatchDesc.downsampleFactor == IGNORE_RS) + { + sx = 1.0f; + sy = 1.0f; + d = 1; + } + + uint16_t w = uint16_t( float(DivideUp(methodData.desc.fullResolutionWidth, d)) * sx + 0.5f ); + uint16_t h = uint16_t( float(DivideUp(methodData.desc.fullResolutionHeight, d)) * sy + 0.5f ); + + dispatchDesc.gridWidth = DivideUp(w, internalDispatchDesc.numThreads.width); + dispatchDesc.gridHeight = DivideUp(h, internalDispatchDesc.numThreads.height); + + // Store + m_ActiveDispatches.push_back(dispatchDesc); + + return (Constant*)dispatchDesc.constantBufferData; +} + void nrd::DenoiserImpl::UpdatePingPong(const MethodData& methodData) { for (uint32_t i = 0; i < methodData.pingPongNum; i++) @@ -1401,26 +718,3 @@ void nrd::DenoiserImpl::UpdateCommonSettings(const CommonSettings& commonSetting float nonLinearAccumSpeed = FPS * 0.25f / (1.0f + FPS * 0.25f); m_CheckerboardResolveAccumSpeed = ml::Lerp(nonLinearAccumSpeed, 0.5f, m_JitterDelta); } - -//============================================================================================================================= -// METHODS -//============================================================================================================================= - -#include "Methods/Reblur_Diffuse.hpp" -#include "Methods/Reblur_DiffuseOcclusion.hpp" -#include "Methods/Reblur_DiffuseSh.hpp" -#include "Methods/Reblur_Specular.hpp" -#include "Methods/Reblur_SpecularOcclusion.hpp" -#include "Methods/Reblur_SpecularSh.hpp" -#include "Methods/Reblur_DiffuseSpecular.hpp" -#include "Methods/Reblur_DiffuseSpecularOcclusion.hpp" -#include "Methods/Reblur_DiffuseSpecularSh.hpp" -#include "Methods/Reblur_DiffuseDirectionalOcclusion.hpp" -#include "Methods/Sigma_Shadow.hpp" -#include "Methods/Sigma_ShadowTranslucency.hpp" -#include "Methods/Relax_Diffuse.hpp" -#include "Methods/Relax_Specular.hpp" -#include "Methods/Relax_DiffuseSpecular.hpp" -#include "Methods/Reference.hpp" -#include "Methods/SpecularReflectionMv.hpp" -#include "Methods/SpecularDeltaMv.hpp" diff --git a/Source/DenoiserImpl.h b/Source/DenoiserImpl.h index 95f13f91..28b68c95 100644 --- a/Source/DenoiserImpl.h +++ b/Source/DenoiserImpl.h @@ -12,9 +12,6 @@ license agreement from NVIDIA CORPORATION is strictly prohibited. #include "NRD.h" -// TODO: move to a C++ / HLSL shared file (most likely with CB layout declarations) -#define NRD_CS_MAIN "main" - #define MATH_NAMESPACE #include "MathLib/MathLib.h" @@ -174,12 +171,18 @@ namespace nrd // Relax void AddMethod_RelaxDiffuse(MethodData& methodData); + void AddMethod_RelaxDiffuseSh(MethodData& methodData); void AddMethod_RelaxSpecular(MethodData& methodData); + void AddMethod_RelaxSpecularSh(MethodData& methodData); void AddMethod_RelaxDiffuseSpecular(MethodData& methodData); + void AddMethod_RelaxDiffuseSpecularSh(MethodData& methodData); void UpdateMethod_RelaxDiffuse(const MethodData& methodData); + void UpdateMethod_RelaxDiffuseSh(const MethodData& methodData); void UpdateMethod_RelaxSpecular(const MethodData& methodData); + void UpdateMethod_RelaxSpecularSh(const MethodData& methodData); void UpdateMethod_RelaxDiffuseSpecular(const MethodData& methodData); + void UpdateMethod_RelaxDiffuseSpecularSh(const MethodData& methodData); void AddSharedConstants_Relax(const MethodData& methodData, Constant*& data, Method method); @@ -270,48 +273,7 @@ namespace nrd void PushOutput(uint16_t indexInPool, uint16_t mipOffset = 0, uint16_t mipNum = 1, uint16_t indexToSwapWith = uint16_t(-1)) { PushTexture(DescriptorType::STORAGE_TEXTURE, indexInPool, mipOffset, mipNum, indexToSwapWith); } - inline Constant* PushDispatch(const MethodData& methodData, uint32_t localIndex) - { - size_t dispatchIndex = methodData.dispatchOffset + localIndex; - const InternalDispatchDesc& internalDispatchDesc = m_Dispatches[dispatchIndex]; - - // Copy data - DispatchDesc dispatchDesc = {}; - dispatchDesc.name = internalDispatchDesc.name; - dispatchDesc.resources = internalDispatchDesc.resources; - dispatchDesc.resourcesNum = internalDispatchDesc.resourcesNum; - dispatchDesc.pipelineIndex = internalDispatchDesc.pipelineIndex; - - // Update constant data - if (m_ConstantDataOffset + internalDispatchDesc.constantBufferDataSize > CONSTANT_DATA_SIZE) - m_ConstantDataOffset = 0; - dispatchDesc.constantBufferData = m_ConstantData + m_ConstantDataOffset; - dispatchDesc.constantBufferDataSize = internalDispatchDesc.constantBufferDataSize; - m_ConstantDataOffset += internalDispatchDesc.constantBufferDataSize; - - // Update grid size - float sx = ml::Max(internalDispatchDesc.downsampleFactor == USE_MAX_DIMS ? m_ResolutionScalePrev.x : 0.0f, m_CommonSettings.resolutionScale[0]); - float sy = ml::Max(internalDispatchDesc.downsampleFactor == USE_MAX_DIMS ? m_ResolutionScalePrev.y : 0.0f, m_CommonSettings.resolutionScale[1]); - uint16_t d = internalDispatchDesc.downsampleFactor == USE_MAX_DIMS ? 1 : internalDispatchDesc.downsampleFactor; - - if (internalDispatchDesc.downsampleFactor == IGNORE_RS) - { - sx = 1.0f; - sy = 1.0f; - d = 1; - } - - uint16_t w = uint16_t( float(DivideUp(methodData.desc.fullResolutionWidth, d)) * sx + 0.5f ); - uint16_t h = uint16_t( float(DivideUp(methodData.desc.fullResolutionHeight, d)) * sy + 0.5f ); - - dispatchDesc.gridWidth = DivideUp(w, internalDispatchDesc.numThreads.width); - dispatchDesc.gridHeight = DivideUp(h, internalDispatchDesc.numThreads.height); - - // Store - m_ActiveDispatches.push_back(dispatchDesc); - - return (Constant*)dispatchDesc.constantBufferData; - } + Constant* PushDispatch(const MethodData& methodData, uint32_t localIndex); inline void _PushPass(const char* name) { diff --git a/Source/Methods/Reblur_Diffuse.hpp b/Source/Methods/Reblur_Diffuse.hpp index 1d615a1b..8bd33215 100644 --- a/Source/Methods/Reblur_Diffuse.hpp +++ b/Source/Methods/Reblur_Diffuse.hpp @@ -8,108 +8,6 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -// Constants -#define REBLUR_SET_SHARED_CONSTANTS SetSharedConstants(2, 5, 9, 22) - -#define REBLUR_HITDIST_RECONSTRUCTION_CONSTANT_NUM SumConstants(0, 0, 0, 0) -#define REBLUR_HITDIST_RECONSTRUCTION_NUM_THREADS NumThreads(8, 8) - -#define REBLUR_PREPASS_CONSTANT_NUM SumConstants(0, 1, 0, 2) -#define REBLUR_PREPASS_NUM_THREADS NumThreads(16, 16) - -#define REBLUR_TEMPORAL_ACCUMULATION_CONSTANT_NUM SumConstants(4, 2, 0, 7) -#define REBLUR_TEMPORAL_ACCUMULATION_NUM_THREADS NumThreads(8, 8) - -#define REBLUR_HISTORY_FIX_CONSTANT_NUM SumConstants(0, 0, 0, 1) -#define REBLUR_HISTORY_FIX_NUM_THREADS NumThreads(16, 16) - -#define REBLUR_BLUR_CONSTANT_NUM SumConstants(0, 1, 0, 0) -#define REBLUR_BLUR_NUM_THREADS NumThreads(8, 8) - -#define REBLUR_POST_BLUR_CONSTANT_NUM SumConstants(0, 1, 0, 0) -#define REBLUR_POST_BLUR_NUM_THREADS NumThreads(8, 8) - -#define REBLUR_COPY_STABILIZED_HISTORY_CONSTANT_NUM SumConstants(0, 0, 0, 0, false) -#define REBLUR_COPY_STABILIZED_HISTORY_NUM_THREADS NumThreads(16, 16) - -#define REBLUR_TEMPORAL_STABILIZATION_CONSTANT_NUM SumConstants(3, 3, 2, 1) -#define REBLUR_TEMPORAL_STABILIZATION_NUM_THREADS NumThreads(8, 8) - -#define REBLUR_SPLIT_SCREEN_CONSTANT_NUM SumConstants(0, 0, 0, 3) -#define REBLUR_SPLIT_SCREEN_NUM_THREADS NumThreads(16, 16) - -// Permutations -#define REBLUR_HITDIST_RECONSTRUCTION_PERMUTATION_NUM 4 -#define REBLUR_PREPASS_PERMUTATION_NUM 2 -#define REBLUR_TEMPORAL_ACCUMULATION_PERMUTATION_NUM 16 -#define REBLUR_HISTORY_FIX_PERMUTATION_NUM 1 -#define REBLUR_BLUR_PERMUTATION_NUM 1 -#define REBLUR_POST_BLUR_PERMUTATION_NUM 2 -#define REBLUR_COPY_STABILIZED_HISTORY_PERMUTATION_NUM 1 -#define REBLUR_TEMPORAL_STABILIZATION_PERMUTATION_NUM 2 -#define REBLUR_SPLIT_SCREEN_PERMUTATION_NUM 1 - -#define REBLUR_OCCLUSION_HITDIST_RECONSTRUCTION_PERMUTATION_NUM 2 -#define REBLUR_OCCLUSION_TEMPORAL_ACCUMULATION_PERMUTATION_NUM 8 -#define REBLUR_OCCLUSION_HISTORY_FIX_PERMUTATION_NUM 1 -#define REBLUR_OCCLUSION_BLUR_PERMUTATION_NUM 1 -#define REBLUR_OCCLUSION_POST_BLUR_PERMUTATION_NUM 1 -#define REBLUR_OCCLUSION_SPLIT_SCREEN_PERMUTATION_NUM 1 - -// Formats -#define REBLUR_FORMAT Format::RGBA16_SFLOAT - -#define REBLUR_FORMAT_DIFF_FAST_HISTORY Format::R16_SFLOAT -#define REBLUR_FORMAT_SPEC_FAST_HISTORY Format::RG16_SFLOAT // .y = hit distance for tracking - -#define REBLUR_FORMAT_SPEC_HITDIST_FOR_TRACKING Format::R16_UNORM // use R16_SFLOAT if pre-pass outputs unnormalized hit distance - -#define REBLUR_FORMAT_OCCLUSION Format::R16_UNORM - -#define REBLUR_FORMAT_DIRECTIONAL_OCCLUSION Format::RGBA16_SNORM -#define REBLUR_FORMAT_DIRECTIONAL_OCCLUSION_FAST_HISTORY REBLUR_FORMAT_OCCLUSION - -#define REBLUR_FORMAT_PREV_VIEWZ Format::R32_SFLOAT -#define REBLUR_FORMAT_PREV_NORMAL_ROUGHNESS Format::RGBA8_UNORM -#define REBLUR_FORMAT_PREV_INTERNAL_DATA Format::R16_UINT - -// Other -#define REBLUR_DUMMY AsUint(ResourceType::IN_VIEWZ) - -#define REBLUR_ADD_VALIDATION_DISPATCH( data2, diff, spec ) \ - PushPass("Validation"); \ - { \ - PushInput( AsUint(ResourceType::IN_NORMAL_ROUGHNESS) ); \ - PushInput( AsUint(ResourceType::IN_VIEWZ) ); \ - PushInput( AsUint(ResourceType::IN_MV) ); \ - PushInput( AsUint(Transient::DATA1) ); \ - PushInput( AsUint(data2) ); \ - PushInput( AsUint(diff) ); \ - PushInput( AsUint(spec) ); \ - PushOutput( AsUint(ResourceType::OUT_VALIDATION) ); \ - AddDispatch( REBLUR_Validation, SumConstants(1, 0, 1, 4), NumThreads(16, 16), IGNORE_RS ); \ - } - -struct ReblurProps -{ - bool hasDiffuse; - bool hasSpecular; -}; - -constexpr std::array g_ReblurProps = -{{ - {true, false}, // REBLUR_DIFFUSE - {true, false}, // REBLUR_DIFFUSE_OCCLUSION - {true, false}, // REBLUR_DIFFUSE_SH - {false, true}, // REBLUR_SPECULAR - {false, true}, // REBLUR_SPECULAR_OCCLUSION - {false, true}, // REBLUR_SPECULAR_SH - {true, true}, // REBLUR_DIFFUSE_SPECULAR - {true, true}, // REBLUR_DIFFUSE_SPECULAR_OCCLUSION - {true, true}, // REBLUR_DIFFUSE_SPECULAR_SH - {true, false}, // REBLUR_DIFFUSE_DIRECTIONAL_OCCLUSION -}}; - void nrd::DenoiserImpl::AddMethod_ReblurDiffuse(MethodData& methodData) { #define METHOD_NAME REBLUR_Diffuse @@ -374,255 +272,3 @@ void nrd::DenoiserImpl::AddMethod_ReblurDiffuse(MethodData& methodData) #undef DIFF_TEMP1 #undef DIFF_TEMP2 } - -void nrd::DenoiserImpl::UpdateMethod_Reblur(const MethodData& methodData) -{ - enum class Dispatch - { - HITDIST_RECONSTRUCTION, - PREPASS = HITDIST_RECONSTRUCTION + REBLUR_HITDIST_RECONSTRUCTION_PERMUTATION_NUM * 2, - TEMPORAL_ACCUMULATION = PREPASS + REBLUR_PREPASS_PERMUTATION_NUM * 2, - HISTORY_FIX = TEMPORAL_ACCUMULATION + REBLUR_TEMPORAL_ACCUMULATION_PERMUTATION_NUM * 2, - BLUR = HISTORY_FIX + REBLUR_HISTORY_FIX_PERMUTATION_NUM * 2, - POST_BLUR = BLUR + REBLUR_BLUR_PERMUTATION_NUM * 2, - COPY_STABILIZED_HISTORY = POST_BLUR + REBLUR_POST_BLUR_PERMUTATION_NUM * 2, - TEMPORAL_STABILIZATION = COPY_STABILIZED_HISTORY + REBLUR_COPY_STABILIZED_HISTORY_PERMUTATION_NUM * 1, // no perf mode for copy - SPLIT_SCREEN = TEMPORAL_STABILIZATION + REBLUR_TEMPORAL_STABILIZATION_PERMUTATION_NUM * 2, - VALIDATION = SPLIT_SCREEN + REBLUR_SPLIT_SCREEN_PERMUTATION_NUM * 1, // no perf mode for split screen - }; - - NRD_DECLARE_DIMS; - - const ReblurSettings& settings = methodData.settings.reblur; - const ReblurProps& props = g_ReblurProps[ size_t(methodData.desc.method) - size_t(Method::REBLUR_DIFFUSE) ]; - - bool enableHitDistanceReconstruction = settings.hitDistanceReconstructionMode != HitDistanceReconstructionMode::OFF && settings.checkerboardMode == CheckerboardMode::OFF; - bool skipTemporalStabilization = settings.stabilizationStrength == 0.0f; - bool skipPrePass = (settings.diffusePrepassBlurRadius == 0.0f || !props.hasDiffuse) && - (settings.specularPrepassBlurRadius == 0.0f || !props.hasSpecular) && - settings.checkerboardMode == CheckerboardMode::OFF; - - float disocclusionThresholdBonus = (1.0f + m_JitterDelta) / float(rectH); - float disocclusionThreshold = m_CommonSettings.disocclusionThreshold + disocclusionThresholdBonus; - float disocclusionThresholdAlternate = m_CommonSettings.disocclusionThresholdAlternate + disocclusionThresholdBonus; - - ml::float4 antilagMinMaxThreshold = ml::float4(settings.antilagIntensitySettings.thresholdMin, settings.antilagHitDistanceSettings.thresholdMin, settings.antilagIntensitySettings.thresholdMax, settings.antilagHitDistanceSettings.thresholdMax); - - if (!settings.antilagIntensitySettings.enable || settings.enableReferenceAccumulation) - { - antilagMinMaxThreshold.x = 99998.0f; - antilagMinMaxThreshold.z = 99999.0f; - } - - if (!settings.antilagHitDistanceSettings.enable || settings.enableReferenceAccumulation) - { - antilagMinMaxThreshold.y = 99998.0f; - antilagMinMaxThreshold.w = 99999.0f; - } - - uint32_t specCheckerboard = 2; - uint32_t diffCheckerboard = 2; - - switch (settings.checkerboardMode) - { - case CheckerboardMode::BLACK: - diffCheckerboard = 0; - specCheckerboard = 1; - break; - case CheckerboardMode::WHITE: - diffCheckerboard = 1; - specCheckerboard = 0; - break; - default: - break; - } - - // SPLIT_SCREEN (passthrough) - if (m_CommonSettings.splitScreen >= 1.0f) - { - Constant* data = PushDispatch(methodData, AsUint(Dispatch::SPLIT_SCREEN)); - AddSharedConstants_Reblur(methodData, settings, data); - AddFloat(data, m_CommonSettings.splitScreen); - AddUint(data, diffCheckerboard); - AddUint(data, specCheckerboard); - ValidateConstants(data); - - return; - } - - // HITDIST_RECONSTRUCTION - if (enableHitDistanceReconstruction) - { - uint32_t passIndex = AsUint(Dispatch::HITDIST_RECONSTRUCTION) + (settings.hitDistanceReconstructionMode == HitDistanceReconstructionMode::AREA_5X5 ? 4 : 0) + (!skipPrePass ? 2 : 0) + (settings.enablePerformanceMode ? 1 : 0); - Constant* data = PushDispatch(methodData, passIndex); - AddSharedConstants_Reblur(methodData, settings, data); - ValidateConstants(data); - } - - // PREPASS - if (!skipPrePass) - { - uint32_t passIndex = AsUint(Dispatch::PREPASS) + (enableHitDistanceReconstruction ? 2 : 0) + (settings.enablePerformanceMode ? 1 : 0); - Constant* data = PushDispatch(methodData, passIndex); - AddSharedConstants_Reblur(methodData, settings, data); - AddFloat4(data, m_Rotator_PrePass); - AddUint(data, diffCheckerboard); - AddUint(data, specCheckerboard); - ValidateConstants(data); - } - - // TEMPORAL_ACCUMULATION - uint32_t passIndex = AsUint(Dispatch::TEMPORAL_ACCUMULATION) + (m_CommonSettings.isDisocclusionThresholdMixAvailable ? 16 : 0) + - (!skipTemporalStabilization ? 8 : 0) + (m_CommonSettings.isHistoryConfidenceAvailable ? 4 : 0) + - ((!skipPrePass || enableHitDistanceReconstruction) ? 2 : 0) + (settings.enablePerformanceMode ? 1 : 0); - Constant* data = PushDispatch(methodData, passIndex); - AddSharedConstants_Reblur(methodData, settings, data); - AddFloat4x4(data, m_WorldToViewPrev); - AddFloat4x4(data, m_WorldToClipPrev); - AddFloat4x4(data, m_WorldToClip); - AddFloat4x4(data, m_WorldPrevToWorld); - AddFloat4(data, m_FrustumPrev); - AddFloat4(data, ml::float4(m_CameraDelta.x, m_CameraDelta.y, m_CameraDelta.z, disocclusionThreshold)); - AddFloat(data, disocclusionThresholdAlternate); - AddFloat(data, m_CheckerboardResolveAccumSpeed); - AddUint(data, diffCheckerboard); - AddUint(data, specCheckerboard); - AddUint(data, skipPrePass ? 0 : 1); - AddUint(data, m_CommonSettings.isHistoryConfidenceAvailable ? 1 : 0); - AddUint(data, m_CommonSettings.isDisocclusionThresholdMixAvailable ? 1 : 0); - ValidateConstants(data); - - // HISTORY_FIX - passIndex = AsUint(Dispatch::HISTORY_FIX) + (settings.enablePerformanceMode ? 1 : 0); - data = PushDispatch(methodData, passIndex); - AddSharedConstants_Reblur(methodData, settings, data); - AddFloat(data, settings.historyFixStrideBetweenSamples); - ValidateConstants(data); - - // BLUR - passIndex = AsUint(Dispatch::BLUR) + (settings.enablePerformanceMode ? 1 : 0); - data = PushDispatch(methodData, passIndex); - AddSharedConstants_Reblur(methodData, settings, data); - AddFloat4(data, m_Rotator_Blur); - ValidateConstants(data); - - // POST_BLUR - passIndex = AsUint(Dispatch::POST_BLUR) + (skipTemporalStabilization ? 0 : 2) + (settings.enablePerformanceMode ? 1 : 0); - data = PushDispatch(methodData, passIndex); - AddSharedConstants_Reblur(methodData, settings, data); - AddFloat4(data, m_Rotator_PostBlur); - ValidateConstants(data); - - // COPY_STABILIZED_HISTORY - if (!skipTemporalStabilization) - { - passIndex = AsUint(Dispatch::COPY_STABILIZED_HISTORY); - data = PushDispatch(methodData, passIndex); - ValidateConstants(data); - } - - // TEMPORAL_STABILIZATION - if (!skipTemporalStabilization) - { - passIndex = AsUint(Dispatch::TEMPORAL_STABILIZATION) + (m_CommonSettings.isBaseColorMetalnessAvailable ? 2 : 0) + (settings.enablePerformanceMode ? 1 : 0); - data = PushDispatch(methodData, passIndex); - AddSharedConstants_Reblur(methodData, settings, data); - AddFloat4x4(data, m_WorldToClip); - AddFloat4x4(data, m_WorldToClipPrev); - AddFloat4x4(data, m_WorldToViewPrev); - AddFloat4(data, m_FrustumPrev); - AddFloat4(data, antilagMinMaxThreshold ); - AddFloat4(data, ml::float4(m_CameraDelta.x, m_CameraDelta.y, m_CameraDelta.z, settings.stabilizationStrength)); - AddFloat2(data, settings.antilagIntensitySettings.sigmaScale, settings.antilagHitDistanceSettings.sigmaScale); - if (m_CommonSettings.isBaseColorMetalnessAvailable) - AddFloat2(data, settings.specularProbabilityThresholdsForMvModification[0], settings.specularProbabilityThresholdsForMvModification[1]); - else - AddFloat2(data, 2.0f, 3.0f); - AddFloat(data, m_CommonSettings.splitScreen); - ValidateConstants(data); - } - - // SPLIT_SCREEN - if (m_CommonSettings.splitScreen > 0.0f) - { - data = PushDispatch(methodData, AsUint(Dispatch::SPLIT_SCREEN)); - AddSharedConstants_Reblur(methodData, settings, data); - AddFloat(data, m_CommonSettings.splitScreen); - AddUint(data, diffCheckerboard); - AddUint(data, specCheckerboard); - ValidateConstants(data); - } - - // VALIDATION - if (m_CommonSettings.enableValidation) - { - data = PushDispatch(methodData, AsUint(Dispatch::VALIDATION)); - AddSharedConstants_Reblur(methodData, settings, data); - AddFloat4x4(data, m_WorldToClipPrev); - AddFloat2(data, m_CommonSettings.cameraJitter[0], m_CommonSettings.cameraJitter[1]); - AddUint(data, props.hasDiffuse ? 1 : 0); - AddUint(data, props.hasSpecular ? 1 : 0); - AddUint(data, diffCheckerboard); - AddUint(data, specCheckerboard); - ValidateConstants(data); - } -} - -void nrd::DenoiserImpl::AddSharedConstants_Reblur(const MethodData& methodData, const ReblurSettings& settings, Constant*& data) -{ - NRD_DECLARE_DIMS; - - bool isHistoryReset = m_CommonSettings.accumulationMode != AccumulationMode::CONTINUE; - float unproject = 1.0f / (0.5f * rectH * m_ProjectY); - uint32_t maxAccumulatedFrameNum = ml::Min(settings.maxAccumulatedFrameNum, REBLUR_MAX_HISTORY_FRAME_NUM); - - AddFloat4x4(data, m_ViewToClip); - AddFloat4x4(data, m_ViewToWorld); - - AddFloat4(data, m_Frustum); - AddFloat4(data, ml::float4(settings.hitDistanceParameters.A, settings.hitDistanceParameters.B, settings.hitDistanceParameters.C, settings.hitDistanceParameters.D)); - AddFloat4(data, ml::float4(m_ViewDirection.x, m_ViewDirection.y, m_ViewDirection.z, 0.0f)); - AddFloat4(data, ml::float4(m_ViewDirectionPrev.x, m_ViewDirectionPrev.y, m_ViewDirectionPrev.z, 0.0f)); - AddFloat4(data, ml::float4(m_CommonSettings.motionVectorScale[0], m_CommonSettings.motionVectorScale[1], m_CommonSettings.motionVectorScale[2], m_CommonSettings.debug)); - - AddFloat2(data, 1.0f / float(screenW), 1.0f / float(screenH)); - AddFloat2(data, float(screenW), float(screenH)); - - AddFloat2(data, 1.0f / float(rectW), 1.0f / float(rectH)); - AddFloat2(data, float(rectW), float(rectH)); - - AddFloat2(data, float(rectWprev), float(rectHprev)); - AddFloat2(data, float(rectW) / float(screenW), float(rectH) / float(screenH)); - - AddFloat2(data, float(m_CommonSettings.inputSubrectOrigin[0]) / float(screenW), float(m_CommonSettings.inputSubrectOrigin[1]) / float(screenH)); - AddFloat2(data, settings.antilagIntensitySettings.sensitivityToDarkness + 1e-6f, settings.antilagHitDistanceSettings.sensitivityToDarkness + 1e-6f); - - AddUint2(data, m_CommonSettings.inputSubrectOrigin[0], m_CommonSettings.inputSubrectOrigin[1]); - AddFloat(data, settings.enableReferenceAccumulation ? 0.0f : 1.0f); - AddFloat(data, m_IsOrtho); - - AddFloat(data, unproject); - AddFloat(data, m_CommonSettings.denoisingRange); - AddFloat(data, settings.planeDistanceSensitivity); - AddFloat(data, m_FrameRateScale); - - AddFloat(data, settings.enableReferenceAccumulation ? 0.0f : settings.blurRadius); - AddFloat(data, isHistoryReset ? 0 : float(maxAccumulatedFrameNum)); - AddFloat(data, float(settings.maxFastAccumulatedFrameNum)); - AddFloat(data, settings.enableAntiFirefly ? 1.0f : 0.0f); - - AddFloat(data, settings.lobeAngleFraction); - AddFloat(data, settings.roughnessFraction); - AddFloat(data, settings.responsiveAccumulationRoughnessThreshold); - AddFloat(data, settings.diffusePrepassBlurRadius); - - AddFloat(data, settings.specularPrepassBlurRadius); - AddFloat(data, (float)settings.historyFixFrameNum); - AddFloat(data, (float)ml::Min(rectW, rectH) * unproject); - AddUint(data, m_CommonSettings.isMotionVectorInWorldSpace ? 1 : 0); - - AddUint(data, m_CommonSettings.frameIndex); - AddUint(data, settings.enableMaterialTestForDiffuse ? 1 : 0); - AddUint(data, settings.enableMaterialTestForSpecular ? 1 : 0); - AddUint(data, isHistoryReset ? 1 : 0); -} diff --git a/Source/Methods/Reblur_DiffuseOcclusion.hpp b/Source/Methods/Reblur_DiffuseOcclusion.hpp index e84e208a..18980d60 100644 --- a/Source/Methods/Reblur_DiffuseOcclusion.hpp +++ b/Source/Methods/Reblur_DiffuseOcclusion.hpp @@ -191,133 +191,3 @@ void nrd::DenoiserImpl::AddMethod_ReblurDiffuseOcclusion(MethodData& methodData) #undef DIFF_TEMP1 #undef DIFF_TEMP2 } - -void nrd::DenoiserImpl::UpdateMethod_ReblurOcclusion(const MethodData& methodData) -{ - enum class Dispatch - { - HITDIST_RECONSTRUCTION, - TEMPORAL_ACCUMULATION = HITDIST_RECONSTRUCTION + REBLUR_OCCLUSION_HITDIST_RECONSTRUCTION_PERMUTATION_NUM * 2, - HISTORY_FIX = TEMPORAL_ACCUMULATION + REBLUR_OCCLUSION_TEMPORAL_ACCUMULATION_PERMUTATION_NUM * 2, - BLUR = HISTORY_FIX + REBLUR_OCCLUSION_HISTORY_FIX_PERMUTATION_NUM * 2, // non perf mode is used for anti-firefly - POST_BLUR = BLUR + REBLUR_OCCLUSION_BLUR_PERMUTATION_NUM * 2, - SPLIT_SCREEN = POST_BLUR + REBLUR_OCCLUSION_POST_BLUR_PERMUTATION_NUM * 2, - VALIDATION = SPLIT_SCREEN + REBLUR_SPLIT_SCREEN_PERMUTATION_NUM * 1, // no perf mode for split screen - }; - - NRD_DECLARE_DIMS; - - const ReblurSettings& settings = methodData.settings.reblur; - const ReblurProps& props = g_ReblurProps[ size_t(methodData.desc.method) - size_t(Method::REBLUR_DIFFUSE) ]; - - bool enableHitDistanceReconstruction = settings.hitDistanceReconstructionMode != HitDistanceReconstructionMode::OFF && settings.checkerboardMode == CheckerboardMode::OFF; - - float disocclusionThresholdBonus = (1.0f + m_JitterDelta) / float(rectH); - float disocclusionThreshold = m_CommonSettings.disocclusionThreshold + disocclusionThresholdBonus; - float disocclusionThresholdAlternate = m_CommonSettings.disocclusionThresholdAlternate + disocclusionThresholdBonus; - - uint32_t specCheckerboard = 2; - uint32_t diffCheckerboard = 2; - - switch (settings.checkerboardMode) - { - case CheckerboardMode::BLACK: - diffCheckerboard = 0; - specCheckerboard = 1; - break; - case CheckerboardMode::WHITE: - diffCheckerboard = 1; - specCheckerboard = 0; - break; - default: - break; - } - - // SPLIT_SCREEN (passthrough) - if (m_CommonSettings.splitScreen >= 1.0f) - { - Constant* data = PushDispatch(methodData, AsUint(Dispatch::SPLIT_SCREEN)); - AddSharedConstants_Reblur(methodData, settings, data); - AddFloat(data, m_CommonSettings.splitScreen); - AddUint(data, diffCheckerboard); - AddUint(data, specCheckerboard); - ValidateConstants(data); - - return; - } - - // HITDIST_RECONSTRUCTION - if (enableHitDistanceReconstruction) - { - uint32_t passIndex = AsUint(Dispatch::HITDIST_RECONSTRUCTION) + (settings.hitDistanceReconstructionMode == HitDistanceReconstructionMode::AREA_5X5 ? 2 : 0) + (settings.enablePerformanceMode ? 1 : 0); - Constant* data = PushDispatch(methodData, passIndex); - AddSharedConstants_Reblur(methodData, settings, data); - ValidateConstants(data); - } - - // TEMPORAL_ACCUMULATION - uint32_t passIndex = AsUint(Dispatch::TEMPORAL_ACCUMULATION) + (m_CommonSettings.isDisocclusionThresholdMixAvailable ? 8 : 0) + - (m_CommonSettings.isHistoryConfidenceAvailable ? 4 : 0) + (enableHitDistanceReconstruction ? 2 : 0) + (settings.enablePerformanceMode ? 1 : 0); - Constant* data = PushDispatch(methodData, passIndex); - AddSharedConstants_Reblur(methodData, settings, data); - AddFloat4x4(data, m_WorldToViewPrev); - AddFloat4x4(data, m_WorldToClipPrev); - AddFloat4x4(data, m_WorldToClip); - AddFloat4x4(data, m_WorldPrevToWorld); - AddFloat4(data, m_FrustumPrev); - AddFloat4(data, ml::float4(m_CameraDelta.x, m_CameraDelta.y, m_CameraDelta.z, disocclusionThreshold)); - AddFloat(data, disocclusionThresholdAlternate); - AddFloat(data, m_CheckerboardResolveAccumSpeed); - AddUint(data, diffCheckerboard); - AddUint(data, specCheckerboard); - AddUint(data, 0); - AddUint(data, m_CommonSettings.isHistoryConfidenceAvailable); - AddUint(data, m_CommonSettings.isDisocclusionThresholdMixAvailable); - ValidateConstants(data); - - // HISTORY_FIX - passIndex = AsUint(Dispatch::HISTORY_FIX) + (!settings.enableAntiFirefly ? 1 : 0); - data = PushDispatch(methodData, passIndex); - AddSharedConstants_Reblur(methodData, settings, data); - AddFloat(data, settings.historyFixStrideBetweenSamples); - ValidateConstants(data); - - // BLUR - passIndex = AsUint(Dispatch::BLUR) + (settings.enablePerformanceMode ? 1 : 0); - data = PushDispatch(methodData, passIndex); - AddSharedConstants_Reblur(methodData, settings, data); - AddFloat4(data, m_Rotator_Blur); - ValidateConstants(data); - - // POST_BLUR - passIndex = AsUint(Dispatch::POST_BLUR) + (settings.enablePerformanceMode ? 1 : 0); - data = PushDispatch(methodData, passIndex); - AddSharedConstants_Reblur(methodData, settings, data); - AddFloat4(data, m_Rotator_PostBlur); - ValidateConstants(data); - - // SPLIT_SCREEN - if (m_CommonSettings.splitScreen > 0.0f) - { - data = PushDispatch(methodData, AsUint(Dispatch::SPLIT_SCREEN)); - AddSharedConstants_Reblur(methodData, settings, data); - AddFloat(data, m_CommonSettings.splitScreen); - AddUint(data, diffCheckerboard); - AddUint(data, specCheckerboard); - ValidateConstants(data); - } - - // VALIDATION - if (m_CommonSettings.enableValidation) - { - data = PushDispatch(methodData, AsUint(Dispatch::VALIDATION)); - AddSharedConstants_Reblur(methodData, settings, data); - AddFloat4x4(data, m_WorldToClipPrev); - AddFloat2(data, m_CommonSettings.cameraJitter[0], m_CommonSettings.cameraJitter[1]); - AddUint(data, props.hasDiffuse ? 1 : 0); - AddUint(data, props.hasSpecular ? 1 : 0); - AddUint(data, diffCheckerboard); - AddUint(data, specCheckerboard); - ValidateConstants(data); - } -} diff --git a/Source/Methods/Relax_Diffuse.hpp b/Source/Methods/Relax_Diffuse.hpp index 13f5e8ca..fdd9bcb0 100644 --- a/Source/Methods/Relax_Diffuse.hpp +++ b/Source/Methods/Relax_Diffuse.hpp @@ -7,120 +7,6 @@ and any modifications thereto. Any use, reproduction, disclosure or distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -constexpr uint32_t RELAX_MAX_ATROUS_PASS_NUM = 8; - -#define RELAX_SET_SHARED_CONSTANTS SetSharedConstants(5, 8, 7, 14) - -#define RELAX_ADD_VALIDATION_DISPATCH \ - PushPass("Validation"); \ - { \ - PushInput( AsUint(ResourceType::IN_NORMAL_ROUGHNESS) ); \ - PushInput( AsUint(ResourceType::IN_VIEWZ) ); \ - PushInput( AsUint(ResourceType::IN_MV) ); \ - PushInput( AsUint(Permanent::HISTORY_LENGTH_CURR) ); \ - PushOutput( AsUint(ResourceType::OUT_VALIDATION) ); \ - AddDispatch( RELAX_Validation, SumConstants(1, 0, 1, 1), NumThreads(16, 16), IGNORE_RS ); \ - } - -inline ml::float3 RELAX_GetFrustumForward(const ml::float4x4& viewToWorld, const ml::float4& frustum) -{ - // Note: this vector is not normalized for non-symmetric projections but that's correct. - // It has to have .z coordinate equal to 1.0 to correctly reconstruct world position in shaders. - ml::float4 frustumForwardView = ml::float4(0.5f, 0.5f, 1.0f, 0.0f) * ml::float4(frustum.z, frustum.w, 1.0f, 0.0f) + ml::float4(frustum.x, frustum.y, 0.0f, 0.0f); - ml::float3 frustumForwardWorld = (viewToWorld * frustumForwardView).To3d(); - return frustumForwardWorld; -} - -inline bool RELAX_IsCameraStatic -( - const ml::float3& cameraDelta, - const ml::float3& frustumRight, const ml::float3& frustumUp, const ml::float3& frustumForward, - const ml::float3& prevFrustumRight, const ml::float3& prevFrustumUp, const ml::float3& prevFrustumForward, float eps = ml::c_fEps -) -{ - return ml::Length(cameraDelta) < eps && ml::Length(frustumRight - prevFrustumRight) < eps && ml::Length(frustumUp - prevFrustumUp) < eps && ml::Length(frustumForward - prevFrustumForward) < eps; -} - -void nrd::DenoiserImpl::AddSharedConstants_Relax(const MethodData& methodData, Constant*& data, Method method) -{ - NRD_DECLARE_DIMS; - - // Calculate camera right and up vectors in worldspace scaled according to frustum extents, - // and unit forward vector, for fast worldspace position reconstruction in shaders - float tanHalfFov = 1.0f / m_ViewToClip.a00; - float aspect = m_ViewToClip.a00 / m_ViewToClip.a11; - ml::float3 frustumRight = m_WorldToView.GetRow0().To3d() * tanHalfFov; - ml::float3 frustumUp = m_WorldToView.GetRow1().To3d() * tanHalfFov * aspect; - ml::float3 frustumForward = RELAX_GetFrustumForward(m_ViewToWorld, m_Frustum); - - float prevTanHalfFov = 1.0f / m_ViewToClipPrev.a00; - float prevAspect = m_ViewToClipPrev.a00 / m_ViewToClipPrev.a11; - ml::float3 prevFrustumRight = m_WorldToViewPrev.GetRow0().To3d() * prevTanHalfFov; - ml::float3 prevFrustumUp = m_WorldToViewPrev.GetRow1().To3d() * prevTanHalfFov * prevAspect; - ml::float3 prevFrustumForward = RELAX_GetFrustumForward(m_ViewToWorldPrev, m_FrustumPrev); - - AddFloat4x4(data, m_WorldToClipPrev); - AddFloat4x4(data, m_WorldToViewPrev); - AddFloat4x4(data, m_WorldToClip); - AddFloat4x4(data, m_WorldPrevToWorld); - AddFloat4x4(data, m_ViewToWorld); - - AddFloat4(data, ml::float4(frustumRight.x, frustumRight.y, frustumRight.z, 0)); - AddFloat4(data, ml::float4(frustumUp.x, frustumUp.y, frustumUp.z, 0)); - AddFloat4(data, ml::float4(frustumForward.x, frustumForward.y, frustumForward.z, 0)); - AddFloat4(data, ml::float4(prevFrustumRight.x, prevFrustumRight.y, prevFrustumRight.z, 0)); - AddFloat4(data, ml::float4(prevFrustumUp.x, prevFrustumUp.y, prevFrustumUp.z, 0)); - AddFloat4(data, ml::float4(prevFrustumForward.x, prevFrustumForward.y, prevFrustumForward.z, 0)); - AddFloat4(data, ml::float4(m_CameraDelta.x, m_CameraDelta.y, m_CameraDelta.z, 0.0f)); - AddFloat4(data, ml::float4(m_CommonSettings.motionVectorScale[0], m_CommonSettings.motionVectorScale[1], m_CommonSettings.motionVectorScale[2], m_CommonSettings.debug)); - - AddFloat2(data, float(rectW) / float(screenW), float(rectH) / float(screenH)); - AddUint2(data, m_CommonSettings.inputSubrectOrigin[0], m_CommonSettings.inputSubrectOrigin[1]); - - AddFloat2(data, float(m_CommonSettings.inputSubrectOrigin[0]) / float(screenW), float(m_CommonSettings.inputSubrectOrigin[1]) / float(screenH)); - AddUint2(data, rectW, rectH); - - AddFloat2(data, 1.0f / screenW, 1.0f / screenH); - AddFloat2(data, 1.0f / rectW, 1.0f / rectH); - - AddFloat2(data, float(rectWprev), float(rectHprev)); - AddUint(data, m_CommonSettings.isMotionVectorInWorldSpace ? 1 : 0); - AddFloat(data, m_IsOrtho); - - AddFloat(data, 1.0f / (0.5f * rectH * m_ProjectY)); - AddUint(data, m_CommonSettings.frameIndex); - AddFloat(data, m_CommonSettings.denoisingRange); - AddFloat(data, ml::Clamp(16.66f / m_TimeDelta, 0.25f, 4.0f)); // Normalizing to 60 FPS - - AddFloat(data, m_CheckerboardResolveAccumSpeed); - AddFloat(data, m_JitterDelta); - switch (method) - { - case Method::RELAX_DIFFUSE: - AddUint(data, methodData.settings.diffuseRelax.enableMaterialTest ? 1 : 0); - AddUint(data, 0); - break; - case Method::RELAX_SPECULAR: - AddUint(data, 0); - AddUint(data, methodData.settings.specularRelax.enableMaterialTest ? 1 : 0); - break; - case Method::RELAX_DIFFUSE_SPECULAR: - AddUint(data, methodData.settings.diffuseSpecularRelax.enableMaterialTestForDiffuse ? 1 : 0); - AddUint(data, methodData.settings.diffuseSpecularRelax.enableMaterialTestForSpecular ? 1 : 0); - break; - default: - // Should never get here - AddUint(data, 0); - AddUint(data, 0); - break; - } - - // 1 if m_WorldPrevToWorld should be used in shader, otherwise we can skip multiplication - AddUint(data, (m_WorldPrevToWorld != ml::float4x4::Identity()) ? 1 : 0); - AddUint(data, m_CommonSettings.accumulationMode != AccumulationMode::CONTINUE ? 1 : 0); - AddUint(data, 0); - AddUint(data, 0); -} void nrd::DenoiserImpl::AddMethod_RelaxDiffuse(MethodData& methodData) { diff --git a/Source/Methods/Relax_DiffuseSh.hpp b/Source/Methods/Relax_DiffuseSh.hpp new file mode 100644 index 00000000..8d763cd3 --- /dev/null +++ b/Source/Methods/Relax_DiffuseSh.hpp @@ -0,0 +1,576 @@ +/* +Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved. + +NVIDIA CORPORATION and its licensors retain all intellectual property +and proprietary rights in and to this software, related documentation +and any modifications thereto. Any use, reproduction, disclosure or +distribution of this software and related documentation without an express +license agreement from NVIDIA CORPORATION is strictly prohibited. +*/ + +void nrd::DenoiserImpl::AddMethod_RelaxDiffuseSh(MethodData& methodData) +{ + #define METHOD_NAME RELAX_Diffuse + + methodData.settings.diffuseRelax = RelaxDiffuseSettings(); + methodData.settingsSize = sizeof(methodData.settings.diffuseRelax); + + uint16_t w = methodData.desc.fullResolutionWidth; + uint16_t h = methodData.desc.fullResolutionHeight; + + enum class Permanent + { + DIFF_ILLUM_PREV = PERMANENT_POOL_START, + DIFF_ILLUM_PREV_SH1, + DIFF_ILLUM_RESPONSIVE_PREV, + DIFF_ILLUM_RESPONSIVE_PREV_SH1, + HISTORY_LENGTH_CURR, + HISTORY_LENGTH_PREV, + NORMAL_ROUGHNESS_PREV, + MATERIAL_ID_PREV, + VIEWZ_CURR, + VIEWZ_PREV + }; + + m_PermanentPool.push_back( {Format::RGBA16_SFLOAT, w, h, 1} ); + m_PermanentPool.push_back( {Format::RGBA16_SFLOAT, w, h, 1} ); + m_PermanentPool.push_back( {Format::RGBA16_SFLOAT, w, h, 1} ); + m_PermanentPool.push_back( {Format::RGBA16_SFLOAT, w, h, 1} ); + m_PermanentPool.push_back( {Format::R8_UNORM, w, h, 1} ); + m_PermanentPool.push_back( {Format::R8_UNORM, w, h, 1} ); + m_PermanentPool.push_back( {Format::RGBA8_UNORM, w, h, 1} ); + m_PermanentPool.push_back( {Format::R8_UNORM, w, h, 1} ); + m_PermanentPool.push_back( {Format::R32_SFLOAT, w, h, 1} ); + m_PermanentPool.push_back( {Format::R32_SFLOAT, w, h, 1} ); + + enum class Transient + { + DIFF_ILLUM_PING = TRANSIENT_POOL_START, + DIFF_ILLUM_PING_SH1, + DIFF_ILLUM_PONG, + DIFF_ILLUM_PONG_SH1, + DIFF_ILLUM_TMP, + DIFF_ILLUM_TMP_SH1, + VIEWZ_R16F + }; + + m_TransientPool.push_back( {Format::RGBA16_SFLOAT, w, h, 1} ); + m_TransientPool.push_back( {Format::RGBA16_SFLOAT, w, h, 1} ); + m_TransientPool.push_back( {Format::RGBA16_SFLOAT, w, h, 1} ); + m_TransientPool.push_back( {Format::RGBA16_SFLOAT, w, h, 1} ); + m_TransientPool.push_back( {Format::RGBA16_SFLOAT, w, h, 1} ); + m_TransientPool.push_back( {Format::RGBA16_SFLOAT, w, h, 1} ); + m_TransientPool.push_back( {Format::R16_SFLOAT, w, h, 1} ); + + RELAX_SET_SHARED_CONSTANTS; + + const uint32_t halfMaxPassNum = (RELAX_MAX_ATROUS_PASS_NUM - 2 + 1) / 2; + + PushPass("Hit distance reconstruction 3x3"); // 3x3 + { + PushInput( AsUint(ResourceType::IN_DIFF_SH0) ); + PushInput( AsUint(ResourceType::IN_NORMAL_ROUGHNESS) ); + PushInput( AsUint(ResourceType::IN_VIEWZ) ); + + PushOutput( AsUint(Transient::DIFF_ILLUM_PING) ); + + AddDispatch( RELAX_Diffuse_HitDistReconstruction, SumConstants(0, 0, 0, 0), NumThreads(8, 8), 1 ); + } + + PushPass("Hit distance reconstruction 5x5"); // 5x5 + { + PushInput( AsUint(ResourceType::IN_DIFF_SH0) ); + PushInput( AsUint(ResourceType::IN_NORMAL_ROUGHNESS) ); + PushInput( AsUint(ResourceType::IN_VIEWZ) ); + + PushOutput( AsUint(Transient::DIFF_ILLUM_PING) ); + + AddDispatch( RELAX_Diffuse_HitDistReconstruction_5x5, SumConstants(0, 0, 0, 0), NumThreads(8, 8), 1 ); + } + + PushPass("Pre-pass"); // After hit distance reconstruction + { + // Does preblur (if enabled), checkerboard reconstruction (if enabled) and generates FP16 ViewZ texture + PushInput( AsUint(Transient::DIFF_ILLUM_PING) ); + PushInput( AsUint(ResourceType::IN_NORMAL_ROUGHNESS) ); + PushInput( AsUint(ResourceType::IN_VIEWZ) ); + PushInput( AsUint(ResourceType::IN_DIFF_SH1) ); + + PushOutput( AsUint(Transient::DIFF_ILLUM_TMP) ); + PushOutput( AsUint(Permanent::VIEWZ_CURR), 0, 1, AsUint(Permanent::VIEWZ_PREV) ); + PushOutput( AsUint(Transient::VIEWZ_R16F) ); + PushOutput( AsUint(Transient::DIFF_ILLUM_TMP_SH1) ); + + AddDispatch( RELAX_DiffuseSh_PrePass, SumConstants(0, 1, 0, 5), NumThreads(16, 16), 1 ); + } + + PushPass("Pre-pass"); // Without hit distance reconstruction + { + // Does preblur (if enabled), checkerboard reconstruction (if enabled) and generates FP16 ViewZ texture + PushInput( AsUint(ResourceType::IN_DIFF_SH0) ); + PushInput( AsUint(ResourceType::IN_NORMAL_ROUGHNESS) ); + PushInput( AsUint(ResourceType::IN_VIEWZ) ); + PushInput( AsUint(ResourceType::IN_DIFF_SH1) ); + + PushOutput( AsUint(Transient::DIFF_ILLUM_TMP) ); + PushOutput( AsUint(Permanent::VIEWZ_CURR), 0, 1, AsUint(Permanent::VIEWZ_PREV) ); + PushOutput( AsUint(Transient::VIEWZ_R16F) ); + PushOutput( AsUint(Transient::DIFF_ILLUM_TMP_SH1) ); + + AddDispatch( RELAX_DiffuseSh_PrePass, SumConstants(0, 1, 0, 5), NumThreads(16, 16), 1 ); + } + + for (int i = 0; i < 4; i++) + { + // The following passes are defined here: + // TEMPORAL_ACCUMULATION, + // TEMPORAL_ACCUMULATION_WITH_CONFIDENCE_INPUTS, + // TEMPORAL_ACCUMULATION_WITH_THRESHOLD_MIX, + // TEMPORAL_ACCUMULATION_WITH_CONFIDENCE_INPUTS_WITH_THRESHOLD_MIX + + PushPass("Temporal accumulation"); + { + PushInput( AsUint(Transient::DIFF_ILLUM_TMP) ); + PushInput( AsUint(ResourceType::IN_MV) ); + PushInput( AsUint(ResourceType::IN_NORMAL_ROUGHNESS) ); + PushInput( AsUint(Permanent::VIEWZ_CURR), 0, 1, AsUint(Permanent::VIEWZ_PREV) ); + PushInput( AsUint(Permanent::DIFF_ILLUM_RESPONSIVE_PREV) ); + PushInput( AsUint(Permanent::DIFF_ILLUM_PREV) ); + PushInput( AsUint(Permanent::NORMAL_ROUGHNESS_PREV) ); + PushInput( AsUint(Permanent::VIEWZ_PREV), 0, 1, AsUint(Permanent::VIEWZ_CURR) ); + PushInput( AsUint(Permanent::HISTORY_LENGTH_PREV) ); + PushInput( AsUint(Permanent::MATERIAL_ID_PREV) ); + // Optional inputs: + if (i == 0) + { + PushInput( AsUint(Transient::VIEWZ_R16F) ); // Bogus input that will not be fetched anyway + PushInput( AsUint(Permanent::HISTORY_LENGTH_PREV) ); // Bogus input that will not be fetched anyway + } + if (i == 1) + { + PushInput( AsUint(ResourceType::IN_DIFF_CONFIDENCE) ); + PushInput( AsUint(Permanent::HISTORY_LENGTH_PREV) ); // Bogus input that will not be fetched anyway + } + if (i == 2) + { + PushInput( AsUint(Transient::VIEWZ_R16F) ); // Bogus input that will not be fetched anyway + PushInput( AsUint(ResourceType::IN_DISOCCLUSION_THRESHOLD_MIX) ); + } + if (i == 3) + { + PushInput( AsUint(ResourceType::IN_DIFF_CONFIDENCE) ); + PushInput( AsUint(ResourceType::IN_DISOCCLUSION_THRESHOLD_MIX) ); + } + PushInput( AsUint(Transient::DIFF_ILLUM_TMP_SH1) ); + PushInput( AsUint(Permanent::DIFF_ILLUM_RESPONSIVE_PREV_SH1) ); + PushInput( AsUint(Permanent::DIFF_ILLUM_PREV_SH1) ); + + PushOutput( AsUint(Transient::DIFF_ILLUM_PING) ); + PushOutput( AsUint(Transient::DIFF_ILLUM_PONG) ); + PushOutput( AsUint(Permanent::HISTORY_LENGTH_CURR) ); + PushOutput( AsUint(Transient::DIFF_ILLUM_PING_SH1) ); + PushOutput( AsUint(Transient::DIFF_ILLUM_PONG_SH1) ); + + AddDispatch( RELAX_DiffuseSh_TemporalAccumulation, SumConstants(0, 0, 0, 8), NumThreads(8, 8), 1 ); + } + } + + PushPass("History fix"); + { + PushInput( AsUint(Transient::DIFF_ILLUM_PING) ); + PushInput( AsUint(Permanent::HISTORY_LENGTH_CURR) ); + PushInput( AsUint(ResourceType::IN_NORMAL_ROUGHNESS) ); + PushInput( AsUint(Transient::VIEWZ_R16F) ); + PushInput( AsUint(Transient::DIFF_ILLUM_PING_SH1) ); + + PushOutput( AsUint(Transient::DIFF_ILLUM_PONG) ); + PushOutput( AsUint(Transient::DIFF_ILLUM_PONG_SH1) ); + + AddDispatch( RELAX_DiffuseSh_HistoryFix, SumConstants(0, 0, 0, 4), NumThreads(8, 8), 1 ); + } + + PushPass("History clamping"); // with firefly after it + { + PushInput( AsUint(Transient::DIFF_ILLUM_PING) ); + PushInput( AsUint(Transient::DIFF_ILLUM_PONG) ); + PushInput( AsUint(Permanent::HISTORY_LENGTH_CURR) ); + PushInput( AsUint(Transient::DIFF_ILLUM_PING_SH1) ); + PushInput( AsUint(Transient::DIFF_ILLUM_PONG_SH1) ); + + PushOutput( AsUint(Transient::DIFF_ILLUM_TMP) ); + PushOutput( AsUint(Permanent::DIFF_ILLUM_RESPONSIVE_PREV) ); + PushOutput( AsUint(Permanent::HISTORY_LENGTH_PREV) ); + PushOutput( AsUint(Permanent::DIFF_ILLUM_PREV_SH1) ); + PushOutput( AsUint(Permanent::DIFF_ILLUM_RESPONSIVE_PREV_SH1) ); + + AddDispatch( RELAX_DiffuseSh_HistoryClamping, SumConstants(0, 0, 0, 3), NumThreads(8, 8), 1 ); + } + + PushPass("History clamping"); // without firefly after it + { + PushInput( AsUint(Transient::DIFF_ILLUM_PING) ); + PushInput( AsUint(Transient::DIFF_ILLUM_PONG) ); + PushInput( AsUint(Permanent::HISTORY_LENGTH_CURR) ); + PushInput( AsUint(Transient::DIFF_ILLUM_PING_SH1) ); + PushInput( AsUint(Transient::DIFF_ILLUM_PONG_SH1) ); + + PushOutput( AsUint(Permanent::DIFF_ILLUM_PREV) ); + PushOutput( AsUint(Permanent::DIFF_ILLUM_RESPONSIVE_PREV) ); + PushOutput( AsUint(Permanent::HISTORY_LENGTH_PREV) ); + PushOutput( AsUint(Permanent::DIFF_ILLUM_PREV_SH1) ); + PushOutput( AsUint(Permanent::DIFF_ILLUM_RESPONSIVE_PREV_SH1) ); + + AddDispatch( RELAX_DiffuseSh_HistoryClamping, SumConstants(0, 0, 0, 3), NumThreads(8, 8), 1 ); + } + + PushPass("Anti-firefly"); + { + PushInput( AsUint(Transient::DIFF_ILLUM_TMP) ); + PushInput( AsUint(ResourceType::IN_NORMAL_ROUGHNESS) ); + PushInput( AsUint(Transient::VIEWZ_R16F) ); + + PushOutput( AsUint(Permanent::DIFF_ILLUM_PREV) ); + + AddDispatch( RELAX_DiffuseSh_AntiFirefly, SumConstants(0, 0, 0, 0), NumThreads(16, 16), 1 ); + } + + for (int i = 0; i < 2; i++) + { + bool withConfidenceInputs = (i == 1); + + // A-trous (first) + PushPass("A-trous (SMEM)"); + { + PushInput( AsUint(Permanent::DIFF_ILLUM_PREV) ); + PushInput( AsUint(Permanent::HISTORY_LENGTH_CURR) ); + PushInput( AsUint(ResourceType::IN_NORMAL_ROUGHNESS) ); + PushInput( AsUint(Transient::VIEWZ_R16F) ); + PushInput( withConfidenceInputs ? AsUint(ResourceType::IN_DIFF_CONFIDENCE) : AsUint(Transient::VIEWZ_R16F) ); + PushInput( AsUint(Permanent::DIFF_ILLUM_PREV_SH1) ); + + PushOutput( AsUint(Transient::DIFF_ILLUM_PING) ); + PushOutput( AsUint(Permanent::NORMAL_ROUGHNESS_PREV) ); + PushOutput( AsUint(Permanent::MATERIAL_ID_PREV) ); + PushOutput( AsUint(Transient::DIFF_ILLUM_PING_SH1) ); + + AddDispatch( RELAX_DiffuseSh_AtrousSmem, SumConstants(0, 0, 1, 10), NumThreads(8, 8), 1 ); + } + + // A-trous (odd) + PushPass("A-trous"); + { + PushInput( AsUint(Transient::DIFF_ILLUM_PING) ); + PushInput( AsUint(Permanent::HISTORY_LENGTH_CURR) ); + PushInput( AsUint(ResourceType::IN_NORMAL_ROUGHNESS) ); + PushInput( AsUint(Transient::VIEWZ_R16F) ); + PushInput( withConfidenceInputs ? AsUint(ResourceType::IN_DIFF_CONFIDENCE) : AsUint(Transient::VIEWZ_R16F) ); + PushInput( AsUint(Transient::DIFF_ILLUM_PING_SH1) ); + + PushOutput( AsUint(Transient::DIFF_ILLUM_PONG) ); + PushOutput( AsUint(Transient::DIFF_ILLUM_PONG_SH1) ); + + AddDispatchRepeated( RELAX_DiffuseSh_Atrous, SumConstants(0, 0, 0, 10), NumThreads(16, 16), 1, halfMaxPassNum ); + } + + // A-trous (even) + PushPass("A-trous"); + { + PushInput( AsUint(Transient::DIFF_ILLUM_PONG) ); + PushInput( AsUint(Permanent::HISTORY_LENGTH_CURR) ); + PushInput( AsUint(ResourceType::IN_NORMAL_ROUGHNESS) ); + PushInput( AsUint(Transient::VIEWZ_R16F) ); + PushInput( withConfidenceInputs ? AsUint(ResourceType::IN_DIFF_CONFIDENCE) : AsUint(Transient::VIEWZ_R16F) ); + PushInput( AsUint(Transient::DIFF_ILLUM_PONG_SH1) ); + + PushOutput( AsUint(Transient::DIFF_ILLUM_PING) ); + PushOutput( AsUint(Transient::DIFF_ILLUM_PING_SH1) ); + + AddDispatchRepeated(RELAX_DiffuseSh_Atrous, SumConstants(0, 0, 0, 10), NumThreads(16, 16), 1, halfMaxPassNum ); + } + + // A-trous (odd, last) + PushPass("A-trous"); + { + PushInput( AsUint(Transient::DIFF_ILLUM_PING) ); + PushInput( AsUint(Permanent::HISTORY_LENGTH_CURR) ); + PushInput( AsUint(ResourceType::IN_NORMAL_ROUGHNESS) ); + PushInput( AsUint(Transient::VIEWZ_R16F) ); + PushInput( withConfidenceInputs ? AsUint(ResourceType::IN_DIFF_CONFIDENCE) : AsUint(Transient::VIEWZ_R16F) ); + PushInput( AsUint(Transient::DIFF_ILLUM_PING_SH1) ); + + PushOutput( AsUint(ResourceType::OUT_DIFF_SH0) ); + PushOutput( AsUint(ResourceType::OUT_DIFF_SH1) ); + + AddDispatch(RELAX_DiffuseSh_Atrous, SumConstants(0, 0, 0, 10), NumThreads(16, 16), 1 ); + } + + // A-trous (even, last) + PushPass("A-trous"); + { + PushInput( AsUint(Transient::DIFF_ILLUM_PONG) ); + PushInput( AsUint(Permanent::HISTORY_LENGTH_CURR) ); + PushInput( AsUint(ResourceType::IN_NORMAL_ROUGHNESS) ); + PushInput( AsUint(Transient::VIEWZ_R16F) ); + PushInput( withConfidenceInputs ? AsUint(ResourceType::IN_DIFF_CONFIDENCE) : AsUint(Transient::VIEWZ_R16F) ); + PushInput( AsUint(Transient::DIFF_ILLUM_PONG_SH1) ); + + PushOutput( AsUint(ResourceType::OUT_DIFF_SH0) ); + PushOutput( AsUint(ResourceType::OUT_DIFF_SH1) ); + + AddDispatch(RELAX_DiffuseSh_Atrous, SumConstants(0, 0, 0, 10), NumThreads(16, 16), 1 ); + } + } + + PushPass("Split screen"); + { + PushInput( AsUint(ResourceType::IN_VIEWZ) ); + PushInput( AsUint(ResourceType::IN_DIFF_RADIANCE_HITDIST) ); + + PushOutput( AsUint( ResourceType::OUT_DIFF_RADIANCE_HITDIST ) ); + + AddDispatch( RELAX_Diffuse_SplitScreen, SumConstants(0, 0, 0, 2), NumThreads(16, 16), 1 ); + } + + RELAX_ADD_VALIDATION_DISPATCH; + + #undef METHOD_NAME +} + +void nrd::DenoiserImpl::UpdateMethod_RelaxDiffuseSh(const MethodData& methodData) +{ + enum class Dispatch + { + HITDIST_RECONSTRUCTION_3x3, + HITDIST_RECONSTRUCTION_5x5, + PREPASS_AFTER_HITDIST_RECONSTRUCTION, + PREPASS, + TEMPORAL_ACCUMULATION, + TEMPORAL_ACCUMULATION_WITH_CONFIDENCE_INPUTS, + TEMPORAL_ACCUMULATION_WITH_THRESHOLD_MIX, + TEMPORAL_ACCUMULATION_WITH_CONFIDENCE_INPUTS_WITH_THRESHOLD_MIX, + HISTORY_FIX, + HISTORY_CLAMPING, + HISTORY_CLAMPING_NO_FIREFLY, + FIREFLY, + ATROUS_SMEM, + ATROUS_ODD, + ATROUS_EVEN, + ATROUS_ODD_LAST, + ATROUS_EVEN_LAST, + ATROUS_SMEM_WITH_CONFIDENCE_INPUTS, + ATROUS_ODD_WITH_CONFIDENCE_INPUTS, + ATROUS_EVEN_WITH_CONFIDENCE_INPUTS, + ATROUS_ODD_LAST_WITH_CONFIDENCE_INPUTS, + ATROUS_EVEN_LAST_WITH_CONFIDENCE_INPUTS, + SPLIT_SCREEN, + VALIDATION, + }; + + const RelaxDiffuseSettings& settings = methodData.settings.diffuseRelax; + + NRD_DECLARE_DIMS; + + float maxLuminanceRelativeDifference = -ml::Log(ml::Saturate(settings.minLuminanceWeight)); + + float disocclusionThreshold = m_CommonSettings.disocclusionThreshold + (1.0f + m_JitterDelta) / float(rectH); + float disocclusionThresholdOrtho = disocclusionThreshold; + float disocclusionThresholdAlternate = m_CommonSettings.disocclusionThresholdAlternate + (1.0f + m_JitterDelta) / float(rectH); + float disocclusionThresholdAlternateOrtho = disocclusionThresholdAlternate; + float depthThresholdOrtho = settings.depthThreshold; + + float tanHalfFov = 1.0f / m_ViewToClip.a00; + float aspect = m_ViewToClip.a00 / m_ViewToClip.a11; + ml::float3 frustumRight = m_WorldToView.GetRow0().To3d() * tanHalfFov; + ml::float3 frustumUp = m_WorldToView.GetRow1().To3d() * tanHalfFov * aspect; + ml::float3 frustumForward = RELAX_GetFrustumForward(m_ViewToWorld, m_Frustum); + + float prevTanHalfFov = 1.0f / m_ViewToClipPrev.a00; + float prevAspect = m_ViewToClipPrev.a00 / m_ViewToClipPrev.a11; + ml::float3 prevFrustumRight = m_WorldToViewPrev.GetRow0().To3d() * prevTanHalfFov; + ml::float3 prevFrustumUp = m_WorldToViewPrev.GetRow1().To3d() * prevTanHalfFov * prevAspect; + ml::float3 prevFrustumForward = RELAX_GetFrustumForward(m_ViewToWorldPrev, m_FrustumPrev); + bool isCameraStatic = RELAX_IsCameraStatic(ml::float3(m_CameraDelta.x, m_CameraDelta.y, m_CameraDelta.z), frustumRight, frustumUp, frustumForward, prevFrustumRight, prevFrustumUp, prevFrustumForward); + + bool enableHitDistanceReconstruction = settings.hitDistanceReconstructionMode != HitDistanceReconstructionMode::OFF && settings.checkerboardMode == CheckerboardMode::OFF; + + // Checkerboard logic + uint32_t diffuseCheckerboard = 2; + + switch (settings.checkerboardMode) + { + case CheckerboardMode::BLACK: + diffuseCheckerboard = 0; + break; + case CheckerboardMode::WHITE: + diffuseCheckerboard = 1; + break; + default: + break; + } + + // SPLIT_SCREEN (passthrough) + if (m_CommonSettings.splitScreen >= 1.0f) + { + Constant* data = PushDispatch(methodData, AsUint(Dispatch::SPLIT_SCREEN)); + AddSharedConstants_Relax(methodData, data, Method::RELAX_DIFFUSE); + AddFloat(data, m_CommonSettings.splitScreen); + AddUint(data, diffuseCheckerboard); + ValidateConstants(data); + + return; + } + + // HITDIST_RECONSTRUCTION + if (enableHitDistanceReconstruction) + { + bool is3x3 = settings.hitDistanceReconstructionMode == HitDistanceReconstructionMode::AREA_3X3; + Constant* data = PushDispatch(methodData, is3x3 ? AsUint(Dispatch::HITDIST_RECONSTRUCTION_3x3) : AsUint(Dispatch::HITDIST_RECONSTRUCTION_5x5)); + AddSharedConstants_Relax(methodData, data, Method::RELAX_DIFFUSE); + ValidateConstants(data); + } + + // PREPASS + Constant* data = PushDispatch(methodData, AsUint(enableHitDistanceReconstruction ? Dispatch::PREPASS_AFTER_HITDIST_RECONSTRUCTION : Dispatch::PREPASS)); + AddSharedConstants_Relax(methodData, data, Method::RELAX_DIFFUSE); + AddFloat4(data, m_Rotator_PrePass); + AddUint(data, diffuseCheckerboard); + AddFloat(data, settings.prepassBlurRadius); + AddFloat(data, 1.0f); + AddFloat(data, m_IsOrtho == 0 ? settings.depthThreshold : depthThresholdOrtho); + AddFloat(data, settings.diffuseLobeAngleFraction); + + ValidateConstants(data); + + // TEMPORAL_ACCUMULATION + if (!m_CommonSettings.isDisocclusionThresholdMixAvailable) + { + data = PushDispatch( + methodData, + AsUint(m_CommonSettings.isHistoryConfidenceAvailable ? + Dispatch::TEMPORAL_ACCUMULATION_WITH_CONFIDENCE_INPUTS : + Dispatch::TEMPORAL_ACCUMULATION)); + } + else + { + data = PushDispatch( + methodData, + AsUint(m_CommonSettings.isHistoryConfidenceAvailable ? + Dispatch::TEMPORAL_ACCUMULATION_WITH_CONFIDENCE_INPUTS_WITH_THRESHOLD_MIX : + Dispatch::TEMPORAL_ACCUMULATION_WITH_THRESHOLD_MIX)); + } + AddSharedConstants_Relax(methodData, data, Method::RELAX_DIFFUSE); + AddFloat(data, (float)settings.diffuseMaxAccumulatedFrameNum); + AddFloat(data, (float)settings.diffuseMaxFastAccumulatedFrameNum); + AddUint(data, diffuseCheckerboard); + AddFloat(data, m_IsOrtho == 0 ? disocclusionThreshold : disocclusionThresholdOrtho); + AddFloat(data, m_IsOrtho == 0 ? disocclusionThresholdAlternate : disocclusionThresholdAlternateOrtho); + AddUint(data, settings.enableReprojectionTestSkippingWithoutMotion && isCameraStatic); + AddUint(data, m_CommonSettings.isHistoryConfidenceAvailable ? 1 : 0); + AddUint(data, m_CommonSettings.isDisocclusionThresholdMixAvailable ? 1 : 0); + ValidateConstants(data); + + // HISTORY_FIX + data = PushDispatch(methodData, AsUint(Dispatch::HISTORY_FIX)); + AddSharedConstants_Relax(methodData, data, Method::RELAX_DIFFUSE); + AddFloat(data, m_IsOrtho == 0 ? settings.depthThreshold : depthThresholdOrtho); + AddFloat(data, settings.historyFixEdgeStoppingNormalPower); + AddFloat(data, settings.historyFixStrideBetweenSamples); + AddFloat(data, float(settings.historyFixFrameNum)); + ValidateConstants(data); + + if (settings.enableAntiFirefly) + { + // HISTORY_CLAMPING + data = PushDispatch(methodData, AsUint(Dispatch::HISTORY_CLAMPING)); + AddSharedConstants_Relax(methodData, data, Method::RELAX_DIFFUSE); + AddFloat(data, settings.historyClampingColorBoxSigmaScale); + AddFloat(data, float(settings.historyFixFrameNum)); + AddUint(data, settings.diffuseMaxFastAccumulatedFrameNum < settings.diffuseMaxAccumulatedFrameNum ? 1 : 0); + ValidateConstants(data); + + // FIREFLY + data = PushDispatch(methodData, AsUint(Dispatch::FIREFLY)); + AddSharedConstants_Relax(methodData, data, Method::RELAX_DIFFUSE); + ValidateConstants(data); + } + else + { + // HISTORY_CLAMPING (without firefly) + data = PushDispatch(methodData, AsUint(Dispatch::HISTORY_CLAMPING_NO_FIREFLY)); + AddSharedConstants_Relax(methodData, data, Method::RELAX_DIFFUSE); + AddFloat(data, settings.historyClampingColorBoxSigmaScale); + AddFloat(data, float(settings.historyFixFrameNum)); + AddUint(data, settings.diffuseMaxFastAccumulatedFrameNum < settings.diffuseMaxAccumulatedFrameNum ? 1 : 0); + ValidateConstants(data); + } + + // A-TROUS + uint32_t iterationNum = ml::Clamp(settings.atrousIterationNum, 2u, RELAX_MAX_ATROUS_PASS_NUM); + for (uint32_t i = 0; i < iterationNum; i++) + { + Dispatch dispatch; + if (!m_CommonSettings.isHistoryConfidenceAvailable) + { + if (i == 0) + dispatch = Dispatch::ATROUS_SMEM; + else if (i == iterationNum - 1) + dispatch = (i % 2 == 0) ? Dispatch::ATROUS_EVEN_LAST : Dispatch::ATROUS_ODD_LAST; + else + dispatch = (i % 2 == 0) ? Dispatch::ATROUS_EVEN : Dispatch::ATROUS_ODD; + } + else + { + if (i == 0) + dispatch = Dispatch::ATROUS_SMEM_WITH_CONFIDENCE_INPUTS; + else if (i == iterationNum - 1) + dispatch = (i % 2 == 0) ? Dispatch::ATROUS_EVEN_LAST_WITH_CONFIDENCE_INPUTS : Dispatch::ATROUS_ODD_LAST_WITH_CONFIDENCE_INPUTS; + else + dispatch = (i % 2 == 0) ? Dispatch::ATROUS_EVEN_WITH_CONFIDENCE_INPUTS : Dispatch::ATROUS_ODD_WITH_CONFIDENCE_INPUTS; + } + + data = PushDispatch(methodData, AsUint(dispatch)); + AddSharedConstants_Relax(methodData, data, Method::RELAX_DIFFUSE); + + if (i == 0) + { + AddUint2(data, screenW, screenH); // For Atrous_shmem + AddUint(data, settings.spatialVarianceEstimationHistoryThreshold); + } + + AddFloat(data, settings.diffusePhiLuminance); + AddFloat(data, maxLuminanceRelativeDifference); + AddFloat(data, m_IsOrtho == 0 ? settings.depthThreshold : depthThresholdOrtho); + AddFloat(data, settings.diffuseLobeAngleFraction); + AddUint(data, 1 << i); + AddUint(data, m_CommonSettings.isHistoryConfidenceAvailable ? 1 : 0); + AddFloat(data, settings.confidenceDrivenRelaxationMultiplier); + AddFloat(data, settings.confidenceDrivenLuminanceEdgeStoppingRelaxation); + AddFloat(data, settings.confidenceDrivenNormalEdgeStoppingRelaxation); + if (i != 0) + { + AddUint(data, (i == iterationNum - 1) ? 1 : 0); + } + ValidateConstants(data); + } + + // SPLIT_SCREEN + if (m_CommonSettings.splitScreen > 0.0f) + { + data = PushDispatch(methodData, AsUint(Dispatch::SPLIT_SCREEN)); + AddSharedConstants_Relax(methodData, data, Method::RELAX_DIFFUSE); + AddFloat(data, m_CommonSettings.splitScreen); + AddUint(data, diffuseCheckerboard); + ValidateConstants(data); + } + + // VALIDATION + if (m_CommonSettings.enableValidation) + { + data = PushDispatch(methodData, AsUint(Dispatch::VALIDATION)); + AddSharedConstants_Relax(methodData, data, Method::RELAX_DIFFUSE_SPECULAR); + AddFloat4x4(data, m_WorldToClipPrev); + AddFloat2(data, m_CommonSettings.cameraJitter[0], m_CommonSettings.cameraJitter[1]); + AddFloat(data, (float)settings.diffuseMaxAccumulatedFrameNum); + ValidateConstants(data); + } +} diff --git a/Source/Methods/Relax_DiffuseSpecularSh.hpp b/Source/Methods/Relax_DiffuseSpecularSh.hpp new file mode 100644 index 00000000..07cae6ee --- /dev/null +++ b/Source/Methods/Relax_DiffuseSpecularSh.hpp @@ -0,0 +1,716 @@ +/* +Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved. + +NVIDIA CORPORATION and its licensors retain all intellectual property +and proprietary rights in and to this software, related documentation +and any modifications thereto. Any use, reproduction, disclosure or +distribution of this software and related documentation without an express +license agreement from NVIDIA CORPORATION is strictly prohibited. +*/ + +void nrd::DenoiserImpl::AddMethod_RelaxDiffuseSpecularSh(MethodData& methodData) +{ + #define METHOD_NAME RELAX_DiffuseSpecular + + methodData.settings.diffuseSpecularRelax = RelaxDiffuseSpecularSettings(); + methodData.settingsSize = sizeof(methodData.settings.diffuseSpecularRelax); + + uint16_t w = methodData.desc.fullResolutionWidth; + uint16_t h = methodData.desc.fullResolutionHeight; + + enum class Permanent + { + SPEC_ILLUM_PREV = PERMANENT_POOL_START, + SPEC_ILLUM_PREV_SH1, + DIFF_ILLUM_PREV, + DIFF_ILLUM_PREV_SH1, + SPEC_ILLUM_RESPONSIVE_PREV, + SPEC_ILLUM_RESPONSIVE_PREV_SH1, + DIFF_ILLUM_RESPONSIVE_PREV, + DIFF_ILLUM_RESPONSIVE_PREV_SH1, + REFLECTION_HIT_T_CURR, + REFLECTION_HIT_T_PREV, + HISTORY_LENGTH_CURR, + HISTORY_LENGTH_PREV, + NORMAL_ROUGHNESS_PREV, + MATERIAL_ID_PREV, + VIEWZ_CURR, + VIEWZ_PREV, + }; + + m_PermanentPool.push_back( {Format::RGBA16_SFLOAT, w, h, 1} ); + m_PermanentPool.push_back( {Format::RGBA16_SFLOAT, w, h, 1} ); + m_PermanentPool.push_back( {Format::RGBA16_SFLOAT, w, h, 1} ); + m_PermanentPool.push_back( {Format::RGBA16_SFLOAT, w, h, 1} ); + m_PermanentPool.push_back( {Format::RGBA16_SFLOAT, w, h, 1} ); + m_PermanentPool.push_back( {Format::RGBA16_SFLOAT, w, h, 1} ); + m_PermanentPool.push_back( {Format::RGBA16_SFLOAT, w, h, 1} ); + m_PermanentPool.push_back( {Format::RGBA16_SFLOAT, w, h, 1} ); + m_PermanentPool.push_back( {Format::R16_SFLOAT, w, h, 1} ); + m_PermanentPool.push_back( {Format::R16_SFLOAT, w, h, 1} ); + m_PermanentPool.push_back( {Format::R8_UNORM, w, h, 1} ); + m_PermanentPool.push_back( {Format::R8_UNORM, w, h, 1} ); + m_PermanentPool.push_back( {Format::RGBA8_UNORM, w, h, 1} ); + m_PermanentPool.push_back( {Format::R8_UNORM, w, h, 1} ); + m_PermanentPool.push_back( {Format::R32_SFLOAT, w, h, 1} ); + m_PermanentPool.push_back( {Format::R32_SFLOAT, w, h, 1} ); + + enum class Transient + { + SPEC_ILLUM_PING = TRANSIENT_POOL_START, + SPEC_ILLUM_PING_SH1, + SPEC_ILLUM_PONG, + SPEC_ILLUM_PONG_SH1, + DIFF_ILLUM_PING, + DIFF_ILLUM_PING_SH1, + DIFF_ILLUM_PONG, + DIFF_ILLUM_PONG_SH1, + SPEC_ILLUM_TMP, + SPEC_ILLUM_TMP_SH1, + DIFF_ILLUM_TMP, + DIFF_ILLUM_TMP_SH1, + SPEC_REPROJECTION_CONFIDENCE, + VIEWZ_R16F + }; + + m_TransientPool.push_back( {Format::RGBA16_SFLOAT, w, h, 1} ); + m_TransientPool.push_back( {Format::RGBA16_SFLOAT, w, h, 1} ); + m_TransientPool.push_back( {Format::RGBA16_SFLOAT, w, h, 1} ); + m_TransientPool.push_back( {Format::RGBA16_SFLOAT, w, h, 1} ); + m_TransientPool.push_back( {Format::RGBA16_SFLOAT, w, h, 1} ); + m_TransientPool.push_back( {Format::RGBA16_SFLOAT, w, h, 1} ); + m_TransientPool.push_back( {Format::RGBA16_SFLOAT, w, h, 1} ); + m_TransientPool.push_back( {Format::RGBA16_SFLOAT, w, h, 1} ); + m_TransientPool.push_back( {Format::RGBA16_SFLOAT, w, h, 1} ); + m_TransientPool.push_back( {Format::RGBA16_SFLOAT, w, h, 1} ); + m_TransientPool.push_back( {Format::RGBA16_SFLOAT, w, h, 1} ); + m_TransientPool.push_back( {Format::RGBA16_SFLOAT, w, h, 1} ); + m_TransientPool.push_back( {Format::R8_UNORM, w, h, 1} ); + m_TransientPool.push_back( {Format::R16_SFLOAT, w, h, 1} ); + + RELAX_SET_SHARED_CONSTANTS; + + const uint32_t halfMaxPassNum = (RELAX_MAX_ATROUS_PASS_NUM - 2 + 1) / 2; + + PushPass("Hit distance reconstruction 3x3"); // 3x3 + { + PushInput( AsUint(ResourceType::IN_SPEC_SH0) ); + PushInput( AsUint(ResourceType::IN_DIFF_SH0) ); + PushInput( AsUint(ResourceType::IN_NORMAL_ROUGHNESS) ); + PushInput( AsUint(ResourceType::IN_VIEWZ) ); + + PushOutput( AsUint(Transient::SPEC_ILLUM_PING) ); + PushOutput( AsUint(Transient::DIFF_ILLUM_PING) ); + + AddDispatch( RELAX_DiffuseSpecular_HitDistReconstruction, SumConstants(0, 0, 0, 0), NumThreads(8, 8), 1 ); + } + + PushPass("Hit distance reconstruction 5x5"); // 5x5 + { + PushInput( AsUint(ResourceType::IN_SPEC_SH0) ); + PushInput( AsUint(ResourceType::IN_DIFF_SH0) ); + PushInput( AsUint(ResourceType::IN_NORMAL_ROUGHNESS) ); + PushInput( AsUint(ResourceType::IN_VIEWZ) ); + + PushOutput(AsUint(Transient::SPEC_ILLUM_PING)); + PushOutput(AsUint(Transient::DIFF_ILLUM_PING)); + + AddDispatch( RELAX_DiffuseSpecular_HitDistReconstruction_5x5, SumConstants(0, 0, 0, 0), NumThreads(8, 8), 1 ); + } + + PushPass("Pre-pass"); // After hit distance reconstruction + { + // Does preblur (if enabled), checkerboard reconstruction (if enabled) and generates FP16 ViewZ texture + PushInput( AsUint(Transient::SPEC_ILLUM_PING) ); + PushInput( AsUint(Transient::DIFF_ILLUM_PING) ); + PushInput( AsUint(ResourceType::IN_NORMAL_ROUGHNESS) ); + PushInput( AsUint(ResourceType::IN_VIEWZ) ); + PushInput( AsUint(ResourceType::IN_SPEC_SH1) ); + PushInput( AsUint(ResourceType::IN_DIFF_SH1) ); + + PushOutput( AsUint(Transient::SPEC_ILLUM_TMP) ); + PushOutput( AsUint(Transient::DIFF_ILLUM_TMP) ); + PushOutput( AsUint(Permanent::VIEWZ_CURR), 0, 1, AsUint(Permanent::VIEWZ_PREV) ); + PushOutput( AsUint(Transient::VIEWZ_R16F) ); + PushOutput( AsUint(Transient::SPEC_ILLUM_TMP_SH1) ); + PushOutput( AsUint(Transient::DIFF_ILLUM_TMP_SH1) ); + + AddDispatch( RELAX_DiffuseSpecularSh_PrePass, SumConstants(0, 1, 0, 10), NumThreads(16, 16), 1 ); + } + + PushPass("Pre-pass"); // Without hit distance reconstruction + { + // Does preblur (if enabled), checkerboard reconstruction (if enabled) and generates FP16 ViewZ texture + PushInput( AsUint(ResourceType::IN_SPEC_SH0) ); + PushInput( AsUint(ResourceType::IN_DIFF_SH0) ); + PushInput( AsUint(ResourceType::IN_NORMAL_ROUGHNESS) ); + PushInput( AsUint(ResourceType::IN_VIEWZ) ); + PushInput( AsUint(ResourceType::IN_SPEC_SH1) ); + PushInput( AsUint(ResourceType::IN_DIFF_SH1) ); + + PushOutput( AsUint(Transient::SPEC_ILLUM_TMP) ); + PushOutput( AsUint(Transient::DIFF_ILLUM_TMP) ); + PushOutput( AsUint(Permanent::VIEWZ_CURR), 0, 1, AsUint(Permanent::VIEWZ_PREV) ); + PushOutput( AsUint(Transient::VIEWZ_R16F) ); + PushOutput( AsUint(Transient::SPEC_ILLUM_TMP_SH1) ); + PushOutput( AsUint(Transient::DIFF_ILLUM_TMP_SH1) ); + + AddDispatch( RELAX_DiffuseSpecularSh_PrePass, SumConstants(0, 1, 0, 10), NumThreads(16, 16), 1 ); + } + + for (int i = 0; i < 4; i++) + { + // The following passes are defined here: + // TEMPORAL_ACCUMULATION, + // TEMPORAL_ACCUMULATION_WITH_CONFIDENCE_INPUTS, + // TEMPORAL_ACCUMULATION_WITH_THRESHOLD_MIX, + // TEMPORAL_ACCUMULATION_WITH_CONFIDENCE_INPUTS_WITH_THRESHOLD_MIX + + PushPass("Temporal accumulation"); + { + PushInput( AsUint(Transient::SPEC_ILLUM_TMP) ); + PushInput( AsUint(Transient::DIFF_ILLUM_TMP) ); + PushInput( AsUint(ResourceType::IN_MV) ); + PushInput( AsUint(ResourceType::IN_NORMAL_ROUGHNESS) ); + PushInput( AsUint(Permanent::VIEWZ_CURR), 0, 1, AsUint(Permanent::VIEWZ_PREV) ); + PushInput( AsUint(Permanent::SPEC_ILLUM_RESPONSIVE_PREV) ); + PushInput( AsUint(Permanent::DIFF_ILLUM_RESPONSIVE_PREV) ); + PushInput( AsUint(Permanent::SPEC_ILLUM_PREV) ); + PushInput( AsUint(Permanent::DIFF_ILLUM_PREV) ); + PushInput( AsUint(Permanent::NORMAL_ROUGHNESS_PREV) ); + PushInput( AsUint(Permanent::VIEWZ_PREV), 0, 1, AsUint(Permanent::VIEWZ_CURR) ); + PushInput( AsUint(Permanent::REFLECTION_HIT_T_PREV), 0, 1, AsUint(Permanent::REFLECTION_HIT_T_CURR) ); + PushInput( AsUint(Permanent::HISTORY_LENGTH_PREV) ); + PushInput( AsUint(Permanent::MATERIAL_ID_PREV) ); + + // Optional inputs: + if (i == 0) + { + PushInput( AsUint(Transient::VIEWZ_R16F) ); // Bogus input that will not be fetched anyway + PushInput( AsUint(Transient::VIEWZ_R16F) ); // Bogus input that will not be fetched anyway + PushInput( AsUint(Permanent::HISTORY_LENGTH_PREV) ); // Bogus input that will not be fetched anyway + } + if (i == 1) + { + PushInput( AsUint(ResourceType::IN_SPEC_CONFIDENCE) ); + PushInput( AsUint(ResourceType::IN_DIFF_CONFIDENCE) ); + PushInput( AsUint(Permanent::HISTORY_LENGTH_PREV) ); // Bogus input that will not be fetched anyway + } + if (i == 2) + { + PushInput( AsUint(Transient::VIEWZ_R16F) ); // Bogus input that will not be fetched anyway + PushInput( AsUint(Transient::VIEWZ_R16F) ); // Bogus input that will not be fetched anyway + PushInput( AsUint(ResourceType::IN_DISOCCLUSION_THRESHOLD_MIX) ); + } + if (i == 3) + { + PushInput( AsUint(ResourceType::IN_SPEC_CONFIDENCE) ); + PushInput( AsUint(ResourceType::IN_DIFF_CONFIDENCE) ); + PushInput( AsUint(ResourceType::IN_DISOCCLUSION_THRESHOLD_MIX) ); + } + PushInput( AsUint(Transient::SPEC_ILLUM_TMP_SH1) ); + PushInput( AsUint(Transient::DIFF_ILLUM_TMP_SH1) ); + PushInput( AsUint(Permanent::SPEC_ILLUM_RESPONSIVE_PREV_SH1) ); + PushInput( AsUint(Permanent::DIFF_ILLUM_RESPONSIVE_PREV_SH1) ); + PushInput( AsUint(Permanent::SPEC_ILLUM_PREV_SH1) ); + PushInput( AsUint(Permanent::DIFF_ILLUM_PREV_SH1) ); + + PushOutput( AsUint(Transient::SPEC_ILLUM_PING) ); + PushOutput( AsUint(Transient::DIFF_ILLUM_PING) ); + PushOutput( AsUint(Transient::SPEC_ILLUM_PONG) ); + PushOutput( AsUint(Transient::DIFF_ILLUM_PONG) ); + PushOutput( AsUint(Permanent::REFLECTION_HIT_T_CURR), 0, 1, AsUint(Permanent::REFLECTION_HIT_T_PREV) ); + PushOutput( AsUint(Permanent::HISTORY_LENGTH_CURR) ); + PushOutput( AsUint(Transient::SPEC_REPROJECTION_CONFIDENCE) ); + PushOutput( AsUint(Transient::SPEC_ILLUM_PING_SH1) ); + PushOutput( AsUint(Transient::DIFF_ILLUM_PING_SH1) ); + PushOutput( AsUint(Transient::SPEC_ILLUM_PONG_SH1) ); + PushOutput( AsUint(Transient::DIFF_ILLUM_PONG_SH1) ); + + AddDispatch(RELAX_DiffuseSpecularSh_TemporalAccumulation, SumConstants(0, 0, 0, 13), NumThreads(8, 8), 1); + } + } + + PushPass("History fix"); + { + PushInput( AsUint(Transient::SPEC_ILLUM_PING) ); // Normal history + PushInput( AsUint(Transient::DIFF_ILLUM_PING) ); + PushInput( AsUint(Permanent::HISTORY_LENGTH_CURR) ); + PushInput( AsUint(ResourceType::IN_NORMAL_ROUGHNESS) ); + PushInput( AsUint(Transient::VIEWZ_R16F) ); + PushInput( AsUint(Transient::SPEC_ILLUM_PING_SH1) ); + PushInput( AsUint(Transient::DIFF_ILLUM_PING_SH1) ); + + PushOutput( AsUint(Transient::SPEC_ILLUM_PONG) ); // Responsive history + PushOutput( AsUint(Transient::DIFF_ILLUM_PONG) ); + PushOutput( AsUint(Transient::SPEC_ILLUM_PONG_SH1) ); + PushOutput( AsUint(Transient::DIFF_ILLUM_PONG_SH1) ); + + AddDispatch( RELAX_DiffuseSpecularSh_HistoryFix, SumConstants(0, 0, 0, 8), NumThreads(8, 8), 1 ); + } + + PushPass("History clamping"); // with firefly after it + { + PushInput( AsUint(Transient::SPEC_ILLUM_PING) ); // Normal history + PushInput( AsUint(Transient::DIFF_ILLUM_PING) ); + PushInput( AsUint(Transient::SPEC_ILLUM_PONG) ); // Responsive history + PushInput( AsUint(Transient::DIFF_ILLUM_PONG) ); + PushInput( AsUint(Permanent::HISTORY_LENGTH_CURR) ); + PushInput( AsUint(Transient::SPEC_ILLUM_PING_SH1) ); + PushInput( AsUint(Transient::DIFF_ILLUM_PING_SH1) ); + PushInput( AsUint(Transient::SPEC_ILLUM_PONG_SH1) ); + PushInput( AsUint(Transient::DIFF_ILLUM_PONG_SH1) ); + + PushOutput( AsUint(Transient::SPEC_ILLUM_TMP) ); + PushOutput( AsUint(Transient::DIFF_ILLUM_TMP) ); + PushOutput( AsUint(Permanent::SPEC_ILLUM_RESPONSIVE_PREV) ); + PushOutput( AsUint(Permanent::DIFF_ILLUM_RESPONSIVE_PREV) ); + PushOutput( AsUint(Permanent::HISTORY_LENGTH_PREV) ); + PushOutput( AsUint(Permanent::SPEC_ILLUM_PREV_SH1) ); + PushOutput( AsUint(Permanent::DIFF_ILLUM_PREV_SH1) ); + PushOutput( AsUint(Permanent::SPEC_ILLUM_RESPONSIVE_PREV_SH1) ); + PushOutput( AsUint(Permanent::DIFF_ILLUM_RESPONSIVE_PREV_SH1) ); + + AddDispatch( RELAX_DiffuseSpecularSh_HistoryClamping, SumConstants(0, 0, 0, 4), NumThreads(8, 8), 1 ); + } + + PushPass("History clamping"); // without firefly after it + { + PushInput( AsUint(Transient::SPEC_ILLUM_PING) ); // Normal history + PushInput( AsUint(Transient::DIFF_ILLUM_PING) ); + PushInput( AsUint(Transient::SPEC_ILLUM_PONG) ); // Responsive history + PushInput( AsUint(Transient::DIFF_ILLUM_PONG) ); + PushInput( AsUint(Permanent::HISTORY_LENGTH_CURR) ); + PushInput( AsUint(Transient::SPEC_ILLUM_PING_SH1) ); + PushInput( AsUint(Transient::DIFF_ILLUM_PING_SH1) ); + PushInput( AsUint(Transient::SPEC_ILLUM_PONG_SH1) ); + PushInput( AsUint(Transient::DIFF_ILLUM_PONG_SH1) ); + + PushOutput( AsUint(Permanent::SPEC_ILLUM_PREV) ); + PushOutput( AsUint(Permanent::DIFF_ILLUM_PREV) ); + PushOutput( AsUint(Permanent::SPEC_ILLUM_RESPONSIVE_PREV) ); + PushOutput( AsUint(Permanent::DIFF_ILLUM_RESPONSIVE_PREV) ); + PushOutput( AsUint(Permanent::HISTORY_LENGTH_PREV) ); + PushOutput( AsUint(Permanent::SPEC_ILLUM_PREV_SH1) ); + PushOutput( AsUint(Permanent::DIFF_ILLUM_PREV_SH1) ); + PushOutput( AsUint(Permanent::SPEC_ILLUM_RESPONSIVE_PREV_SH1) ); + PushOutput( AsUint(Permanent::DIFF_ILLUM_RESPONSIVE_PREV_SH1) ); + + AddDispatch( RELAX_DiffuseSpecularSh_HistoryClamping, SumConstants(0, 0, 0, 4), NumThreads(8, 8), 1 ); + } + + PushPass("Anti-firefly"); + { + PushInput( AsUint(Transient::SPEC_ILLUM_TMP) ); + PushInput( AsUint(Transient::DIFF_ILLUM_TMP) ); + PushInput( AsUint(ResourceType::IN_NORMAL_ROUGHNESS) ); + PushInput( AsUint(Transient::VIEWZ_R16F) ); + + PushOutput( AsUint(Permanent::SPEC_ILLUM_PREV) ); + PushOutput( AsUint(Permanent::DIFF_ILLUM_PREV) ); + + AddDispatch( RELAX_DiffuseSpecularSh_AntiFirefly, SumConstants(0, 0, 0, 0), NumThreads(16, 16), 1 ); + } + + for (int i = 0; i < 2; i++) + { + bool withConfidenceInputs = (i == 1); + + // A-trous (first) + PushPass("A-trous (SMEM)"); + { + PushInput( AsUint(Permanent::SPEC_ILLUM_PREV) ); + PushInput( AsUint(Permanent::DIFF_ILLUM_PREV) ); + PushInput( AsUint(Permanent::HISTORY_LENGTH_CURR) ); + PushInput( AsUint(Transient::SPEC_REPROJECTION_CONFIDENCE) ); + PushInput( AsUint(ResourceType::IN_NORMAL_ROUGHNESS) ); + PushInput( AsUint(Transient::VIEWZ_R16F) ); + PushInput( withConfidenceInputs ? AsUint(ResourceType::IN_SPEC_CONFIDENCE) : AsUint(Transient::VIEWZ_R16F) ); + PushInput( withConfidenceInputs ? AsUint(ResourceType::IN_DIFF_CONFIDENCE) : AsUint(Transient::VIEWZ_R16F) ); + PushInput( AsUint(Permanent::SPEC_ILLUM_PREV_SH1) ); + PushInput( AsUint(Permanent::DIFF_ILLUM_PREV_SH1) ); + + PushOutput( AsUint(Transient::SPEC_ILLUM_PING) ); + PushOutput( AsUint(Transient::DIFF_ILLUM_PING) ); + PushOutput( AsUint(Permanent::NORMAL_ROUGHNESS_PREV) ); + PushOutput( AsUint(Permanent::MATERIAL_ID_PREV) ); + PushOutput( AsUint(Transient::SPEC_ILLUM_PING_SH1) ); + PushOutput( AsUint(Transient::DIFF_ILLUM_PING_SH1) ); + + AddDispatch( RELAX_DiffuseSpecularSh_AtrousSmem, SumConstants(0, 0, 1, 19), NumThreads(8, 8), 1 ); + } + + // A-trous (odd) + PushPass("A-trous"); + { + PushInput( AsUint(Transient::SPEC_ILLUM_PING) ); + PushInput( AsUint(Transient::DIFF_ILLUM_PING) ); + PushInput( AsUint(Permanent::HISTORY_LENGTH_CURR) ); + PushInput( AsUint(Transient::SPEC_REPROJECTION_CONFIDENCE) ); + PushInput( AsUint(ResourceType::IN_NORMAL_ROUGHNESS) ); + PushInput( AsUint(Transient::VIEWZ_R16F) ); + PushInput( withConfidenceInputs ? AsUint(ResourceType::IN_SPEC_CONFIDENCE) : AsUint(Transient::VIEWZ_R16F) ); + PushInput( withConfidenceInputs ? AsUint(ResourceType::IN_DIFF_CONFIDENCE) : AsUint(Transient::VIEWZ_R16F) ); + PushInput( AsUint(Transient::SPEC_ILLUM_PING_SH1) ); + PushInput( AsUint(Transient::DIFF_ILLUM_PING_SH1) ); + + PushOutput( AsUint(Transient::SPEC_ILLUM_PONG) ); + PushOutput( AsUint(Transient::DIFF_ILLUM_PONG) ); + PushOutput( AsUint(Transient::SPEC_ILLUM_PONG_SH1) ); + PushOutput( AsUint(Transient::DIFF_ILLUM_PONG_SH1) ); + + AddDispatchRepeated( RELAX_DiffuseSpecularSh_Atrous, SumConstants(0, 0, 0, 19), NumThreads(16, 16), 1, halfMaxPassNum ); + } + + // A-trous (even) + PushPass("A-trous"); + { + PushInput( AsUint(Transient::SPEC_ILLUM_PONG) ); + PushInput( AsUint(Transient::DIFF_ILLUM_PONG) ); + PushInput( AsUint(Permanent::HISTORY_LENGTH_CURR) ); + PushInput( AsUint(Transient::SPEC_REPROJECTION_CONFIDENCE) ); + PushInput( AsUint(ResourceType::IN_NORMAL_ROUGHNESS) ); + PushInput( AsUint(Transient::VIEWZ_R16F) ); + PushInput( withConfidenceInputs ? AsUint(ResourceType::IN_SPEC_CONFIDENCE) : AsUint(Transient::VIEWZ_R16F) ); + PushInput( withConfidenceInputs ? AsUint(ResourceType::IN_DIFF_CONFIDENCE) : AsUint(Transient::VIEWZ_R16F) ); + PushInput( AsUint(Transient::SPEC_ILLUM_PONG_SH1) ); + PushInput( AsUint(Transient::DIFF_ILLUM_PONG_SH1) ); + + PushOutput( AsUint(Transient::SPEC_ILLUM_PING) ); + PushOutput( AsUint(Transient::DIFF_ILLUM_PING) ); + PushOutput( AsUint(Transient::SPEC_ILLUM_PING_SH1) ); + PushOutput( AsUint(Transient::DIFF_ILLUM_PING_SH1) ); + + AddDispatchRepeated( RELAX_DiffuseSpecularSh_Atrous, SumConstants(0, 0, 0, 19), NumThreads(16, 16), 1, halfMaxPassNum ); + } + + // A-trous (odd, last) + PushPass("A-trous"); + { + PushInput( AsUint(Transient::SPEC_ILLUM_PING) ); + PushInput( AsUint(Transient::DIFF_ILLUM_PING) ); + PushInput( AsUint(Permanent::HISTORY_LENGTH_CURR) ); + PushInput( AsUint(Transient::SPEC_REPROJECTION_CONFIDENCE) ); + PushInput( AsUint(ResourceType::IN_NORMAL_ROUGHNESS) ); + PushInput( AsUint(Transient::VIEWZ_R16F) ); + PushInput( withConfidenceInputs ? AsUint(ResourceType::IN_SPEC_CONFIDENCE) : AsUint(Transient::VIEWZ_R16F) ); + PushInput( withConfidenceInputs ? AsUint(ResourceType::IN_DIFF_CONFIDENCE) : AsUint(Transient::VIEWZ_R16F) ); + PushInput( AsUint(Transient::SPEC_ILLUM_PING_SH1) ); + PushInput( AsUint(Transient::DIFF_ILLUM_PING_SH1) ); + + PushOutput( AsUint(ResourceType::OUT_SPEC_SH0) ); + PushOutput( AsUint(ResourceType::OUT_DIFF_SH0) ); + PushOutput( AsUint(ResourceType::OUT_SPEC_SH1) ); + PushOutput( AsUint(ResourceType::OUT_DIFF_SH1) ); + + AddDispatch( RELAX_DiffuseSpecularSh_Atrous, SumConstants(0, 0, 0, 19), NumThreads(16, 16), 1 ); + } + + // A-trous (even, last) + PushPass("A-trous"); + { + PushInput( AsUint(Transient::SPEC_ILLUM_PONG) ); + PushInput( AsUint(Transient::DIFF_ILLUM_PONG) ); + PushInput( AsUint(Permanent::HISTORY_LENGTH_CURR) ); + PushInput( AsUint(Transient::SPEC_REPROJECTION_CONFIDENCE) ); + PushInput( AsUint(ResourceType::IN_NORMAL_ROUGHNESS) ); + PushInput( AsUint(Transient::VIEWZ_R16F) ); + PushInput( withConfidenceInputs ? AsUint(ResourceType::IN_SPEC_CONFIDENCE) : AsUint(Transient::VIEWZ_R16F) ); + PushInput( withConfidenceInputs ? AsUint(ResourceType::IN_DIFF_CONFIDENCE) : AsUint(Transient::VIEWZ_R16F) ); + PushInput( AsUint(Transient::SPEC_ILLUM_PONG_SH1) ); + PushInput( AsUint(Transient::DIFF_ILLUM_PONG_SH1) ); + + PushOutput( AsUint(ResourceType::OUT_SPEC_SH0) ); + PushOutput( AsUint(ResourceType::OUT_DIFF_SH0) ); + PushOutput( AsUint(ResourceType::OUT_SPEC_SH1) ); + PushOutput( AsUint(ResourceType::OUT_DIFF_SH1) ); + + AddDispatch( RELAX_DiffuseSpecularSh_Atrous, SumConstants(0, 0, 0, 19), NumThreads(16, 16), 1 ); + } + } + + PushPass("Split screen"); + { + PushInput( AsUint(ResourceType::IN_VIEWZ) ); + PushInput( AsUint(ResourceType::IN_SPEC_RADIANCE_HITDIST) ); + PushInput( AsUint(ResourceType::IN_DIFF_RADIANCE_HITDIST) ); + + PushOutput( AsUint( ResourceType::OUT_SPEC_RADIANCE_HITDIST ) ); + PushOutput( AsUint( ResourceType::OUT_DIFF_RADIANCE_HITDIST ) ); + + AddDispatch( RELAX_DiffuseSpecular_SplitScreen, SumConstants(0, 0, 0, 3), NumThreads(16, 16), 1 ); + } + + RELAX_ADD_VALIDATION_DISPATCH; + + #undef METHOD_NAME +} + +void nrd::DenoiserImpl::UpdateMethod_RelaxDiffuseSpecularSh(const MethodData& methodData) +{ + enum class Dispatch + { + HITDIST_RECONSTRUCTION_3x3, + HITDIST_RECONSTRUCTION_5x5, + PREPASS_AFTER_HITDIST_RECONSTRUCTION, + PREPASS, + TEMPORAL_ACCUMULATION, + TEMPORAL_ACCUMULATION_WITH_CONFIDENCE_INPUTS, + TEMPORAL_ACCUMULATION_WITH_THRESHOLD_MIX, + TEMPORAL_ACCUMULATION_WITH_CONFIDENCE_INPUTS_WITH_THRESHOLD_MIX, + HISTORY_FIX, + HISTORY_CLAMPING, + HISTORY_CLAMPING_NO_FIREFLY, + FIREFLY, + ATROUS_SMEM, + ATROUS_ODD, + ATROUS_EVEN, + ATROUS_ODD_LAST, + ATROUS_EVEN_LAST, + ATROUS_SMEM_WITH_CONFIDENCE_INPUTS, + ATROUS_ODD_WITH_CONFIDENCE_INPUTS, + ATROUS_EVEN_WITH_CONFIDENCE_INPUTS, + ATROUS_ODD_LAST_WITH_CONFIDENCE_INPUTS, + ATROUS_EVEN_LAST_WITH_CONFIDENCE_INPUTS, + SPLIT_SCREEN, + VALIDATION, + }; + + const RelaxDiffuseSpecularSettings& settings = methodData.settings.diffuseSpecularRelax; + + NRD_DECLARE_DIMS; + + float maxDiffuseLuminanceRelativeDifference = -ml::Log( ml::Saturate(settings.diffuseMinLuminanceWeight) ); + float maxSpecularLuminanceRelativeDifference = -ml::Log( ml::Saturate(settings.specularMinLuminanceWeight) ); + + float disocclusionThreshold = m_CommonSettings.disocclusionThreshold + (1.0f + m_JitterDelta) / float(rectH); + float disocclusionThresholdOrtho = disocclusionThreshold; + float disocclusionThresholdAlternate = m_CommonSettings.disocclusionThresholdAlternate + (1.0f + m_JitterDelta) / float(rectH); + float disocclusionThresholdAlternateOrtho = disocclusionThresholdAlternate; + float depthThresholdOrtho = settings.depthThreshold; + + float tanHalfFov = 1.0f / m_ViewToClip.a00; + float aspect = m_ViewToClip.a00 / m_ViewToClip.a11; + ml::float3 frustumRight = m_WorldToView.GetRow0().To3d() * tanHalfFov; + ml::float3 frustumUp = m_WorldToView.GetRow1().To3d() * tanHalfFov * aspect; + ml::float3 frustumForward = RELAX_GetFrustumForward(m_ViewToWorld, m_Frustum); + + float prevTanHalfFov = 1.0f / m_ViewToClipPrev.a00; + float prevAspect = m_ViewToClipPrev.a00 / m_ViewToClipPrev.a11; + ml::float3 prevFrustumRight = m_WorldToViewPrev.GetRow0().To3d() * prevTanHalfFov; + ml::float3 prevFrustumUp = m_WorldToViewPrev.GetRow1().To3d() * prevTanHalfFov * prevAspect; + ml::float3 prevFrustumForward = RELAX_GetFrustumForward(m_ViewToWorldPrev, m_FrustumPrev); + bool isCameraStatic = RELAX_IsCameraStatic(ml::float3(m_CameraDelta.x, m_CameraDelta.y, m_CameraDelta.z), frustumRight, frustumUp, frustumForward, prevFrustumRight, prevFrustumUp, prevFrustumForward); + + bool enableHitDistanceReconstruction = settings.hitDistanceReconstructionMode != HitDistanceReconstructionMode::OFF && settings.checkerboardMode == CheckerboardMode::OFF; + + // Checkerboard logic + uint32_t specularCheckerboard = 2; + uint32_t diffuseCheckerboard = 2; + + switch (settings.checkerboardMode) + { + case CheckerboardMode::BLACK: + diffuseCheckerboard = 0; + specularCheckerboard = 1; + break; + case CheckerboardMode::WHITE: + diffuseCheckerboard = 1; + specularCheckerboard = 0; + break; + default: + break; + } + + // SPLIT_SCREEN (passthrough) + if (m_CommonSettings.splitScreen >= 1.0f) + { + Constant* data = PushDispatch(methodData, AsUint(Dispatch::SPLIT_SCREEN)); + AddSharedConstants_Relax(methodData, data, Method::RELAX_DIFFUSE_SPECULAR); + AddFloat(data, m_CommonSettings.splitScreen); + AddUint(data, diffuseCheckerboard); + AddUint(data, specularCheckerboard); + ValidateConstants(data); + + return; + } + + // HITDIST_RECONSTRUCTION + if (enableHitDistanceReconstruction) + { + bool is3x3 = settings.hitDistanceReconstructionMode == HitDistanceReconstructionMode::AREA_3X3; + Constant* data = PushDispatch(methodData, is3x3 ? AsUint(Dispatch::HITDIST_RECONSTRUCTION_3x3) : AsUint(Dispatch::HITDIST_RECONSTRUCTION_5x5)); + AddSharedConstants_Relax(methodData, data, Method::RELAX_DIFFUSE_SPECULAR); + ValidateConstants(data); + } + + // PREPASS + Constant* data = PushDispatch(methodData, AsUint(enableHitDistanceReconstruction ? Dispatch::PREPASS_AFTER_HITDIST_RECONSTRUCTION : Dispatch::PREPASS)); + AddSharedConstants_Relax(methodData, data, Method::RELAX_DIFFUSE_SPECULAR); + AddFloat4(data, m_Rotator_PrePass); + AddUint(data, diffuseCheckerboard); + AddUint(data, specularCheckerboard); + AddFloat(data, settings.diffusePrepassBlurRadius); + AddFloat(data, settings.specularPrepassBlurRadius); + AddFloat(data, 1.0f); + AddFloat(data, m_IsOrtho == 0 ? settings.depthThreshold : depthThresholdOrtho); + AddFloat(data, settings.diffuseLobeAngleFraction); + AddFloat(data, settings.specularLobeAngleFraction); + AddFloat(data, settings.specularLobeAngleSlack); + AddFloat(data, settings.roughnessFraction); + ValidateConstants(data); + + // TEMPORAL_ACCUMULATION + if (!m_CommonSettings.isDisocclusionThresholdMixAvailable) + { + data = PushDispatch( + methodData, + AsUint(m_CommonSettings.isHistoryConfidenceAvailable ? + Dispatch::TEMPORAL_ACCUMULATION_WITH_CONFIDENCE_INPUTS : + Dispatch::TEMPORAL_ACCUMULATION)); + } + else + { + data = PushDispatch( + methodData, + AsUint(m_CommonSettings.isHistoryConfidenceAvailable ? + Dispatch::TEMPORAL_ACCUMULATION_WITH_CONFIDENCE_INPUTS_WITH_THRESHOLD_MIX : + Dispatch::TEMPORAL_ACCUMULATION_WITH_THRESHOLD_MIX)); + } + AddSharedConstants_Relax(methodData, data, Method::RELAX_DIFFUSE_SPECULAR); + AddFloat(data, (float)settings.specularMaxAccumulatedFrameNum); + AddFloat(data, (float)settings.specularMaxFastAccumulatedFrameNum); + AddFloat(data, (float)settings.diffuseMaxAccumulatedFrameNum); + AddFloat(data, (float)settings.diffuseMaxFastAccumulatedFrameNum); + AddUint(data, diffuseCheckerboard); + AddUint(data, specularCheckerboard); + AddFloat(data, m_IsOrtho == 0 ? disocclusionThreshold : disocclusionThresholdOrtho); + AddFloat(data, m_IsOrtho == 0 ? disocclusionThresholdAlternate : disocclusionThresholdAlternateOrtho); + AddFloat(data, settings.roughnessFraction); + AddFloat(data, settings.specularVarianceBoost); + AddUint(data, settings.enableReprojectionTestSkippingWithoutMotion && isCameraStatic); + AddUint(data, m_CommonSettings.isHistoryConfidenceAvailable ? 1 : 0); + AddUint(data, m_CommonSettings.isDisocclusionThresholdMixAvailable ? 1 : 0); + ValidateConstants(data); + + // HISTORY_FIX + data = PushDispatch(methodData, AsUint(Dispatch::HISTORY_FIX)); + AddSharedConstants_Relax(methodData, data, Method::RELAX_DIFFUSE_SPECULAR); + AddFloat(data, m_IsOrtho == 0 ? settings.depthThreshold : depthThresholdOrtho); + AddFloat(data, settings.historyFixEdgeStoppingNormalPower); + AddFloat(data, settings.historyFixStrideBetweenSamples); + AddFloat(data, float(settings.historyFixFrameNum)); + AddFloat(data, settings.specularLobeAngleFraction); + AddFloat(data, ml::DegToRad(settings.specularLobeAngleSlack)); + AddFloat(data, settings.roughnessEdgeStoppingRelaxation); + AddFloat(data, settings.normalEdgeStoppingRelaxation); + ValidateConstants(data); + + if (settings.enableAntiFirefly) + { + // HISTORY_CLAMPING + data = PushDispatch(methodData, AsUint(Dispatch::HISTORY_CLAMPING)); + AddSharedConstants_Relax(methodData, data, Method::RELAX_DIFFUSE_SPECULAR); + AddFloat(data, settings.historyClampingColorBoxSigmaScale); + AddFloat(data, float(settings.historyFixFrameNum)); + AddUint(data, settings.specularMaxFastAccumulatedFrameNum < settings.specularMaxAccumulatedFrameNum ? 1 : 0); + AddUint(data, settings.diffuseMaxFastAccumulatedFrameNum < settings.diffuseMaxAccumulatedFrameNum ? 1 : 0); + ValidateConstants(data); + + // FIREFLY + data = PushDispatch(methodData, AsUint(Dispatch::FIREFLY)); + AddSharedConstants_Relax(methodData, data, Method::RELAX_DIFFUSE_SPECULAR); + ValidateConstants(data); + } + else + { + // HISTORY_CLAMPING (without firefly) + data = PushDispatch(methodData, AsUint(Dispatch::HISTORY_CLAMPING_NO_FIREFLY)); + AddSharedConstants_Relax(methodData, data, Method::RELAX_DIFFUSE_SPECULAR); + AddFloat(data, settings.historyClampingColorBoxSigmaScale); + AddFloat(data, float(settings.historyFixFrameNum)); + AddUint(data, settings.specularMaxFastAccumulatedFrameNum < settings.specularMaxAccumulatedFrameNum ? 1 : 0); + AddUint(data, settings.diffuseMaxFastAccumulatedFrameNum < settings.diffuseMaxAccumulatedFrameNum ? 1 : 0); + ValidateConstants(data); + } + + // A-TROUS + uint32_t iterationNum = ml::Clamp(settings.atrousIterationNum, 2u, RELAX_MAX_ATROUS_PASS_NUM); + for (uint32_t i = 0; i < iterationNum; i++) + { + Dispatch dispatch; + if (!m_CommonSettings.isHistoryConfidenceAvailable) + { + if (i == 0) + dispatch = Dispatch::ATROUS_SMEM; + else if (i == iterationNum - 1) + dispatch = (i % 2 == 0) ? Dispatch::ATROUS_EVEN_LAST : Dispatch::ATROUS_ODD_LAST; + else + dispatch = (i % 2 == 0) ? Dispatch::ATROUS_EVEN : Dispatch::ATROUS_ODD; + } + else + { + if (i == 0) + dispatch = Dispatch::ATROUS_SMEM_WITH_CONFIDENCE_INPUTS; + else if (i == iterationNum - 1) + dispatch = (i % 2 == 0) ? Dispatch::ATROUS_EVEN_LAST_WITH_CONFIDENCE_INPUTS : Dispatch::ATROUS_ODD_LAST_WITH_CONFIDENCE_INPUTS; + else + dispatch = (i % 2 == 0) ? Dispatch::ATROUS_EVEN_WITH_CONFIDENCE_INPUTS : Dispatch::ATROUS_ODD_WITH_CONFIDENCE_INPUTS; + } + + data = PushDispatch(methodData, AsUint(dispatch)); + AddSharedConstants_Relax(methodData, data, Method::RELAX_DIFFUSE_SPECULAR); + + if (i == 0) + { + AddUint2(data, screenW, screenH); // For Atrous_shmem + AddUint(data, settings.spatialVarianceEstimationHistoryThreshold); + } + + AddFloat(data, settings.specularPhiLuminance); + AddFloat(data, settings.diffusePhiLuminance); + AddFloat(data, maxDiffuseLuminanceRelativeDifference); + AddFloat(data, maxSpecularLuminanceRelativeDifference); + AddFloat(data, m_IsOrtho == 0 ? settings.depthThreshold : depthThresholdOrtho); + AddFloat(data, settings.diffuseLobeAngleFraction); + AddFloat(data, settings.roughnessFraction); + AddFloat(data, settings.specularLobeAngleFraction); + AddFloat(data, ml::DegToRad(settings.specularLobeAngleSlack)); + AddUint(data, 1 << i); + AddUint(data, settings.enableRoughnessEdgeStopping); + AddFloat(data, settings.roughnessEdgeStoppingRelaxation); + AddFloat(data, settings.normalEdgeStoppingRelaxation); + AddFloat(data, settings.luminanceEdgeStoppingRelaxation); + AddUint(data, m_CommonSettings.isHistoryConfidenceAvailable ? 1 : 0); + AddFloat(data, settings.confidenceDrivenRelaxationMultiplier); + AddFloat(data, settings.confidenceDrivenLuminanceEdgeStoppingRelaxation); + AddFloat(data, settings.confidenceDrivenNormalEdgeStoppingRelaxation); + if (i != 0) + { + AddUint(data, (i == iterationNum - 1) ? 1 : 0); + } + ValidateConstants(data); + } + + // SPLIT_SCREEN + if (m_CommonSettings.splitScreen > 0.0f) + { + data = PushDispatch(methodData, AsUint(Dispatch::SPLIT_SCREEN)); + AddSharedConstants_Relax(methodData, data, Method::RELAX_DIFFUSE_SPECULAR); + AddFloat(data, m_CommonSettings.splitScreen); + AddUint(data, diffuseCheckerboard); + AddUint(data, specularCheckerboard); + ValidateConstants(data); + } + + // VALIDATION + if (m_CommonSettings.enableValidation) + { + data = PushDispatch(methodData, AsUint(Dispatch::VALIDATION)); + AddSharedConstants_Relax(methodData, data, Method::RELAX_DIFFUSE_SPECULAR); + AddFloat4x4(data, m_WorldToClipPrev); + AddFloat2(data, m_CommonSettings.cameraJitter[0], m_CommonSettings.cameraJitter[1]); + AddFloat(data, (float)ml::Max(settings.diffuseMaxAccumulatedFrameNum, settings.specularMaxAccumulatedFrameNum)); + ValidateConstants(data); + } +} diff --git a/Source/Methods/Relax_SpecularSh.hpp b/Source/Methods/Relax_SpecularSh.hpp new file mode 100644 index 00000000..788979e6 --- /dev/null +++ b/Source/Methods/Relax_SpecularSh.hpp @@ -0,0 +1,603 @@ +/* +Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved. + +NVIDIA CORPORATION and its licensors retain all intellectual property +and proprietary rights in and to this software, related documentation +and any modifications thereto. Any use, reproduction, disclosure or +distribution of this software and related documentation without an express +license agreement from NVIDIA CORPORATION is strictly prohibited. +*/ + +void nrd::DenoiserImpl::AddMethod_RelaxSpecularSh(MethodData& methodData) +{ + #define METHOD_NAME RELAX_Specular + + methodData.settings.specularRelax = RelaxSpecularSettings(); + methodData.settingsSize = sizeof(methodData.settings.specularRelax); + + uint16_t w = methodData.desc.fullResolutionWidth; + uint16_t h = methodData.desc.fullResolutionHeight; + + enum class Permanent + { + SPEC_ILLUM_PREV = PERMANENT_POOL_START, + SPEC_ILLUM_PREV_SH1, + SPEC_ILLUM_RESPONSIVE_PREV, + SPEC_ILLUM_RESPONSIVE_PREV_SH1, + REFLECTION_HIT_T_CURR, + REFLECTION_HIT_T_PREV, + HISTORY_LENGTH_CURR, + HISTORY_LENGTH_PREV, + NORMAL_ROUGHNESS_PREV, + MATERIAL_ID_PREV, + VIEWZ_CURR, + VIEWZ_PREV + }; + + m_PermanentPool.push_back({ Format::RGBA16_SFLOAT, w, h, 1 }); + m_PermanentPool.push_back({ Format::RGBA16_SFLOAT, w, h, 1 }); + m_PermanentPool.push_back( {Format::RGBA16_SFLOAT, w, h, 1} ); + m_PermanentPool.push_back( {Format::RGBA16_SFLOAT, w, h, 1} ); + m_PermanentPool.push_back( {Format::R16_SFLOAT, w, h, 1} ); + m_PermanentPool.push_back( {Format::R16_SFLOAT, w, h, 1} ); + m_PermanentPool.push_back( {Format::R8_UNORM, w, h, 1} ); + m_PermanentPool.push_back( {Format::R8_UNORM, w, h, 1} ); + m_PermanentPool.push_back( {Format::RGBA8_UNORM, w, h, 1} ); + m_PermanentPool.push_back( {Format::R8_UNORM, w, h, 1} ); + m_PermanentPool.push_back( {Format::R32_SFLOAT, w, h, 1} ); + m_PermanentPool.push_back( {Format::R32_SFLOAT, w, h, 1} ); + + enum class Transient + { + SPEC_ILLUM_PING = TRANSIENT_POOL_START, + SPEC_ILLUM_PING_SH1, + SPEC_ILLUM_PONG, + SPEC_ILLUM_PONG_SH1, + SPEC_ILLUM_TMP, + SPEC_ILLUM_TMP_SH1, + SPEC_REPROJECTION_CONFIDENCE, + VIEWZ_R16F + }; + + m_TransientPool.push_back( {Format::RGBA16_SFLOAT, w, h, 1} ); + m_TransientPool.push_back( {Format::RGBA16_SFLOAT, w, h, 1} ); + m_TransientPool.push_back( {Format::RGBA16_SFLOAT, w, h, 1} ); + m_TransientPool.push_back( {Format::RGBA16_SFLOAT, w, h, 1} ); + m_TransientPool.push_back( {Format::RGBA16_SFLOAT, w, h, 1} ); + m_TransientPool.push_back( {Format::RGBA16_SFLOAT, w, h, 1} ); + m_TransientPool.push_back( {Format::R8_UNORM, w, h, 1} ); + m_TransientPool.push_back( {Format::R16_SFLOAT, w, h, 1} ); + + RELAX_SET_SHARED_CONSTANTS; + + const uint32_t halfMaxPassNum = (RELAX_MAX_ATROUS_PASS_NUM - 2 + 1) / 2; + + PushPass("Hit distance reconstruction 3x3"); // 3x3 + { + PushInput( AsUint(ResourceType::IN_SPEC_SH0) ); + PushInput( AsUint(ResourceType::IN_NORMAL_ROUGHNESS) ); + PushInput( AsUint(ResourceType::IN_VIEWZ) ); + + PushOutput( AsUint(Transient::SPEC_ILLUM_PING) ); + + AddDispatch( RELAX_Specular_HitDistReconstruction, SumConstants(0, 0, 0, 0), NumThreads(8, 8), 1 ); + } + + PushPass("Hit distance reconstruction 5x5"); // 5x5 + { + PushInput( AsUint(ResourceType::IN_SPEC_SH0) ); + PushInput( AsUint(ResourceType::IN_NORMAL_ROUGHNESS) ); + PushInput( AsUint(ResourceType::IN_VIEWZ) ); + + PushOutput( AsUint(Transient::SPEC_ILLUM_PING) ); + + AddDispatch( RELAX_Specular_HitDistReconstruction_5x5, SumConstants(0, 0, 0, 0), NumThreads(8, 8), 1 ); + } + + PushPass("Pre-pass"); // After hit distance reconstruction + { + // Does preblur (if enabled), checkerboard reconstruction (if enabled) and generates FP16 ViewZ texture + PushInput( AsUint(Transient::SPEC_ILLUM_PING) ); + PushInput( AsUint(ResourceType::IN_NORMAL_ROUGHNESS) ); + PushInput( AsUint(ResourceType::IN_VIEWZ) ); + PushInput( AsUint(ResourceType::IN_SPEC_SH1) ); + + PushOutput( AsUint(Transient::SPEC_ILLUM_TMP) ); + PushOutput( AsUint(Permanent::VIEWZ_CURR), 0, 1, AsUint(Permanent::VIEWZ_PREV) ); + PushOutput( AsUint(Transient::VIEWZ_R16F) ); + PushOutput( AsUint(Transient::SPEC_ILLUM_TMP_SH1) ); + + AddDispatch( RELAX_SpecularSh_PrePass, SumConstants(0, 1, 0, 7), NumThreads(16, 16), 1 ); + } + + PushPass("Pre-pass"); // Without hit distance reconstruction + { + // Does preblur (if enabled), checkerboard reconstruction (if enabled) and generates FP16 ViewZ texture + PushInput( AsUint(ResourceType::IN_SPEC_SH0) ); + PushInput( AsUint(ResourceType::IN_NORMAL_ROUGHNESS) ); + PushInput( AsUint(ResourceType::IN_VIEWZ) ); + PushInput( AsUint(ResourceType::IN_SPEC_SH1) ); + + PushOutput( AsUint(Transient::SPEC_ILLUM_TMP) ); + PushOutput( AsUint(Permanent::VIEWZ_CURR), 0, 1, AsUint(Permanent::VIEWZ_PREV)); + PushOutput( AsUint(Transient::VIEWZ_R16F) ); + PushOutput( AsUint(Transient::SPEC_ILLUM_TMP_SH1) ); + + AddDispatch( RELAX_SpecularSh_PrePass, SumConstants(0, 1, 0, 7), NumThreads(16, 16), 1 ); + } + + for (int i = 0; i < 4; i++) + { + // The following passes are defined here: + // REPROJECT, + // REPROJECT_WITH_CONFIDENCE_INPUTS, + // REPROJECT_WITH_THRESHOLD_MIX, + // REPROJECT_WITH_CONFIDENCE_INPUTS_WITH_THRESHOLD_MIX + + PushPass("Temporal accumulation"); + { + PushInput( AsUint(Transient::SPEC_ILLUM_TMP) ); + PushInput( AsUint(ResourceType::IN_MV) ); + PushInput( AsUint(ResourceType::IN_NORMAL_ROUGHNESS) ); + PushInput( AsUint(Permanent::VIEWZ_CURR), 0, 1, AsUint(Permanent::VIEWZ_PREV) ); + PushInput( AsUint(Permanent::SPEC_ILLUM_RESPONSIVE_PREV) ); + PushInput( AsUint(Permanent::SPEC_ILLUM_PREV) ); + PushInput( AsUint(Permanent::NORMAL_ROUGHNESS_PREV) ); + PushInput( AsUint(Permanent::VIEWZ_PREV), 0, 1, AsUint(Permanent::VIEWZ_CURR) ); + PushInput( AsUint(Permanent::REFLECTION_HIT_T_PREV), 0, 1, AsUint(Permanent::REFLECTION_HIT_T_CURR) ); + PushInput( AsUint(Permanent::HISTORY_LENGTH_PREV) ); + PushInput( AsUint(Permanent::MATERIAL_ID_PREV) ); + // Optional inputs: + if (i == 0) + { + PushInput( AsUint(Transient::VIEWZ_R16F) ); // Bogus input that will not be fetched anyway + PushInput( AsUint(Permanent::HISTORY_LENGTH_PREV) ); // Bogus input that will not be fetched anyway + } + if (i == 1) + { + PushInput( AsUint(ResourceType::IN_SPEC_CONFIDENCE) ); + PushInput( AsUint(Permanent::HISTORY_LENGTH_PREV) ); // Bogus input that will not be fetched anyway + } + if (i == 2) + { + PushInput( AsUint(Transient::VIEWZ_R16F) ); // Bogus input that will not be fetched anyway + PushInput( AsUint(ResourceType::IN_DISOCCLUSION_THRESHOLD_MIX) ); + } + if (i == 3) + { + PushInput( AsUint(ResourceType::IN_SPEC_CONFIDENCE) ); + PushInput( AsUint(ResourceType::IN_DISOCCLUSION_THRESHOLD_MIX) ); + } + PushInput( AsUint(Transient::SPEC_ILLUM_TMP_SH1) ); + PushInput( AsUint(Permanent::SPEC_ILLUM_RESPONSIVE_PREV_SH1) ); + PushInput( AsUint(Permanent::SPEC_ILLUM_PREV_SH1) ); + + PushOutput( AsUint(Transient::SPEC_ILLUM_PING) ); + PushOutput( AsUint(Transient::SPEC_ILLUM_PONG) ); + PushOutput( AsUint(Permanent::REFLECTION_HIT_T_CURR), 0, 1, AsUint(Permanent::REFLECTION_HIT_T_PREV) ); + PushOutput( AsUint(Permanent::HISTORY_LENGTH_CURR) ); + PushOutput( AsUint(Transient::SPEC_REPROJECTION_CONFIDENCE) ); + PushOutput( AsUint(Transient::SPEC_ILLUM_PING_SH1) ); + PushOutput( AsUint(Transient::SPEC_ILLUM_PONG_SH1) ); + + AddDispatch( RELAX_SpecularSh_TemporalAccumulation, SumConstants(0, 0, 0, 10), NumThreads(8, 8), 1 ); + } + } + + PushPass("History fix"); + { + PushInput( AsUint(Transient::SPEC_ILLUM_PING) ); + PushInput( AsUint(Permanent::HISTORY_LENGTH_CURR) ); + PushInput( AsUint(ResourceType::IN_NORMAL_ROUGHNESS) ); + PushInput( AsUint(Transient::VIEWZ_R16F) ); + PushInput( AsUint(Transient::SPEC_ILLUM_PING_SH1) ); + + PushOutput( AsUint(Transient::SPEC_ILLUM_PONG) ); + PushOutput( AsUint(Transient::SPEC_ILLUM_PONG_SH1) ); + + AddDispatch( RELAX_SpecularSh_HistoryFix, SumConstants(0, 0, 0, 8), NumThreads(8, 8), 1 ); + } + + PushPass("History clamping"); // with firefly after it + { + PushInput( AsUint(Transient::SPEC_ILLUM_PING) ); + PushInput( AsUint(Transient::SPEC_ILLUM_PONG) ); + PushInput( AsUint(Permanent::HISTORY_LENGTH_CURR) ); + PushInput( AsUint(Transient::SPEC_ILLUM_PING_SH1) ); + PushInput( AsUint(Transient::SPEC_ILLUM_PONG_SH1) ); + + PushOutput( AsUint(Transient::SPEC_ILLUM_TMP) ); + PushOutput( AsUint(Permanent::SPEC_ILLUM_RESPONSIVE_PREV) ); + PushOutput( AsUint(Permanent::HISTORY_LENGTH_PREV) ); + PushOutput( AsUint(Permanent::SPEC_ILLUM_PREV_SH1) ); + PushOutput( AsUint(Permanent::SPEC_ILLUM_RESPONSIVE_PREV_SH1) ); + + AddDispatch( RELAX_SpecularSh_HistoryClamping, SumConstants(0, 0, 0, 3), NumThreads(8, 8), 1 ); + } + + PushPass("History clamping"); // without firefly after it + { + PushInput( AsUint(Transient::SPEC_ILLUM_PING) ); + PushInput( AsUint(Transient::SPEC_ILLUM_PONG) ); + PushInput( AsUint(Permanent::HISTORY_LENGTH_CURR) ); + PushInput( AsUint(Transient::SPEC_ILLUM_PING_SH1) ); + PushInput( AsUint(Transient::SPEC_ILLUM_PONG_SH1) ); + + PushOutput( AsUint(Permanent::SPEC_ILLUM_PREV) ); + PushOutput( AsUint(Permanent::SPEC_ILLUM_RESPONSIVE_PREV) ); + PushOutput( AsUint(Permanent::HISTORY_LENGTH_PREV) ); + PushOutput( AsUint(Permanent::SPEC_ILLUM_PREV_SH1) ); + PushOutput( AsUint(Permanent::SPEC_ILLUM_RESPONSIVE_PREV_SH1) ); + + AddDispatch( RELAX_SpecularSh_HistoryClamping, SumConstants(0, 0, 0, 3), NumThreads(8, 8), 1 ); + } + + PushPass("Anti-firefly"); + { + PushInput( AsUint(Transient::SPEC_ILLUM_TMP) ); + PushInput( AsUint(ResourceType::IN_NORMAL_ROUGHNESS) ); + PushInput( AsUint(Transient::VIEWZ_R16F) ); + + PushOutput( AsUint(Permanent::SPEC_ILLUM_PREV) ); + + AddDispatch( RELAX_SpecularSh_AntiFirefly, SumConstants(0, 0, 0, 0), NumThreads(16, 16), 1 ); + } + for (int i = 0; i < 2; i++) + { + bool withConfidenceInputs = (i == 1); + + // A-trous (first) + PushPass("A-trous (SMEM)"); + { + PushInput( AsUint(Permanent::SPEC_ILLUM_PREV) ); + PushInput( AsUint(Permanent::HISTORY_LENGTH_CURR) ); + PushInput( AsUint(Transient::SPEC_REPROJECTION_CONFIDENCE) ); + PushInput( AsUint(ResourceType::IN_NORMAL_ROUGHNESS) ); + PushInput( AsUint(Transient::VIEWZ_R16F) ); + PushInput( withConfidenceInputs ? AsUint(ResourceType::IN_SPEC_CONFIDENCE) : AsUint(Transient::VIEWZ_R16F) ); + PushInput( AsUint(Permanent::SPEC_ILLUM_PREV_SH1) ); + + PushOutput( AsUint(Transient::SPEC_ILLUM_PING) ); + PushOutput( AsUint(Permanent::NORMAL_ROUGHNESS_PREV) ); + PushOutput( AsUint(Permanent::MATERIAL_ID_PREV) ); + PushOutput( AsUint(Transient::SPEC_ILLUM_PING_SH1) ); + + AddDispatch( RELAX_SpecularSh_AtrousSmem, SumConstants(0, 0, 1, 17), NumThreads(8, 8), 1 ); + } + + // A-trous (odd) + PushPass("A-trous"); + { + PushInput( AsUint(Transient::SPEC_ILLUM_PING) ); + PushInput( AsUint(Permanent::HISTORY_LENGTH_CURR) ); + PushInput( AsUint(Transient::SPEC_REPROJECTION_CONFIDENCE) ); + PushInput( AsUint(ResourceType::IN_NORMAL_ROUGHNESS) ); + PushInput( AsUint(Transient::VIEWZ_R16F) ); + PushInput( withConfidenceInputs ? AsUint(ResourceType::IN_SPEC_CONFIDENCE) : AsUint(Transient::VIEWZ_R16F) ); + PushInput( AsUint(Transient::SPEC_ILLUM_PING_SH1) ); + + PushOutput( AsUint(Transient::SPEC_ILLUM_PONG) ); + PushOutput( AsUint(Transient::SPEC_ILLUM_PONG_SH1) ); + + AddDispatchRepeated( RELAX_SpecularSh_Atrous, SumConstants(0, 0, 0, 17), NumThreads(16, 16), 1, halfMaxPassNum ); + } + + // A-trous (even) + PushPass("A-trous"); + { + PushInput( AsUint(Transient::SPEC_ILLUM_PONG) ); + PushInput( AsUint(Permanent::HISTORY_LENGTH_CURR) ); + PushInput( AsUint(Transient::SPEC_REPROJECTION_CONFIDENCE) ); + PushInput( AsUint(ResourceType::IN_NORMAL_ROUGHNESS) ); + PushInput( AsUint(Transient::VIEWZ_R16F) ); + PushInput( withConfidenceInputs ? AsUint(ResourceType::IN_SPEC_CONFIDENCE) : AsUint(Transient::VIEWZ_R16F) ); + PushInput( AsUint(Transient::SPEC_ILLUM_PONG_SH1) ); + + PushOutput( AsUint(Transient::SPEC_ILLUM_PING) ); + PushOutput( AsUint(Transient::SPEC_ILLUM_PING_SH1) ); + + AddDispatchRepeated( RELAX_SpecularSh_Atrous, SumConstants(0, 0, 0, 17), NumThreads(16, 16), 1, halfMaxPassNum ); + } + + // A-trous (odd, last) + PushPass("A-trous"); + { + PushInput( AsUint(Transient::SPEC_ILLUM_PING) ); + PushInput( AsUint(Permanent::HISTORY_LENGTH_CURR) ); + PushInput( AsUint(Transient::SPEC_REPROJECTION_CONFIDENCE) ); + PushInput( AsUint(ResourceType::IN_NORMAL_ROUGHNESS) ); + PushInput( AsUint(Transient::VIEWZ_R16F) ); + PushInput( withConfidenceInputs ? AsUint(ResourceType::IN_SPEC_CONFIDENCE) : AsUint(Transient::VIEWZ_R16F) ); + PushInput( AsUint(Transient::SPEC_ILLUM_PING_SH1) ); + + PushOutput( AsUint(ResourceType::OUT_SPEC_SH0) ); + PushOutput( AsUint(ResourceType::OUT_SPEC_SH1) ); + + AddDispatch( RELAX_SpecularSh_Atrous, SumConstants(0, 0, 0, 17), NumThreads(16, 16), 1 ); + } + + // A-trous (even, last) + PushPass("A-trous"); + { + PushInput( AsUint(Transient::SPEC_ILLUM_PONG) ); + PushInput( AsUint(Permanent::HISTORY_LENGTH_CURR) ); + PushInput( AsUint(Transient::SPEC_REPROJECTION_CONFIDENCE) ); + PushInput( AsUint(ResourceType::IN_NORMAL_ROUGHNESS) ); + PushInput( AsUint(Transient::VIEWZ_R16F) ); + PushInput( withConfidenceInputs ? AsUint(ResourceType::IN_SPEC_CONFIDENCE) : AsUint(Transient::VIEWZ_R16F) ); + PushInput( AsUint(Transient::SPEC_ILLUM_PONG_SH1) ); + + PushOutput( AsUint(ResourceType::OUT_SPEC_SH0) ); + PushOutput( AsUint(ResourceType::OUT_SPEC_SH1) ); + + AddDispatch( RELAX_SpecularSh_Atrous, SumConstants(0, 0, 0, 17), NumThreads(16, 16), 1 ); + } + } + + PushPass("Split screen"); + { + PushInput( AsUint(ResourceType::IN_VIEWZ) ); + PushInput( AsUint(ResourceType::IN_SPEC_RADIANCE_HITDIST)); + + PushOutput( AsUint( ResourceType::OUT_SPEC_RADIANCE_HITDIST ) ); + + AddDispatch( RELAX_Specular_SplitScreen, SumConstants(0, 0, 0, 2), NumThreads(16, 16), 1 ); + } + + RELAX_ADD_VALIDATION_DISPATCH; + + #undef METHOD_NAME +} + +void nrd::DenoiserImpl::UpdateMethod_RelaxSpecularSh(const MethodData& methodData) +{ + enum class Dispatch + { + HITDIST_RECONSTRUCTION_3x3, + HITDIST_RECONSTRUCTION_5x5, + PREPASS_AFTER_HITDIST_RECONSTRUCTION, + PREPASS, + TEMPORAL_ACCUMULATION, + TEMPORAL_ACCUMULATION_WITH_CONFIDENCE_INPUTS, + TEMPORAL_ACCUMULATION_WITH_THRESHOLD_MIX, + TEMPORAL_ACCUMULATION_WITH_CONFIDENCE_INPUTS_WITH_THRESHOLD_MIX, + HISTORY_FIX, + HISTORY_CLAMPING, + HISTORY_CLAMPING_NO_FIREFLY, + FIREFLY, + ATROUS_SMEM, + ATROUS_ODD, + ATROUS_EVEN, + ATROUS_ODD_LAST, + ATROUS_EVEN_LAST, + ATROUS_SMEM_WITH_CONFIDENCE_INPUTS, + ATROUS_ODD_WITH_CONFIDENCE_INPUTS, + ATROUS_EVEN_WITH_CONFIDENCE_INPUTS, + ATROUS_ODD_LAST_WITH_CONFIDENCE_INPUTS, + ATROUS_EVEN_LAST_WITH_CONFIDENCE_INPUTS, + SPLIT_SCREEN, + VALIDATION, + }; + + const RelaxSpecularSettings& settings = methodData.settings.specularRelax; + + NRD_DECLARE_DIMS; + + float maxLuminanceRelativeDifference = -ml::Log(ml::Saturate(settings.minLuminanceWeight)); + + float disocclusionThreshold = m_CommonSettings.disocclusionThreshold + (1.0f + m_JitterDelta) / float(rectH); + float disocclusionThresholdOrtho = disocclusionThreshold; + float disocclusionThresholdAlternate = m_CommonSettings.disocclusionThresholdAlternate + (1.0f + m_JitterDelta) / float(rectH); + float disocclusionThresholdAlternateOrtho = disocclusionThresholdAlternate; + float depthThresholdOrtho = settings.depthThreshold; + + float tanHalfFov = 1.0f / m_ViewToClip.a00; + float aspect = m_ViewToClip.a00 / m_ViewToClip.a11; + ml::float3 frustumRight = m_WorldToView.GetRow0().To3d() * tanHalfFov; + ml::float3 frustumUp = m_WorldToView.GetRow1().To3d() * tanHalfFov * aspect; + ml::float3 frustumForward = RELAX_GetFrustumForward(m_ViewToWorld, m_Frustum); + + float prevTanHalfFov = 1.0f / m_ViewToClipPrev.a00; + float prevAspect = m_ViewToClipPrev.a00 / m_ViewToClipPrev.a11; + ml::float3 prevFrustumRight = m_WorldToViewPrev.GetRow0().To3d() * prevTanHalfFov; + ml::float3 prevFrustumUp = m_WorldToViewPrev.GetRow1().To3d() * prevTanHalfFov * prevAspect; + ml::float3 prevFrustumForward = RELAX_GetFrustumForward(m_ViewToWorldPrev, m_FrustumPrev); + bool isCameraStatic = RELAX_IsCameraStatic(ml::float3(m_CameraDelta.x, m_CameraDelta.y, m_CameraDelta.z), frustumRight, frustumUp, frustumForward, prevFrustumRight, prevFrustumUp, prevFrustumForward); + + bool enableHitDistanceReconstruction = settings.hitDistanceReconstructionMode != HitDistanceReconstructionMode::OFF && settings.checkerboardMode == CheckerboardMode::OFF; + + // Checkerboard logic + uint32_t specularCheckerboard = 2; + + switch (settings.checkerboardMode) + { + case CheckerboardMode::BLACK: + specularCheckerboard = 0; + break; + case CheckerboardMode::WHITE: + specularCheckerboard = 1; + break; + default: + break; + } + + // SPLIT_SCREEN (passthrough) + if (m_CommonSettings.splitScreen >= 1.0f) + { + Constant* data = PushDispatch(methodData, AsUint(Dispatch::SPLIT_SCREEN)); + AddSharedConstants_Relax(methodData, data, Method::RELAX_SPECULAR); + AddFloat(data, m_CommonSettings.splitScreen); + AddUint(data, specularCheckerboard); + ValidateConstants(data); + + return; + } + + // HITDIST_RECONSTRUCTION + if (enableHitDistanceReconstruction) + { + bool is3x3 = settings.hitDistanceReconstructionMode == HitDistanceReconstructionMode::AREA_3X3; + Constant* data = PushDispatch(methodData, is3x3 ? AsUint(Dispatch::HITDIST_RECONSTRUCTION_3x3) : AsUint(Dispatch::HITDIST_RECONSTRUCTION_5x5)); + AddSharedConstants_Relax(methodData, data, Method::RELAX_SPECULAR); + ValidateConstants(data); + } + + // PREPASS + Constant* data = PushDispatch(methodData, AsUint(enableHitDistanceReconstruction ? Dispatch::PREPASS_AFTER_HITDIST_RECONSTRUCTION : Dispatch::PREPASS)); + AddSharedConstants_Relax(methodData, data, Method::RELAX_SPECULAR); + AddFloat4(data, m_Rotator_PrePass); + AddUint(data, specularCheckerboard); + AddFloat(data, settings.prepassBlurRadius); + AddFloat(data, 1.0f); + AddFloat(data, m_IsOrtho == 0 ? settings.depthThreshold : depthThresholdOrtho); + AddFloat(data, settings.specularLobeAngleFraction); + AddFloat(data, settings.specularLobeAngleSlack); + AddFloat(data, settings.roughnessFraction); + ValidateConstants(data); + + // TEMPORAL_ACCUMULATION + if (!m_CommonSettings.isDisocclusionThresholdMixAvailable) + { + data = PushDispatch( + methodData, + AsUint(m_CommonSettings.isHistoryConfidenceAvailable ? + Dispatch::TEMPORAL_ACCUMULATION_WITH_CONFIDENCE_INPUTS : + Dispatch::TEMPORAL_ACCUMULATION)); + } + else + { + data = PushDispatch( + methodData, + AsUint(m_CommonSettings.isHistoryConfidenceAvailable ? + Dispatch::TEMPORAL_ACCUMULATION_WITH_CONFIDENCE_INPUTS_WITH_THRESHOLD_MIX : + Dispatch::TEMPORAL_ACCUMULATION_WITH_THRESHOLD_MIX)); + } + AddSharedConstants_Relax(methodData, data, Method::RELAX_SPECULAR); + AddFloat(data, (float)settings.specularMaxAccumulatedFrameNum); + AddFloat(data, (float)settings.specularMaxFastAccumulatedFrameNum); + AddUint(data, specularCheckerboard); + AddFloat(data, m_IsOrtho == 0 ? disocclusionThreshold : disocclusionThresholdOrtho); + AddFloat(data, m_IsOrtho == 0 ? disocclusionThresholdAlternate : disocclusionThresholdAlternateOrtho); + AddFloat(data, settings.roughnessFraction); + AddFloat(data, settings.specularVarianceBoost); + AddUint(data, settings.enableReprojectionTestSkippingWithoutMotion && isCameraStatic); + AddUint(data, m_CommonSettings.isHistoryConfidenceAvailable ? 1 : 0); + AddUint(data, m_CommonSettings.isDisocclusionThresholdMixAvailable ? 1 : 0); + ValidateConstants(data); + + // HISTORY_FIX + data = PushDispatch(methodData, AsUint(Dispatch::HISTORY_FIX)); + AddSharedConstants_Relax(methodData, data, Method::RELAX_SPECULAR); + AddFloat(data, m_IsOrtho == 0 ? settings.depthThreshold : depthThresholdOrtho); + AddFloat(data, settings.historyFixEdgeStoppingNormalPower); + AddFloat(data, settings.historyFixStrideBetweenSamples); + AddFloat(data, float(settings.historyFixFrameNum)); + AddFloat(data, settings.specularLobeAngleFraction); + AddFloat(data, ml::DegToRad(settings.specularLobeAngleSlack)); + AddFloat(data, settings.roughnessEdgeStoppingRelaxation); + AddFloat(data, settings.normalEdgeStoppingRelaxation); + ValidateConstants(data); + + if (settings.enableAntiFirefly) + { + // HISTORY_CLAMPING + data = PushDispatch(methodData, AsUint(Dispatch::HISTORY_CLAMPING)); + AddSharedConstants_Relax(methodData, data, Method::RELAX_SPECULAR); + AddFloat(data, settings.historyClampingColorBoxSigmaScale); + AddFloat(data, float(settings.historyFixFrameNum)); + AddUint(data, settings.specularMaxFastAccumulatedFrameNum < settings.specularMaxAccumulatedFrameNum ? 1 : 0); + ValidateConstants(data); + + // FIREFLY + data = PushDispatch(methodData, AsUint(Dispatch::FIREFLY)); + AddSharedConstants_Relax(methodData, data, Method::RELAX_SPECULAR); + ValidateConstants(data); + } + else + { + // HISTORY_CLAMPING (without firefly) + data = PushDispatch(methodData, AsUint(Dispatch::HISTORY_CLAMPING_NO_FIREFLY)); + AddSharedConstants_Relax(methodData, data, Method::RELAX_SPECULAR); + AddFloat(data, settings.historyClampingColorBoxSigmaScale); + AddFloat(data, float(settings.historyFixFrameNum)); + AddUint(data, settings.specularMaxFastAccumulatedFrameNum < settings.specularMaxAccumulatedFrameNum ? 1 : 0); + ValidateConstants(data); + } + + // A-TROUS + uint32_t iterationNum = ml::Clamp(settings.atrousIterationNum, 2u, RELAX_MAX_ATROUS_PASS_NUM); + for (uint32_t i = 0; i < iterationNum; i++) + { + Dispatch dispatch; + if (!m_CommonSettings.isHistoryConfidenceAvailable) + { + if (i == 0) + dispatch = Dispatch::ATROUS_SMEM; + else if (i == iterationNum - 1) + dispatch = (i % 2 == 0) ? Dispatch::ATROUS_EVEN_LAST : Dispatch::ATROUS_ODD_LAST; + else + dispatch = (i % 2 == 0) ? Dispatch::ATROUS_EVEN : Dispatch::ATROUS_ODD; + } + else + { + if (i == 0) + dispatch = Dispatch::ATROUS_SMEM_WITH_CONFIDENCE_INPUTS; + else if (i == iterationNum - 1) + dispatch = (i % 2 == 0) ? Dispatch::ATROUS_EVEN_LAST_WITH_CONFIDENCE_INPUTS : Dispatch::ATROUS_ODD_LAST_WITH_CONFIDENCE_INPUTS; + else + dispatch = (i % 2 == 0) ? Dispatch::ATROUS_EVEN_WITH_CONFIDENCE_INPUTS : Dispatch::ATROUS_ODD_WITH_CONFIDENCE_INPUTS; + } + + data = PushDispatch(methodData, AsUint(dispatch)); + AddSharedConstants_Relax(methodData, data, Method::RELAX_SPECULAR); + + if (i == 0) + { + AddUint2(data, screenW, screenH); // For Atrous_shmem + AddUint(data, settings.spatialVarianceEstimationHistoryThreshold); + } + + AddFloat(data, settings.specularPhiLuminance); + AddFloat(data, maxLuminanceRelativeDifference); + AddFloat(data, m_IsOrtho == 0 ? settings.depthThreshold : depthThresholdOrtho); + AddFloat(data, settings.diffuseLobeAngleFraction); + AddFloat(data, settings.roughnessFraction); + AddFloat(data, settings.specularLobeAngleFraction); + AddFloat(data, ml::DegToRad(settings.specularLobeAngleSlack)); + AddUint(data, 1 << i); + AddUint(data, settings.enableRoughnessEdgeStopping); + AddFloat(data, settings.roughnessEdgeStoppingRelaxation); + AddFloat(data, settings.normalEdgeStoppingRelaxation); + AddFloat(data, settings.luminanceEdgeStoppingRelaxation); + AddUint(data, m_CommonSettings.isHistoryConfidenceAvailable ? 1 : 0); + AddFloat(data, settings.confidenceDrivenRelaxationMultiplier); + AddFloat(data, settings.confidenceDrivenLuminanceEdgeStoppingRelaxation); + AddFloat(data, settings.confidenceDrivenNormalEdgeStoppingRelaxation); + if (i != 0) + { + AddUint(data, (i == iterationNum - 1) ? 1 : 0); + } + ValidateConstants(data); + } + + // SPLIT_SCREEN + if (m_CommonSettings.splitScreen > 0.0f) + { + data = PushDispatch(methodData, AsUint(Dispatch::SPLIT_SCREEN)); + AddSharedConstants_Relax(methodData, data, Method::RELAX_SPECULAR); + AddFloat(data, m_CommonSettings.splitScreen); + AddUint(data, specularCheckerboard); + ValidateConstants(data); + } + + // VALIDATION + if (m_CommonSettings.enableValidation) + { + data = PushDispatch(methodData, AsUint(Dispatch::VALIDATION)); + AddSharedConstants_Relax(methodData, data, Method::RELAX_DIFFUSE_SPECULAR); + AddFloat4x4(data, m_WorldToClipPrev); + AddFloat2(data, m_CommonSettings.cameraJitter[0], m_CommonSettings.cameraJitter[1]); + AddFloat(data, (float)settings.specularMaxAccumulatedFrameNum); + ValidateConstants(data); + } +} diff --git a/Source/Methods/Sigma_Shadow.hpp b/Source/Methods/Sigma_Shadow.hpp index 9fe30793..99792681 100644 --- a/Source/Methods/Sigma_Shadow.hpp +++ b/Source/Methods/Sigma_Shadow.hpp @@ -8,23 +8,6 @@ distribution of this software and related documentation without an express license agreement from NVIDIA CORPORATION is strictly prohibited. */ -#define SIGMA_SET_SHARED_CONSTANTS SetSharedConstants(1, 2, 8, 8) - -#define SIGMA_CLASSIFY_TILES_SET_CONSTANTS SumConstants(0, 0, 0, 0) -#define SIGMA_CLASSIFY_TILES_NUM_THREADS NumThreads(1, 1) - -#define SIGMA_SMOOTH_TILES_SET_CONSTANTS SumConstants(0, 0, 1, 0) -#define SIGMA_SMOOTH_TILES_NUM_THREADS NumThreads(16, 16) - -#define SIGMA_BLUR_SET_CONSTANTS SumConstants(1, 1, 0, 0) -#define SIGMA_BLUR_NUM_THREADS NumThreads(16, 16) - -#define SIGMA_TEMPORAL_STABILIZATION_SET_CONSTANTS SumConstants(2, 0, 0, 0) -#define SIGMA_TEMPORAL_STABILIZATION_NUM_THREADS NumThreads(16, 16) - -#define SIGMA_SPLIT_SCREEN_SET_CONSTANTS SumConstants(0, 0, 0, 1) -#define SIGMA_SPLIT_SCREEN_NUM_THREADS NumThreads(16, 16) - void nrd::DenoiserImpl::AddMethod_SigmaShadow(MethodData& methodData) { #define METHOD_NAME SIGMA_Shadow @@ -126,110 +109,3 @@ void nrd::DenoiserImpl::AddMethod_SigmaShadow(MethodData& methodData) #undef METHOD_NAME } - -void nrd::DenoiserImpl::UpdateMethod_SigmaShadow(const MethodData& methodData) -{ - enum class Dispatch - { - CLASSIFY_TILES, - SMOOTH_TILES, - BLUR, - POST_BLUR, - TEMPORAL_STABILIZATION, - SPLIT_SCREEN, - }; - - const SigmaSettings& settings = methodData.settings.sigma; - - NRD_DECLARE_DIMS; - - uint16_t tilesW = DivideUp(rectW, 16); - uint16_t tilesH = DivideUp(rectH, 16); - - // SPLIT_SCREEN (passthrough) - if (m_CommonSettings.splitScreen >= 1.0f) - { - Constant* data = PushDispatch(methodData, AsUint(Dispatch::SPLIT_SCREEN)); - AddSharedConstants_Sigma(methodData, settings, data); - AddFloat(data, m_CommonSettings.splitScreen); - ValidateConstants(data); - - return; - } - - // CLASSIFY_TILES - Constant* data = PushDispatch(methodData, AsUint(Dispatch::CLASSIFY_TILES)); - AddSharedConstants_Sigma(methodData, settings, data); - ValidateConstants(data); - - // SMOOTH_TILES - data = PushDispatch(methodData, AsUint(Dispatch::SMOOTH_TILES)); - AddSharedConstants_Sigma(methodData, settings, data); - AddUint2(data, tilesW, tilesH); - ValidateConstants(data); - - // BLUR - data = PushDispatch(methodData, AsUint(Dispatch::BLUR)); - AddSharedConstants_Sigma(methodData, settings, data); - AddFloat4x4(data, m_WorldToView); - AddFloat4(data, m_Rotator_Blur); - ValidateConstants(data); - - // POST_BLUR - data = PushDispatch(methodData, AsUint(Dispatch::POST_BLUR)); - AddSharedConstants_Sigma(methodData, settings, data); - AddFloat4x4(data, m_WorldToView); - AddFloat4(data, m_Rotator_PostBlur); - ValidateConstants(data); - - // TEMPORAL_STABILIZATION - data = PushDispatch(methodData, AsUint(Dispatch::TEMPORAL_STABILIZATION)); - AddSharedConstants_Sigma(methodData, settings, data); - AddFloat4x4(data, m_WorldToClipPrev); - AddFloat4x4(data, m_ViewToWorld); - ValidateConstants(data); - - // SPLIT_SCREEN - if (m_CommonSettings.splitScreen > 0.0f) - { - data = PushDispatch(methodData, AsUint(Dispatch::SPLIT_SCREEN)); - AddSharedConstants_Sigma(methodData, settings, data); - AddFloat(data, m_CommonSettings.splitScreen); - ValidateConstants(data); - } -} - -void nrd::DenoiserImpl::AddSharedConstants_Sigma(const MethodData& methodData, const SigmaSettings& settings, Constant*& data) -{ - NRD_DECLARE_DIMS; - - // Even with DRS keep radius, it works well for shadows - float unproject = 1.0f / (0.5f * screenH * m_ProjectY); - - AddFloat4x4(data, m_ViewToClip); - - AddFloat4(data, m_Frustum); - AddFloat4(data, ml::float4(m_CommonSettings.motionVectorScale[0], m_CommonSettings.motionVectorScale[1], m_CommonSettings.motionVectorScale[2], m_CommonSettings.debug)); - - AddFloat2(data, 1.0f / float(screenW), 1.0f / float(screenH)); - AddFloat2(data, float(screenW), float(screenH)); - - AddFloat2(data, 1.0f / float(rectW), 1.0f / float(rectH)); - AddFloat2(data, float(rectW), float(rectH)); - - AddFloat2(data, float(rectWprev), float(rectHprev)); - AddFloat2(data, float(rectW) / float(screenW), float(rectH) / float(screenH)); - - AddFloat2(data, float(m_CommonSettings.inputSubrectOrigin[0]) / float(screenW), float(m_CommonSettings.inputSubrectOrigin[1]) / float(screenH)); - AddUint2(data, m_CommonSettings.inputSubrectOrigin[0], m_CommonSettings.inputSubrectOrigin[1]); - - AddFloat(data, m_IsOrtho); - AddFloat(data, unproject); - AddFloat(data, m_CommonSettings.denoisingRange); - AddFloat(data, settings.planeDistanceSensitivity); - - AddFloat(data, settings.blurRadiusScale); - AddFloat(data, m_CommonSettings.accumulationMode != AccumulationMode::CONTINUE ? 0.0f : 1.0f); - AddUint(data, m_CommonSettings.isMotionVectorInWorldSpace ? 1 : 0); - AddUint(data, m_CommonSettings.frameIndex); -} diff --git a/Source/Other.cpp b/Source/Other.cpp new file mode 100644 index 00000000..f47ecd32 --- /dev/null +++ b/Source/Other.cpp @@ -0,0 +1,46 @@ +/* +Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved. + +NVIDIA CORPORATION and its licensors retain all intellectual property +and proprietary rights in and to this software, related documentation +and any modifications thereto. Any use, reproduction, disclosure or +distribution of this software and related documentation without an express +license agreement from NVIDIA CORPORATION is strictly prohibited. +*/ + +#include "DenoiserImpl.h" + +#ifdef NRD_USE_PRECOMPILED_SHADERS + + // REFERENCE + #if !NRD_ONLY_SPIRV_SHADERS_AVAILABLE + #include "REFERENCE_TemporalAccumulation.cs.dxbc.h" + #include "REFERENCE_TemporalAccumulation.cs.dxil.h" + #include "REFERENCE_SplitScreen.cs.dxbc.h" + #include "REFERENCE_SplitScreen.cs.dxil.h" + #endif + + #include "REFERENCE_TemporalAccumulation.cs.spirv.h" + #include "REFERENCE_SplitScreen.cs.spirv.h" + + // SPECULAR_REFLECTION_MV + #if !NRD_ONLY_SPIRV_SHADERS_AVAILABLE + #include "SpecularReflectionMv_Compute.cs.dxbc.h" + #include "SpecularReflectionMv_Compute.cs.dxil.h" + #endif + + #include "SpecularReflectionMv_Compute.cs.spirv.h" + + // SPECULAR_DELTA_MV + #if !NRD_ONLY_SPIRV_SHADERS_AVAILABLE + #include "SpecularDeltaMv_Compute.cs.dxbc.h" + #include "SpecularDeltaMv_Compute.cs.dxil.h" + #endif + + #include "SpecularDeltaMv_Compute.cs.spirv.h" + +#endif + +#include "Methods/Reference.hpp" +#include "Methods/SpecularReflectionMv.hpp" +#include "Methods/SpecularDeltaMv.hpp" diff --git a/Source/Reblur.cpp b/Source/Reblur.cpp new file mode 100644 index 00000000..cbfbaa47 --- /dev/null +++ b/Source/Reblur.cpp @@ -0,0 +1,1063 @@ +/* +Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved. + +NVIDIA CORPORATION and its licensors retain all intellectual property +and proprietary rights in and to this software, related documentation +and any modifications thereto. Any use, reproduction, disclosure or +distribution of this software and related documentation without an express +license agreement from NVIDIA CORPORATION is strictly prohibited. +*/ + +#include "DenoiserImpl.h" + +#include + +// Constants +#define REBLUR_SET_SHARED_CONSTANTS SetSharedConstants(2, 5, 10, 24) + +#define REBLUR_HITDIST_RECONSTRUCTION_CONSTANT_NUM SumConstants(0, 0, 0, 0) +#define REBLUR_HITDIST_RECONSTRUCTION_NUM_THREADS NumThreads(8, 8) + +#define REBLUR_PREPASS_CONSTANT_NUM SumConstants(0, 1, 0, 2) +#define REBLUR_PREPASS_NUM_THREADS NumThreads(16, 16) + +#define REBLUR_TEMPORAL_ACCUMULATION_CONSTANT_NUM SumConstants(4, 2, 0, 7) +#define REBLUR_TEMPORAL_ACCUMULATION_NUM_THREADS NumThreads(8, 8) + +#define REBLUR_HISTORY_FIX_CONSTANT_NUM SumConstants(0, 0, 0, 1) +#define REBLUR_HISTORY_FIX_NUM_THREADS NumThreads(16, 16) + +#define REBLUR_BLUR_CONSTANT_NUM SumConstants(0, 1, 0, 0) +#define REBLUR_BLUR_NUM_THREADS NumThreads(8, 8) + +#define REBLUR_POST_BLUR_CONSTANT_NUM SumConstants(0, 1, 0, 0) +#define REBLUR_POST_BLUR_NUM_THREADS NumThreads(8, 8) + +#define REBLUR_COPY_STABILIZED_HISTORY_CONSTANT_NUM SumConstants(0, 0, 0, 0, false) +#define REBLUR_COPY_STABILIZED_HISTORY_NUM_THREADS NumThreads(16, 16) + +#define REBLUR_TEMPORAL_STABILIZATION_CONSTANT_NUM SumConstants(3, 3, 2, 1) +#define REBLUR_TEMPORAL_STABILIZATION_NUM_THREADS NumThreads(8, 8) + +#define REBLUR_SPLIT_SCREEN_CONSTANT_NUM SumConstants(0, 0, 0, 3) +#define REBLUR_SPLIT_SCREEN_NUM_THREADS NumThreads(16, 16) + +// Permutations +#define REBLUR_HITDIST_RECONSTRUCTION_PERMUTATION_NUM 4 +#define REBLUR_PREPASS_PERMUTATION_NUM 2 +#define REBLUR_TEMPORAL_ACCUMULATION_PERMUTATION_NUM 16 +#define REBLUR_HISTORY_FIX_PERMUTATION_NUM 1 +#define REBLUR_BLUR_PERMUTATION_NUM 1 +#define REBLUR_POST_BLUR_PERMUTATION_NUM 2 +#define REBLUR_COPY_STABILIZED_HISTORY_PERMUTATION_NUM 1 +#define REBLUR_TEMPORAL_STABILIZATION_PERMUTATION_NUM 2 +#define REBLUR_SPLIT_SCREEN_PERMUTATION_NUM 1 + +#define REBLUR_OCCLUSION_HITDIST_RECONSTRUCTION_PERMUTATION_NUM 2 +#define REBLUR_OCCLUSION_TEMPORAL_ACCUMULATION_PERMUTATION_NUM 8 +#define REBLUR_OCCLUSION_HISTORY_FIX_PERMUTATION_NUM 1 +#define REBLUR_OCCLUSION_BLUR_PERMUTATION_NUM 1 +#define REBLUR_OCCLUSION_POST_BLUR_PERMUTATION_NUM 1 +#define REBLUR_OCCLUSION_SPLIT_SCREEN_PERMUTATION_NUM 1 + +// Formats +#define REBLUR_FORMAT Format::RGBA16_SFLOAT + +#define REBLUR_FORMAT_DIFF_FAST_HISTORY Format::R16_SFLOAT +#define REBLUR_FORMAT_SPEC_FAST_HISTORY Format::RG16_SFLOAT // .y = hit distance for tracking + +#define REBLUR_FORMAT_SPEC_HITDIST_FOR_TRACKING Format::R16_UNORM // use R16_SFLOAT if pre-pass outputs unnormalized hit distance + +#define REBLUR_FORMAT_OCCLUSION Format::R16_UNORM + +#define REBLUR_FORMAT_DIRECTIONAL_OCCLUSION Format::RGBA16_SNORM +#define REBLUR_FORMAT_DIRECTIONAL_OCCLUSION_FAST_HISTORY REBLUR_FORMAT_OCCLUSION + +#define REBLUR_FORMAT_PREV_VIEWZ Format::R32_SFLOAT +#define REBLUR_FORMAT_PREV_NORMAL_ROUGHNESS Format::RGBA8_UNORM +#define REBLUR_FORMAT_PREV_INTERNAL_DATA Format::R16_UINT + +// Other +#define REBLUR_DUMMY AsUint(ResourceType::IN_VIEWZ) + +#define REBLUR_ADD_VALIDATION_DISPATCH( data2, diff, spec ) \ + PushPass("Validation"); \ + { \ + PushInput( AsUint(ResourceType::IN_NORMAL_ROUGHNESS) ); \ + PushInput( AsUint(ResourceType::IN_VIEWZ) ); \ + PushInput( AsUint(ResourceType::IN_MV) ); \ + PushInput( AsUint(Transient::DATA1) ); \ + PushInput( AsUint(data2) ); \ + PushInput( AsUint(diff) ); \ + PushInput( AsUint(spec) ); \ + PushOutput( AsUint(ResourceType::OUT_VALIDATION) ); \ + AddDispatch( REBLUR_Validation, SumConstants(1, 0, 1, 4), NumThreads(16, 16), IGNORE_RS ); \ + } + +struct ReblurProps +{ + bool hasDiffuse; + bool hasSpecular; +}; + +constexpr std::array g_ReblurProps = +{{ + {true, false}, // REBLUR_DIFFUSE + {true, false}, // REBLUR_DIFFUSE_OCCLUSION + {true, false}, // REBLUR_DIFFUSE_SH + {false, true}, // REBLUR_SPECULAR + {false, true}, // REBLUR_SPECULAR_OCCLUSION + {false, true}, // REBLUR_SPECULAR_SH + {true, true}, // REBLUR_DIFFUSE_SPECULAR + {true, true}, // REBLUR_DIFFUSE_SPECULAR_OCCLUSION + {true, true}, // REBLUR_DIFFUSE_SPECULAR_SH + {true, false}, // REBLUR_DIFFUSE_DIRECTIONAL_OCCLUSION +}}; + +void nrd::DenoiserImpl::UpdateMethod_Reblur(const MethodData& methodData) +{ + enum class Dispatch + { + HITDIST_RECONSTRUCTION, + PREPASS = HITDIST_RECONSTRUCTION + REBLUR_HITDIST_RECONSTRUCTION_PERMUTATION_NUM * 2, + TEMPORAL_ACCUMULATION = PREPASS + REBLUR_PREPASS_PERMUTATION_NUM * 2, + HISTORY_FIX = TEMPORAL_ACCUMULATION + REBLUR_TEMPORAL_ACCUMULATION_PERMUTATION_NUM * 2, + BLUR = HISTORY_FIX + REBLUR_HISTORY_FIX_PERMUTATION_NUM * 2, + POST_BLUR = BLUR + REBLUR_BLUR_PERMUTATION_NUM * 2, + COPY_STABILIZED_HISTORY = POST_BLUR + REBLUR_POST_BLUR_PERMUTATION_NUM * 2, + TEMPORAL_STABILIZATION = COPY_STABILIZED_HISTORY + REBLUR_COPY_STABILIZED_HISTORY_PERMUTATION_NUM * 1, // no perf mode for copy + SPLIT_SCREEN = TEMPORAL_STABILIZATION + REBLUR_TEMPORAL_STABILIZATION_PERMUTATION_NUM * 2, + VALIDATION = SPLIT_SCREEN + REBLUR_SPLIT_SCREEN_PERMUTATION_NUM * 1, // no perf mode for split screen + }; + + NRD_DECLARE_DIMS; + + const ReblurSettings& settings = methodData.settings.reblur; + const ReblurProps& props = g_ReblurProps[ size_t(methodData.desc.method) - size_t(Method::REBLUR_DIFFUSE) ]; + + bool enableHitDistanceReconstruction = settings.hitDistanceReconstructionMode != HitDistanceReconstructionMode::OFF && settings.checkerboardMode == CheckerboardMode::OFF; + bool skipTemporalStabilization = settings.stabilizationStrength == 0.0f; + bool skipPrePass = (settings.diffusePrepassBlurRadius == 0.0f || !props.hasDiffuse) && + (settings.specularPrepassBlurRadius == 0.0f || !props.hasSpecular) && + settings.checkerboardMode == CheckerboardMode::OFF; + + float disocclusionThresholdBonus = (1.0f + m_JitterDelta) / float(rectH); + float disocclusionThreshold = m_CommonSettings.disocclusionThreshold + disocclusionThresholdBonus; + float disocclusionThresholdAlternate = m_CommonSettings.disocclusionThresholdAlternate + disocclusionThresholdBonus; + + ml::float4 antilagMinMaxThreshold = ml::float4(settings.antilagIntensitySettings.thresholdMin, settings.antilagHitDistanceSettings.thresholdMin, settings.antilagIntensitySettings.thresholdMax, settings.antilagHitDistanceSettings.thresholdMax); + + if (!settings.antilagIntensitySettings.enable || settings.enableReferenceAccumulation) + { + antilagMinMaxThreshold.x = 99998.0f; + antilagMinMaxThreshold.z = 99999.0f; + } + + if (!settings.antilagHitDistanceSettings.enable || settings.enableReferenceAccumulation) + { + antilagMinMaxThreshold.y = 99998.0f; + antilagMinMaxThreshold.w = 99999.0f; + } + + uint32_t specCheckerboard = 2; + uint32_t diffCheckerboard = 2; + + switch (settings.checkerboardMode) + { + case CheckerboardMode::BLACK: + diffCheckerboard = 0; + specCheckerboard = 1; + break; + case CheckerboardMode::WHITE: + diffCheckerboard = 1; + specCheckerboard = 0; + break; + default: + break; + } + + // SPLIT_SCREEN (passthrough) + if (m_CommonSettings.splitScreen >= 1.0f) + { + Constant* data = PushDispatch(methodData, AsUint(Dispatch::SPLIT_SCREEN)); + AddSharedConstants_Reblur(methodData, settings, data); + AddFloat(data, m_CommonSettings.splitScreen); + AddUint(data, diffCheckerboard); + AddUint(data, specCheckerboard); + ValidateConstants(data); + + return; + } + + // HITDIST_RECONSTRUCTION + if (enableHitDistanceReconstruction) + { + uint32_t passIndex = AsUint(Dispatch::HITDIST_RECONSTRUCTION) + (settings.hitDistanceReconstructionMode == HitDistanceReconstructionMode::AREA_5X5 ? 4 : 0) + (!skipPrePass ? 2 : 0) + (settings.enablePerformanceMode ? 1 : 0); + Constant* data = PushDispatch(methodData, passIndex); + AddSharedConstants_Reblur(methodData, settings, data); + ValidateConstants(data); + } + + // PREPASS + if (!skipPrePass) + { + uint32_t passIndex = AsUint(Dispatch::PREPASS) + (enableHitDistanceReconstruction ? 2 : 0) + (settings.enablePerformanceMode ? 1 : 0); + Constant* data = PushDispatch(methodData, passIndex); + AddSharedConstants_Reblur(methodData, settings, data); + AddFloat4(data, m_Rotator_PrePass); + AddUint(data, diffCheckerboard); + AddUint(data, specCheckerboard); + ValidateConstants(data); + } + + // TEMPORAL_ACCUMULATION + uint32_t passIndex = AsUint(Dispatch::TEMPORAL_ACCUMULATION) + (m_CommonSettings.isDisocclusionThresholdMixAvailable ? 16 : 0) + + (!skipTemporalStabilization ? 8 : 0) + (m_CommonSettings.isHistoryConfidenceAvailable ? 4 : 0) + + ((!skipPrePass || enableHitDistanceReconstruction) ? 2 : 0) + (settings.enablePerformanceMode ? 1 : 0); + Constant* data = PushDispatch(methodData, passIndex); + AddSharedConstants_Reblur(methodData, settings, data); + AddFloat4x4(data, m_WorldToViewPrev); + AddFloat4x4(data, m_WorldToClipPrev); + AddFloat4x4(data, m_WorldToClip); + AddFloat4x4(data, m_WorldPrevToWorld); + AddFloat4(data, m_FrustumPrev); + AddFloat4(data, ml::float4(m_CameraDelta.x, m_CameraDelta.y, m_CameraDelta.z, disocclusionThreshold)); + AddFloat(data, disocclusionThresholdAlternate); + AddFloat(data, m_CheckerboardResolveAccumSpeed); + AddUint(data, diffCheckerboard); + AddUint(data, specCheckerboard); + AddUint(data, skipPrePass ? 0 : 1); + AddUint(data, m_CommonSettings.isHistoryConfidenceAvailable ? 1 : 0); + AddUint(data, m_CommonSettings.isDisocclusionThresholdMixAvailable ? 1 : 0); + ValidateConstants(data); + + // HISTORY_FIX + passIndex = AsUint(Dispatch::HISTORY_FIX) + (settings.enablePerformanceMode ? 1 : 0); + data = PushDispatch(methodData, passIndex); + AddSharedConstants_Reblur(methodData, settings, data); + AddFloat(data, settings.historyFixStrideBetweenSamples); + ValidateConstants(data); + + // BLUR + passIndex = AsUint(Dispatch::BLUR) + (settings.enablePerformanceMode ? 1 : 0); + data = PushDispatch(methodData, passIndex); + AddSharedConstants_Reblur(methodData, settings, data); + AddFloat4(data, m_Rotator_Blur); + ValidateConstants(data); + + // POST_BLUR + passIndex = AsUint(Dispatch::POST_BLUR) + (skipTemporalStabilization ? 0 : 2) + (settings.enablePerformanceMode ? 1 : 0); + data = PushDispatch(methodData, passIndex); + AddSharedConstants_Reblur(methodData, settings, data); + AddFloat4(data, m_Rotator_PostBlur); + ValidateConstants(data); + + // COPY_STABILIZED_HISTORY + if (!skipTemporalStabilization) + { + passIndex = AsUint(Dispatch::COPY_STABILIZED_HISTORY); + data = PushDispatch(methodData, passIndex); + ValidateConstants(data); + } + + // TEMPORAL_STABILIZATION + if (!skipTemporalStabilization) + { + passIndex = AsUint(Dispatch::TEMPORAL_STABILIZATION) + (m_CommonSettings.isBaseColorMetalnessAvailable ? 2 : 0) + (settings.enablePerformanceMode ? 1 : 0); + data = PushDispatch(methodData, passIndex); + AddSharedConstants_Reblur(methodData, settings, data); + AddFloat4x4(data, m_WorldToClip); + AddFloat4x4(data, m_WorldToClipPrev); + AddFloat4x4(data, m_WorldToViewPrev); + AddFloat4(data, m_FrustumPrev); + AddFloat4(data, antilagMinMaxThreshold ); + AddFloat4(data, ml::float4(m_CameraDelta.x, m_CameraDelta.y, m_CameraDelta.z, settings.stabilizationStrength)); + AddFloat2(data, settings.antilagIntensitySettings.sigmaScale, settings.antilagHitDistanceSettings.sigmaScale); + if (m_CommonSettings.isBaseColorMetalnessAvailable) + AddFloat2(data, settings.specularProbabilityThresholdsForMvModification[0], settings.specularProbabilityThresholdsForMvModification[1]); + else + AddFloat2(data, 2.0f, 3.0f); + AddFloat(data, m_CommonSettings.splitScreen); + ValidateConstants(data); + } + + // SPLIT_SCREEN + if (m_CommonSettings.splitScreen > 0.0f) + { + data = PushDispatch(methodData, AsUint(Dispatch::SPLIT_SCREEN)); + AddSharedConstants_Reblur(methodData, settings, data); + AddFloat(data, m_CommonSettings.splitScreen); + AddUint(data, diffCheckerboard); + AddUint(data, specCheckerboard); + ValidateConstants(data); + } + + // VALIDATION + if (m_CommonSettings.enableValidation) + { + data = PushDispatch(methodData, AsUint(Dispatch::VALIDATION)); + AddSharedConstants_Reblur(methodData, settings, data); + AddFloat4x4(data, m_WorldToClipPrev); + AddFloat2(data, m_CommonSettings.cameraJitter[0], m_CommonSettings.cameraJitter[1]); + AddUint(data, props.hasDiffuse ? 1 : 0); + AddUint(data, props.hasSpecular ? 1 : 0); + AddUint(data, diffCheckerboard); + AddUint(data, specCheckerboard); + ValidateConstants(data); + } +} + +void nrd::DenoiserImpl::UpdateMethod_ReblurOcclusion(const MethodData& methodData) +{ + enum class Dispatch + { + HITDIST_RECONSTRUCTION, + TEMPORAL_ACCUMULATION = HITDIST_RECONSTRUCTION + REBLUR_OCCLUSION_HITDIST_RECONSTRUCTION_PERMUTATION_NUM * 2, + HISTORY_FIX = TEMPORAL_ACCUMULATION + REBLUR_OCCLUSION_TEMPORAL_ACCUMULATION_PERMUTATION_NUM * 2, + BLUR = HISTORY_FIX + REBLUR_OCCLUSION_HISTORY_FIX_PERMUTATION_NUM * 2, // non perf mode is used for anti-firefly + POST_BLUR = BLUR + REBLUR_OCCLUSION_BLUR_PERMUTATION_NUM * 2, + SPLIT_SCREEN = POST_BLUR + REBLUR_OCCLUSION_POST_BLUR_PERMUTATION_NUM * 2, + VALIDATION = SPLIT_SCREEN + REBLUR_SPLIT_SCREEN_PERMUTATION_NUM * 1, // no perf mode for split screen + }; + + NRD_DECLARE_DIMS; + + const ReblurSettings& settings = methodData.settings.reblur; + const ReblurProps& props = g_ReblurProps[ size_t(methodData.desc.method) - size_t(Method::REBLUR_DIFFUSE) ]; + + bool enableHitDistanceReconstruction = settings.hitDistanceReconstructionMode != HitDistanceReconstructionMode::OFF && settings.checkerboardMode == CheckerboardMode::OFF; + + float disocclusionThresholdBonus = (1.0f + m_JitterDelta) / float(rectH); + float disocclusionThreshold = m_CommonSettings.disocclusionThreshold + disocclusionThresholdBonus; + float disocclusionThresholdAlternate = m_CommonSettings.disocclusionThresholdAlternate + disocclusionThresholdBonus; + + uint32_t specCheckerboard = 2; + uint32_t diffCheckerboard = 2; + + switch (settings.checkerboardMode) + { + case CheckerboardMode::BLACK: + diffCheckerboard = 0; + specCheckerboard = 1; + break; + case CheckerboardMode::WHITE: + diffCheckerboard = 1; + specCheckerboard = 0; + break; + default: + break; + } + + // SPLIT_SCREEN (passthrough) + if (m_CommonSettings.splitScreen >= 1.0f) + { + Constant* data = PushDispatch(methodData, AsUint(Dispatch::SPLIT_SCREEN)); + AddSharedConstants_Reblur(methodData, settings, data); + AddFloat(data, m_CommonSettings.splitScreen); + AddUint(data, diffCheckerboard); + AddUint(data, specCheckerboard); + ValidateConstants(data); + + return; + } + + // HITDIST_RECONSTRUCTION + if (enableHitDistanceReconstruction) + { + uint32_t passIndex = AsUint(Dispatch::HITDIST_RECONSTRUCTION) + (settings.hitDistanceReconstructionMode == HitDistanceReconstructionMode::AREA_5X5 ? 2 : 0) + (settings.enablePerformanceMode ? 1 : 0); + Constant* data = PushDispatch(methodData, passIndex); + AddSharedConstants_Reblur(methodData, settings, data); + ValidateConstants(data); + } + + // TEMPORAL_ACCUMULATION + uint32_t passIndex = AsUint(Dispatch::TEMPORAL_ACCUMULATION) + (m_CommonSettings.isDisocclusionThresholdMixAvailable ? 8 : 0) + + (m_CommonSettings.isHistoryConfidenceAvailable ? 4 : 0) + (enableHitDistanceReconstruction ? 2 : 0) + (settings.enablePerformanceMode ? 1 : 0); + Constant* data = PushDispatch(methodData, passIndex); + AddSharedConstants_Reblur(methodData, settings, data); + AddFloat4x4(data, m_WorldToViewPrev); + AddFloat4x4(data, m_WorldToClipPrev); + AddFloat4x4(data, m_WorldToClip); + AddFloat4x4(data, m_WorldPrevToWorld); + AddFloat4(data, m_FrustumPrev); + AddFloat4(data, ml::float4(m_CameraDelta.x, m_CameraDelta.y, m_CameraDelta.z, disocclusionThreshold)); + AddFloat(data, disocclusionThresholdAlternate); + AddFloat(data, m_CheckerboardResolveAccumSpeed); + AddUint(data, diffCheckerboard); + AddUint(data, specCheckerboard); + AddUint(data, 0); + AddUint(data, m_CommonSettings.isHistoryConfidenceAvailable); + AddUint(data, m_CommonSettings.isDisocclusionThresholdMixAvailable); + ValidateConstants(data); + + // HISTORY_FIX + passIndex = AsUint(Dispatch::HISTORY_FIX) + (!settings.enableAntiFirefly ? 1 : 0); + data = PushDispatch(methodData, passIndex); + AddSharedConstants_Reblur(methodData, settings, data); + AddFloat(data, settings.historyFixStrideBetweenSamples); + ValidateConstants(data); + + // BLUR + passIndex = AsUint(Dispatch::BLUR) + (settings.enablePerformanceMode ? 1 : 0); + data = PushDispatch(methodData, passIndex); + AddSharedConstants_Reblur(methodData, settings, data); + AddFloat4(data, m_Rotator_Blur); + ValidateConstants(data); + + // POST_BLUR + passIndex = AsUint(Dispatch::POST_BLUR) + (settings.enablePerformanceMode ? 1 : 0); + data = PushDispatch(methodData, passIndex); + AddSharedConstants_Reblur(methodData, settings, data); + AddFloat4(data, m_Rotator_PostBlur); + ValidateConstants(data); + + // SPLIT_SCREEN + if (m_CommonSettings.splitScreen > 0.0f) + { + data = PushDispatch(methodData, AsUint(Dispatch::SPLIT_SCREEN)); + AddSharedConstants_Reblur(methodData, settings, data); + AddFloat(data, m_CommonSettings.splitScreen); + AddUint(data, diffCheckerboard); + AddUint(data, specCheckerboard); + ValidateConstants(data); + } + + // VALIDATION + if (m_CommonSettings.enableValidation) + { + data = PushDispatch(methodData, AsUint(Dispatch::VALIDATION)); + AddSharedConstants_Reblur(methodData, settings, data); + AddFloat4x4(data, m_WorldToClipPrev); + AddFloat2(data, m_CommonSettings.cameraJitter[0], m_CommonSettings.cameraJitter[1]); + AddUint(data, props.hasDiffuse ? 1 : 0); + AddUint(data, props.hasSpecular ? 1 : 0); + AddUint(data, diffCheckerboard); + AddUint(data, specCheckerboard); + ValidateConstants(data); + } +} + +void nrd::DenoiserImpl::AddSharedConstants_Reblur(const MethodData& methodData, const ReblurSettings& settings, Constant*& data) +{ + NRD_DECLARE_DIMS; + + bool isHistoryReset = m_CommonSettings.accumulationMode != AccumulationMode::CONTINUE; + float unproject = 1.0f / (0.5f * rectH * m_ProjectY); + uint32_t maxAccumulatedFrameNum = ml::Min(settings.maxAccumulatedFrameNum, REBLUR_MAX_HISTORY_FRAME_NUM); + + AddFloat4x4(data, m_ViewToClip); + AddFloat4x4(data, m_ViewToWorld); + + AddFloat4(data, m_Frustum); + AddFloat4(data, ml::float4(settings.hitDistanceParameters.A, settings.hitDistanceParameters.B, settings.hitDistanceParameters.C, settings.hitDistanceParameters.D)); + AddFloat4(data, ml::float4(m_ViewDirection.x, m_ViewDirection.y, m_ViewDirection.z, 0.0f)); + AddFloat4(data, ml::float4(m_ViewDirectionPrev.x, m_ViewDirectionPrev.y, m_ViewDirectionPrev.z, 0.0f)); + AddFloat4(data, ml::float4(m_CommonSettings.motionVectorScale[0], m_CommonSettings.motionVectorScale[1], m_CommonSettings.motionVectorScale[2], m_CommonSettings.debug)); + + AddFloat2(data, 1.0f / float(screenW), 1.0f / float(screenH)); + AddFloat2(data, float(screenW), float(screenH)); + + AddFloat2(data, 1.0f / float(rectW), 1.0f / float(rectH)); + AddFloat2(data, float(rectW), float(rectH)); + + AddFloat2(data, float(rectW) / float(screenW), float(rectH) / float(screenH)); + AddFloat2(data, float(rectWprev) / float(screenW), float(rectHprev) / float(screenH)); + + AddFloat2(data, float(rectWprev), float(rectHprev)); + AddFloat2(data, settings.antilagIntensitySettings.sensitivityToDarkness + 1e-6f, settings.antilagHitDistanceSettings.sensitivityToDarkness + 1e-6f); + + AddFloat2(data, float(m_CommonSettings.inputSubrectOrigin[0]) / float(screenW), float(m_CommonSettings.inputSubrectOrigin[1]) / float(screenH)); + AddUint2(data, m_CommonSettings.inputSubrectOrigin[0], m_CommonSettings.inputSubrectOrigin[1]); + + AddFloat(data, settings.enableReferenceAccumulation ? 0.0f : 1.0f); + AddFloat(data, m_IsOrtho); + AddFloat(data, unproject); + AddFloat(data, m_CommonSettings.denoisingRange); + + AddFloat(data, settings.planeDistanceSensitivity); + AddFloat(data, m_FrameRateScale); + AddFloat(data, settings.enableReferenceAccumulation ? 0.0f : settings.blurRadius); + AddFloat(data, isHistoryReset ? 0 : float(maxAccumulatedFrameNum)); + + AddFloat(data, float(settings.maxFastAccumulatedFrameNum)); + AddFloat(data, settings.enableAntiFirefly ? 1.0f : 0.0f); + AddFloat(data, settings.lobeAngleFraction); + AddFloat(data, settings.roughnessFraction); + + AddFloat(data, settings.responsiveAccumulationRoughnessThreshold); + AddFloat(data, settings.diffusePrepassBlurRadius); + AddFloat(data, settings.specularPrepassBlurRadius); + AddFloat(data, (float)settings.historyFixFrameNum); + + AddFloat(data, (float)ml::Min(rectW, rectH) * unproject); + AddUint(data, m_CommonSettings.isMotionVectorInWorldSpace ? 1 : 0); + AddUint(data, m_CommonSettings.frameIndex); + AddUint(data, settings.enableMaterialTestForDiffuse ? 1 : 0); + + AddUint(data, settings.enableMaterialTestForSpecular ? 1 : 0); + AddUint(data, isHistoryReset ? 1 : 0); + AddUint(data, 0); + AddUint(data, 0); +} + +#ifdef NRD_USE_PRECOMPILED_SHADERS + + // REBLUR_DIFFUSE + #if !NRD_ONLY_SPIRV_SHADERS_AVAILABLE + #include "REBLUR_Diffuse_HitDistReconstruction.cs.dxbc.h" + #include "REBLUR_Diffuse_HitDistReconstruction.cs.dxil.h" + #include "REBLUR_Diffuse_HitDistReconstruction_5x5.cs.dxbc.h" + #include "REBLUR_Diffuse_HitDistReconstruction_5x5.cs.dxil.h" + #include "REBLUR_Diffuse_PrePass.cs.dxbc.h" + #include "REBLUR_Diffuse_PrePass.cs.dxil.h" + #include "REBLUR_Diffuse_TemporalAccumulation.cs.dxbc.h" + #include "REBLUR_Diffuse_TemporalAccumulation.cs.dxil.h" + #include "REBLUR_Diffuse_HistoryFix.cs.dxbc.h" + #include "REBLUR_Diffuse_HistoryFix.cs.dxil.h" + #include "REBLUR_Diffuse_Blur.cs.dxbc.h" + #include "REBLUR_Diffuse_Blur.cs.dxil.h" + #include "REBLUR_Diffuse_PostBlur.cs.dxbc.h" + #include "REBLUR_Diffuse_PostBlur.cs.dxil.h" + #include "REBLUR_Diffuse_PostBlur_NoTemporalStabilization.cs.dxbc.h" + #include "REBLUR_Diffuse_PostBlur_NoTemporalStabilization.cs.dxil.h" + #include "REBLUR_Diffuse_CopyStabilizedHistory.cs.dxbc.h" + #include "REBLUR_Diffuse_CopyStabilizedHistory.cs.dxil.h" + #include "REBLUR_Diffuse_TemporalStabilization.cs.dxbc.h" + #include "REBLUR_Diffuse_TemporalStabilization.cs.dxil.h" + #include "REBLUR_Diffuse_SplitScreen.cs.dxbc.h" + #include "REBLUR_Diffuse_SplitScreen.cs.dxil.h" + #include "REBLUR_Validation.cs.dxbc.h" + #include "REBLUR_Validation.cs.dxil.h" + + #include "REBLUR_Perf_Diffuse_HitDistReconstruction.cs.dxbc.h" + #include "REBLUR_Perf_Diffuse_HitDistReconstruction.cs.dxil.h" + #include "REBLUR_Perf_Diffuse_HitDistReconstruction_5x5.cs.dxil.h" + #include "REBLUR_Perf_Diffuse_HitDistReconstruction_5x5.cs.dxbc.h" + #include "REBLUR_Perf_Diffuse_PrePass.cs.dxbc.h" + #include "REBLUR_Perf_Diffuse_PrePass.cs.dxil.h" + #include "REBLUR_Perf_Diffuse_TemporalAccumulation.cs.dxbc.h" + #include "REBLUR_Perf_Diffuse_TemporalAccumulation.cs.dxil.h" + #include "REBLUR_Perf_Diffuse_HistoryFix.cs.dxbc.h" + #include "REBLUR_Perf_Diffuse_HistoryFix.cs.dxil.h" + #include "REBLUR_Perf_Diffuse_Blur.cs.dxbc.h" + #include "REBLUR_Perf_Diffuse_Blur.cs.dxil.h" + #include "REBLUR_Perf_Diffuse_PostBlur.cs.dxbc.h" + #include "REBLUR_Perf_Diffuse_PostBlur.cs.dxil.h" + #include "REBLUR_Perf_Diffuse_PostBlur_NoTemporalStabilization.cs.dxbc.h" + #include "REBLUR_Perf_Diffuse_PostBlur_NoTemporalStabilization.cs.dxil.h" + #include "REBLUR_Perf_Diffuse_TemporalStabilization.cs.dxbc.h" + #include "REBLUR_Perf_Diffuse_TemporalStabilization.cs.dxil.h" + #endif + + #include "REBLUR_Diffuse_HitDistReconstruction.cs.spirv.h" + #include "REBLUR_Diffuse_HitDistReconstruction_5x5.cs.spirv.h" + #include "REBLUR_Diffuse_PrePass.cs.spirv.h" + #include "REBLUR_Diffuse_TemporalAccumulation.cs.spirv.h" + #include "REBLUR_Diffuse_HistoryFix.cs.spirv.h" + #include "REBLUR_Diffuse_Blur.cs.spirv.h" + #include "REBLUR_Diffuse_CopyStabilizedHistory.cs.spirv.h" + #include "REBLUR_Diffuse_TemporalStabilization.cs.spirv.h" + #include "REBLUR_Diffuse_PostBlur.cs.spirv.h" + #include "REBLUR_Diffuse_PostBlur_NoTemporalStabilization.cs.spirv.h" + #include "REBLUR_Diffuse_SplitScreen.cs.spirv.h" + #include "REBLUR_Validation.cs.spirv.h" + + #include "REBLUR_Perf_Diffuse_HitDistReconstruction.cs.spirv.h" + #include "REBLUR_Perf_Diffuse_HitDistReconstruction_5x5.cs.spirv.h" + #include "REBLUR_Perf_Diffuse_PrePass.cs.spirv.h" + #include "REBLUR_Perf_Diffuse_TemporalAccumulation.cs.spirv.h" + #include "REBLUR_Perf_Diffuse_HistoryFix.cs.spirv.h" + #include "REBLUR_Perf_Diffuse_Blur.cs.spirv.h" + #include "REBLUR_Perf_Diffuse_TemporalStabilization.cs.spirv.h" + #include "REBLUR_Perf_Diffuse_PostBlur.cs.spirv.h" + #include "REBLUR_Perf_Diffuse_PostBlur_NoTemporalStabilization.cs.spirv.h" + + // REBLUR_DIFFUSE_OCCLUSION + #if !NRD_ONLY_SPIRV_SHADERS_AVAILABLE + #include "REBLUR_DiffuseOcclusion_HitDistReconstruction.cs.dxbc.h" + #include "REBLUR_DiffuseOcclusion_HitDistReconstruction.cs.dxil.h" + #include "REBLUR_DiffuseOcclusion_HitDistReconstruction_5x5.cs.dxbc.h" + #include "REBLUR_DiffuseOcclusion_HitDistReconstruction_5x5.cs.dxil.h" + #include "REBLUR_DiffuseOcclusion_TemporalAccumulation.cs.dxbc.h" + #include "REBLUR_DiffuseOcclusion_TemporalAccumulation.cs.dxil.h" + #include "REBLUR_DiffuseOcclusion_HistoryFix.cs.dxbc.h" + #include "REBLUR_DiffuseOcclusion_HistoryFix.cs.dxil.h" + #include "REBLUR_DiffuseOcclusion_Blur.cs.dxbc.h" + #include "REBLUR_DiffuseOcclusion_Blur.cs.dxil.h" + #include "REBLUR_DiffuseOcclusion_PostBlur_NoTemporalStabilization.cs.dxbc.h" + #include "REBLUR_DiffuseOcclusion_PostBlur_NoTemporalStabilization.cs.dxil.h" + + #include "REBLUR_Perf_DiffuseOcclusion_HitDistReconstruction.cs.dxbc.h" + #include "REBLUR_Perf_DiffuseOcclusion_HitDistReconstruction.cs.dxil.h" + #include "REBLUR_Perf_DiffuseOcclusion_HitDistReconstruction_5x5.cs.dxbc.h" + #include "REBLUR_Perf_DiffuseOcclusion_HitDistReconstruction_5x5.cs.dxil.h" + #include "REBLUR_Perf_DiffuseOcclusion_TemporalAccumulation.cs.dxbc.h" + #include "REBLUR_Perf_DiffuseOcclusion_TemporalAccumulation.cs.dxil.h" + #include "REBLUR_Perf_DiffuseOcclusion_HistoryFix.cs.dxbc.h" + #include "REBLUR_Perf_DiffuseOcclusion_HistoryFix.cs.dxil.h" + #include "REBLUR_Perf_DiffuseOcclusion_Blur.cs.dxbc.h" + #include "REBLUR_Perf_DiffuseOcclusion_Blur.cs.dxil.h" + #include "REBLUR_Perf_DiffuseOcclusion_PostBlur_NoTemporalStabilization.cs.dxbc.h" + #include "REBLUR_Perf_DiffuseOcclusion_PostBlur_NoTemporalStabilization.cs.dxil.h" + #endif + + #include "REBLUR_DiffuseOcclusion_HitDistReconstruction.cs.spirv.h" + #include "REBLUR_DiffuseOcclusion_HitDistReconstruction_5x5.cs.spirv.h" + #include "REBLUR_DiffuseOcclusion_TemporalAccumulation.cs.spirv.h" + #include "REBLUR_DiffuseOcclusion_HistoryFix.cs.spirv.h" + #include "REBLUR_DiffuseOcclusion_Blur.cs.spirv.h" + #include "REBLUR_DiffuseOcclusion_PostBlur_NoTemporalStabilization.cs.spirv.h" + + #include "REBLUR_Perf_DiffuseOcclusion_HitDistReconstruction.cs.spirv.h" + #include "REBLUR_Perf_DiffuseOcclusion_HitDistReconstruction_5x5.cs.spirv.h" + #include "REBLUR_Perf_DiffuseOcclusion_TemporalAccumulation.cs.spirv.h" + #include "REBLUR_Perf_DiffuseOcclusion_HistoryFix.cs.spirv.h" + #include "REBLUR_Perf_DiffuseOcclusion_Blur.cs.spirv.h" + #include "REBLUR_Perf_DiffuseOcclusion_PostBlur_NoTemporalStabilization.cs.spirv.h" + + // REBLUR_DIFFUSE_SH + #if !NRD_ONLY_SPIRV_SHADERS_AVAILABLE + #include "REBLUR_DiffuseSh_PrePass.cs.dxbc.h" + #include "REBLUR_DiffuseSh_PrePass.cs.dxil.h" + #include "REBLUR_DiffuseSh_TemporalAccumulation.cs.dxbc.h" + #include "REBLUR_DiffuseSh_TemporalAccumulation.cs.dxil.h" + #include "REBLUR_DiffuseSh_HistoryFix.cs.dxbc.h" + #include "REBLUR_DiffuseSh_HistoryFix.cs.dxil.h" + #include "REBLUR_DiffuseSh_Blur.cs.dxbc.h" + #include "REBLUR_DiffuseSh_Blur.cs.dxil.h" + #include "REBLUR_DiffuseSh_PostBlur.cs.dxbc.h" + #include "REBLUR_DiffuseSh_PostBlur.cs.dxil.h" + #include "REBLUR_DiffuseSh_PostBlur_NoTemporalStabilization.cs.dxbc.h" + #include "REBLUR_DiffuseSh_PostBlur_NoTemporalStabilization.cs.dxil.h" + #include "REBLUR_DiffuseSh_CopyStabilizedHistory.cs.dxbc.h" + #include "REBLUR_DiffuseSh_CopyStabilizedHistory.cs.dxil.h" + #include "REBLUR_DiffuseSh_TemporalStabilization.cs.dxbc.h" + #include "REBLUR_DiffuseSh_TemporalStabilization.cs.dxil.h" + #include "REBLUR_DiffuseSh_SplitScreen.cs.dxbc.h" + #include "REBLUR_DiffuseSh_SplitScreen.cs.dxil.h" + + #include "REBLUR_Perf_DiffuseSh_PrePass.cs.dxbc.h" + #include "REBLUR_Perf_DiffuseSh_PrePass.cs.dxil.h" + #include "REBLUR_Perf_DiffuseSh_TemporalAccumulation.cs.dxbc.h" + #include "REBLUR_Perf_DiffuseSh_TemporalAccumulation.cs.dxil.h" + #include "REBLUR_Perf_DiffuseSh_HistoryFix.cs.dxbc.h" + #include "REBLUR_Perf_DiffuseSh_HistoryFix.cs.dxil.h" + #include "REBLUR_Perf_DiffuseSh_Blur.cs.dxbc.h" + #include "REBLUR_Perf_DiffuseSh_Blur.cs.dxil.h" + #include "REBLUR_Perf_DiffuseSh_PostBlur.cs.dxbc.h" + #include "REBLUR_Perf_DiffuseSh_PostBlur.cs.dxil.h" + #include "REBLUR_Perf_DiffuseSh_PostBlur_NoTemporalStabilization.cs.dxbc.h" + #include "REBLUR_Perf_DiffuseSh_PostBlur_NoTemporalStabilization.cs.dxil.h" + #include "REBLUR_Perf_DiffuseSh_TemporalStabilization.cs.dxbc.h" + #include "REBLUR_Perf_DiffuseSh_TemporalStabilization.cs.dxil.h" + #endif + + #include "REBLUR_DiffuseSh_PrePass.cs.spirv.h" + #include "REBLUR_DiffuseSh_TemporalAccumulation.cs.spirv.h" + #include "REBLUR_DiffuseSh_HistoryFix.cs.spirv.h" + #include "REBLUR_DiffuseSh_Blur.cs.spirv.h" + #include "REBLUR_DiffuseSh_CopyStabilizedHistory.cs.spirv.h" + #include "REBLUR_DiffuseSh_TemporalStabilization.cs.spirv.h" + #include "REBLUR_DiffuseSh_PostBlur.cs.spirv.h" + #include "REBLUR_DiffuseSh_PostBlur_NoTemporalStabilization.cs.spirv.h" + #include "REBLUR_DiffuseSh_SplitScreen.cs.spirv.h" + + #include "REBLUR_Perf_DiffuseSh_PrePass.cs.spirv.h" + #include "REBLUR_Perf_DiffuseSh_TemporalAccumulation.cs.spirv.h" + #include "REBLUR_Perf_DiffuseSh_HistoryFix.cs.spirv.h" + #include "REBLUR_Perf_DiffuseSh_Blur.cs.spirv.h" + #include "REBLUR_Perf_DiffuseSh_TemporalStabilization.cs.spirv.h" + #include "REBLUR_Perf_DiffuseSh_PostBlur.cs.spirv.h" + #include "REBLUR_Perf_DiffuseSh_PostBlur_NoTemporalStabilization.cs.spirv.h" + + // REBLUR_SPECULAR + #if !NRD_ONLY_SPIRV_SHADERS_AVAILABLE + #include "REBLUR_Specular_HitDistReconstruction.cs.dxbc.h" + #include "REBLUR_Specular_HitDistReconstruction.cs.dxil.h" + #include "REBLUR_Specular_HitDistReconstruction_5x5.cs.dxbc.h" + #include "REBLUR_Specular_HitDistReconstruction_5x5.cs.dxil.h" + #include "REBLUR_Specular_PrePass.cs.dxbc.h" + #include "REBLUR_Specular_PrePass.cs.dxil.h" + #include "REBLUR_Specular_TemporalAccumulation.cs.dxbc.h" + #include "REBLUR_Specular_TemporalAccumulation.cs.dxil.h" + #include "REBLUR_Specular_HistoryFix.cs.dxbc.h" + #include "REBLUR_Specular_HistoryFix.cs.dxil.h" + #include "REBLUR_Specular_Blur.cs.dxbc.h" + #include "REBLUR_Specular_Blur.cs.dxil.h" + #include "REBLUR_Specular_PostBlur.cs.dxbc.h" + #include "REBLUR_Specular_PostBlur.cs.dxil.h" + #include "REBLUR_Specular_PostBlur_NoTemporalStabilization.cs.dxbc.h" + #include "REBLUR_Specular_PostBlur_NoTemporalStabilization.cs.dxil.h" + #include "REBLUR_Specular_CopyStabilizedHistory.cs.dxbc.h" + #include "REBLUR_Specular_CopyStabilizedHistory.cs.dxil.h" + #include "REBLUR_Specular_TemporalStabilization.cs.dxbc.h" + #include "REBLUR_Specular_TemporalStabilization.cs.dxil.h" + #include "REBLUR_Specular_SplitScreen.cs.dxbc.h" + #include "REBLUR_Specular_SplitScreen.cs.dxil.h" + + #include "REBLUR_Perf_Specular_HitDistReconstruction.cs.dxbc.h" + #include "REBLUR_Perf_Specular_HitDistReconstruction.cs.dxil.h" + #include "REBLUR_Perf_Specular_HitDistReconstruction_5x5.cs.dxbc.h" + #include "REBLUR_Perf_Specular_HitDistReconstruction_5x5.cs.dxil.h" + #include "REBLUR_Perf_Specular_PrePass.cs.dxbc.h" + #include "REBLUR_Perf_Specular_PrePass.cs.dxil.h" + #include "REBLUR_Perf_Specular_TemporalAccumulation.cs.dxbc.h" + #include "REBLUR_Perf_Specular_TemporalAccumulation.cs.dxil.h" + #include "REBLUR_Perf_Specular_HistoryFix.cs.dxbc.h" + #include "REBLUR_Perf_Specular_HistoryFix.cs.dxil.h" + #include "REBLUR_Perf_Specular_Blur.cs.dxbc.h" + #include "REBLUR_Perf_Specular_Blur.cs.dxil.h" + #include "REBLUR_Perf_Specular_PostBlur.cs.dxbc.h" + #include "REBLUR_Perf_Specular_PostBlur.cs.dxil.h" + #include "REBLUR_Perf_Specular_PostBlur_NoTemporalStabilization.cs.dxbc.h" + #include "REBLUR_Perf_Specular_PostBlur_NoTemporalStabilization.cs.dxil.h" + #include "REBLUR_Perf_Specular_TemporalStabilization.cs.dxbc.h" + #include "REBLUR_Perf_Specular_TemporalStabilization.cs.dxil.h" + #endif + + #include "REBLUR_Specular_HitDistReconstruction.cs.spirv.h" + #include "REBLUR_Specular_HitDistReconstruction_5x5.cs.spirv.h" + #include "REBLUR_Specular_PrePass.cs.spirv.h" + #include "REBLUR_Specular_TemporalAccumulation.cs.spirv.h" + #include "REBLUR_Specular_HistoryFix.cs.spirv.h" + #include "REBLUR_Specular_Blur.cs.spirv.h" + #include "REBLUR_Specular_PostBlur.cs.spirv.h" + #include "REBLUR_Specular_PostBlur_NoTemporalStabilization.cs.spirv.h" + #include "REBLUR_Specular_CopyStabilizedHistory.cs.spirv.h" + #include "REBLUR_Specular_TemporalStabilization.cs.spirv.h" + #include "REBLUR_Specular_SplitScreen.cs.spirv.h" + + #include "REBLUR_Perf_Specular_HitDistReconstruction.cs.spirv.h" + #include "REBLUR_Perf_Specular_HitDistReconstruction_5x5.cs.spirv.h" + #include "REBLUR_Perf_Specular_PrePass.cs.spirv.h" + #include "REBLUR_Perf_Specular_TemporalAccumulation.cs.spirv.h" + #include "REBLUR_Perf_Specular_HistoryFix.cs.spirv.h" + #include "REBLUR_Perf_Specular_Blur.cs.spirv.h" + #include "REBLUR_Perf_Specular_PostBlur.cs.spirv.h" + #include "REBLUR_Perf_Specular_PostBlur_NoTemporalStabilization.cs.spirv.h" + #include "REBLUR_Perf_Specular_TemporalStabilization.cs.spirv.h" + + // REBLUR_SPECULAR_OCCLUSION + #if !NRD_ONLY_SPIRV_SHADERS_AVAILABLE + #include "REBLUR_SpecularOcclusion_HitDistReconstruction.cs.dxbc.h" + #include "REBLUR_SpecularOcclusion_HitDistReconstruction.cs.dxil.h" + #include "REBLUR_SpecularOcclusion_HitDistReconstruction_5x5.cs.dxbc.h" + #include "REBLUR_SpecularOcclusion_HitDistReconstruction_5x5.cs.dxil.h" + #include "REBLUR_SpecularOcclusion_TemporalAccumulation.cs.dxbc.h" + #include "REBLUR_SpecularOcclusion_TemporalAccumulation.cs.dxil.h" + #include "REBLUR_SpecularOcclusion_HistoryFix.cs.dxbc.h" + #include "REBLUR_SpecularOcclusion_HistoryFix.cs.dxil.h" + #include "REBLUR_SpecularOcclusion_Blur.cs.dxbc.h" + #include "REBLUR_SpecularOcclusion_Blur.cs.dxil.h" + #include "REBLUR_SpecularOcclusion_PostBlur_NoTemporalStabilization.cs.dxbc.h" + #include "REBLUR_SpecularOcclusion_PostBlur_NoTemporalStabilization.cs.dxil.h" + + #include "REBLUR_Perf_SpecularOcclusion_HitDistReconstruction.cs.dxbc.h" + #include "REBLUR_Perf_SpecularOcclusion_HitDistReconstruction.cs.dxil.h" + #include "REBLUR_Perf_SpecularOcclusion_HitDistReconstruction_5x5.cs.dxbc.h" + #include "REBLUR_Perf_SpecularOcclusion_HitDistReconstruction_5x5.cs.dxil.h" + #include "REBLUR_Perf_SpecularOcclusion_TemporalAccumulation.cs.dxbc.h" + #include "REBLUR_Perf_SpecularOcclusion_TemporalAccumulation.cs.dxil.h" + #include "REBLUR_Perf_SpecularOcclusion_HistoryFix.cs.dxbc.h" + #include "REBLUR_Perf_SpecularOcclusion_HistoryFix.cs.dxil.h" + #include "REBLUR_Perf_SpecularOcclusion_Blur.cs.dxbc.h" + #include "REBLUR_Perf_SpecularOcclusion_Blur.cs.dxil.h" + #include "REBLUR_Perf_SpecularOcclusion_PostBlur_NoTemporalStabilization.cs.dxbc.h" + #include "REBLUR_Perf_SpecularOcclusion_PostBlur_NoTemporalStabilization.cs.dxil.h" + #endif + + #include "REBLUR_SpecularOcclusion_HitDistReconstruction.cs.spirv.h" + #include "REBLUR_SpecularOcclusion_HitDistReconstruction_5x5.cs.spirv.h" + #include "REBLUR_SpecularOcclusion_TemporalAccumulation.cs.spirv.h" + #include "REBLUR_SpecularOcclusion_HistoryFix.cs.spirv.h" + #include "REBLUR_SpecularOcclusion_Blur.cs.spirv.h" + #include "REBLUR_SpecularOcclusion_PostBlur_NoTemporalStabilization.cs.spirv.h" + + #include "REBLUR_Perf_SpecularOcclusion_HitDistReconstruction.cs.spirv.h" + #include "REBLUR_Perf_SpecularOcclusion_HitDistReconstruction_5x5.cs.spirv.h" + #include "REBLUR_Perf_SpecularOcclusion_TemporalAccumulation.cs.spirv.h" + #include "REBLUR_Perf_SpecularOcclusion_HistoryFix.cs.spirv.h" + #include "REBLUR_Perf_SpecularOcclusion_Blur.cs.spirv.h" + #include "REBLUR_Perf_SpecularOcclusion_PostBlur_NoTemporalStabilization.cs.spirv.h" + + // REBLUR_SPECULAR_SH + #if !NRD_ONLY_SPIRV_SHADERS_AVAILABLE + #include "REBLUR_SpecularSh_PrePass.cs.dxbc.h" + #include "REBLUR_SpecularSh_PrePass.cs.dxil.h" + #include "REBLUR_SpecularSh_TemporalAccumulation.cs.dxbc.h" + #include "REBLUR_SpecularSh_TemporalAccumulation.cs.dxil.h" + #include "REBLUR_SpecularSh_HistoryFix.cs.dxbc.h" + #include "REBLUR_SpecularSh_HistoryFix.cs.dxil.h" + #include "REBLUR_SpecularSh_Blur.cs.dxbc.h" + #include "REBLUR_SpecularSh_Blur.cs.dxil.h" + #include "REBLUR_SpecularSh_PostBlur.cs.dxbc.h" + #include "REBLUR_SpecularSh_PostBlur.cs.dxil.h" + #include "REBLUR_SpecularSh_PostBlur_NoTemporalStabilization.cs.dxbc.h" + #include "REBLUR_SpecularSh_PostBlur_NoTemporalStabilization.cs.dxil.h" + #include "REBLUR_SpecularSh_CopyStabilizedHistory.cs.dxbc.h" + #include "REBLUR_SpecularSh_CopyStabilizedHistory.cs.dxil.h" + #include "REBLUR_SpecularSh_TemporalStabilization.cs.dxbc.h" + #include "REBLUR_SpecularSh_TemporalStabilization.cs.dxil.h" + #include "REBLUR_SpecularSh_SplitScreen.cs.dxbc.h" + #include "REBLUR_SpecularSh_SplitScreen.cs.dxil.h" + + #include "REBLUR_Perf_SpecularSh_PrePass.cs.dxbc.h" + #include "REBLUR_Perf_SpecularSh_PrePass.cs.dxil.h" + #include "REBLUR_Perf_SpecularSh_TemporalAccumulation.cs.dxbc.h" + #include "REBLUR_Perf_SpecularSh_TemporalAccumulation.cs.dxil.h" + #include "REBLUR_Perf_SpecularSh_HistoryFix.cs.dxbc.h" + #include "REBLUR_Perf_SpecularSh_HistoryFix.cs.dxil.h" + #include "REBLUR_Perf_SpecularSh_Blur.cs.dxbc.h" + #include "REBLUR_Perf_SpecularSh_Blur.cs.dxil.h" + #include "REBLUR_Perf_SpecularSh_PostBlur.cs.dxbc.h" + #include "REBLUR_Perf_SpecularSh_PostBlur.cs.dxil.h" + #include "REBLUR_Perf_SpecularSh_PostBlur_NoTemporalStabilization.cs.dxbc.h" + #include "REBLUR_Perf_SpecularSh_PostBlur_NoTemporalStabilization.cs.dxil.h" + #include "REBLUR_Perf_SpecularSh_TemporalStabilization.cs.dxbc.h" + #include "REBLUR_Perf_SpecularSh_TemporalStabilization.cs.dxil.h" + #endif + + #include "REBLUR_SpecularSh_PrePass.cs.spirv.h" + #include "REBLUR_SpecularSh_TemporalAccumulation.cs.spirv.h" + #include "REBLUR_SpecularSh_HistoryFix.cs.spirv.h" + #include "REBLUR_SpecularSh_Blur.cs.spirv.h" + #include "REBLUR_SpecularSh_PostBlur.cs.spirv.h" + #include "REBLUR_SpecularSh_PostBlur_NoTemporalStabilization.cs.spirv.h" + #include "REBLUR_SpecularSh_CopyStabilizedHistory.cs.spirv.h" + #include "REBLUR_SpecularSh_TemporalStabilization.cs.spirv.h" + #include "REBLUR_SpecularSh_SplitScreen.cs.spirv.h" + + #include "REBLUR_Perf_SpecularSh_PrePass.cs.spirv.h" + #include "REBLUR_Perf_SpecularSh_TemporalAccumulation.cs.spirv.h" + #include "REBLUR_Perf_SpecularSh_HistoryFix.cs.spirv.h" + #include "REBLUR_Perf_SpecularSh_Blur.cs.spirv.h" + #include "REBLUR_Perf_SpecularSh_PostBlur.cs.spirv.h" + #include "REBLUR_Perf_SpecularSh_PostBlur_NoTemporalStabilization.cs.spirv.h" + #include "REBLUR_Perf_SpecularSh_TemporalStabilization.cs.spirv.h" + + // REBLUR_DIFFUSE_SPECULAR + #if !NRD_ONLY_SPIRV_SHADERS_AVAILABLE + #include "REBLUR_DiffuseSpecular_HitDistReconstruction.cs.dxbc.h" + #include "REBLUR_DiffuseSpecular_HitDistReconstruction.cs.dxil.h" + #include "REBLUR_DiffuseSpecular_HitDistReconstruction_5x5.cs.dxbc.h" + #include "REBLUR_DiffuseSpecular_HitDistReconstruction_5x5.cs.dxil.h" + #include "REBLUR_DiffuseSpecular_PrePass.cs.dxbc.h" + #include "REBLUR_DiffuseSpecular_PrePass.cs.dxil.h" + #include "REBLUR_DiffuseSpecular_TemporalAccumulation.cs.dxbc.h" + #include "REBLUR_DiffuseSpecular_TemporalAccumulation.cs.dxil.h" + #include "REBLUR_DiffuseSpecular_HistoryFix.cs.dxbc.h" + #include "REBLUR_DiffuseSpecular_HistoryFix.cs.dxil.h" + #include "REBLUR_DiffuseSpecular_Blur.cs.dxbc.h" + #include "REBLUR_DiffuseSpecular_Blur.cs.dxil.h" + #include "REBLUR_DiffuseSpecular_CopyStabilizedHistory.cs.dxbc.h" + #include "REBLUR_DiffuseSpecular_CopyStabilizedHistory.cs.dxil.h" + #include "REBLUR_DiffuseSpecular_TemporalStabilization.cs.dxbc.h" + #include "REBLUR_DiffuseSpecular_TemporalStabilization.cs.dxil.h" + #include "REBLUR_DiffuseSpecular_PostBlur.cs.dxbc.h" + #include "REBLUR_DiffuseSpecular_PostBlur.cs.dxil.h" + #include "REBLUR_DiffuseSpecular_PostBlur_NoTemporalStabilization.cs.dxbc.h" + #include "REBLUR_DiffuseSpecular_PostBlur_NoTemporalStabilization.cs.dxil.h" + #include "REBLUR_DiffuseSpecular_SplitScreen.cs.dxbc.h" + #include "REBLUR_DiffuseSpecular_SplitScreen.cs.dxil.h" + + #include "REBLUR_Perf_DiffuseSpecular_HitDistReconstruction.cs.dxbc.h" + #include "REBLUR_Perf_DiffuseSpecular_HitDistReconstruction.cs.dxil.h" + #include "REBLUR_Perf_DiffuseSpecular_HitDistReconstruction_5x5.cs.dxbc.h" + #include "REBLUR_Perf_DiffuseSpecular_HitDistReconstruction_5x5.cs.dxil.h" + #include "REBLUR_Perf_DiffuseSpecular_PrePass.cs.dxbc.h" + #include "REBLUR_Perf_DiffuseSpecular_PrePass.cs.dxil.h" + #include "REBLUR_Perf_DiffuseSpecular_TemporalAccumulation.cs.dxbc.h" + #include "REBLUR_Perf_DiffuseSpecular_TemporalAccumulation.cs.dxil.h" + #include "REBLUR_Perf_DiffuseSpecular_HistoryFix.cs.dxbc.h" + #include "REBLUR_Perf_DiffuseSpecular_HistoryFix.cs.dxil.h" + #include "REBLUR_Perf_DiffuseSpecular_Blur.cs.dxbc.h" + #include "REBLUR_Perf_DiffuseSpecular_Blur.cs.dxil.h" + #include "REBLUR_Perf_DiffuseSpecular_TemporalStabilization.cs.dxbc.h" + #include "REBLUR_Perf_DiffuseSpecular_TemporalStabilization.cs.dxil.h" + #include "REBLUR_Perf_DiffuseSpecular_PostBlur.cs.dxbc.h" + #include "REBLUR_Perf_DiffuseSpecular_PostBlur.cs.dxil.h" + #include "REBLUR_Perf_DiffuseSpecular_PostBlur_NoTemporalStabilization.cs.dxbc.h" + #include "REBLUR_Perf_DiffuseSpecular_PostBlur_NoTemporalStabilization.cs.dxil.h" + #endif + + #include "REBLUR_DiffuseSpecular_HitDistReconstruction.cs.spirv.h" + #include "REBLUR_DiffuseSpecular_HitDistReconstruction_5x5.cs.spirv.h" + #include "REBLUR_DiffuseSpecular_PrePass.cs.spirv.h" + #include "REBLUR_DiffuseSpecular_TemporalAccumulation.cs.spirv.h" + #include "REBLUR_DiffuseSpecular_HistoryFix.cs.spirv.h" + #include "REBLUR_DiffuseSpecular_Blur.cs.spirv.h" + #include "REBLUR_DiffuseSpecular_CopyStabilizedHistory.cs.spirv.h" + #include "REBLUR_DiffuseSpecular_TemporalStabilization.cs.spirv.h" + #include "REBLUR_DiffuseSpecular_PostBlur.cs.spirv.h" + #include "REBLUR_DiffuseSpecular_PostBlur_NoTemporalStabilization.cs.spirv.h" + #include "REBLUR_DiffuseSpecular_SplitScreen.cs.spirv.h" + + #include "REBLUR_Perf_DiffuseSpecular_HitDistReconstruction.cs.spirv.h" + #include "REBLUR_Perf_DiffuseSpecular_HitDistReconstruction_5x5.cs.spirv.h" + #include "REBLUR_Perf_DiffuseSpecular_PrePass.cs.spirv.h" + #include "REBLUR_Perf_DiffuseSpecular_TemporalAccumulation.cs.spirv.h" + #include "REBLUR_Perf_DiffuseSpecular_HistoryFix.cs.spirv.h" + #include "REBLUR_Perf_DiffuseSpecular_Blur.cs.spirv.h" + #include "REBLUR_Perf_DiffuseSpecular_TemporalStabilization.cs.spirv.h" + #include "REBLUR_Perf_DiffuseSpecular_PostBlur.cs.spirv.h" + #include "REBLUR_Perf_DiffuseSpecular_PostBlur_NoTemporalStabilization.cs.spirv.h" + + // REBLUR_DIFFUSE_SPECULAR_OCCLUSION + #if !NRD_ONLY_SPIRV_SHADERS_AVAILABLE + #include "REBLUR_DiffuseSpecularOcclusion_HitDistReconstruction.cs.dxbc.h" + #include "REBLUR_DiffuseSpecularOcclusion_HitDistReconstruction.cs.dxil.h" + #include "REBLUR_DiffuseSpecularOcclusion_HitDistReconstruction_5x5.cs.dxbc.h" + #include "REBLUR_DiffuseSpecularOcclusion_HitDistReconstruction_5x5.cs.dxil.h" + #include "REBLUR_DiffuseSpecularOcclusion_TemporalAccumulation.cs.dxbc.h" + #include "REBLUR_DiffuseSpecularOcclusion_TemporalAccumulation.cs.dxil.h" + #include "REBLUR_DiffuseSpecularOcclusion_HistoryFix.cs.dxbc.h" + #include "REBLUR_DiffuseSpecularOcclusion_HistoryFix.cs.dxil.h" + #include "REBLUR_DiffuseSpecularOcclusion_Blur.cs.dxbc.h" + #include "REBLUR_DiffuseSpecularOcclusion_Blur.cs.dxil.h" + #include "REBLUR_DiffuseSpecularOcclusion_PostBlur_NoTemporalStabilization.cs.dxbc.h" + #include "REBLUR_DiffuseSpecularOcclusion_PostBlur_NoTemporalStabilization.cs.dxil.h" + + #include "REBLUR_Perf_DiffuseSpecularOcclusion_HitDistReconstruction.cs.dxbc.h" + #include "REBLUR_Perf_DiffuseSpecularOcclusion_HitDistReconstruction.cs.dxil.h" + #include "REBLUR_Perf_DiffuseSpecularOcclusion_HitDistReconstruction_5x5.cs.dxbc.h" + #include "REBLUR_Perf_DiffuseSpecularOcclusion_HitDistReconstruction_5x5.cs.dxil.h" + #include "REBLUR_Perf_DiffuseSpecularOcclusion_TemporalAccumulation.cs.dxbc.h" + #include "REBLUR_Perf_DiffuseSpecularOcclusion_TemporalAccumulation.cs.dxil.h" + #include "REBLUR_Perf_DiffuseSpecularOcclusion_HistoryFix.cs.dxbc.h" + #include "REBLUR_Perf_DiffuseSpecularOcclusion_HistoryFix.cs.dxil.h" + #include "REBLUR_Perf_DiffuseSpecularOcclusion_Blur.cs.dxbc.h" + #include "REBLUR_Perf_DiffuseSpecularOcclusion_Blur.cs.dxil.h" + #include "REBLUR_Perf_DiffuseSpecularOcclusion_PostBlur_NoTemporalStabilization.cs.dxbc.h" + #include "REBLUR_Perf_DiffuseSpecularOcclusion_PostBlur_NoTemporalStabilization.cs.dxil.h" + #endif + + #include "REBLUR_DiffuseSpecularOcclusion_HitDistReconstruction.cs.spirv.h" + #include "REBLUR_DiffuseSpecularOcclusion_HitDistReconstruction_5x5.cs.spirv.h" + #include "REBLUR_DiffuseSpecularOcclusion_TemporalAccumulation.cs.spirv.h" + #include "REBLUR_DiffuseSpecularOcclusion_HistoryFix.cs.spirv.h" + #include "REBLUR_DiffuseSpecularOcclusion_Blur.cs.spirv.h" + #include "REBLUR_DiffuseSpecularOcclusion_PostBlur_NoTemporalStabilization.cs.spirv.h" + + #include "REBLUR_Perf_DiffuseSpecularOcclusion_HitDistReconstruction.cs.spirv.h" + #include "REBLUR_Perf_DiffuseSpecularOcclusion_HitDistReconstruction_5x5.cs.spirv.h" + #include "REBLUR_Perf_DiffuseSpecularOcclusion_TemporalAccumulation.cs.spirv.h" + #include "REBLUR_Perf_DiffuseSpecularOcclusion_HistoryFix.cs.spirv.h" + #include "REBLUR_Perf_DiffuseSpecularOcclusion_Blur.cs.spirv.h" + #include "REBLUR_Perf_DiffuseSpecularOcclusion_PostBlur_NoTemporalStabilization.cs.spirv.h" + + // REBLUR_DIFFUSE_SPECULAR_SH + #if !NRD_ONLY_SPIRV_SHADERS_AVAILABLE + #include "REBLUR_DiffuseSpecularSh_PrePass.cs.dxbc.h" + #include "REBLUR_DiffuseSpecularSh_PrePass.cs.dxil.h" + #include "REBLUR_DiffuseSpecularSh_TemporalAccumulation.cs.dxbc.h" + #include "REBLUR_DiffuseSpecularSh_TemporalAccumulation.cs.dxil.h" + #include "REBLUR_DiffuseSpecularSh_HistoryFix.cs.dxbc.h" + #include "REBLUR_DiffuseSpecularSh_HistoryFix.cs.dxil.h" + #include "REBLUR_DiffuseSpecularSh_Blur.cs.dxbc.h" + #include "REBLUR_DiffuseSpecularSh_Blur.cs.dxil.h" + #include "REBLUR_DiffuseSpecularSh_CopyStabilizedHistory.cs.dxbc.h" + #include "REBLUR_DiffuseSpecularSh_CopyStabilizedHistory.cs.dxil.h" + #include "REBLUR_DiffuseSpecularSh_TemporalStabilization.cs.dxbc.h" + #include "REBLUR_DiffuseSpecularSh_TemporalStabilization.cs.dxil.h" + #include "REBLUR_DiffuseSpecularSh_PostBlur.cs.dxbc.h" + #include "REBLUR_DiffuseSpecularSh_PostBlur.cs.dxil.h" + #include "REBLUR_DiffuseSpecularSh_PostBlur_NoTemporalStabilization.cs.dxbc.h" + #include "REBLUR_DiffuseSpecularSh_PostBlur_NoTemporalStabilization.cs.dxil.h" + #include "REBLUR_DiffuseSpecularSh_SplitScreen.cs.dxbc.h" + #include "REBLUR_DiffuseSpecularSh_SplitScreen.cs.dxil.h" + + #include "REBLUR_Perf_DiffuseSpecularSh_PrePass.cs.dxbc.h" + #include "REBLUR_Perf_DiffuseSpecularSh_PrePass.cs.dxil.h" + #include "REBLUR_Perf_DiffuseSpecularSh_TemporalAccumulation.cs.dxbc.h" + #include "REBLUR_Perf_DiffuseSpecularSh_TemporalAccumulation.cs.dxil.h" + #include "REBLUR_Perf_DiffuseSpecularSh_HistoryFix.cs.dxbc.h" + #include "REBLUR_Perf_DiffuseSpecularSh_HistoryFix.cs.dxil.h" + #include "REBLUR_Perf_DiffuseSpecularSh_Blur.cs.dxbc.h" + #include "REBLUR_Perf_DiffuseSpecularSh_Blur.cs.dxil.h" + #include "REBLUR_Perf_DiffuseSpecularSh_TemporalStabilization.cs.dxbc.h" + #include "REBLUR_Perf_DiffuseSpecularSh_TemporalStabilization.cs.dxil.h" + #include "REBLUR_Perf_DiffuseSpecularSh_PostBlur.cs.dxbc.h" + #include "REBLUR_Perf_DiffuseSpecularSh_PostBlur.cs.dxil.h" + #include "REBLUR_Perf_DiffuseSpecularSh_PostBlur_NoTemporalStabilization.cs.dxbc.h" + #include "REBLUR_Perf_DiffuseSpecularSh_PostBlur_NoTemporalStabilization.cs.dxil.h" + #endif + + #include "REBLUR_DiffuseSpecularSh_PrePass.cs.spirv.h" + #include "REBLUR_DiffuseSpecularSh_TemporalAccumulation.cs.spirv.h" + #include "REBLUR_DiffuseSpecularSh_HistoryFix.cs.spirv.h" + #include "REBLUR_DiffuseSpecularSh_Blur.cs.spirv.h" + #include "REBLUR_DiffuseSpecularSh_CopyStabilizedHistory.cs.spirv.h" + #include "REBLUR_DiffuseSpecularSh_TemporalStabilization.cs.spirv.h" + #include "REBLUR_DiffuseSpecularSh_PostBlur.cs.spirv.h" + #include "REBLUR_DiffuseSpecularSh_PostBlur_NoTemporalStabilization.cs.spirv.h" + #include "REBLUR_DiffuseSpecularSh_SplitScreen.cs.spirv.h" + + #include "REBLUR_Perf_DiffuseSpecularSh_PrePass.cs.spirv.h" + #include "REBLUR_Perf_DiffuseSpecularSh_TemporalAccumulation.cs.spirv.h" + #include "REBLUR_Perf_DiffuseSpecularSh_HistoryFix.cs.spirv.h" + #include "REBLUR_Perf_DiffuseSpecularSh_Blur.cs.spirv.h" + #include "REBLUR_Perf_DiffuseSpecularSh_TemporalStabilization.cs.spirv.h" + #include "REBLUR_Perf_DiffuseSpecularSh_PostBlur.cs.spirv.h" + #include "REBLUR_Perf_DiffuseSpecularSh_PostBlur_NoTemporalStabilization.cs.spirv.h" + + // REBLUR_DIFFUSE_DIRECTIONAL_OCCLUSION + #if !NRD_ONLY_SPIRV_SHADERS_AVAILABLE + #include "REBLUR_DiffuseDirectionalOcclusion_PrePass.cs.dxbc.h" + #include "REBLUR_DiffuseDirectionalOcclusion_PrePass.cs.dxil.h" + #include "REBLUR_DiffuseDirectionalOcclusion_TemporalAccumulation.cs.dxbc.h" + #include "REBLUR_DiffuseDirectionalOcclusion_TemporalAccumulation.cs.dxil.h" + #include "REBLUR_DiffuseDirectionalOcclusion_HistoryFix.cs.dxbc.h" + #include "REBLUR_DiffuseDirectionalOcclusion_HistoryFix.cs.dxil.h" + #include "REBLUR_DiffuseDirectionalOcclusion_Blur.cs.dxbc.h" + #include "REBLUR_DiffuseDirectionalOcclusion_Blur.cs.dxil.h" + #include "REBLUR_DiffuseDirectionalOcclusion_PostBlur.cs.dxbc.h" + #include "REBLUR_DiffuseDirectionalOcclusion_PostBlur.cs.dxil.h" + #include "REBLUR_DiffuseDirectionalOcclusion_PostBlur_NoTemporalStabilization.cs.dxbc.h" + #include "REBLUR_DiffuseDirectionalOcclusion_PostBlur_NoTemporalStabilization.cs.dxil.h" + #include "REBLUR_DiffuseDirectionalOcclusion_TemporalStabilization.cs.dxbc.h" + #include "REBLUR_DiffuseDirectionalOcclusion_TemporalStabilization.cs.dxil.h" + + #include "REBLUR_Perf_DiffuseDirectionalOcclusion_PrePass.cs.dxbc.h" + #include "REBLUR_Perf_DiffuseDirectionalOcclusion_PrePass.cs.dxil.h" + #include "REBLUR_Perf_DiffuseDirectionalOcclusion_TemporalAccumulation.cs.dxbc.h" + #include "REBLUR_Perf_DiffuseDirectionalOcclusion_TemporalAccumulation.cs.dxil.h" + #include "REBLUR_Perf_DiffuseDirectionalOcclusion_HistoryFix.cs.dxbc.h" + #include "REBLUR_Perf_DiffuseDirectionalOcclusion_HistoryFix.cs.dxil.h" + #include "REBLUR_Perf_DiffuseDirectionalOcclusion_Blur.cs.dxbc.h" + #include "REBLUR_Perf_DiffuseDirectionalOcclusion_Blur.cs.dxil.h" + #include "REBLUR_Perf_DiffuseDirectionalOcclusion_PostBlur.cs.dxbc.h" + #include "REBLUR_Perf_DiffuseDirectionalOcclusion_PostBlur.cs.dxil.h" + #include "REBLUR_Perf_DiffuseDirectionalOcclusion_PostBlur_NoTemporalStabilization.cs.dxbc.h" + #include "REBLUR_Perf_DiffuseDirectionalOcclusion_PostBlur_NoTemporalStabilization.cs.dxil.h" + #include "REBLUR_Perf_DiffuseDirectionalOcclusion_TemporalStabilization.cs.dxbc.h" + #include "REBLUR_Perf_DiffuseDirectionalOcclusion_TemporalStabilization.cs.dxil.h" + #endif + + #include "REBLUR_DiffuseDirectionalOcclusion_PrePass.cs.spirv.h" + #include "REBLUR_DiffuseDirectionalOcclusion_TemporalAccumulation.cs.spirv.h" + #include "REBLUR_DiffuseDirectionalOcclusion_HistoryFix.cs.spirv.h" + #include "REBLUR_DiffuseDirectionalOcclusion_Blur.cs.spirv.h" + #include "REBLUR_DiffuseDirectionalOcclusion_TemporalStabilization.cs.spirv.h" + #include "REBLUR_DiffuseDirectionalOcclusion_PostBlur.cs.spirv.h" + #include "REBLUR_DiffuseDirectionalOcclusion_PostBlur_NoTemporalStabilization.cs.spirv.h" + + #include "REBLUR_Perf_DiffuseDirectionalOcclusion_PrePass.cs.spirv.h" + #include "REBLUR_Perf_DiffuseDirectionalOcclusion_TemporalAccumulation.cs.spirv.h" + #include "REBLUR_Perf_DiffuseDirectionalOcclusion_HistoryFix.cs.spirv.h" + #include "REBLUR_Perf_DiffuseDirectionalOcclusion_Blur.cs.spirv.h" + #include "REBLUR_Perf_DiffuseDirectionalOcclusion_TemporalStabilization.cs.spirv.h" + #include "REBLUR_Perf_DiffuseDirectionalOcclusion_PostBlur.cs.spirv.h" + #include "REBLUR_Perf_DiffuseDirectionalOcclusion_PostBlur_NoTemporalStabilization.cs.spirv.h" + +#endif + +#include "Methods/Reblur_Diffuse.hpp" +#include "Methods/Reblur_DiffuseOcclusion.hpp" +#include "Methods/Reblur_DiffuseSh.hpp" +#include "Methods/Reblur_Specular.hpp" +#include "Methods/Reblur_SpecularOcclusion.hpp" +#include "Methods/Reblur_SpecularSh.hpp" +#include "Methods/Reblur_DiffuseSpecular.hpp" +#include "Methods/Reblur_DiffuseSpecularOcclusion.hpp" +#include "Methods/Reblur_DiffuseSpecularSh.hpp" +#include "Methods/Reblur_DiffuseDirectionalOcclusion.hpp" diff --git a/Source/Relax.cpp b/Source/Relax.cpp new file mode 100644 index 00000000..c1e957d2 --- /dev/null +++ b/Source/Relax.cpp @@ -0,0 +1,335 @@ +/* +Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved. + +NVIDIA CORPORATION and its licensors retain all intellectual property +and proprietary rights in and to this software, related documentation +and any modifications thereto. Any use, reproduction, disclosure or +distribution of this software and related documentation without an express +license agreement from NVIDIA CORPORATION is strictly prohibited. +*/ + +#include "DenoiserImpl.h" + +constexpr uint32_t RELAX_MAX_ATROUS_PASS_NUM = 8; + +#define RELAX_SET_SHARED_CONSTANTS SetSharedConstants(5, 8, 7, 14) + +#define RELAX_ADD_VALIDATION_DISPATCH \ + PushPass("Validation"); \ + { \ + PushInput( AsUint(ResourceType::IN_NORMAL_ROUGHNESS) ); \ + PushInput( AsUint(ResourceType::IN_VIEWZ) ); \ + PushInput( AsUint(ResourceType::IN_MV) ); \ + PushInput( AsUint(Permanent::HISTORY_LENGTH_CURR) ); \ + PushOutput( AsUint(ResourceType::OUT_VALIDATION) ); \ + AddDispatch( RELAX_Validation, SumConstants(1, 0, 1, 1), NumThreads(16, 16), IGNORE_RS ); \ + } + +inline ml::float3 RELAX_GetFrustumForward(const ml::float4x4& viewToWorld, const ml::float4& frustum) +{ + // Note: this vector is not normalized for non-symmetric projections but that's correct. + // It has to have .z coordinate equal to 1.0 to correctly reconstruct world position in shaders. + ml::float4 frustumForwardView = ml::float4(0.5f, 0.5f, 1.0f, 0.0f) * ml::float4(frustum.z, frustum.w, 1.0f, 0.0f) + ml::float4(frustum.x, frustum.y, 0.0f, 0.0f); + ml::float3 frustumForwardWorld = (viewToWorld * frustumForwardView).To3d(); + return frustumForwardWorld; +} + +inline bool RELAX_IsCameraStatic +( + const ml::float3& cameraDelta, + const ml::float3& frustumRight, const ml::float3& frustumUp, const ml::float3& frustumForward, + const ml::float3& prevFrustumRight, const ml::float3& prevFrustumUp, const ml::float3& prevFrustumForward, float eps = ml::c_fEps +) +{ + return ml::Length(cameraDelta) < eps && ml::Length(frustumRight - prevFrustumRight) < eps && ml::Length(frustumUp - prevFrustumUp) < eps && ml::Length(frustumForward - prevFrustumForward) < eps; +} + +void nrd::DenoiserImpl::AddSharedConstants_Relax(const MethodData& methodData, Constant*& data, Method method) +{ + NRD_DECLARE_DIMS; + + // Calculate camera right and up vectors in worldspace scaled according to frustum extents, + // and unit forward vector, for fast worldspace position reconstruction in shaders + float tanHalfFov = 1.0f / m_ViewToClip.a00; + float aspect = m_ViewToClip.a00 / m_ViewToClip.a11; + ml::float3 frustumRight = m_WorldToView.GetRow0().To3d() * tanHalfFov; + ml::float3 frustumUp = m_WorldToView.GetRow1().To3d() * tanHalfFov * aspect; + ml::float3 frustumForward = RELAX_GetFrustumForward(m_ViewToWorld, m_Frustum); + + float prevTanHalfFov = 1.0f / m_ViewToClipPrev.a00; + float prevAspect = m_ViewToClipPrev.a00 / m_ViewToClipPrev.a11; + ml::float3 prevFrustumRight = m_WorldToViewPrev.GetRow0().To3d() * prevTanHalfFov; + ml::float3 prevFrustumUp = m_WorldToViewPrev.GetRow1().To3d() * prevTanHalfFov * prevAspect; + ml::float3 prevFrustumForward = RELAX_GetFrustumForward(m_ViewToWorldPrev, m_FrustumPrev); + + AddFloat4x4(data, m_WorldToClipPrev); + AddFloat4x4(data, m_WorldToViewPrev); + AddFloat4x4(data, m_WorldToClip); + AddFloat4x4(data, m_WorldPrevToWorld); + AddFloat4x4(data, m_ViewToWorld); + + AddFloat4(data, ml::float4(frustumRight.x, frustumRight.y, frustumRight.z, 0)); + AddFloat4(data, ml::float4(frustumUp.x, frustumUp.y, frustumUp.z, 0)); + AddFloat4(data, ml::float4(frustumForward.x, frustumForward.y, frustumForward.z, 0)); + AddFloat4(data, ml::float4(prevFrustumRight.x, prevFrustumRight.y, prevFrustumRight.z, 0)); + AddFloat4(data, ml::float4(prevFrustumUp.x, prevFrustumUp.y, prevFrustumUp.z, 0)); + AddFloat4(data, ml::float4(prevFrustumForward.x, prevFrustumForward.y, prevFrustumForward.z, 0)); + AddFloat4(data, ml::float4(m_CameraDelta.x, m_CameraDelta.y, m_CameraDelta.z, 0.0f)); + AddFloat4(data, ml::float4(m_CommonSettings.motionVectorScale[0], m_CommonSettings.motionVectorScale[1], m_CommonSettings.motionVectorScale[2], m_CommonSettings.debug)); + + AddFloat2(data, float(rectW) / float(screenW), float(rectH) / float(screenH)); + AddUint2(data, m_CommonSettings.inputSubrectOrigin[0], m_CommonSettings.inputSubrectOrigin[1]); + + AddFloat2(data, float(m_CommonSettings.inputSubrectOrigin[0]) / float(screenW), float(m_CommonSettings.inputSubrectOrigin[1]) / float(screenH)); + AddUint2(data, rectW, rectH); + + AddFloat2(data, 1.0f / screenW, 1.0f / screenH); + AddFloat2(data, 1.0f / rectW, 1.0f / rectH); + + AddFloat2(data, float(rectWprev), float(rectHprev)); + AddUint(data, m_CommonSettings.isMotionVectorInWorldSpace ? 1 : 0); + AddFloat(data, m_IsOrtho); + + AddFloat(data, 1.0f / (0.5f * rectH * m_ProjectY)); + AddUint(data, m_CommonSettings.frameIndex); + AddFloat(data, m_CommonSettings.denoisingRange); + AddFloat(data, ml::Clamp(16.66f / m_TimeDelta, 0.25f, 4.0f)); // Normalizing to 60 FPS + + AddFloat(data, m_CheckerboardResolveAccumSpeed); + AddFloat(data, m_JitterDelta); + switch (method) + { + case Method::RELAX_DIFFUSE: + case Method::RELAX_DIFFUSE_SH: + AddUint(data, methodData.settings.diffuseRelax.enableMaterialTest ? 1 : 0); + AddUint(data, 0); + break; + case Method::RELAX_SPECULAR: + case Method::RELAX_SPECULAR_SH: + AddUint(data, 0); + AddUint(data, methodData.settings.specularRelax.enableMaterialTest ? 1 : 0); + break; + case Method::RELAX_DIFFUSE_SPECULAR: + case Method::RELAX_DIFFUSE_SPECULAR_SH: + AddUint(data, methodData.settings.diffuseSpecularRelax.enableMaterialTestForDiffuse ? 1 : 0); + AddUint(data, methodData.settings.diffuseSpecularRelax.enableMaterialTestForSpecular ? 1 : 0); + break; + default: + // Should never get here + AddUint(data, 0); + AddUint(data, 0); + break; + } + + // 1 if m_WorldPrevToWorld should be used in shader, otherwise we can skip multiplication + AddUint(data, (m_WorldPrevToWorld != ml::float4x4::Identity()) ? 1 : 0); + AddUint(data, m_CommonSettings.accumulationMode != AccumulationMode::CONTINUE ? 1 : 0); + AddUint(data, 0); + AddUint(data, 0); +} + +#ifdef NRD_USE_PRECOMPILED_SHADERS + + // RELAX_DIFFUSE + #if !NRD_ONLY_SPIRV_SHADERS_AVAILABLE + #include "RELAX_Diffuse_HitDistReconstruction.cs.dxbc.h" + #include "RELAX_Diffuse_HitDistReconstruction.cs.dxil.h" + #include "RELAX_Diffuse_HitDistReconstruction_5x5.cs.dxbc.h" + #include "RELAX_Diffuse_HitDistReconstruction_5x5.cs.dxil.h" + #include "RELAX_Diffuse_PrePass.cs.dxbc.h" + #include "RELAX_Diffuse_PrePass.cs.dxil.h" + #include "RELAX_Diffuse_TemporalAccumulation.cs.dxbc.h" + #include "RELAX_Diffuse_TemporalAccumulation.cs.dxil.h" + #include "RELAX_Diffuse_HistoryFix.cs.dxbc.h" + #include "RELAX_Diffuse_HistoryFix.cs.dxil.h" + #include "RELAX_Diffuse_HistoryClamping.cs.dxbc.h" + #include "RELAX_Diffuse_HistoryClamping.cs.dxil.h" + #include "RELAX_Diffuse_AntiFirefly.cs.dxbc.h" + #include "RELAX_Diffuse_AntiFirefly.cs.dxil.h" + #include "RELAX_Diffuse_AtrousSmem.cs.dxbc.h" + #include "RELAX_Diffuse_AtrousSmem.cs.dxil.h" + #include "RELAX_Diffuse_Atrous.cs.dxbc.h" + #include "RELAX_Diffuse_Atrous.cs.dxil.h" + #include "RELAX_Diffuse_SplitScreen.cs.dxbc.h" + #include "RELAX_Diffuse_SplitScreen.cs.dxil.h" + #include "RELAX_Validation.cs.dxbc.h" + #include "RELAX_Validation.cs.dxil.h" + #endif + + #include "RELAX_Diffuse_HitDistReconstruction.cs.spirv.h" + #include "RELAX_Diffuse_HitDistReconstruction_5x5.cs.spirv.h" + #include "RELAX_Diffuse_PrePass.cs.spirv.h" + #include "RELAX_Diffuse_TemporalAccumulation.cs.spirv.h" + #include "RELAX_Diffuse_HistoryFix.cs.spirv.h" + #include "RELAX_Diffuse_HistoryClamping.cs.spirv.h" + #include "RELAX_Diffuse_AntiFirefly.cs.spirv.h" + #include "RELAX_Diffuse_AtrousSmem.cs.spirv.h" + #include "RELAX_Diffuse_Atrous.cs.spirv.h" + #include "RELAX_Diffuse_SplitScreen.cs.spirv.h" + #include "RELAX_Validation.cs.spirv.h" + + // RELAX_DIFFUSE_SH + #if !NRD_ONLY_SPIRV_SHADERS_AVAILABLE + #include "RELAX_DiffuseSh_PrePass.cs.dxbc.h" + #include "RELAX_DiffuseSh_PrePass.cs.dxil.h" + #include "RELAX_DiffuseSh_TemporalAccumulation.cs.dxbc.h" + #include "RELAX_DiffuseSh_TemporalAccumulation.cs.dxil.h" + #include "RELAX_DiffuseSh_HistoryFix.cs.dxbc.h" + #include "RELAX_DiffuseSh_HistoryFix.cs.dxil.h" + #include "RELAX_DiffuseSh_HistoryClamping.cs.dxbc.h" + #include "RELAX_DiffuseSh_HistoryClamping.cs.dxil.h" + #include "RELAX_DiffuseSh_AntiFirefly.cs.dxbc.h" + #include "RELAX_DiffuseSh_AntiFirefly.cs.dxil.h" + #include "RELAX_DiffuseSh_AtrousSmem.cs.dxbc.h" + #include "RELAX_DiffuseSh_AtrousSmem.cs.dxil.h" + #include "RELAX_DiffuseSh_Atrous.cs.dxbc.h" + #include "RELAX_DiffuseSh_Atrous.cs.dxil.h" + #include "RELAX_DiffuseSh_SplitScreen.cs.dxbc.h" + #include "RELAX_DiffuseSh_SplitScreen.cs.dxil.h" + #endif + + #include "RELAX_DiffuseSh_PrePass.cs.spirv.h" + #include "RELAX_DiffuseSh_TemporalAccumulation.cs.spirv.h" + #include "RELAX_DiffuseSh_HistoryFix.cs.spirv.h" + #include "RELAX_DiffuseSh_HistoryClamping.cs.spirv.h" + #include "RELAX_DiffuseSh_AntiFirefly.cs.spirv.h" + #include "RELAX_DiffuseSh_AtrousSmem.cs.spirv.h" + #include "RELAX_DiffuseSh_Atrous.cs.spirv.h" + #include "RELAX_DiffuseSh_SplitScreen.cs.spirv.h" + + // RELAX_SPECULAR + #if !NRD_ONLY_SPIRV_SHADERS_AVAILABLE + #include "RELAX_Specular_HitDistReconstruction.cs.dxbc.h" + #include "RELAX_Specular_HitDistReconstruction.cs.dxil.h" + #include "RELAX_Specular_HitDistReconstruction_5x5.cs.dxbc.h" + #include "RELAX_Specular_HitDistReconstruction_5x5.cs.dxil.h" + #include "RELAX_Specular_PrePass.cs.dxbc.h" + #include "RELAX_Specular_PrePass.cs.dxil.h" + #include "RELAX_Specular_TemporalAccumulation.cs.dxbc.h" + #include "RELAX_Specular_TemporalAccumulation.cs.dxil.h" + #include "RELAX_Specular_HistoryFix.cs.dxbc.h" + #include "RELAX_Specular_HistoryFix.cs.dxil.h" + #include "RELAX_Specular_HistoryClamping.cs.dxbc.h" + #include "RELAX_Specular_HistoryClamping.cs.dxil.h" + #include "RELAX_Specular_AntiFirefly.cs.dxbc.h" + #include "RELAX_Specular_AntiFirefly.cs.dxil.h" + #include "RELAX_Specular_AtrousSmem.cs.dxbc.h" + #include "RELAX_Specular_AtrousSmem.cs.dxil.h" + #include "RELAX_Specular_Atrous.cs.dxbc.h" + #include "RELAX_Specular_Atrous.cs.dxil.h" + #include "RELAX_Specular_SplitScreen.cs.dxbc.h" + #include "RELAX_Specular_SplitScreen.cs.dxil.h" + #endif + + #include "RELAX_Specular_HitDistReconstruction.cs.spirv.h" + #include "RELAX_Specular_HitDistReconstruction_5x5.cs.spirv.h" + #include "RELAX_Specular_PrePass.cs.spirv.h" + #include "RELAX_Specular_TemporalAccumulation.cs.spirv.h" + #include "RELAX_Specular_HistoryFix.cs.spirv.h" + #include "RELAX_Specular_HistoryClamping.cs.spirv.h" + #include "RELAX_Specular_AntiFirefly.cs.spirv.h" + #include "RELAX_Specular_AtrousSmem.cs.spirv.h" + #include "RELAX_Specular_Atrous.cs.spirv.h" + #include "RELAX_Specular_SplitScreen.cs.spirv.h" + + // RELAX_SPECULAR_SH + #if !NRD_ONLY_SPIRV_SHADERS_AVAILABLE + #include "RELAX_SpecularSh_PrePass.cs.dxbc.h" + #include "RELAX_SpecularSh_PrePass.cs.dxil.h" + #include "RELAX_SpecularSh_TemporalAccumulation.cs.dxbc.h" + #include "RELAX_SpecularSh_TemporalAccumulation.cs.dxil.h" + #include "RELAX_SpecularSh_HistoryFix.cs.dxbc.h" + #include "RELAX_SpecularSh_HistoryFix.cs.dxil.h" + #include "RELAX_SpecularSh_HistoryClamping.cs.dxbc.h" + #include "RELAX_SpecularSh_HistoryClamping.cs.dxil.h" + #include "RELAX_SpecularSh_AntiFirefly.cs.dxbc.h" + #include "RELAX_SpecularSh_AntiFirefly.cs.dxil.h" + #include "RELAX_SpecularSh_AtrousSmem.cs.dxbc.h" + #include "RELAX_SpecularSh_AtrousSmem.cs.dxil.h" + #include "RELAX_SpecularSh_Atrous.cs.dxbc.h" + #include "RELAX_SpecularSh_Atrous.cs.dxil.h" + #include "RELAX_SpecularSh_SplitScreen.cs.dxbc.h" + #include "RELAX_SpecularSh_SplitScreen.cs.dxil.h" + #endif + + #include "RELAX_SpecularSh_PrePass.cs.spirv.h" + #include "RELAX_SpecularSh_TemporalAccumulation.cs.spirv.h" + #include "RELAX_SpecularSh_HistoryFix.cs.spirv.h" + #include "RELAX_SpecularSh_HistoryClamping.cs.spirv.h" + #include "RELAX_SpecularSh_AntiFirefly.cs.spirv.h" + #include "RELAX_SpecularSh_AtrousSmem.cs.spirv.h" + #include "RELAX_SpecularSh_Atrous.cs.spirv.h" + #include "RELAX_SpecularSh_SplitScreen.cs.spirv.h" + + // RELAX_DIFFUSE_SPECULAR + #if !NRD_ONLY_SPIRV_SHADERS_AVAILABLE + #include "RELAX_DiffuseSpecular_HitDistReconstruction.cs.dxbc.h" + #include "RELAX_DiffuseSpecular_HitDistReconstruction.cs.dxil.h" + #include "RELAX_DiffuseSpecular_HitDistReconstruction_5x5.cs.dxbc.h" + #include "RELAX_DiffuseSpecular_HitDistReconstruction_5x5.cs.dxil.h" + #include "RELAX_DiffuseSpecular_PrePass.cs.dxbc.h" + #include "RELAX_DiffuseSpecular_PrePass.cs.dxil.h" + #include "RELAX_DiffuseSpecular_TemporalAccumulation.cs.dxbc.h" + #include "RELAX_DiffuseSpecular_TemporalAccumulation.cs.dxil.h" + #include "RELAX_DiffuseSpecular_HistoryFix.cs.dxbc.h" + #include "RELAX_DiffuseSpecular_HistoryFix.cs.dxil.h" + #include "RELAX_DiffuseSpecular_HistoryClamping.cs.dxbc.h" + #include "RELAX_DiffuseSpecular_HistoryClamping.cs.dxil.h" + #include "RELAX_DiffuseSpecular_AntiFirefly.cs.dxbc.h" + #include "RELAX_DiffuseSpecular_AntiFirefly.cs.dxil.h" + #include "RELAX_DiffuseSpecular_AtrousSmem.cs.dxbc.h" + #include "RELAX_DiffuseSpecular_AtrousSmem.cs.dxil.h" + #include "RELAX_DiffuseSpecular_Atrous.cs.dxbc.h" + #include "RELAX_DiffuseSpecular_Atrous.cs.dxil.h" + #include "RELAX_DiffuseSpecular_SplitScreen.cs.dxbc.h" + #include "RELAX_DiffuseSpecular_SplitScreen.cs.dxil.h" + #endif + + #include "RELAX_DiffuseSpecular_HitDistReconstruction.cs.spirv.h" + #include "RELAX_DiffuseSpecular_HitDistReconstruction_5x5.cs.spirv.h" + #include "RELAX_DiffuseSpecular_PrePass.cs.spirv.h" + #include "RELAX_DiffuseSpecular_TemporalAccumulation.cs.spirv.h" + #include "RELAX_DiffuseSpecular_HistoryFix.cs.spirv.h" + #include "RELAX_DiffuseSpecular_HistoryClamping.cs.spirv.h" + #include "RELAX_DiffuseSpecular_AntiFirefly.cs.spirv.h" + #include "RELAX_DiffuseSpecular_AtrousSmem.cs.spirv.h" + #include "RELAX_DiffuseSpecular_Atrous.cs.spirv.h" + #include "RELAX_DiffuseSpecular_SplitScreen.cs.spirv.h" + + // RELAX_DIFFUSE_SPECULAR_SH + #if !NRD_ONLY_SPIRV_SHADERS_AVAILABLE + #include "RELAX_DiffuseSpecularSh_PrePass.cs.dxbc.h" + #include "RELAX_DiffuseSpecularSh_PrePass.cs.dxil.h" + #include "RELAX_DiffuseSpecularSh_TemporalAccumulation.cs.dxbc.h" + #include "RELAX_DiffuseSpecularSh_TemporalAccumulation.cs.dxil.h" + #include "RELAX_DiffuseSpecularSh_HistoryFix.cs.dxbc.h" + #include "RELAX_DiffuseSpecularSh_HistoryFix.cs.dxil.h" + #include "RELAX_DiffuseSpecularSh_HistoryClamping.cs.dxbc.h" + #include "RELAX_DiffuseSpecularSh_HistoryClamping.cs.dxil.h" + #include "RELAX_DiffuseSpecularSh_AntiFirefly.cs.dxbc.h" + #include "RELAX_DiffuseSpecularSh_AntiFirefly.cs.dxil.h" + #include "RELAX_DiffuseSpecularSh_AtrousSmem.cs.dxbc.h" + #include "RELAX_DiffuseSpecularSh_AtrousSmem.cs.dxil.h" + #include "RELAX_DiffuseSpecularSh_Atrous.cs.dxbc.h" + #include "RELAX_DiffuseSpecularSh_Atrous.cs.dxil.h" + #include "RELAX_DiffuseSpecularSh_SplitScreen.cs.dxbc.h" + #include "RELAX_DiffuseSpecularSh_SplitScreen.cs.dxil.h" + #endif + + #include "RELAX_DiffuseSpecularSh_PrePass.cs.spirv.h" + #include "RELAX_DiffuseSpecularSh_TemporalAccumulation.cs.spirv.h" + #include "RELAX_DiffuseSpecularSh_HistoryFix.cs.spirv.h" + #include "RELAX_DiffuseSpecularSh_HistoryClamping.cs.spirv.h" + #include "RELAX_DiffuseSpecularSh_AntiFirefly.cs.spirv.h" + #include "RELAX_DiffuseSpecularSh_AtrousSmem.cs.spirv.h" + #include "RELAX_DiffuseSpecularSh_Atrous.cs.spirv.h" + #include "RELAX_DiffuseSpecularSh_SplitScreen.cs.spirv.h" + +#endif + +#include "Methods/Relax_Diffuse.hpp" +#include "Methods/Relax_DiffuseSh.hpp" +#include "Methods/Relax_Specular.hpp" +#include "Methods/Relax_SpecularSh.hpp" +#include "Methods/Relax_DiffuseSpecular.hpp" +#include "Methods/Relax_DiffuseSpecularSh.hpp" diff --git a/Source/Sigma.cpp b/Source/Sigma.cpp new file mode 100644 index 00000000..14cf97d1 --- /dev/null +++ b/Source/Sigma.cpp @@ -0,0 +1,185 @@ +/* +Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved. + +NVIDIA CORPORATION and its licensors retain all intellectual property +and proprietary rights in and to this software, related documentation +and any modifications thereto. Any use, reproduction, disclosure or +distribution of this software and related documentation without an express +license agreement from NVIDIA CORPORATION is strictly prohibited. +*/ + +#include "DenoiserImpl.h" + +#define SIGMA_SET_SHARED_CONSTANTS SetSharedConstants(1, 2, 8, 8) + +#define SIGMA_CLASSIFY_TILES_SET_CONSTANTS SumConstants(0, 0, 0, 0) +#define SIGMA_CLASSIFY_TILES_NUM_THREADS NumThreads(1, 1) + +#define SIGMA_SMOOTH_TILES_SET_CONSTANTS SumConstants(0, 0, 1, 0) +#define SIGMA_SMOOTH_TILES_NUM_THREADS NumThreads(16, 16) + +#define SIGMA_BLUR_SET_CONSTANTS SumConstants(1, 1, 0, 0) +#define SIGMA_BLUR_NUM_THREADS NumThreads(16, 16) + +#define SIGMA_TEMPORAL_STABILIZATION_SET_CONSTANTS SumConstants(2, 0, 0, 0) +#define SIGMA_TEMPORAL_STABILIZATION_NUM_THREADS NumThreads(16, 16) + +#define SIGMA_SPLIT_SCREEN_SET_CONSTANTS SumConstants(0, 0, 0, 1) +#define SIGMA_SPLIT_SCREEN_NUM_THREADS NumThreads(16, 16) + +void nrd::DenoiserImpl::UpdateMethod_SigmaShadow(const MethodData& methodData) +{ + enum class Dispatch + { + CLASSIFY_TILES, + SMOOTH_TILES, + BLUR, + POST_BLUR, + TEMPORAL_STABILIZATION, + SPLIT_SCREEN, + }; + + const SigmaSettings& settings = methodData.settings.sigma; + + NRD_DECLARE_DIMS; + + uint16_t tilesW = DivideUp(rectW, 16); + uint16_t tilesH = DivideUp(rectH, 16); + + // SPLIT_SCREEN (passthrough) + if (m_CommonSettings.splitScreen >= 1.0f) + { + Constant* data = PushDispatch(methodData, AsUint(Dispatch::SPLIT_SCREEN)); + AddSharedConstants_Sigma(methodData, settings, data); + AddFloat(data, m_CommonSettings.splitScreen); + ValidateConstants(data); + + return; + } + + // CLASSIFY_TILES + Constant* data = PushDispatch(methodData, AsUint(Dispatch::CLASSIFY_TILES)); + AddSharedConstants_Sigma(methodData, settings, data); + ValidateConstants(data); + + // SMOOTH_TILES + data = PushDispatch(methodData, AsUint(Dispatch::SMOOTH_TILES)); + AddSharedConstants_Sigma(methodData, settings, data); + AddUint2(data, tilesW, tilesH); + ValidateConstants(data); + + // BLUR + data = PushDispatch(methodData, AsUint(Dispatch::BLUR)); + AddSharedConstants_Sigma(methodData, settings, data); + AddFloat4x4(data, m_WorldToView); + AddFloat4(data, m_Rotator_Blur); + ValidateConstants(data); + + // POST_BLUR + data = PushDispatch(methodData, AsUint(Dispatch::POST_BLUR)); + AddSharedConstants_Sigma(methodData, settings, data); + AddFloat4x4(data, m_WorldToView); + AddFloat4(data, m_Rotator_PostBlur); + ValidateConstants(data); + + // TEMPORAL_STABILIZATION + data = PushDispatch(methodData, AsUint(Dispatch::TEMPORAL_STABILIZATION)); + AddSharedConstants_Sigma(methodData, settings, data); + AddFloat4x4(data, m_WorldToClipPrev); + AddFloat4x4(data, m_ViewToWorld); + ValidateConstants(data); + + // SPLIT_SCREEN + if (m_CommonSettings.splitScreen > 0.0f) + { + data = PushDispatch(methodData, AsUint(Dispatch::SPLIT_SCREEN)); + AddSharedConstants_Sigma(methodData, settings, data); + AddFloat(data, m_CommonSettings.splitScreen); + ValidateConstants(data); + } +} + +void nrd::DenoiserImpl::AddSharedConstants_Sigma(const MethodData& methodData, const SigmaSettings& settings, Constant*& data) +{ + NRD_DECLARE_DIMS; + + // Even with DRS keep radius, it works well for shadows + float unproject = 1.0f / (0.5f * screenH * m_ProjectY); + + AddFloat4x4(data, m_ViewToClip); + + AddFloat4(data, m_Frustum); + AddFloat4(data, ml::float4(m_CommonSettings.motionVectorScale[0], m_CommonSettings.motionVectorScale[1], m_CommonSettings.motionVectorScale[2], m_CommonSettings.debug)); + + AddFloat2(data, 1.0f / float(screenW), 1.0f / float(screenH)); + AddFloat2(data, float(screenW), float(screenH)); + + AddFloat2(data, 1.0f / float(rectW), 1.0f / float(rectH)); + AddFloat2(data, float(rectW), float(rectH)); + + AddFloat2(data, float(rectWprev), float(rectHprev)); + AddFloat2(data, float(rectW) / float(screenW), float(rectH) / float(screenH)); + + AddFloat2(data, float(m_CommonSettings.inputSubrectOrigin[0]) / float(screenW), float(m_CommonSettings.inputSubrectOrigin[1]) / float(screenH)); + AddUint2(data, m_CommonSettings.inputSubrectOrigin[0], m_CommonSettings.inputSubrectOrigin[1]); + + AddFloat(data, m_IsOrtho); + AddFloat(data, unproject); + AddFloat(data, m_CommonSettings.denoisingRange); + AddFloat(data, settings.planeDistanceSensitivity); + + AddFloat(data, settings.blurRadiusScale); + AddFloat(data, m_CommonSettings.accumulationMode != AccumulationMode::CONTINUE ? 0.0f : 1.0f); + AddUint(data, m_CommonSettings.isMotionVectorInWorldSpace ? 1 : 0); + AddUint(data, m_CommonSettings.frameIndex); +} + +#ifdef NRD_USE_PRECOMPILED_SHADERS + + // SIGMA_SHADOW + #if !NRD_ONLY_SPIRV_SHADERS_AVAILABLE + #include "SIGMA_Shadow_ClassifyTiles.cs.dxbc.h" + #include "SIGMA_Shadow_ClassifyTiles.cs.dxil.h" + #include "SIGMA_Shadow_SmoothTiles.cs.dxbc.h" + #include "SIGMA_Shadow_SmoothTiles.cs.dxil.h" + #include "SIGMA_Shadow_Blur.cs.dxbc.h" + #include "SIGMA_Shadow_Blur.cs.dxil.h" + #include "SIGMA_Shadow_PostBlur.cs.dxbc.h" + #include "SIGMA_Shadow_PostBlur.cs.dxil.h" + #include "SIGMA_Shadow_TemporalStabilization.cs.dxbc.h" + #include "SIGMA_Shadow_TemporalStabilization.cs.dxil.h" + #include "SIGMA_Shadow_SplitScreen.cs.dxbc.h" + #include "SIGMA_Shadow_SplitScreen.cs.dxil.h" + #endif + + #include "SIGMA_Shadow_ClassifyTiles.cs.spirv.h" + #include "SIGMA_Shadow_SmoothTiles.cs.spirv.h" + #include "SIGMA_Shadow_Blur.cs.spirv.h" + #include "SIGMA_Shadow_PostBlur.cs.spirv.h" + #include "SIGMA_Shadow_TemporalStabilization.cs.spirv.h" + #include "SIGMA_Shadow_SplitScreen.cs.spirv.h" + + // SIGMA_SHADOW_TRANSLUCENCY + #if !NRD_ONLY_SPIRV_SHADERS_AVAILABLE + #include "SIGMA_ShadowTranslucency_ClassifyTiles.cs.dxbc.h" + #include "SIGMA_ShadowTranslucency_ClassifyTiles.cs.dxil.h" + #include "SIGMA_ShadowTranslucency_Blur.cs.dxbc.h" + #include "SIGMA_ShadowTranslucency_Blur.cs.dxil.h" + #include "SIGMA_ShadowTranslucency_PostBlur.cs.dxbc.h" + #include "SIGMA_ShadowTranslucency_PostBlur.cs.dxil.h" + #include "SIGMA_ShadowTranslucency_TemporalStabilization.cs.dxbc.h" + #include "SIGMA_ShadowTranslucency_TemporalStabilization.cs.dxil.h" + #include "SIGMA_ShadowTranslucency_SplitScreen.cs.dxbc.h" + #include "SIGMA_ShadowTranslucency_SplitScreen.cs.dxil.h" + #endif + + #include "SIGMA_ShadowTranslucency_ClassifyTiles.cs.spirv.h" + #include "SIGMA_ShadowTranslucency_Blur.cs.spirv.h" + #include "SIGMA_ShadowTranslucency_PostBlur.cs.spirv.h" + #include "SIGMA_ShadowTranslucency_TemporalStabilization.cs.spirv.h" + #include "SIGMA_ShadowTranslucency_SplitScreen.cs.spirv.h" + +#endif + +#include "Methods/Sigma_Shadow.hpp" +#include "Methods/Sigma_ShadowTranslucency.hpp" diff --git a/Source/Wrapper.cpp b/Source/Wrapper.cpp index ecee6117..c2830b9e 100644 --- a/Source/Wrapper.cpp +++ b/Source/Wrapper.cpp @@ -33,8 +33,11 @@ constexpr std::array g_NrdSupportedMe nrd::Method::SIGMA_SHADOW, nrd::Method::SIGMA_SHADOW_TRANSLUCENCY, nrd::Method::RELAX_DIFFUSE, + nrd::Method::RELAX_DIFFUSE_SH, nrd::Method::RELAX_SPECULAR, + nrd::Method::RELAX_SPECULAR_SH, nrd::Method::RELAX_DIFFUSE_SPECULAR, + nrd::Method::RELAX_DIFFUSE_SPECULAR_SH, nrd::Method::REFERENCE, nrd::Method::SPECULAR_REFLECTION_MV, nrd::Method::SPECULAR_DELTA_MV @@ -114,8 +117,11 @@ const char* g_NrdMethodNames[] = "SIGMA_SHADOW_TRANSLUCENCY", "RELAX_DIFFUSE", + "RELAX_DIFFUSE_SH", "RELAX_SPECULAR", + "RELAX_SPECULAR_SH", "RELAX_DIFFUSE_SPECULAR", + "RELAX_DIFFUSE_SPECULAR_SH", "REFERENCE", @@ -211,7 +217,7 @@ NRD_API nrd::Result NRD_CALL nrd::CreateDenoiser(const DenoiserCreationDesc& den "license agreement from NVIDIA CORPORATION is strictly prohibited.\n" "*/\n" "\n" - "#include \"../Include/NRD.hlsli\"\n" + "#include \"NRD.hlsli\"\n" "#include \"STL.hlsli\"\n" "\n" "%s" @@ -219,18 +225,18 @@ NRD_API nrd::Result NRD_CALL nrd::CreateDenoiser(const DenoiserCreationDesc& den "%s" "%s" "\n" - "#include \"../Include/REBLUR/REBLUR_Config.hlsli\"\n" - "#include \"../Resources/REBLUR_DiffuseSpecular_%s.resources.hlsli\"\n" + "#include \"REBLUR/REBLUR_Config.hlsli\"\n" + "#include \"REBLUR_DiffuseSpecular_%s.resources.hlsli\"\n" "\n" - "#include \"../Include/Common.hlsli\"\n" + "#include \"Common.hlsli\"\n" "%s" - "#include \"../Include/REBLUR/REBLUR_DiffuseSpecular_%s.hlsli\"\n", + "#include \"REBLUR/REBLUR_DiffuseSpecular_%s.hlsli\"\n", perf == 0 ? "" : "#define REBLUR_PERFORMANCE_MODE\n", typeMacros[type], permutationMacros[permutation], passPermutation == 0 ? "" : passPermutationMacros[pass], passNames[pass], - pass == 6 ? "" : "#include \"../Include/REBLUR/REBLUR_Common.hlsli\"\n", + pass == 6 ? "" : "#include \"REBLUR/REBLUR_Common.hlsli\"\n", passNames[pass] ); fclose(fp); diff --git a/UPDATE.md b/UPDATE.md index 2824aaf9..9416e10d 100644 --- a/UPDATE.md +++ b/UPDATE.md @@ -143,4 +143,16 @@ Since *NRD* tracks specular motion, now, if requested, it can modify provided *d - *REBLUR*: - Exposed `specularProbabilityThresholdsForMvModification` to control diffuse / specular motion mixing - *RELAX*: - - Removed `enableSpecularVirtualHistoryClamping` \ No newline at end of file + - Removed `enableSpecularVirtualHistoryClamping` + +## To v4.1 + +SH (spherical harmonics) have been replaced with SG (spherical gaussians). It unlocks physically-based high quality diffuse & specular resolve. The following functions have been added to `NRD.hlsli` (or renamed): +- `NRD_SG_ExtractColor` - extracts unresolved denoised radiance +- `NRD_SG_ExtractDirection` - extracts light dominant direction +- `NRD_SG_ExtractRoughnessAA` - extracts modified roughness (increased in areas with high normal variance) +- `NRD_SG_ResolveDiffuse` - reconstructs diffuse macro details +- `NRD_SG_ResolveSpecular` - reconstructs specular macro details +- `NRD_SG_ReJitter` - reconstructs diffuse & specular micro details (resurrects jitter vanished out after denoising) +- `NRD_SH_ResolveDiffuse` - reconstructs diffuse macro details using SH resolve (for comparison only) +- `NRD_SH_ResolveSpecular` - reconstructs specular macro details using SH resolve (for comparison only) \ No newline at end of file