Added samples.

Added more details about the screenshots.

Author: yahiaetman

README.md

@@ -1,6 +1,6 @@
 # Post-processing Stack for Universal Render Pipeline
 
-This package add the ability to creating custom post-processing effects to the universal render pipeline in a manner similar to [PPSv2](https://github.com/Unity-Technologies/PostProcessing) and [HDRP's Custom Post Process](https://docs.unity3d.com/Packages/com.unity.render-pipelines.high-definition@8.2/manual/Custom-Post-Process.html). It is supposed to be a replacement for Unity's **PPSv2** till URP internally supports custom post-processing effect.
+This package adds the ability to create custom post-processing effects for the universal render pipeline in a manner similar to [PPSv2](https://github.com/Unity-Technologies/PostProcessing) and [HDRP's Custom Post Process](https://docs.unity3d.com/Packages/com.unity.render-pipelines.high-definition@8.2/manual/Custom-Post-Process.html). It is supposed to be a replacement for Unity's **PPSv2** till URP internally supports custom post-processing effect.
 
 ## System Requirements
 
@@ -12,6 +12,18 @@ This package add the ability to creating custom post-processing effects to the u
 ![Scene-Screenshot-1](Documentation~/scene-screenshot-1.png)
 ![Scene-Screenshot-2](Documentation~/scene-screenshot-2.png)
 
+The screenshots uses the following builtin effects:
+* Tonemapping
+* Vignette
+* Film Grain
+* Split Toning
+
+They also contain the following custom effects:
+* Edge Detection (Adapted from [this tutorial](https://halisavakis.com/my-take-on-shaders-edge-detection-image-effect/) by [Harry Alisavakis](https://halisavakis.com/)).
+* Gradient Fog (A simplified version of [Multi-Colored Fog](https://halisavakis.com/my-take-on-shaders-firewatch-multi-colored-fog/) by [Harry Alisavakis](https://halisavakis.com/)).
+* Chromatic Splitting.
+* Streak (Adapted from [Kino](https://github.com/keijiro/Kino) by [Keijiro Takahashi](https://github.com/keijiro)).
+
 ## How To Install
 
 **TODO**

Samples~/Examples/Resources/Shaders/PostProcessing/Blend.shader

@@ -0,0 +1,36 @@
+Shader "Hidden/Blend"
+{
+    HLSLINCLUDE
+    #include "Packages/com.yetman.render-pipelines.universal.postprocessing/ShaderLibrary/Core.hlsl"
+
+    TEXTURE2D_X(_MainTex);
+    TEXTURE2D_X(_SecondaryTex);
+
+    float3 _blend;
+
+    float4 BlendFragmentProgram(PostProcessVaryings input) : SV_Target
+    {
+        UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);
+        float2 uv = UnityStereoTransformScreenSpaceTex(input.texcoord);
+        uint2 positionSS = uv * _ScreenParams.xy;
+        float3 mainColor = LOAD_TEXTURE2D_X(_MainTex, positionSS).rgb;
+        float3 secondaryColor = LOAD_TEXTURE2D_X(_SecondaryTex, positionSS).rgb;
+        // blend the main and secondary color
+        float3 color = lerp(mainColor, secondaryColor, _blend);
+        return float4(color, 1);
+    }
+    ENDHLSL
+
+    SubShader
+    {
+        Cull Off ZWrite Off ZTest Always
+        Pass
+        {
+            HLSLPROGRAM
+            #pragma vertex FullScreenTrianglePostProcessVertexProgram
+            #pragma fragment BlendFragmentProgram
+            ENDHLSL
+        }
+    }
+    Fallback Off
+}

Samples~/Examples/Resources/Shaders/PostProcessing/ChromaSplit.shader

@@ -0,0 +1,39 @@
+Shader "Hidden/ChromaSplit"
+{
+    HLSLINCLUDE
+    #include "Packages/com.yetman.render-pipelines.universal.postprocessing/ShaderLibrary/Core.hlsl"
+
+    TEXTURE2D_X(_MainTex);
+
+    // The split amount
+    uint2 _split;
+
+    float4 ChromaSplitFragmentProgram(PostProcessVaryings input) : SV_Target
+    {
+        UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);
+        float2 uv = UnityStereoTransformScreenSpaceTex(input.texcoord);
+        uint2 positionSS = uv * _ScreenParams.xy;
+
+        float4 color = LOAD_TEXTURE2D_X(_MainTex, positionSS);
+        
+        // Read read and blue from the neighbouring pixels at the given split offset
+        color.r = LOAD_TEXTURE2D_X(_MainTex, positionSS - _split).r;
+        color.b = LOAD_TEXTURE2D_X(_MainTex, positionSS + _split).b;
+        
+        return color;
+    }
+    ENDHLSL
+
+    SubShader
+    {
+        Cull Off ZWrite Off ZTest Always
+        Pass
+        {
+            HLSLPROGRAM
+            #pragma vertex FullScreenTrianglePostProcessVertexProgram
+            #pragma fragment ChromaSplitFragmentProgram
+            ENDHLSL
+        }
+    }
+    Fallback Off
+}

Samples~/Examples/Resources/Shaders/PostProcessing/EdgeDetection.shader

@@ -0,0 +1,107 @@
+Shader "Hidden/EdgeDetection"
+{
+    HLSLINCLUDE
+    #include "Packages/com.yetman.render-pipelines.universal.postprocessing/ShaderLibrary/Core.hlsl"
+    // In URP 10, this should be replaced by the same file from URP's ShaderLibrary
+    #include "Packages/com.yetman.render-pipelines.universal.postprocessing/ShaderLibrary/DeclareNormalsTexture.hlsl"
+    #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DeclareDepthTexture.hlsl"
+
+    TEXTURE2D_X(_MainTex);
+    float4 _MainTex_TexelSize;
+
+    // The blending factor for the edges with the original color
+    float _intensity;
+    // The threshold ranges for edge detection (xy used for normals, zw used for depth)
+    float4 _threshold;
+    // The thickness of the edge (determines how far the neighbour samples spread around the center sample)
+    float _thickness;
+    // The color of the edge
+    float3 _color;
+
+    // Curtom Scene normal and depth sampling function to read from a custom texture and sampler
+    float3 SampleSceneNormals(float2 uv, TEXTURE2D_X_FLOAT(_Texture), SAMPLER(sampler_Texture))
+    {
+        return UnpackNormalOctRectEncode(SAMPLE_TEXTURE2D_X(_Texture, sampler_Texture, UnityStereoTransformScreenSpaceTex(uv)).xy) * float3(1.0, 1.0, -1.0);
+    }
+
+    float SampleSceneDepth(float2 uv, TEXTURE2D_X_FLOAT(_Texture), SAMPLER(sampler_Texture))
+    {
+        return SAMPLE_TEXTURE2D_X(_Texture, sampler_Texture, UnityStereoTransformScreenSpaceTex(uv)).r;
+    }
+
+    // A Bilinear sampler to allow for subpixel thickness for the edge 
+    SAMPLER(sampler_linear_clamp);
+
+    // Sample normal & depth and combine them to a single 4D vector (xyz for normal, w for depth)
+    float4 SampleSceneDepthNormal(float2 uv){
+        float depth = SampleSceneDepth(uv, _CameraDepthTexture, sampler_linear_clamp);
+        float depthEye = LinearEyeDepth(depth, _ZBufferParams);
+        float3 normal = SampleSceneNormals(uv, _CameraNormalsTexture, sampler_linear_clamp);
+        return float4(normal, depthEye);
+    }
+
+    // Read the 8 surrounding samples and average them with perspective correction
+    // The perspective correction helps when the surface normal is almost orthogonal to the view direction
+    float4 SampleNeighborhood(float2 uv, float thickness){
+        // The surrounding pixel offsets
+        const float2 offsets[8] = {
+            float2(-1, -1),
+            float2(-1, 0),
+            float2(-1, 1),
+            float2(0, -1),
+            float2(0, 1),
+            float2(1, -1),
+            float2(1, 0),
+            float2(1, 1)
+        };
+        
+        float2 delta = _MainTex_TexelSize.xy * thickness;
+        float4 sum = 0;
+        float weight = 0;
+        for(int i=0; i<8; i++){
+            float4 sample = SampleSceneDepthNormal(uv + delta * offsets[i]);
+            // The sum is weight by 1/depth for perspecive correction
+            sum += sample / sample.w;
+            weight += 1/sample.w;
+        }
+        sum /= weight;
+        // Doesn't make a visible difference but it feels more correct
+        // May remove it for performance benefits
+        sum.xyz = normalize(sum.xyz);
+        return sum;
+    }
+
+    float4 EdgeDetectionFragmentProgram (PostProcessVaryings input) : SV_Target
+    {
+        UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);
+
+        float2 uv = UnityStereoTransformScreenSpaceTex(input.texcoord);
+        float4 color = LOAD_TEXTURE2D_X(_MainTex, uv * _ScreenParams.xy);
+        
+        float4 center = SampleSceneDepthNormal(uv);
+        float4 neighborhood = SampleNeighborhood(uv,  _thickness);
+        // Normal similarity is calculated using a dot product
+        float normalSame = smoothstep(_threshold.x, _threshold.y, dot(center.xyz, neighborhood.xyz));
+        // Depth similarity is calculated using absolute difference
+        float depthSame = smoothstep(_threshold.w, _threshold.z, abs(center.w - neighborhood.w));
+        // Combine normal and depth sameness to get edge factor
+        float edge = 1 - normalSame * depthSame;
+
+        color.rgb = lerp(color.rgb, _color, edge * _intensity);
+        return color;
+    }
+    ENDHLSL
+
+    SubShader
+    {
+        Cull Off ZWrite Off ZTest Always
+        Pass
+        {
+            HLSLPROGRAM
+            #pragma vertex FullScreenTrianglePostProcessVertexProgram
+            #pragma fragment EdgeDetectionFragmentProgram
+            ENDHLSL
+        }
+    }
+    Fallback Off
+}