NLDClient-yudde/ProjectNLD/Assets/Code/Shaders/Scene/NLD_Scene_Opaque.shader

Shader "NLD_URP/NLD_Scene_Opaque"
{
    Properties
    {
        [Header(Main map)]
        _MainTex ("MainTex", 2D) = "white" {}
        _Color("Base Tint", color) = (1,1,1,1)

        _CutOff("Alpha测试值",Range(0,1)) = 0.5
        _ShadowIntensity("阴影强度",Range(0,1)) = 1
        _AmbientMultiplier("环境光强度",Range(0,2)) = 1
    }
    SubShader
    {
        Tags
        {
            "RenderType" = "Transparent"
            "RenderPipeline" = "UniversalPipeline"
            "IgnoreProjector" = "True"
        }
        pass
        {
            name "Base"
            Tags
            {
                "LightMode" = "UniversalForward"
            }
            Cull Back
            ZWrite On
            ZTest Less
            Blend SrcAlpha OneMinusSrcAlpha
            //ZWrite On

            HLSLPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #pragma multi_compile _ _MAIN_LIGHT_SHADOWS
            #pragma multi_compile_instancing

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

            TEXTURE2D(_MainTex);
            SAMPLER(sampler_MainTex);

            half4 _MainTex_ST;
            half4 _Color;

            half _CutOff;
            half _ShadowIntensity;
            half _AmbientMultiplier;

            struct Attributes
            {
                float3 positionOS : POSITION;
                float3 normalOS : NORMAL;
                // float4 tangentOS : TANGENT;
                float4 texcoord : TEXCOORD0;
                UNITY_VERTEX_INPUT_INSTANCE_ID
            };

            struct Varyings
            {
                float2 uv : TEXCOORD0;
                float3 normalWS : TEXCOORD1;
                float3 positionWS : TEXCOORD2;
                float4 positionCS : SV_POSITION;
                float4 shadowCoord : TEXCOORD3;
            };

            Varyings vert(Attributes input)
            {
                Varyings output;
                UNITY_SETUP_INSTANCE_ID(input);
                VertexPositionInputs positionInputs = GetVertexPositionInputs(input.positionOS);
                output.positionWS = positionInputs.positionWS;
                output.positionCS = positionInputs.positionCS;

                VertexNormalInputs vertexNormalInput = GetVertexNormalInputs(input.normalOS);
                output.normalWS = vertexNormalInput.normalWS;

                output.uv = TRANSFORM_TEX(input.texcoord, _MainTex);
                output.shadowCoord = GetShadowCoord(positionInputs);
                return output;
            }

            float4 frag(Varyings input) : SV_Target
            {
                #if _MAIN_LIGHT_SHADOWS
                    Light mainLight = GetMainLight(input.shadowCoord);
                #else
                Light mainLight = GetMainLight();
                #endif

                float3 N = normalize(input.normalWS);
                float3 L = normalize(mainLight.direction);

                half4 baseColor = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, input.uv);
                clip(baseColor.a - _CutOff);

                half3 albedo = baseColor * _Color;
                half3 mainLightColor = mainLight.color.rgb;
                //漫反射
                half3 diffuse = saturate(dot(N, L)) * albedo * mainLightColor;
                diffuse *= lerp(1, mainLight.shadowAttenuation, _ShadowIntensity);

                //全局光照，目前只有环境光提供的部分
                //参考URP内置SimpleLit，直接采样球谐函数
                //没有考虑环境光遮蔽，光照贴图等，此计算方式目前正确，但不敢保证后续不会出错
                //如果没有该部分光照，由于没有光照探针和光照贴图提供的间接光照，模型背光面会很黑，所以这部分是用来弥补间接光照的
                half3 gi = SampleSH(input.normalWS) * albedo * _AmbientMultiplier;

                half3 finalColor = diffuse + gi;
                float4 col = float4(finalColor, 1);

                return col;
            }
            ENDHLSL
        }

        Pass
        {
            Name "ShadowCaster"
            Tags
            {
                "LightMode" = "ShadowCaster"
            }

            ZWrite On
            ColorMask 0

            HLSLPROGRAM
            #pragma target 3.0
            #pragma vertex ShadowPassVertex
            #pragma fragment ShadowPassFragment
            #pragma multi_compile_instancing
            
            // -------------------------------------
            // Universal Pipeline keywords

            // This is used during shadow map generation to differentiate between directional and punctual light shadows, as they use different formulas to apply Normal Bias
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"

            float3 _LightDirection;
            float3 _LightPosition;
            TEXTURE2D(_MainTex);
            SAMPLER(sampler_MainTex);
            half4 _MainTex_ST;

            half _CutOff;

            struct AttributesLean
            {
                float4 position : POSITION;
                float3 normalOS : NORMAL;
                float2 texcoord : TEXCOORD0;
                UNITY_VERTEX_INPUT_INSTANCE_ID
            };

            struct VaryingsLean
            {
                float4 clipPos : SV_POSITION;
                float2 texcoord : TEXCOORD0;
            };

            VaryingsLean ShadowPassVertex(AttributesLean v)
            {
                VaryingsLean o = (VaryingsLean)0;
                UNITY_SETUP_INSTANCE_ID(v);
                float3 positionWS = TransformObjectToWorld(v.position.xyz);
                float3 normalWS = TransformObjectToWorldNormal(v.normalOS);

                float3 lightDirectionWS = _LightDirection;

                float4 clipPos = TransformWorldToHClip(ApplyShadowBias(positionWS, normalWS, lightDirectionWS));

                #if UNITY_REVERSED_Z
                clipPos.z = min(clipPos.z, UNITY_NEAR_CLIP_VALUE);
                #else
                clipPos.z = max(clipPos.z, UNITY_NEAR_CLIP_VALUE);
                #endif

                o.clipPos = clipPos;

                o.texcoord = v.texcoord;

                return o;
            }

            half4 ShadowPassFragment(VaryingsLean IN) : SV_TARGET
            {
                float4 texcol = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, IN.texcoord);
                clip(texcol.a - _CutOff);
                return 0;
            }
            ENDHLSL
        }
    }
}