694 lines
24 KiB
Plaintext
694 lines
24 KiB
Plaintext
Shader "Hidden/Screen Space Path Tracing GBufferExtract"
|
|
{
|
|
Properties
|
|
{
|
|
[HideInInspector] _Seed("Private: Random Seed", Float) = 0.0
|
|
[HideInInspector] [IntRange] _MaxSteps("Maximum Steps", Range(24, 64)) = 32
|
|
[HideInInspector] _StepSize("Step Size", Range(0.01, 1)) = 0.3
|
|
[HideInInspector] [IntRange] _MaxBounce("Maximum Bounces", Range(1, 16)) = 4
|
|
[HideInInspector] [IntRange] _RayCount("Samples Per Pixel", Range(1, 16)) = 1
|
|
[HideInInspector] _MaxBrightness("Maximum Brightness", Float) = 10
|
|
|
|
[Toggle] _Dithering("Dithering", Float) = 1
|
|
_Dither_Intensity("Intensity", Range(0.01, 2)) = 1.5
|
|
[Toggle(_IGNORE_FORWARD_OBJECTS)]_IGNORE_FORWARD_OBJECTS("Ignore Deferred 0 smoothness", Float) = 0
|
|
|
|
[NoScaleOffset] _OwenScrambledTexture("Owen Scrambled Texture", 2D) = "black" {}
|
|
[NoScaleOffset] _ScramblingTileXSPP("Scrambling Tile XSPP", 2D) = "black" {}
|
|
[NoScaleOffset] _RankingTileXSPP("Ranking Tile XSPP", 2D) = "black" {}
|
|
|
|
[HideInInspector] _TemporalIntensity("Private: Temporal Intensity", Float) = 0.93
|
|
[HideInInspector] _Sample("Current Sample", Float) = 0.0
|
|
[HideInInspector] _MaxSample("Maximum Sample", Float) = 64.0
|
|
}
|
|
|
|
SubShader
|
|
{
|
|
Cull Off ZWrite Off ZTest Always
|
|
|
|
Pass
|
|
{
|
|
Name "Screen Space Path Tracing"
|
|
Tags { "LightMode" = "Screen Space Path Tracing" }
|
|
|
|
Blend One Zero
|
|
|
|
HLSLPROGRAM
|
|
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
|
|
// The Blit.hlsl file provides the vertex shader (Vert),
|
|
// input structure (Attributes) and output strucutre (Varyings)
|
|
#include "Packages/com.unity.render-pipelines.core/Runtime/Utilities/Blit.hlsl"
|
|
|
|
#pragma vertex Vert
|
|
#pragma fragment frag
|
|
|
|
#pragma target 3.5
|
|
|
|
#pragma multi_compile_local_fragment _ _TEMPORAL_ACCUMULATION
|
|
#pragma multi_compile_local_fragment _METHOD_HASHED_RANDOM _METHOD_BLUE_NOISE
|
|
#pragma multi_compile_local_fragment _ _FP_REFL_PROBE_ATLAS
|
|
#pragma multi_compile_local_fragment _ _SUPPORT_REFRACTION
|
|
#pragma multi_compile_local_fragment _ _BACKFACE_TEXTURES
|
|
|
|
#pragma shader_feature_local_fragment _ _IGNORE_FORWARD_OBJECTS
|
|
|
|
#pragma multi_compile_fragment _ _GBUFFER_NORMALS_OCT
|
|
|
|
CBUFFER_START(UnityPerMaterial)
|
|
half _MaxSteps;
|
|
half _StepSize;
|
|
half _MaxBounce;
|
|
half _RayCount;
|
|
half _Dither_Intensity;
|
|
half _Dithering;
|
|
float _Seed;
|
|
half _TemporalIntensity;
|
|
half _Sample;
|
|
half _MaxSample;
|
|
half _MaxBrightness;
|
|
CBUFFER_END
|
|
|
|
#ifdef _METHOD_BLUE_NOISE
|
|
TEXTURE2D(_OwenScrambledTexture);
|
|
//SAMPLER(sampler_OwenScrambledTexture);
|
|
TEXTURE2D(_ScramblingTileXSPP);
|
|
//SAMPLER(sampler_ScramblingTileXSPP);
|
|
TEXTURE2D(_RankingTileXSPP);
|
|
//SAMPLER(sampler_RankingTileXSPP);
|
|
float4 _OwenScrambledTexture_TexelSize;
|
|
float4 _ScramblingTileXSPP_TexelSize;
|
|
float4 _RankingTileXSPP_TexelSize;
|
|
#endif
|
|
|
|
#ifndef _FP_REFL_PROBE_ATLAS
|
|
TEXTURECUBE(_SpecCube0);
|
|
SAMPLER(sampler_SpecCube0);
|
|
float4 _SpecCube0_ProbePosition;
|
|
float3 _SpecCube0_BoxMin;
|
|
float3 _SpecCube0_BoxMax;
|
|
half4 _SpecCube0_HDR;
|
|
TEXTURECUBE(_SpecCube1);
|
|
SAMPLER(sampler_SpecCube1);
|
|
float4 _SpecCube1_ProbePosition;
|
|
float3 _SpecCube1_BoxMin;
|
|
float3 _SpecCube1_BoxMax;
|
|
half4 _SpecCube1_HDR;
|
|
half _ProbeWeight;
|
|
half _ProbeSet;
|
|
#endif
|
|
|
|
half _BackDepthEnabled;
|
|
half _IsProbeCamera;
|
|
|
|
// URP pre-defined the following variable on 2023.2+.
|
|
#if UNITY_VERSION < 202320
|
|
float4 _BlitTexture_TexelSize;
|
|
#endif
|
|
|
|
TEXTURE2D_X(_PathTracingSampleTexture);
|
|
|
|
//#include "./PathTracing.hlsl"
|
|
|
|
half4 frag(Varyings input) : SV_Target
|
|
{
|
|
// UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);
|
|
// float2 screenUV = input.texcoord;
|
|
|
|
//#if defined(_SUPPORT_REFRACTION)
|
|
// float depth = SAMPLE_TEXTURE2D_X_LOD(_CameraDepthAttachment, my_point_clamp_sampler, screenUV, 0).r;
|
|
//#else
|
|
// float depth = SAMPLE_TEXTURE2D_X_LOD(_CameraDepthTexture, my_point_clamp_sampler, screenUV, 0).r;
|
|
//#endif
|
|
// // If the current pixel is sky
|
|
// bool isBackground = depth == UNITY_RAW_FAR_CLIP_VALUE ? true : false;
|
|
|
|
// if (isBackground)
|
|
// discard;
|
|
|
|
// #if !UNITY_REVERSED_Z
|
|
// depth = lerp(UNITY_NEAR_CLIP_VALUE, 1, depth);
|
|
// #endif
|
|
|
|
// float3 positionWS = ComputeWorldSpacePosition(screenUV, depth, UNITY_MATRIX_I_VP);
|
|
// float3 camPositionWS = GetCameraPositionWS();
|
|
// half3 viewDirWS = normalize(camPositionWS - positionWS);
|
|
|
|
// half3 result = half3(0.0, 0.0, 0.0);
|
|
// ScreenSpacePathTracing(depth, positionWS, camPositionWS, viewDirWS, screenUV, result.rgb);
|
|
|
|
// // Reduce noise and fireflies by limiting the maximum brightness
|
|
// result = RgbToHsv(result);
|
|
// result.z = clamp(result.z, 0.0, _MaxBrightness);
|
|
// result = HsvToRgb(result);
|
|
|
|
// return half4(result.rgb, 1.0);
|
|
|
|
return half4(1,1,1, 1.0);
|
|
}
|
|
ENDHLSL
|
|
}
|
|
|
|
Pass
|
|
{
|
|
Name "Temporal Accumulation"
|
|
Tags { "LightMode" = "Screen Space Path Tracing" }
|
|
|
|
Blend One Zero
|
|
|
|
HLSLPROGRAM
|
|
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
|
|
// The Blit.hlsl file provides the vertex shader (Vert),
|
|
// input structure (Attributes) and output strucutre (Varyings)
|
|
#include "Packages/com.unity.render-pipelines.core/Runtime/Utilities/Blit.hlsl"
|
|
|
|
#pragma vertex Vert
|
|
#pragma fragment frag//accumulationFrag
|
|
|
|
#pragma target 3.5
|
|
|
|
#pragma multi_compile_fragment _ _GBUFFER_NORMALS_OCT
|
|
#pragma multi_compile_local_fragment _ _SUPPORT_REFRACTION
|
|
|
|
CBUFFER_START(UnityPerMaterial)
|
|
half _MaxSteps;
|
|
half _StepSize;
|
|
half _MaxBounce;
|
|
half _RayCount;
|
|
half _Dither_Intensity;
|
|
half _Dithering;
|
|
float _Seed;
|
|
half _TemporalIntensity;
|
|
half _Sample;
|
|
half _MaxSample;
|
|
half _MaxBrightness;
|
|
CBUFFER_END
|
|
|
|
|
|
#ifndef _FP_REFL_PROBE_ATLAS
|
|
TEXTURECUBE(_SpecCube0);
|
|
SAMPLER(sampler_SpecCube0);
|
|
float4 _SpecCube0_ProbePosition;
|
|
float3 _SpecCube0_BoxMin;
|
|
float3 _SpecCube0_BoxMax;
|
|
half4 _SpecCube0_HDR;
|
|
TEXTURECUBE(_SpecCube1);
|
|
SAMPLER(sampler_SpecCube1);
|
|
float4 _SpecCube1_ProbePosition;
|
|
float3 _SpecCube1_BoxMin;
|
|
float3 _SpecCube1_BoxMax;
|
|
half4 _SpecCube1_HDR;
|
|
half _ProbeWeight;
|
|
half _ProbeSet;
|
|
#endif
|
|
|
|
half _BackDepthEnabled;
|
|
half _IsProbeCamera;
|
|
|
|
float4x4 _PrevInvViewProjMatrix;
|
|
float3 _PrevCameraPositionWS;
|
|
half _PixelSpreadAngleTangent;
|
|
|
|
// URP pre-defined the following variable on 2023.2+.
|
|
#if UNITY_VERSION < 202320
|
|
float4 _BlitTexture_TexelSize;
|
|
#endif
|
|
|
|
// Camera or Per Object motion vectors.
|
|
TEXTURE2D_X(_MotionVectorTexture);
|
|
float4 _MotionVectorTexture_TexelSize;
|
|
|
|
TEXTURE2D_X(_PathTracingHistorySampleTexture);
|
|
|
|
TEXTURE2D_X(_PathTracingHistoryTexture);
|
|
TEXTURE2D_X(_PathTracingHistoryDepthTexture);
|
|
|
|
TEXTURE2D_X(_PathTracingEmissionTexture);
|
|
TEXTURE2D_X(_PathTracingHistoryEmissionTexture);
|
|
|
|
//#include "./PathTracingDenoise.hlsl"
|
|
TEXTURE2D_X(_CameraDepthAttachment);
|
|
SAMPLER(my_point_clamp_sampler);
|
|
float frag(Varyings input) : SV_Target
|
|
{
|
|
UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);
|
|
float2 screenUV = input.texcoord;
|
|
|
|
float depth = SAMPLE_TEXTURE2D_X_LOD(_CameraDepthAttachment, my_point_clamp_sampler, screenUV, 0).r;
|
|
|
|
return depth;
|
|
}
|
|
|
|
ENDHLSL
|
|
}
|
|
|
|
Pass
|
|
{
|
|
Name "Copy History Depth"
|
|
Tags { "LightMode" = "Screen Space Path Tracing" }
|
|
|
|
Blend One Zero
|
|
|
|
HLSLPROGRAM
|
|
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
|
|
// The Blit.hlsl file provides the vertex shader (Vert),
|
|
// input structure (Attributes) and output strucutre (Varyings)
|
|
#include "Packages/com.unity.render-pipelines.core/Runtime/Utilities/Blit.hlsl"
|
|
|
|
#pragma vertex Vert
|
|
#pragma fragment frag
|
|
|
|
#pragma target 3.5
|
|
|
|
CBUFFER_START(UnityPerMaterial)
|
|
half _MaxSteps;
|
|
half _StepSize;
|
|
half _MaxBounce;
|
|
half _RayCount;
|
|
half _Dither_Intensity;
|
|
half _Dithering;
|
|
float _Seed;
|
|
half _TemporalIntensity;
|
|
half _Sample;
|
|
half _MaxSample;
|
|
half _MaxBrightness;
|
|
CBUFFER_END
|
|
|
|
// URP pre-defined the following variable on 2023.2+.
|
|
#if UNITY_VERSION < 202320
|
|
float4 _BlitTexture_TexelSize;
|
|
#endif
|
|
|
|
TEXTURE2D_X(_CameraDepthAttachment);
|
|
SAMPLER(my_point_clamp_sampler);
|
|
|
|
float frag(Varyings input) : SV_Target
|
|
{
|
|
UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);
|
|
float2 screenUV = input.texcoord;
|
|
|
|
float depth = SAMPLE_TEXTURE2D_X_LOD(_CameraDepthAttachment, my_point_clamp_sampler, screenUV, 0).r;
|
|
|
|
return depth;
|
|
}
|
|
ENDHLSL
|
|
}
|
|
|
|
Pass
|
|
{
|
|
Name "Offline Accumulation"
|
|
Tags { "LightMode" = "Screen Space Path Tracing" }
|
|
|
|
Blend SrcAlpha OneMinusSrcAlpha
|
|
|
|
HLSLPROGRAM
|
|
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
|
|
// The Blit.hlsl file provides the vertex shader (Vert),
|
|
// input structure (Attributes) and output strucutre (Varyings)
|
|
#include "Packages/com.unity.render-pipelines.core/Runtime/Utilities/Blit.hlsl"
|
|
|
|
#pragma vertex Vert
|
|
#pragma fragment frag
|
|
|
|
#pragma target 3.5
|
|
|
|
SAMPLER(my_point_clamp_sampler);
|
|
|
|
CBUFFER_START(UnityPerMaterial)
|
|
half _MaxSteps;
|
|
half _StepSize;
|
|
half _MaxBounce;
|
|
half _RayCount;
|
|
half _Dither_Intensity;
|
|
half _Dithering;
|
|
float _Seed;
|
|
half _TemporalIntensity;
|
|
half _Sample;
|
|
half _MaxSample;
|
|
half _MaxBrightness;
|
|
CBUFFER_END
|
|
|
|
half _IsAccumulationPaused;
|
|
|
|
half4 frag(Varyings input) : SV_Target
|
|
{
|
|
UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);
|
|
float2 screenUV = input.texcoord;
|
|
|
|
half3 color = SAMPLE_TEXTURE2D_X_LOD(_BlitTexture, my_point_clamp_sampler, screenUV, 0).rgb;
|
|
|
|
// When object or camera moves, we should re-accumulate the pixel.
|
|
bool reAccumulate = (_Sample == 0.0) ? true : false;
|
|
|
|
if (reAccumulate)
|
|
return half4(color, 1.0);
|
|
else if (_Sample >= _MaxSample || _IsAccumulationPaused) // Do not accumulate when reaching maximum samples allowed.
|
|
return half4(color, 0.0);
|
|
else
|
|
return half4(color, (1.0 / (_Sample + 1.0)));
|
|
}
|
|
ENDHLSL
|
|
}
|
|
|
|
Pass
|
|
{
|
|
Name "Offline Accumulation Blit"
|
|
Tags { "LightMode" = "Screen Space Path Tracing" }
|
|
|
|
Blend One Zero
|
|
|
|
HLSLPROGRAM
|
|
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
|
|
// The Blit.hlsl file provides the vertex shader (Vert),
|
|
// input structure (Attributes) and output strucutre (Varyings)
|
|
#include "Packages/com.unity.render-pipelines.core/Runtime/Utilities/Blit.hlsl"
|
|
|
|
#pragma vertex Vert
|
|
#pragma fragment frag
|
|
|
|
#pragma target 3.5
|
|
|
|
SAMPLER(my_point_clamp_sampler);
|
|
|
|
CBUFFER_START(UnityPerMaterial)
|
|
half _MaxSteps;
|
|
half _StepSize;
|
|
half _MaxBounce;
|
|
half _RayCount;
|
|
half _Dither_Intensity;
|
|
half _Dithering;
|
|
float _Seed;
|
|
half _TemporalIntensity;
|
|
half _Sample;
|
|
half _MaxSample;
|
|
half _MaxBrightness;
|
|
CBUFFER_END
|
|
|
|
// From HDRP's "./Runtime/RenderPipeline/Accumulation/Shaders/Accumulation.compute"
|
|
void AddConvergenceCue(float2 screenUV, half currentSample, inout half3 color)
|
|
{
|
|
// If we reached 100%, do not display the bar anymore
|
|
if (currentSample >= _MaxSample)
|
|
return;
|
|
|
|
float width = _ScreenSize.x;
|
|
float height = _ScreenSize.y;
|
|
|
|
// Define progress bar height as 0.5% of the resolution (and at least 4 pixels high)
|
|
float barHeight = max(4.0, ceil(height * 0.005)) * _ScreenSize.w;
|
|
|
|
// Change color only in a region corresponding to a progress bar, at the bottom of the screen
|
|
if (screenUV.y < barHeight && screenUV.x <= currentSample * rcp(_MaxSample))
|
|
{
|
|
half lum = Luminance(color);
|
|
|
|
if (lum > 1.0)
|
|
{
|
|
color *= rcp(lum);
|
|
lum = 1.0;
|
|
}
|
|
|
|
// Make dark color brighter, and vice versa
|
|
color += lum > 0.5 ? -0.5 * lum : 0.05 + 0.5 * lum;
|
|
}
|
|
}
|
|
|
|
half4 frag(Varyings input) : SV_Target
|
|
{
|
|
UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);
|
|
float2 screenUV = input.texcoord;
|
|
|
|
half3 color = SAMPLE_TEXTURE2D_X_LOD(_BlitTexture, my_point_clamp_sampler, screenUV, 0).rgb;
|
|
AddConvergenceCue(screenUV, _Sample, color);
|
|
return half4(color, 1.0);
|
|
}
|
|
ENDHLSL
|
|
}
|
|
|
|
Pass
|
|
{
|
|
Name "Edge-Avoiding Spatial Denoise"
|
|
Tags { "LightMode" = "Screen Space Path Tracing" }
|
|
|
|
Blend One Zero
|
|
|
|
HLSLPROGRAM
|
|
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
|
|
// The Blit.hlsl file provides the vertex shader (Vert),
|
|
// input structure (Attributes) and output strucutre (Varyings)
|
|
#include "Packages/com.unity.render-pipelines.core/Runtime/Utilities/Blit.hlsl"
|
|
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/CommonLighting.hlsl"
|
|
|
|
//#include "./PathTracingConfig.hlsl"
|
|
|
|
#pragma vertex Vert
|
|
#pragma fragment frag
|
|
|
|
#pragma multi_compile_local_fragment _ _SUPPORT_REFRACTION // _TRANSPARENT_GBUFFERS
|
|
|
|
TEXTURE2D_X(_CameraDepthAttachment);
|
|
|
|
TEXTURE2D_X_HALF(_GBuffer0);
|
|
TEXTURE2D_X_HALF(_GBuffer2);
|
|
|
|
TEXTURE2D_X_HALF(_TransparentGBuffer0);
|
|
TEXTURE2D_X_HALF(_TransparentGBuffer1);
|
|
TEXTURE2D_X_HALF(_TransparentGBuffer2);
|
|
SAMPLER(my_point_clamp_sampler);
|
|
|
|
TEXTURE2D_X(_PathTracingEmissionTexture);
|
|
TEXTURE2D_X(_PathTracingSampleTexture);
|
|
|
|
CBUFFER_START(UnityPerMaterial)
|
|
half _MaxSteps;
|
|
half _StepSize;
|
|
half _MaxBounce;
|
|
half _RayCount;
|
|
half _Dither_Intensity;
|
|
half _Dithering;
|
|
float _Seed;
|
|
half _TemporalIntensity;
|
|
half _Sample;
|
|
half _MaxSample;
|
|
half _MaxBrightness;
|
|
CBUFFER_END
|
|
|
|
// URP pre-defined the following variable on 2023.2+.
|
|
#if UNITY_VERSION < 202320
|
|
float4 _BlitTexture_TexelSize;
|
|
#endif
|
|
|
|
float GetSpecularDominantFactor(float NoV, float linearRoughness)
|
|
{
|
|
float a = 0.298475 * log(39.4115 - 39.0029 * linearRoughness);
|
|
float dominantFactor = pow(saturate(1.0 - NoV), 10.8649) * (1.0 - a) + a;
|
|
return saturate(dominantFactor);
|
|
}
|
|
|
|
half4 frag(Varyings input) : SV_Target
|
|
{
|
|
// Edge-Avoiding A-TrousWavelet Transform for denoising
|
|
// Modified from "https://www.shadertoy.com/view/ldKBzG"
|
|
// feel free to use it
|
|
|
|
//UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);
|
|
//float2 screenUV = input.texcoord;
|
|
|
|
//// Dynamic dilation rate
|
|
//// This reduces repetitive artifacts of A-Trous filtering.
|
|
//
|
|
//half blurAmount = 1.0 - saturate(min(SAMPLE_TEXTURE2D_X_LOD(_PathTracingSampleTexture, my_point_clamp_sampler, screenUV, 0).r / MAX_ACCUM_FRAME_NUM, MAX_ACCUM_FRAME_NUM) - rcp(MAX_ACCUM_FRAME_NUM));
|
|
//if (blurAmount == 0.0)
|
|
// discard;
|
|
//
|
|
//half intensity = floor(lerp(3.0, 9.0, GenerateHashedRandomFloat(uint3(screenUV * _ScreenSize.xy, 1))));
|
|
////intensity *= (1.0 - historySample);
|
|
//// 3x3 gaussian kernel texel offset
|
|
//const half2 offset[9] =
|
|
//{
|
|
// half2(-1.0, -1.0), half2(0.0, -1.0), half2(1.0, -1.0), // offset[0]..[2]
|
|
// half2(-1.0, 0.0), half2(0.0, 0.0), half2(1.0, 0.0), // offset[3]..[5]
|
|
// half2(-1.0, 1.0), half2(0.0, 1.0), half2(1.0, 1.0) // offset[6]..[8]
|
|
//};
|
|
|
|
//// 3x3 approximate gaussian kernel
|
|
//const half kernel[9] =
|
|
//{
|
|
// half(0.0625), half(0.125), half(0.0625), // kernel[0]..[2]
|
|
// half(0.125), half(0.25), half(0.125), // kernel[3]..[5]
|
|
// half(0.0625), half(0.125), half(0.0625) // kernel[6]..[8]
|
|
//};
|
|
|
|
//// URP doesn't clear color targets of GBuffers, only depth and stencil.
|
|
//float deviceDepth = SAMPLE_TEXTURE2D_X_LOD(_CameraDepthAttachment, my_point_clamp_sampler, UnityStereoTransformScreenSpaceTex(screenUV), 0).r;
|
|
//bool isSky;
|
|
//#if (UNITY_REVERSED_Z == 1)
|
|
// isSky = deviceDepth == 0.0;
|
|
//#else
|
|
// isSky = deviceDepth == 1.0; // OpenGL Platforms.
|
|
//#endif
|
|
|
|
//UNITY_BRANCH
|
|
//if (isSky)
|
|
//{
|
|
// return SAMPLE_TEXTURE2D_X_LOD(_BlitTexture, my_point_clamp_sampler, UnityStereoTransformScreenSpaceTex(screenUV), 0);
|
|
//}
|
|
//else
|
|
//{
|
|
// bool transparentGBuffers = false;
|
|
//#if defined(_SUPPORT_REFRACTION)
|
|
// uint surfaceType = uint((SAMPLE_TEXTURE2D_X_LOD(_TransparentGBuffer1, my_point_clamp_sampler, UnityStereoTransformScreenSpaceTex(screenUV), 0).a * 255.0h) + 0.5h);
|
|
// transparentGBuffers = surfaceType == 2;
|
|
//#endif
|
|
|
|
// half3 centerColor = SAMPLE_TEXTURE2D_X_LOD(_BlitTexture, my_point_clamp_sampler, UnityStereoTransformScreenSpaceTex(screenUV), 0).rgb;
|
|
// half3 centerEmission = half3(0.0, 0.0, 0.0);
|
|
// UNITY_BRANCH
|
|
// if (!transparentGBuffers)
|
|
// centerEmission = SAMPLE_TEXTURE2D_X_LOD(_PathTracingEmissionTexture, my_point_clamp_sampler, UnityStereoTransformScreenSpaceTex(screenUV), 0).rgb;
|
|
|
|
// half4 normalSmoothness;
|
|
// half3 centerNormal;
|
|
// half3 centerAlbedo;
|
|
// UNITY_BRANCH
|
|
// if (transparentGBuffers)
|
|
// {
|
|
// normalSmoothness = SAMPLE_TEXTURE2D_X_LOD(_TransparentGBuffer2, my_point_clamp_sampler, UnityStereoTransformScreenSpaceTex(screenUV), 0).rgba;
|
|
// if (!any(normalSmoothness.rgb))
|
|
// normalSmoothness = SAMPLE_TEXTURE2D_X_LOD(_GBuffer2, my_point_clamp_sampler, UnityStereoTransformScreenSpaceTex(screenUV), 0).rgba;
|
|
// centerAlbedo = SAMPLE_TEXTURE2D_X_LOD(_TransparentGBuffer0, my_point_clamp_sampler, UnityStereoTransformScreenSpaceTex(screenUV), 0).rgb;
|
|
// if (!any(centerAlbedo))
|
|
// centerAlbedo = SAMPLE_TEXTURE2D_X_LOD(_GBuffer0, my_point_clamp_sampler, UnityStereoTransformScreenSpaceTex(screenUV), 0).rgb;
|
|
// }
|
|
// else
|
|
// {
|
|
// normalSmoothness = SAMPLE_TEXTURE2D_X_LOD(_GBuffer2, my_point_clamp_sampler, UnityStereoTransformScreenSpaceTex(screenUV), 0).rgba;
|
|
// centerAlbedo = SAMPLE_TEXTURE2D_X_LOD(_GBuffer0, my_point_clamp_sampler, UnityStereoTransformScreenSpaceTex(screenUV), 0).rgb;
|
|
// }
|
|
|
|
// centerNormal = normalSmoothness.rgb;
|
|
|
|
// float3 positionWS = ComputeWorldSpacePosition(screenUV, deviceDepth, UNITY_MATRIX_I_VP);
|
|
|
|
// half3 viewDirWS = normalize(GetCameraPositionWS() - positionWS);
|
|
|
|
// // Convert both directions to view space
|
|
// half NdotV = abs(dot(normalSmoothness.xyz, viewDirWS));
|
|
// float amount = GetSpecularDominantFactor(NdotV, 1.0 - normalSmoothness.w);
|
|
|
|
// half3 sumColor = half3(0.0, 0.0, 0.0);
|
|
// half sumWeight = half(0.0);
|
|
// for (uint i = 0; i < 9; i++)
|
|
// {
|
|
// float2 uv = UnityStereoTransformScreenSpaceTex(clamp(screenUV + offset[i] * intensity * _BlitTexture_TexelSize.xy, float2(0.0, 0.0), _BlitTexture_TexelSize.zw));
|
|
|
|
// half3 color = SAMPLE_TEXTURE2D_X_LOD(_BlitTexture, my_point_clamp_sampler, uv, 0).rgb;
|
|
// half3 diff = centerColor - color;
|
|
// half distance = dot(diff, diff);
|
|
// half colorWeight = min(exp(-distance * 1.1), 1.0); // rcp(0.9)
|
|
|
|
// half emissionWeight = half(1.0);
|
|
// UNITY_BRANCH
|
|
// if (!transparentGBuffers)
|
|
// {
|
|
// half3 emission = SAMPLE_TEXTURE2D_X_LOD(_PathTracingEmissionTexture, my_point_clamp_sampler, uv, 0).rgb;
|
|
// diff = centerEmission - emission;
|
|
// distance = dot(diff, diff);
|
|
// emissionWeight = min(exp(-distance * 2000.0), 1.0); // rcp(0.0005)
|
|
// }
|
|
|
|
// half3 normal;
|
|
// UNITY_BRANCH
|
|
// if (transparentGBuffers)
|
|
// {
|
|
// normal = SAMPLE_TEXTURE2D_X_LOD(_TransparentGBuffer2, my_point_clamp_sampler, uv, 0).rgb;
|
|
// if (!any(normal))
|
|
// normal = SAMPLE_TEXTURE2D_X_LOD(_GBuffer2, my_point_clamp_sampler, uv, 0).rgb;
|
|
// }
|
|
// else
|
|
// normal = SAMPLE_TEXTURE2D_X_LOD(_GBuffer2, my_point_clamp_sampler, uv, 0).rgb;
|
|
|
|
// diff = centerNormal - normal;
|
|
// distance = max(dot(diff, diff), 0.0);
|
|
// half normalWeight = min(exp(-distance * 20.0), 1.0); // rcp(0.05)
|
|
|
|
// half3 albedo;
|
|
// UNITY_BRANCH
|
|
// if (transparentGBuffers)
|
|
// {
|
|
// albedo = SAMPLE_TEXTURE2D_X_LOD(_TransparentGBuffer0, my_point_clamp_sampler, uv, 0).rgb;
|
|
// if (!any(albedo))
|
|
// albedo = SAMPLE_TEXTURE2D_X_LOD(_GBuffer0, my_point_clamp_sampler, uv, 0).rgb;
|
|
// }
|
|
// else
|
|
// albedo = SAMPLE_TEXTURE2D_X_LOD(_GBuffer0, my_point_clamp_sampler, uv, 0).rgb;
|
|
|
|
// diff = sqrt(centerAlbedo) - sqrt(albedo);
|
|
// distance = dot(diff, diff);
|
|
// half albedoWeight = min(exp(-distance * 400.0), 1.0); // rcp(0.0025)
|
|
|
|
// half weight = colorWeight * emissionWeight * normalWeight * albedoWeight * kernel[i];
|
|
|
|
// sumColor += color * weight;
|
|
// sumWeight += weight;
|
|
// }
|
|
|
|
// blurAmount = 1.0 - blurAmount;
|
|
// blurAmount *= blurAmount;
|
|
// blurAmount *= blurAmount;
|
|
// blurAmount = 1.0 - blurAmount;
|
|
// //return half4(lerp(centerColor, sumColor * rcp(sumWeight), blurAmount * (1.0 - amount)), 1.0);
|
|
// return half4(lerp(centerColor, sumColor * rcp(sumWeight), blurAmount), 1.0);
|
|
//return blurAmount.xxxx;
|
|
return float4(0, 0, 0, 0);
|
|
//}
|
|
}
|
|
ENDHLSL
|
|
}
|
|
|
|
Pass
|
|
{
|
|
Name "Copy History Emission"
|
|
Tags { "LightMode" = "Screen Space Path Tracing" }
|
|
|
|
Blend One Zero
|
|
|
|
HLSLPROGRAM
|
|
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
|
|
// The Blit.hlsl file provides the vertex shader (Vert),
|
|
// input structure (Attributes) and output strucutre (Varyings)
|
|
#include "Packages/com.unity.render-pipelines.core/Runtime/Utilities/Blit.hlsl"
|
|
|
|
#pragma vertex Vert
|
|
#pragma fragment frag
|
|
|
|
#pragma target 3.5
|
|
|
|
TEXTURE2D_X(_PathTracingEmissionTexture);
|
|
SAMPLER(my_point_clamp_sampler);
|
|
|
|
CBUFFER_START(UnityPerMaterial)
|
|
half _MaxSteps;
|
|
half _StepSize;
|
|
half _MaxBounce;
|
|
half _RayCount;
|
|
half _Dither_Intensity;
|
|
half _Dithering;
|
|
float _Seed;
|
|
half _TemporalIntensity;
|
|
half _Sample;
|
|
half _MaxSample;
|
|
half _MaxBrightness;
|
|
CBUFFER_END
|
|
|
|
half4 frag(Varyings input) : SV_Target
|
|
{
|
|
UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);
|
|
float2 screenUV = input.texcoord;
|
|
|
|
return SAMPLE_TEXTURE2D_X_LOD(_PathTracingEmissionTexture, my_point_clamp_sampler, screenUV, 0).rgba;
|
|
}
|
|
ENDHLSL
|
|
}
|
|
}
|
|
}
|