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

Shader "NLD_URP/NLD_Scene_Transparent"
{
    //目前效果还有问题，可能需要新加pass写入深度一次
    Properties
    {
        [Header(Main map)]
        _MainTex ("MainTex", 2D) = "white" {}
        _Color("Base Tint", color) = (1,1,1,1)
        
        _ShadowIntensity("阴影强度",Range(0,1)) = 1
        _AmbientMultiplier("环境光强度",Range(0,2)) = 1
    }
    SubShader
    {
        Tags
        {
            "RenderType" = "Transparent" "RenderPipeline" = "UniversalPipeline" "IgnoreProjector" = "True" "Queue" = "Transparent"
        }
        pass
        {
            name "Base"
            Tags
            {
                "LightMode" = "UniversalForward"
            }
            Cull Back
            ZWrite Off
            ZTest On
            Blend SrcAlpha OneMinusSrcAlpha

            HLSLPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #pragma multi_compile _ _MAIN_LIGHT_SHADOWS
            #pragma multi_compile _ _MAIN_LIGHT_SHADOWS_CASCADE
            #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;
            half4 _BaseColorBottom;
            half4 _BaseColorTop;
            
            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 || _MAIN_LIGHT_SHADOWS_CASCADE
                    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);

                half4 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, albedo.a);

                return col;
            }
            ENDHLSL
        }
//        Pass
//        {
//            Name "ShadowCaster"
//            Tags
//            {
//                "LightMode" = "ShadowCaster"
//            }
//
//            ZWrite On
//            ColorMask 0
//
//            HLSLPROGRAM
//            #pragma vertex ShadowPassVertex
//            #pragma fragment ShadowPassFragment
//            #pragma multi_compile _ _MAIN_LIGHT_SHADOWS
//            #pragma multi_compile_instancing
//            #pragma shader_feature _ALPHA_TEST_ON
//            
//            // -------------------------------------
//            // 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
//            #pragma multi_compile_vertex _ _CASTING_PUNCTUAL_LIGHT_SHADOW
//            #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;
//                UNITY_VERTEX_OUTPUT_STEREO
//            };
//
//            VaryingsLean ShadowPassVertex(AttributesLean v)
//            {
//                VaryingsLean o = (VaryingsLean)0;
//                UNITY_SETUP_INSTANCE_ID(v);
//                float3 positionWS = TransformObjectToWorld(v.position.xyz);
//                float3 normalWS = TransformObjectToWorldNormal(v.normalOS);
//
//                #if _CASTING_PUNCTUAL_LIGHT_SHADOW
//                float3 lightDirectionWS = normalize(_LightPosition - positionWS);
//                #else
//                float3 lightDirectionWS = _LightDirection;
//                #endif
//
//                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);
//                #if _ALPHA_TEST_ON
//                    clip(texcol.a - _CutOff);
//                #endif
//                return 0;
//            }
//            ENDHLSL
//        }
    }
    Fallback "VertexLit"
}