Fixed distance fading; disabled contacts

Author: Chman

PostProcessing/Runtime/Effects/ScreenSpaceReflections.cs

@@ -13,7 +13,7 @@ public sealed class ScreenSpaceReflections
         public float maximumMarchDistance = 100f;
 
         [Range(0f, 1f)]
-        public float distanceFade = 0f; // TODO: Currently broken
+        public float distanceFade = 0.25f;
 
         [Range(0f, 1f)]
         public float attenuation = 0.25f;
@@ -96,8 +96,6 @@ internal void Render(PostProcessRenderContext context)
 
             var sheet = context.propertySheets.Get(context.resources.shaders.screenSpaceReflections);
             sheet.properties.SetTexture(ShaderIDs.Noise, context.resources.blueNoise256[0]);
-            sheet.properties.SetTexture(ShaderIDs.Test, m_Test);
-            sheet.properties.SetTexture(ShaderIDs.History, m_History);
 
             var screenSpaceProjectionMatrix = new Matrix4x4();
             screenSpaceProjectionMatrix.SetRow(0, new Vector4(size * 0.5f, 0f, 0f, size * 0.5f));
@@ -121,6 +119,10 @@ internal void Render(PostProcessRenderContext context)
             cmd.GetTemporaryRT(ShaderIDs.SSRResolveTemp, size, size, 0, FilterMode.Bilinear, context.sourceFormat);
             cmd.BlitFullscreenTriangle(context.source, m_Test, sheet, (int)Pass.Test);
             cmd.BlitFullscreenTriangle(context.source, ShaderIDs.SSRResolveTemp, sheet, (int)Pass.Resolve);
+
+            sheet.properties.SetTexture(ShaderIDs.Test, m_Test);
+            sheet.properties.SetTexture(ShaderIDs.History, m_History);
+
             cmd.BlitFullscreenTriangle(ShaderIDs.SSRResolveTemp, m_Resolve, sheet, (int)Pass.Reproject);
             cmd.ReleaseTemporaryRT(ShaderIDs.SSRResolveTemp);
 

PostProcessing/Shaders/Builtins/GaussianDownsample.compute

@@ -34,13 +34,12 @@ CBUFFER_END
 // channels packed together.
 // The reason for separating channels is to reduce bank conflicts in the local data memory
 // controller. A large stride will cause more threads to collide on the same memory bank.
-//
-// TODO: skip alpha for now, will probably be needed for AR though.
 groupshared uint gs_cacheR[128];
 groupshared uint gs_cacheG[128];
 groupshared uint gs_cacheB[128];
+groupshared uint gs_cacheA[128];
 
