[Code] Update SSR for SSLPackage.

.gitattributes

@@ -0,0 +1,8 @@
+*.tif filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.tga filter=lfs diff=lfs merge=lfs -text
+*.unity filter=lfs diff=lfs merge=lfs -text
+*.asset filter=lfs diff=lfs merge=lfs -text
+*.meta filter=lfs diff=lfs merge=lfs -text
+*.hdr filter=lfs diff=lfs merge=lfs -text
+*.fbx filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,38 @@
+[Ll]ibrary/
+[Tt]emp/
+[Oo]bj/
+[Bb]uild/
+[Bb]uilds/
+[Ll]ogs/
+Assets/TemporalFolder*
+
+# Visual Studio cache directory
+.vs/
+.vscode/
+
+# Autogenerated VS/MD/Consulo solution and project files
+ExportedObj/
+.consulo/
+*.csproj
+*.unityproj
+*.sln
+*.suo
+*.tmp
+*.user
+*.userprefs
+*.pidb
+*.booproj
+*.svd
+*.pdb
+*.opendb
+
+# Unity3D generated meta files
+*.pidb.meta
+*.pdb.meta
+
+# Unity3D Generated File On Crash Reports
+sysinfo.txt
+
+# Builds
+*.apk
+*.unitypackage

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Pseudo-Game-Tech
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

com.infinity.ssl/Runtime/Infinity.Render.Runtime.asmdef

@@ -0,0 +1,22 @@
+{
+    "name": "Infinity.Render.Runtime",
+    "references": [
+        "Unity.Mathematics",
+        "Unity.Postprocessing.Runtime"
+    ],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": true,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [
+        {
+            "name": "com.infinity.render",
+            "expression": "0.0.0",
+            "define": "InfinityRenderRuntime"
+        }
+    ],
+    "noEngineReferences": false
+}

com.infinity.ssl/Runtime/RenderFeature/PyramidColorGenerator/Resources/Shaders/GaussianDownsampleShader.compute

@@ -0,0 +1,126 @@
+float4 _Size;
+Texture2D<float4> _Source;
+RWTexture2D<float4> _Result;
+SamplerState sampler_LinearClamp;
+
+// 16x16 pixels with an 8x8 center that we will be blurring writing out. Each uint is two color
+// 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.
+groupshared uint gs_cacheR[128];
+groupshared uint gs_cacheG[128];
+groupshared uint gs_cacheB[128];
+groupshared uint gs_cacheA[128];
+
+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)
+         + 0.10937500 * (c + g)
+         + 0.03125000 * (b + h)
+         + 0.00390625 * (a + i);
+}
+
+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 float4 pixel1, out float4 pixel2)
+{
+    uint rr = gs_cacheR[index];
+    uint gg = gs_cacheG[index];
+    uint bb = gs_cacheB[index];
+    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, 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 float4 pixel)
+{
+    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)
+{
+    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);
+    Load2Pixels(leftMostIndex + 3, s6, s7);
+    Load2Pixels(leftMostIndex + 4, s8, s9);
+
+    Store1Pixel(outIndex    , BlurPixels(s0, s1, s2, s3, s4, s5, s6, s7, s8));
+    Store1Pixel(outIndex + 1, BlurPixels(s1, s2, s3, s4, s5, s6, s7, s8, s9));
+}
+
+void BlurVertically(uint2 pixelCoord, uint topMostIndex)
+{
+    float4 s0, s1, s2, s3, s4, s5, s6, s7, s8;
+    Load1Pixel(topMostIndex     , s0);
+    Load1Pixel(topMostIndex +  8, s1);
+    Load1Pixel(topMostIndex + 16, s2);
+    Load1Pixel(topMostIndex + 24, s3);
+    Load1Pixel(topMostIndex + 32, s4);
+    Load1Pixel(topMostIndex + 40, s5);
+    Load1Pixel(topMostIndex + 48, s6);
+    Load1Pixel(topMostIndex + 56, s7);
+    Load1Pixel(topMostIndex + 64, s8);
+
+    float4 blurred = BlurPixels(s0, s1, s2, s3, s4, s5, s6, s7, s8);
+
+    // Write to the final target
+    _Result[pixelCoord] = blurred;
+}
+
+#pragma kernel KMain
+
+#ifdef DISABLE_COMPUTE_SHADERS
+
+TRIVIAL_COMPUTE_KERNEL(KMain)
+
+#else
+
+[numthreads(8, 8, 1)]
+void KMain(uint2 groupId : SV_GroupID, uint2 groupThreadId : SV_GroupThreadID, uint2 dispatchThreadId : SV_DispatchThreadID)
+{
+    // Upper-left pixel coordinate of quad that this thread will read
+    int2 threadUL = (groupThreadId << 1) + (groupId << 3) - 4;
+
+    // Downsample the block
+    float2 offset = float2(threadUL);
+    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);
+    Store2Pixels(destIdx     , p00, p10);
+    Store2Pixels(destIdx + 8u, p01, p11);
+
+    GroupMemoryBarrierWithGroupSync();
+
+    // Horizontally blur the pixels in LDS
+    uint row = groupThreadId.y << 4u;
+    BlurHorizontally(row + (groupThreadId.x << 1u), row + groupThreadId.x + (groupThreadId.x & 4u));
+
+    GroupMemoryBarrierWithGroupSync();
+
+    // Vertically blur the pixels in LDS and write the result to memory
+    BlurVertically(dispatchThreadId, (groupThreadId.y << 3u) + groupThreadId.x);
+}
+
+#endif // DISABLE_COMPUTE_SHADERS

