Revise paste bd0ecad880325

Shader "Custom/Chunk"
{
    Properties
    {
        _AmbientLighting ("Ambient lighting", Color) = (0.2, 0.2, 0.2, 1)
        _EdgeDetection ("Edge detection", Range(0, 1)) = 0.95
        _EdgeColorLightness ("Edge lightness", Range(0, 1)) = 0.015
    }

SubShader
    {
        Tags
        {
            "RenderType" = "Opaque" "RenderPipeline" = "UniversalPipeline"
        }

Pass
        {
            HLSLPROGRAM
            #pragma vertex vert
            #pragma fragment frag

#pragma multi_compile _ _MAIN_LIGHT_SHADOWS _MAIN_LIGHT_SHADOWS_CASCADE
            #pragma multi_compile _ _SHADOW_SOFT
            #pragma multi_compile_fog

#define _MAIN_LIGHT_SHADOWS

#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"

struct vertexInput
            {
                float4 positionOS : POSITION;
                float3 normalOS : NORMAL;
                float4 color : COLOR;
                float2 uv : TEXCOORD0;
                float  uv1 : TEXCOORD1;
            };

struct fragmentInput
            {
                float4 positionCS : SV_POSITION;
                float3 positionWS : TEXCOORD0;
                float3 normalWS : NORMAL;
                float3 color : COLOR;
                float2 uv : TEXCOORD1;
                uint   neighbours : TEXCOORD2;
                float  ao : TEXCOORD3;
                float4 shadowCoords : TEXCOORD4;
            };

float GetAmbientOcclusion(float alpha)
            {
                int t = clamp(alpha * 255, 0.0, 3.0);

if (t == 0)
                {
                    return 0.1;
                }
                if (t == 1)
                {
                    return 0.6;
                }
                if (t == 2)
                {
                    return 0.8;
                }

return 1;
            }

float maxcomp(float4 v)
            {
                return max(v.x, max(v.y, max(v.z, v.w)));
            }

float _EdgeDetection;

float EdgeDetection(float2 uv0, uint neighbours)
            {
                float4 va = float4(neighbours >> 0 & 1, neighbours >> 1 & 1, neighbours >> 2 & 1, neighbours >> 3 & 1);
                float4 vb = float4(neighbours >> 4 & 1, neighbours >> 5 & 1, neighbours >> 6 & 1, neighbours >> 7 & 1);
                float4 vc = float4(neighbours >> 8 & 1, neighbours >> 9 & 1, neighbours >> 10 & 1, neighbours >> 11 & 1);
                float4 vd = float4(neighbours >> 12 & 1, neighbours >> 13 & 1, neighbours >> 14 & 1, neighbours >> 15 & 1);

float2 st = 1.0 - uv0;
                // sides    
                float4 wb = smoothstep(_EdgeDetection, 1, float4(uv0.x, st.x, uv0.y, st.y)) * (1.0 - va + va * vc);
                // corners
                float4 wc = smoothstep(_EdgeDetection, 1, float4(uv0.x * uv0.y, st.x * uv0.y, st.x * st.y, uv0.x * st.y)) * (1.0 - vb + vd * vb);
                return maxcomp(max(wb, wc));
            }

float3 RGBToLinear(float3 color)
            {
                float3 linearRGBLo = color / 12.92;;
                float3 linearRGBHi = pow(max(abs((color + 0.055) / 1.055), 1.192092896e-07), float3(2.4, 2.4, 2.4));
                return float3(color <= 0.04045) ? linearRGBLo : linearRGBHi;
            }

float4 ApplyFog(float4 color, float3 worldPos)
            {
                float viewDistance = length(_WorldSpaceCameraPos - worldPos);
                float clipZ_01 = UNITY_Z_0_FAR_FROM_CLIPSPACE(viewDistance);
                float fogFactor = saturate(clipZ_01 * unity_FogParams.z + unity_FogParams.w);
                //float fogFactor = ComputeFogFactor(viewDistance);
                return unity_FogParams;
            }

fragmentInput vert(vertexInput IN)
            {
                fragmentInput OUT;
                OUT.positionWS = TransformObjectToWorld(IN.positionOS);
                OUT.positionCS = TransformWorldToHClip(OUT.positionWS);
                OUT.color = IN.color.xyz;
                OUT.normalWS = TransformObjectToWorldNormal(IN.normalOS);
                OUT.uv = IN.uv;
                OUT.neighbours = asuint(IN.uv1);
                OUT.ao = GetAmbientOcclusion(IN.color.a);
                OUT.shadowCoords = TransformWorldToShadowCoord(OUT.positionWS);
                return OUT;
            }

float4 _AmbientLighting;
            float _EdgeColorLightness;

float4 frag(fragmentInput IN) : SV_Target
            {
                float4 color = float4(RGBToLinear(IN.color), 1);
                
                Light  mainLight = GetMainLight(IN.shadowCoords);
                float3 attenuatedLightColor = mainLight.color * (mainLight.distanceAttenuation * mainLight.shadowAttenuation);
                float3 lightingColor = LightingLambert(attenuatedLightColor, mainLight.direction, IN.normalWS);
                lightingColor = saturate(lightingColor + _AmbientLighting);
                //color.rgb *= lightingColor;

float4 edge = EdgeDetection(IN.uv, IN.neighbours);
                float3 hsv = RgbToHsv(color.rgb);
                float4 edgeColor = float4(HsvToRgb(float3(hsv.rg, saturate(hsv.b + _EdgeColorLightness))), 1);
                //float fogFactor = saturate(UNITY_Z_0_FAR_FROM_CLIPSPACE(IN.positionCS.z) * unity_FogParams.z + unity_FogParams.w);
                //float fogFactor = ComputeFogFactor(IN.positionCS.z); // Using clip space Z for built-in fog
                return ApplyFog(color, IN.positionWS);

return (color * (1 - edge) + edgeColor * edge) * IN.ao;
            }
            ENDHLSL
        }
        Pass
        {
            Name "ShadowCaster"
            Tags
            {
                "LightMode"="ShadowCaster"
            }

ZWrite On
            ZTest LEqual

HLSLPROGRAM
            // Required to compile gles 2.0 with standard srp library
            #pragma prefer_hlslcc gles
            #pragma exclude_renderers d3d11_9x gles
            //#pragma target 4.5

// Material Keywords
            #pragma shader_feature _ALPHATEST_ON
            #pragma shader_feature _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A

#pragma vertex ShadowPassVertex
            #pragma fragment ShadowPassFragment

#include "Packages/com.unity.render-pipelines.universal/Shaders/ShadowCasterPass.hlsl"
            ENDHLSL
        }
    }
}