-float3 BlurPixels(float3 a, float3 b, float3 c, float3 d, float3 e, float3 f, float3 g, float3 h, float3 i)
+float4 BlurPixels(float4 a, float4 b, float4 c, float4 d, float4 e, float4 f, float4 g, float4 h, float4 i)
 {
     return 0.27343750 * (e    )
          + 0.21875000 * (d + f)
@@ -49,38 +48,41 @@ float3 BlurPixels(float3 a, float3 b, float3 c, float3 d, float3 e, float3 f, fl
          + 0.00390625 * (a + i);
 }
 
-void Store2Pixels(uint index, float3 pixel1, float3 pixel2)
+void Store2Pixels(uint index, float4 pixel1, float4 pixel2)
 {
     gs_cacheR[index] = f32tof16(pixel1.r) | f32tof16(pixel2.r) << 16;
     gs_cacheG[index] = f32tof16(pixel1.g) | f32tof16(pixel2.g) << 16;
     gs_cacheB[index] = f32tof16(pixel1.b) | f32tof16(pixel2.b) << 16;
+    gs_cacheA[index] = f32tof16(pixel1.a) | f32tof16(pixel2.a) << 16;
 }
 
-void Load2Pixels(uint index, out float3 pixel1, out float3 pixel2)
+void Load2Pixels(uint index, out float4 pixel1, out float4 pixel2)
 {
     uint rr = gs_cacheR[index];
     uint gg = gs_cacheG[index];
     uint bb = gs_cacheB[index];
-    pixel1 = float3(f16tof32(rr      ), f16tof32(gg      ), f16tof32(bb      ));
-    pixel2 = float3(f16tof32(rr >> 16), f16tof32(gg >> 16), f16tof32(bb >> 16));
+    uint aa = gs_cacheA[index];
+    pixel1 = float4(f16tof32(rr      ), f16tof32(gg      ), f16tof32(bb      ), f16tof32(aa      ));
+    pixel2 = float4(f16tof32(rr >> 16), f16tof32(gg >> 16), f16tof32(bb >> 16), f16tof32(aa >> 16));
 }
 
-void Store1Pixel(uint index, float3 pixel)
+void Store1Pixel(uint index, float4 pixel)
 {
     gs_cacheR[index] = asuint(pixel.r);
     gs_cacheG[index] = asuint(pixel.g);
     gs_cacheB[index] = asuint(pixel.b);
+    gs_cacheA[index] = asuint(pixel.a);
 }
 
-void Load1Pixel(uint index, out float3 pixel)
+void Load1Pixel(uint index, out float4 pixel)
 {
-    pixel = asfloat(uint3(gs_cacheR[index], gs_cacheG[index], gs_cacheB[index]));
+    pixel = asfloat(uint4(gs_cacheR[index], gs_cacheG[index], gs_cacheB[index], gs_cacheA[index]));
 }
 
 // Blur two pixels horizontally.  This reduces LDS reads and pixel unpacking.
 void BlurHorizontally(uint outIndex, uint leftMostIndex)
 {
-    float3 s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
+    float4 s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
     Load2Pixels(leftMostIndex + 0, s0, s1);
     Load2Pixels(leftMostIndex + 1, s2, s3);
     Load2Pixels(leftMostIndex + 2, s4, s5);
@@ -93,7 +95,7 @@ void BlurHorizontally(uint outIndex, uint leftMostIndex)
 
 void BlurVertically(uint2 pixelCoord, uint topMostIndex)
 {
-    float3 s0, s1, s2, s3, s4, s5, s6, s7, s8;
+    float4 s0, s1, s2, s3, s4, s5, s6, s7, s8;
     Load1Pixel(topMostIndex     , s0);
     Load1Pixel(topMostIndex +  8, s1);
     Load1Pixel(topMostIndex + 16, s2);
@@ -104,10 +106,10 @@ void BlurVertically(uint2 pixelCoord, uint topMostIndex)
     Load1Pixel(topMostIndex + 56, s7);
     Load1Pixel(topMostIndex + 64, s8);
 
-    float3 blurred = BlurPixels(s0, s1, s2, s3, s4, s5, s6, s7, s8);
+    float4 blurred = BlurPixels(s0, s1, s2, s3, s4, s5, s6, s7, s8);
 
     // Write to the final target
-    _Result[pixelCoord] = float4(blurred, 1.0);
+    _Result[pixelCoord] = blurred;
 }
 
 #pragma kernel KMain
@@ -119,10 +121,10 @@ void KMain(uint2 groupId : SV_GroupID, uint2 groupThreadId : SV_GroupThreadID, u
 
     // Downsample the block
     float2 offset = float2(threadUL);
-    float3 p00 = _Source.SampleLevel(sampler_LinearClamp, (offset                    + 0.5) * _Size.zw, 0.0).rgb;
-    float3 p10 = _Source.SampleLevel(sampler_LinearClamp, (offset + float2(1.0, 0.0) + 0.5) * _Size.zw, 0.0).rgb;
-    float3 p01 = _Source.SampleLevel(sampler_LinearClamp, (offset + float2(0.0, 1.0) + 0.5) * _Size.zw, 0.0).rgb;
-    float3 p11 = _Source.SampleLevel(sampler_LinearClamp, (offset + float2(1.0, 1.0) + 0.5) * _Size.zw, 0.0).rgb;
+    float4 p00 = _Source.SampleLevel(sampler_LinearClamp, (offset                    + 0.5) * _Size.zw, 0.0);
+    float4 p10 = _Source.SampleLevel(sampler_LinearClamp, (offset + float2(1.0, 0.0) + 0.5) * _Size.zw, 0.0);
+    float4 p01 = _Source.SampleLevel(sampler_LinearClamp, (offset + float2(0.0, 1.0) + 0.5) * _Size.zw, 0.0);
+    float4 p11 = _Source.SampleLevel(sampler_LinearClamp, (offset + float2(1.0, 1.0) + 0.5) * _Size.zw, 0.0);
 
     // Store the 4 downsampled pixels in LDS
     uint destIdx = groupThreadId.x + (groupThreadId.y << 4u);

PostProcessing/Shaders/Builtins/ScreenSpaceReflections.hlsl

@@ -203,8 +203,8 @@ Result march(Ray ray, VaryingsDefault input)
         tracker += derivatives;
 
         z.x = z.y;
-        z.y = tracker.w + derivatives.w * .5;
-        z.y /= tracker.z + derivatives.z * .5;
+        z.y = tracker.w + derivatives.w * 0.5;
+        z.y /= tracker.z + derivatives.z * 0.5;
 
         UNITY_FLATTEN
         if (z.y > z.x)
@@ -348,13 +348,12 @@ float4 FragComposite(VaryingsDefault i) : SV_Target
     float3 normal = 2.0 * gbuffer2.rgb - 1.0;
     float3 position = GetViewSpacePosition(i.texcoord);
 
-    float3 eye = mul((float3x3) _InverseViewMatrix, normalize(position));
+    float3 eye = mul((float3x3)_InverseViewMatrix, normalize(position));
     position = mul(_InverseViewMatrix, float4(position, 1.0)).xyz;
 
-    float4 test = _Test.SampleLevel(sampler_Test, i.texcoord, 0);
+    //float4 test = _Test.SampleLevel(sampler_Test, i.texcoord, 0);
 
-    // _BlurPyramidLODCount needs to be clamped after nudge
-    float4 resolve = _Resolve.SampleLevel(sampler_Resolve, i.texcoord, SmoothnessToRoughness(gbuffer1.a) * (_BlurPyramidLODCount - 2.0) * test.z + 1.0);
+    float4 resolve = _Resolve.SampleLevel(sampler_Resolve, i.texcoord, SmoothnessToRoughness(gbuffer1.a) * (_BlurPyramidLODCount - 1.0) /* * test.z */ + 1.0);
     float confidence = saturate(2.0 * dot(-eye, normalize(reflect(-eye, normal))));
 
     UnityLight light;