com.infinity.ssl/Runtime/RenderFeature/PyramidColorGenerator/Script/PyramidColorGenerator.cs

@@ -0,0 +1,58 @@
+using UnityEngine;
+using Unity.Mathematics;
+using UnityEngine.Rendering;
+
+namespace InfinityExtend.Rendering.Runtime
+{
+    public static class PyramidColorUniform
+    {
+        public static int PrevLevelColor = Shader.PropertyToID("_Source");
+        public static int CurrLevelColor = Shader.PropertyToID("_Result");
+        public static int PrevCurr_Size = Shader.PropertyToID("_Size");
+        public static int ColorPyramidNumLOD = Shader.PropertyToID("ColorPyramidNumLOD");
+    }
+
+    public static class PyramidColorGenerator
+    {
+        private static ComputeShader PyramidColorShader {
+            get {
+                return Resources.Load<ComputeShader>("Shaders/GaussianDownsampleShader");
+            }
+        }
+
+        public static void ColorPyramidInit(ref int[] ColorPyramidMipIDs)
+        {
+            if (ColorPyramidMipIDs == null || ColorPyramidMipIDs.Length == 0) {
+                ColorPyramidMipIDs = new int[12];
+
+                for (int i = 0; i < 12; i++) {
+                    ColorPyramidMipIDs[i] = Shader.PropertyToID("_SSSRGaussianMip" + i);
+                }
+            }
+        }
+
+        public static void ColorPyramidUpdate(ref int[] ColorPyramidMipIDs, ref int2 ScreenSize, RenderTargetIdentifier DstRT , CommandBuffer CommandList)
+        {
+            int ColorPyramidCount = Mathf.FloorToInt(Mathf.Log(ScreenSize.x, 2) - 3);
+            ColorPyramidCount = Mathf.Min(ColorPyramidCount, 12);
+            CommandList.SetGlobalFloat(PyramidColorUniform.ColorPyramidNumLOD, (float)ColorPyramidCount);
+            RenderTargetIdentifier PrevColorPyramid = DstRT;
+            int2 ColorPyramidSize = ScreenSize;
+            for (int i = 0; i < ColorPyramidCount; i++) {
+                ColorPyramidSize.x >>= 1;
+                ColorPyramidSize.y >>= 1;
+
+                CommandList.GetTemporaryRT(ColorPyramidMipIDs[i], ColorPyramidSize.x, ColorPyramidSize.y, 0, FilterMode.Bilinear, RenderTextureFormat.ARGBHalf, RenderTextureReadWrite.Default, 1, true);
+                CommandList.SetComputeTextureParam(PyramidColorShader, 0, PyramidColorUniform.PrevLevelColor, PrevColorPyramid);
+                CommandList.SetComputeTextureParam(PyramidColorShader, 0, PyramidColorUniform.CurrLevelColor, ColorPyramidMipIDs[i]);
+                CommandList.SetComputeVectorParam(PyramidColorShader, PyramidColorUniform.PrevCurr_Size, new float4(ColorPyramidSize.x, ColorPyramidSize.y, 1f / ColorPyramidSize.x, 1f / ColorPyramidSize.y));
+                CommandList.DispatchCompute(PyramidColorShader, 0, Mathf.CeilToInt(ColorPyramidSize.x / 8f), Mathf.CeilToInt(ColorPyramidSize.y / 8f), 1);
+                CommandList.CopyTexture(ColorPyramidMipIDs[i], 0, 0, DstRT, 0, i + 1);
+
+                PrevColorPyramid = ColorPyramidMipIDs[i];
+            } for (int i = 0; i < ColorPyramidCount; i++) {
+                CommandList.ReleaseTemporaryRT(ColorPyramidMipIDs[i]);
+            }
+        }
+    }
+}

