Shader "PeachValley/GameObjectLit"
{
    Properties
    {
        _MainTex("Diffuse", 2D) = "white" {}
        _MaskTex("Mask", 2D) = "white" {}
        _NormalMap("Normal Map", 2D) = "bump" {}

        // Legacy properties. They're here so that materials using this shader can gracefully fallback to the legacy sprite shader.
        [HideInInspector] _Color("Tint", Color) = (1,1,1,1)
        [HideInInspector] _RendererColor("RendererColor", Color) = (1,1,1,1)
        [HideInInspector] _Flip("Flip", Vector) = (1,1,1,1)
        [HideInInspector] _AlphaTex("External Alpha", 2D) = "white" {}
        [HideInInspector] _EnableExternalAlpha("Enable External Alpha", Float) = 0

        [Space]
        [Header(Edge)]
        [Toggle] _EFFECT_EDGE ("Enable Edge", Float) = 0
        _OutLineColor ("Outline color", Color) = (0.804, 0.2, 0, 1)//描边颜色
        _PixelSize ("Pixel Size", Range(0, 10)) = 6
        _DetectAlpha ("DetectAlpha", Range(0, 0.2)) = 0.1 //四周的点算alpha平均，若大于则显示描边
        _ImageCullAlpha ("ImageCullAlpha", Range(0, 1)) = 0.2 //当前所在的点若大于改值，则无条件原图
        // _Smooth ("Smooth", Range(1, 10)) = 10
        // _SmoothAlphaBase ("SmoothAlphaBase", Range(0, 1)) = 0.8
        _HaveEdgeEffect ("HaveEdgeEffect", Range(0, 1)) = 1

        [Space]
        [Header(Highlight)]
        [Toggle] _EFFECT_HIGHLIGHT("Enable Highlight", Float) = 0
    }

    SubShader
    {
        Tags {"Queue" = "Transparent" "RenderType" = "Transparent" "RenderPipeline" = "UniversalPipeline" }

        Blend SrcAlpha OneMinusSrcAlpha, One OneMinusSrcAlpha
        Cull Off
        ZWrite Off

        Pass
        {
            Tags { "LightMode" = "Universal2D" }

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

            #pragma vertex CombinedShapeLightVertex
            #pragma fragment CombinedShapeLightFragment

            #pragma multi_compile USE_SHAPE_LIGHT_TYPE_0 __
            #pragma multi_compile USE_SHAPE_LIGHT_TYPE_1 __
            #pragma multi_compile USE_SHAPE_LIGHT_TYPE_2 __
            #pragma multi_compile USE_SHAPE_LIGHT_TYPE_3 __
            #pragma multi_compile _ DEBUG_DISPLAY

            #pragma multi_compile _EFFECT_EDGE _EFFECT_EDGE_ON
            #pragma multi_compile _EFFECT_HIGHLIGHT _EFFECT_HIGHLIGHT_ON

            struct Attributes
            {
                float3 positionOS   : POSITION;
                float4 color        : COLOR;
                float2  uv          : TEXCOORD0;
                UNITY_VERTEX_INPUT_INSTANCE_ID
            };

            struct Varyings
            {
                float4  positionCS  : SV_POSITION;
                half4   color       : COLOR;
                float2  uv          : TEXCOORD0;
                half2   lightingUV  : TEXCOORD1;
                #if defined(DEBUG_DISPLAY)
                float3  positionWS  : TEXCOORD2;
                #endif
                UNITY_VERTEX_OUTPUT_STEREO
            };

            #include "Packages/com.unity.render-pipelines.universal/Shaders/2D/Include/LightingUtility.hlsl"

            TEXTURE2D(_MainTex);
            SAMPLER(sampler_MainTex);
            TEXTURE2D(_MaskTex);
            SAMPLER(sampler_MaskTex);
            half4 _MainTex_ST;
            float4 _Color;
            half4 _RendererColor;

            #if USE_SHAPE_LIGHT_TYPE_0
            SHAPE_LIGHT(0)
            #endif

            #if USE_SHAPE_LIGHT_TYPE_1
            SHAPE_LIGHT(1)
            #endif

            #if USE_SHAPE_LIGHT_TYPE_2
            SHAPE_LIGHT(2)
            #endif

            #if USE_SHAPE_LIGHT_TYPE_3
            SHAPE_LIGHT(3)
            #endif

            Varyings CombinedShapeLightVertex(Attributes v)
            {
                Varyings o = (Varyings)0;
                UNITY_SETUP_INSTANCE_ID(v);
                UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);

                o.positionCS = TransformObjectToHClip(v.positionOS);
                #if defined(DEBUG_DISPLAY)
                o.positionWS = TransformObjectToWorld(v.positionOS);
                #endif
                o.uv = TRANSFORM_TEX(v.uv, _MainTex);
                o.lightingUV = half2(ComputeScreenPos(o.positionCS / o.positionCS.w).xy);

                o.color = v.color * _Color * _RendererColor;
                return o;
            }

            // for edge
            half4 _OutLineColor;
            float _PixelSize;
            float2 _MainTex_TexelSize;
            float _DetectAlpha;
            float _ImageCullAlpha;
            // float _Smooth;
            // float _SmoothAlphaBase;
            half _HaveEdgeEffect;

            void Edge(inout half4 outColor, half2 changedUV)
            {
                _PixelSize = _PixelSize * _MainTex_TexelSize;
                // fixed4 color = tex2D(_MainTex, fixed2(changedUV.x, changedUV.y));
                half color1 = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, half2(changedUV.x + _PixelSize, changedUV.y + _PixelSize)).a;
                half color2 = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, half2(changedUV.x - _PixelSize, changedUV.y - _PixelSize)).a;
                half color3 = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, half2(changedUV.x + _PixelSize, changedUV.y - _PixelSize)).a;
                half color4 = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, half2(changedUV.x - _PixelSize, changedUV.y + _PixelSize)).a;
                half a = (color1 + color2 + color3 + color4) / 4;
                int if1 = step(outColor.a, _ImageCullAlpha);
                int if2 = step(a, _DetectAlpha);
                // outColor = outColor* (1 - _HaveEdgeEffect) + _HaveEdgeEffect *(if1 * (((1 - if2) * fixed4(_OutLineColor.rgb, pow(a + _SmoothAlphaBase, _Smooth) * _OutLineColor.a))) + color * (1 - if1));
                outColor = outColor* (1 - _HaveEdgeEffect) + _HaveEdgeEffect *(if1 * (((1 - if2) * _OutLineColor)) + outColor * (1 - if1));
            }

            void Outline(inout half4 outColor, half2 uv)
            {
                float totalAlpha = 1.0;

                [unroll(16)]
                for (int i = 1; i < _PixelSize + 1; i++) {
                    half4 pixelUp =     SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, uv + half2(0, i * _MainTex_TexelSize.y));
                    half4 pixelDown =   SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, uv - half2(0,i *  _MainTex_TexelSize.y));
                    half4 pixelRight =  SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, uv + half2(i * _MainTex_TexelSize.x, 0));
                    half4 pixelLeft =   SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, uv - half2(i * _MainTex_TexelSize.x, 0));

                    totalAlpha = totalAlpha * pixelUp.a * pixelDown.a * pixelRight.a * pixelLeft.a;
                }

                if (totalAlpha == 0) {
                    outColor.rgba = half4(1, 1, 1, 1) * _OutLineColor;
                }
            }

            #include "Packages/com.unity.render-pipelines.universal/Shaders/2D/Include/CombinedShapeLightShared.hlsl"

            half4 CombinedShapeLightFragment(Varyings i) : SV_Target
            {
                const half4 main = i.color * SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, i.uv);
                const half4 mask = SAMPLE_TEXTURE2D(_MaskTex, sampler_MaskTex, i.uv);
                SurfaceData2D surfaceData;
                InputData2D inputData;

                InitializeSurfaceData(main.rgb, main.a, mask, surfaceData);
                InitializeInputData(i.uv, i.lightingUV, inputData);

                half4 outColor = CombinedShapeLightShared(surfaceData, inputData);

            #if _EFFECT_HIGHLIGHT_ON
                outColor.rgb *= half3(1.3, 1.3, 1.3);
            #endif

            #if _EFFECT_EDGE_ON
                // Edge(outColor, i.uv);
                Outline(outColor, i.uv);
            #endif

                return outColor;
            }
            ENDHLSL
        }

        Pass
        {
            Tags { "LightMode" = "NormalsRendering"}

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

            #pragma vertex NormalsRenderingVertex
            #pragma fragment NormalsRenderingFragment

            struct Attributes
            {
                float3 positionOS   : POSITION;
                float4 color        : COLOR;
                float2 uv           : TEXCOORD0;
                float4 tangent      : TANGENT;
                UNITY_VERTEX_INPUT_INSTANCE_ID
            };

            struct Varyings
            {
                float4  positionCS      : SV_POSITION;
                half4   color           : COLOR;
                float2  uv              : TEXCOORD0;
                half3   normalWS        : TEXCOORD1;
                half3   tangentWS       : TEXCOORD2;
                half3   bitangentWS     : TEXCOORD3;
                UNITY_VERTEX_OUTPUT_STEREO
            };

            TEXTURE2D(_MainTex);
            SAMPLER(sampler_MainTex);
            TEXTURE2D(_NormalMap);
            SAMPLER(sampler_NormalMap);
            half4 _NormalMap_ST;  // Is this the right way to do this?

            Varyings NormalsRenderingVertex(Attributes attributes)
            {
                Varyings o = (Varyings)0;
                UNITY_SETUP_INSTANCE_ID(attributes);
                UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);

                o.positionCS = TransformObjectToHClip(attributes.positionOS);
                o.uv = TRANSFORM_TEX(attributes.uv, _NormalMap);
                o.color = attributes.color;
                o.normalWS = -GetViewForwardDir();
                o.tangentWS = TransformObjectToWorldDir(attributes.tangent.xyz);
                o.bitangentWS = cross(o.normalWS, o.tangentWS) * attributes.tangent.w;
                return o;
            }

            #include "Packages/com.unity.render-pipelines.universal/Shaders/2D/Include/NormalsRenderingShared.hlsl"

            half4 NormalsRenderingFragment(Varyings i) : SV_Target
            {
                const half4 mainTex = i.color * SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, i.uv);
                const half3 normalTS = UnpackNormal(SAMPLE_TEXTURE2D(_NormalMap, sampler_NormalMap, i.uv));

                return NormalsRenderingShared(mainTex, normalTS, i.tangentWS.xyz, i.bitangentWS.xyz, i.normalWS.xyz);
            }
            ENDHLSL
        }

        Pass
        {
            Tags { "LightMode" = "UniversalForward" "Queue"="Transparent" "RenderType"="Transparent"}

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

            #pragma vertex UnlitVertex
            #pragma fragment UnlitFragment

            struct Attributes
            {
                float3 positionOS   : POSITION;
                float4 color        : COLOR;
                float2 uv           : TEXCOORD0;
                UNITY_VERTEX_INPUT_INSTANCE_ID
            };

            struct Varyings
            {
                float4  positionCS      : SV_POSITION;
                float4  color           : COLOR;
                float2  uv              : TEXCOORD0;
                #if defined(DEBUG_DISPLAY)
                float3  positionWS  : TEXCOORD2;
                #endif
                UNITY_VERTEX_OUTPUT_STEREO
            };

            TEXTURE2D(_MainTex);
            SAMPLER(sampler_MainTex);
            float4 _MainTex_ST;
            float4 _Color;
            half4 _RendererColor;

            Varyings UnlitVertex(Attributes attributes)
            {
                Varyings o = (Varyings)0;
                UNITY_SETUP_INSTANCE_ID(attributes);
                UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);

                o.positionCS = TransformObjectToHClip(attributes.positionOS);
                #if defined(DEBUG_DISPLAY)
                o.positionWS = TransformObjectToWorld(v.positionOS);
                #endif
                o.uv = TRANSFORM_TEX(attributes.uv, _MainTex);
                o.color = attributes.color * _Color * _RendererColor;
                return o;
            }

            float4 UnlitFragment(Varyings i) : SV_Target
            {
                float4 mainTex = i.color * SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, i.uv);

                #if defined(DEBUG_DISPLAY)
                SurfaceData2D surfaceData;
                InputData2D inputData;
                half4 debugColor = 0;

                InitializeSurfaceData(mainTex.rgb, mainTex.a, surfaceData);
                InitializeInputData(i.uv, inputData);
                SETUP_DEBUG_DATA_2D(inputData, i.positionWS);

                if(CanDebugOverrideOutputColor(surfaceData, inputData, debugColor))
                {
                    return debugColor;
                }
                #endif

                return mainTex;
            }
            ENDHLSL
        }
    }

    Fallback "Sprites/Default"

}