2026-03-18 허수아비 추가

Assets/Ilumisoft/Outline Plus/Shaders/OutlineShader.shader

@@ -0,0 +1,203 @@
+Shader "Hidden/Ilumisoft/PostProcessing/Outline"
+{
+    HLSLINCLUDE
+    
+        #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
+        #include "Packages/com.unity.render-pipelines.core/Runtime/Utilities/Blit.hlsl"
+        #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DeclareDepthTexture.hlsl"
+        #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DeclareNormalsTexture.hlsl"
+
+        float4 _OutlineColor;
+        float4 _BackgroundColor;
+        float _BackgroundColorOpacity;
+        float _ReferenceHeight;
+        int _OutlineThickness;
+        int _IsFadeEnabled;
+        float _FadeStart;
+        float _FadeEnd;
+        float2 _DepthEdge;
+        float2 _NormalEdge;
+        float _LuminancePower;
+        float _LuminanceContrast;
+
+        // Samples the scene normals remapped to [0,1]
+        inline float3 SampleNormal(float2 uv)
+        {
+            return SampleSceneNormals(uv) * 0.5 + 0.5;
+        }
+
+        // Samples the scene color
+        inline float3 SampleColor(float2 uv)
+        {
+            return SAMPLE_TEXTURE2D(_BlitTexture,sampler_LinearClamp,  uv).rgb;
+        }
+
+        // Samples the scene depth linear01
+        inline float SampleDepthLinear01(float2 uv)
+        {
+            return Linear01Depth(SampleSceneDepth(uv),_ZBufferParams);
+        }
+
+        float GetNormalOutline(float3 topLeft, float3 bottomRight, float3 topRight, float3 bottomLeft)
+        {
+            float3 delta = abs(topLeft-bottomRight) + abs(topRight-bottomLeft);
+
+            float normalOutline = saturate(max(delta.r, max(delta.g, delta.b)));
+
+            return smoothstep(_NormalEdge.x, _NormalEdge.y, normalOutline);
+        }
+
+        float GetDepthOutline(float topLeft, float bottomRight, float topRight, float bottomLeft)
+        {
+            float result = abs(topLeft - bottomRight) + abs(topRight - bottomLeft);
+            
+            result /= max(topLeft, max(bottomRight, max(topRight, bottomLeft)));
+
+            return smoothstep(_DepthEdge.x, _DepthEdge.y, saturate(result));
+        }
+
+        inline float InverseLerp(float a, float b, float t)
+        {
+            return saturate((t-a)/(b-a));
+        }
+
+        float LuminancePowerContrast(float3 color, float power, float contrast)
+        {
+            float luminance = pow(saturate(Luminance(color)), power);
+            float midpoint = pow(0.5, 2.2);
+            return saturate((luminance - midpoint) * contrast + midpoint);
+        }
+
+        float4 OutlineDepthOnly (Varyings input) : SV_Target
+        {
+            float2 offset = _OutlineThickness * _BlitTexture_TexelSize.xy*_ScreenParams.y/_ReferenceHeight;
+            float2 centerUV = input.texcoord;
+            
+            // Sample color and depth of the current pixel
+            float3 centerColor = SampleColor(centerUV);
+            float centerDepth = SampleSceneDepth(centerUV);
+            float distance = LinearEyeDepth(centerDepth,_ZBufferParams);
+            centerDepth = Linear01Depth(centerDepth,_ZBufferParams);   
+
+            float cornerDepths[4];
+            float2 cornerUVs[4];
+
+            // Create corner UVs
+            cornerUVs[0] = centerUV + float2(-offset.x, offset.y);
+            cornerUVs[1] = centerUV - float2(-offset.x, offset.y);
+            cornerUVs[2] = centerUV + offset;
+            cornerUVs[3] = centerUV - offset;
+
+            [unroll]
+            for(int i=0; i<4; i++)
+            {
+                // depth
+                cornerDepths[i] = SampleDepthLinear01(cornerUVs[i]);
+
+                // Discard values with a lower depth
+                cornerDepths[i] = (cornerDepths[i]>centerDepth) ? cornerDepths[i] : centerDepth;
+            }
+
+            // Compute outline
+            float outline = GetDepthOutline(cornerDepths[0], cornerDepths[1], cornerDepths[2], cornerDepths[3]);
+
+            // Apply distance fade
+            outline *= 1.0 - InverseLerp(_FadeStart, _FadeEnd, distance) * _IsFadeEnabled;
+
+            // Apply background color fill
+            float3 color = LuminancePowerContrast(centerColor, _LuminancePower, _LuminanceContrast) * _BackgroundColor.rgb;
+            color = lerp(centerColor, color, _BackgroundColorOpacity);
+
+            // Apply outline
+            color = lerp(color, _OutlineColor.rgb, outline*_OutlineColor.a);
+
+            return float4(color, 1.0);
+        }
+
+        float4 OutlineDepthNormal (Varyings input) : SV_Target
+        {
+            float2 offset = _OutlineThickness * _BlitTexture_TexelSize.xy*_ScreenParams.y/_ReferenceHeight;
+            float2 centerUV = input.texcoord;
+            
+            // Sample color, depth and normal of the current pixel
+            float3 centerNormal = SampleNormal(centerUV);
+            float3 centerColor = SampleColor(centerUV);
+            float centerDepth = SampleSceneDepth(centerUV);
+            float distance = LinearEyeDepth(centerDepth,_ZBufferParams);
+            centerDepth = Linear01Depth(centerDepth,_ZBufferParams);
+
+            float3 cornerNormals[4];
+            float cornerDepths[4];
+            float2 cornerUVs[4];
+
+            // Create corner UVs
+            cornerUVs[0] = centerUV + float2(-offset.x, offset.y);
+            cornerUVs[1] = centerUV - float2(-offset.x, offset.y);
+            cornerUVs[2] = centerUV + offset;
+            cornerUVs[3] = centerUV - offset;
+
+            [unroll]
+            for(int i=0; i<4; i++)
+            {
+                // sample normal and depth
+                cornerNormals[i] = SampleNormal(cornerUVs[i]);
+                cornerDepths[i] = SampleDepthLinear01(cornerUVs[i]);
+
+                // Discard values with a lower depth
+                cornerNormals[i] = (cornerDepths[i]>centerDepth) ? cornerNormals[i] : centerNormal;
+                cornerDepths[i] = (cornerDepths[i]>centerDepth) ? cornerDepths[i] : centerDepth;
+            }
+
+            // Compute outline
+            float normalOutline = GetNormalOutline(cornerNormals[0], cornerNormals[1], cornerNormals[2], cornerNormals[3]);
+
+            float depthOutline = GetDepthOutline(cornerDepths[0], cornerDepths[1], cornerDepths[2], cornerDepths[3]);
+
+            float outline = max(normalOutline, depthOutline);
+
+            // Apply distance fade
+            outline *= 1.0 - InverseLerp(_FadeStart, _FadeEnd, distance) * _IsFadeEnabled;
+
+            // Apply background color fill
+            float3 color = LuminancePowerContrast(centerColor, _LuminancePower, _LuminanceContrast) * _BackgroundColor.rgb;
+            color = lerp(centerColor, color, _BackgroundColorOpacity);
+
+            // Apply outline
+            color = lerp(color, _OutlineColor.rgb, outline*_OutlineColor.a);
+
+            return float4(color, 1.0);
+        }
+
+    ENDHLSL
+    
+    SubShader
+    {
+        Tags { "RenderType"="Opaque" "RenderPipeline" = "UniversalPipeline"}
+        LOD 100
+        ZWrite Off Cull Off
+
+        Pass
+        {
+            Name "OutlineDepthOnlyPass"
+
+            HLSLPROGRAM
+            
+            #pragma vertex Vert
+            #pragma fragment OutlineDepthOnly
+            
+            ENDHLSL
+        }
+
+        Pass
+        {
+            Name "OutlineDepthNormalPass"
+
+            HLSLPROGRAM
+            
+            #pragma vertex Vert
+            #pragma fragment OutlineDepthNormal
+            
+            ENDHLSL
+        }
+    }
+}