com.infinity.ssl/Runtime/RenderFeature/PyramidDepthGenerator/Resources/Shaders/HierarchicalZ_Shader.compute

@@ -0,0 +1,27 @@
+#pragma kernel HiZ_Generation
+
+float4 _PrevCurr_Inverse_Size;
+Texture2D<float> _PrevMipDepth; SamplerState sampler_PrevMipDepth;
+RWTexture2D<float> _HierarchicalDepth;
+
+[numthreads(8, 8, 1)]
+void HiZ_Generation (uint3 id : SV_DispatchThreadID)
+{
+    float2 uv = (id.xy + 0.5) * _PrevCurr_Inverse_Size.xy;
+    float FinalMinZ = _PrevMipDepth.SampleLevel(sampler_PrevMipDepth, uv, 0);
+
+    /*FinalMinZ = max( FinalMinZ, _PrevMipDepth.SampleLevel(sampler_PrevMipDepth, uv + int2( 1,  0) * _PrevCurr_Inverse_Size.zw, 0) );
+    FinalMinZ = max( FinalMinZ, _PrevMipDepth.SampleLevel(sampler_PrevMipDepth, uv + int2(-1,  0) * _PrevCurr_Inverse_Size.zw, 0) );
+    FinalMinZ = max( FinalMinZ, _PrevMipDepth.SampleLevel(sampler_PrevMipDepth, uv + int2( 0,  1) * _PrevCurr_Inverse_Size.zw, 0) );
+    FinalMinZ = max( FinalMinZ, _PrevMipDepth.SampleLevel(sampler_PrevMipDepth, uv + int2( 0, -1) * _PrevCurr_Inverse_Size.zw, 0) );
+    FinalMinZ = max( FinalMinZ, _PrevMipDepth.SampleLevel(sampler_PrevMipDepth, uv + int2( 1,  1) * _PrevCurr_Inverse_Size.zw, 0) );
+    FinalMinZ = max( FinalMinZ, _PrevMipDepth.SampleLevel(sampler_PrevMipDepth, uv + int2(-1,  1) * _PrevCurr_Inverse_Size.zw, 0) );
+    FinalMinZ = max( FinalMinZ, _PrevMipDepth.SampleLevel(sampler_PrevMipDepth, uv + int2( 1, -1) * _PrevCurr_Inverse_Size.zw, 0) );
+    FinalMinZ = max( FinalMinZ, _PrevMipDepth.SampleLevel(sampler_PrevMipDepth, uv + int2(-1, -1) * _PrevCurr_Inverse_Size.zw, 0) );*/
+
+    FinalMinZ = max(FinalMinZ, _PrevMipDepth.SampleLevel(sampler_PrevMipDepth, uv + int2(0, -1) * _PrevCurr_Inverse_Size.zw, 0));
+    FinalMinZ = max(FinalMinZ, _PrevMipDepth.SampleLevel(sampler_PrevMipDepth, uv + int2(-1, 0) * _PrevCurr_Inverse_Size.zw, 0));
+    FinalMinZ = max(FinalMinZ, _PrevMipDepth.SampleLevel(sampler_PrevMipDepth, uv + int2(-1, -1) * _PrevCurr_Inverse_Size.zw, 0));
+
+    _HierarchicalDepth[id.xy] = FinalMinZ;
+}