Add Shadows Transparent URP

2025-06-13 15:37 UTC o4-mini Open in ChatGPT ↗

To get shadows working in URP on a transparent (code) shader you have to explicitly opt-in for both casting and receiving shadows. There are two pieces to this:

Receiving shadows in your forward pass
Casting shadows via a dedicated ShadowCaster (and optionally DepthOnly) pass

1. Receiving shadows

In your UniversalForward pass (the one where you draw your transparent object), you need to:

Include the URP lighting library
Turn on the shadow-map variants
Compute and apply the shadow attenuation

Here’s a minimal setup:

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

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

        // standard alpha blending for transparency
        Blend SrcAlpha OneMinusSrcAlpha
        ZWrite Off

        HLSLPROGRAM
        #pragma vertex Vert
        #pragma fragment Frag

        // enable fog if you need it
        #pragma multi_compile_fog

        // enable main-light & additional-light shadows
        #pragma multi_compile _ _MAIN_LIGHT_SHADOWS _MAIN_LIGHT_SHADOWS_CASCADE _MAIN_LIGHT_SHADOWS_SCREEN
        #pragma multi_compile _ _ADDITIONAL_LIGHT_SHADOWS

        // URP lighting / shadow helpers
        #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
        #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"

        struct Attributes
        {
            float4 positionOS : POSITION;
            float3 normalOS   : NORMAL;
            // ... any UVs, colors, etc.
        };

        struct Varyings
        {
            float4 positionCS   : SV_POSITION;
            float3 normalWS     : NORMAL;
            float3 positionWS   : TEXCOORD0;
            float4 shadowCoord  : TEXCOORD1;
            UNITY_FOG_COORDS(2)
        };

        Varyings Vert(Attributes IN)
        {
            Varyings OUT;
            // object→clip
            OUT.positionCS = TransformObjectToHClip(IN.positionOS.xyz);
            // object→world
            float3 worldPos = TransformObjectToWorld(IN.positionOS.xyz);
            OUT.positionWS = worldPos;
            OUT.normalWS   = TransformObjectToWorldNormal(IN.normalOS);

            // compute shadow-map UVs
            VertexPositionInputs vpi = GetVertexPositionInputs(IN.positionOS.xyz);
            OUT.shadowCoord = GetShadowCoord(vpi);

            UNITY_TRANSFER_FOG(OUT, OUT.positionCS);
            return OUT;
        }

        half4 Frag(Varyings IN) : SV_Target
        {
            // sample your base color/texture here...
            half4 baseCol = half4(1,1,1, IN.shadowCoord.w /* or your alpha */);

            // get the shadow weight [0..1] from the main light
            half shadowMain = MainLightRealtimeShadow(IN.shadowCoord);

            // if you also want additional lights:
            // int addCount = GetAdditionalLightsCount();
            // for(...) shadowMain *= AdditionalLightRealtimeShadow(...);

            // modulate your lighting by the shadow
            baseCol.rgb *= shadowMain;

            UNITY_APPLY_FOG(IN.fogCoord, baseCol);
            return baseCol;
        }
        ENDHLSL
    }

    // … ShadowCaster / DepthOnly passes go here …
}

Why this works

#pragma multi_compile …_MAIN_LIGHT_SHADOWS… and …_ADDITIONAL_LIGHT_SHADOWS… pull in the shadow-sampling code.

GetShadowCoord packs your vertex into light-space.

MainLightRealtimeShadow reads the shadow map at that coord and returns 0 (in shadow) → 1 (lit). citeturn1view0

2. Casting shadows

Transparent objects in URP do not cast shadows unless you explicitly give them a ShadowCaster pass (and often a DepthOnly pass for correct depth pre-pass). The easiest way is to borrow URP’s built-in Lit shader’s passes:

    // after your forward pass, still inside the same SubShader
    UsePass "Universal Render Pipeline/Lit/ShadowCaster"
    UsePass "Universal Render Pipeline/Lit/DepthOnly"

This will pull in exactly the same HLSL that URP uses to write into the shadow map and depth buffer, keeping SRP Batcher compatibility citeturn5view0.

Putting it all together

Shader "Custom/TransparentWithShadows"
{
    Properties
    {
        _MainTex ("Albedo (RGB)", 2D) = "white" {}
        _Color   ("Tint", Color)   = (1,1,1,1)
    }
    SubShader
    {
        Tags { "RenderType"="Transparent" "Queue"="Transparent" "RenderPipeline"="UniversalPipeline" }

        // 1) Forward pass (receive shadows)
        Pass
        {
            Name "UniversalForward"
            Tags { "LightMode"="UniversalForward" }
            Blend SrcAlpha OneMinusSrcAlpha
            ZWrite Off

            HLSLPROGRAM
            #pragma vertex Vert
            #pragma fragment Frag
            #pragma multi_compile_fog
            #pragma multi_compile _ _MAIN_LIGHT_SHADOWS _MAIN_LIGHT_SHADOWS_CASCADE _MAIN_LIGHT_SHADOWS_SCREEN
            #pragma multi_compile _ _ADDITIONAL_LIGHT_SHADOWS

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

            struct Attributes { float4 posOS:POSITION; float2 uv:TEXCOORD0; };
            struct Varyings {
                float4 posCS : SV_POSITION;
                float2 uv     : TEXCOORD0;
                float4 shadowCoord : TEXCOORD1;
                UNITY_FOG_COORDS(2)
            };

            Varyings Vert(Attributes IN)
            {
                Varyings OUT;
                OUT.posCS = TransformObjectToHClip(IN.posOS.xyz);
                OUT.uv    = IN.uv;

                VertexPositionInputs vpi = GetVertexPositionInputs(IN.posOS.xyz);
                OUT.shadowCoord = GetShadowCoord(vpi);

                UNITY_TRANSFER_FOG(OUT, OUT.posCS);
                return OUT;
            }

            half4 Frag(Varyings IN) : SV_Target
            {
                half4 col = tex2D(_MainTex, IN.uv) * _Color;
                half s = MainLightRealtimeShadow(IN.shadowCoord);
                col.rgb *= s;
                UNITY_APPLY_FOG(IN.fogCoord, col);
                return col;
            }
            ENDHLSL
        }

        // 2) Cast shadows
        UsePass "Universal Render Pipeline/Lit/ShadowCaster"
        UsePass "Universal Render Pipeline/Lit/DepthOnly"
    }
}

With that in place:

Your object will cast real shadows into the scene (via the ShadowCaster pass).
Your transparent surface will receive shadows (by sampling MainLightRealtimeShadow in your forward pass).

–––

References

Use shadows in a custom URP shader citeturn1view0
Template shader… UsePass “Universal Render Pipeline/Lit/ShadowCaster” citeturn5view0

To make your transparent object cast shadows in URP, you don’t need to sample or apply any shadow‐receiving code in your forward pass at all—you just need to include a dedicated ShadowCaster pass (and optionally a DepthOnly pass if you want to participate in the depth pre-pass). URP already provides a drop-in ShadowCaster implementation that you can “borrow” via UsePass. Here’s all you need:

Shader "Custom/OnlyCastShadows"
{
    Properties
    {
        _MainTex ("Albedo (RGB)", 2D) = "white" {}
        _Color   ("Tint", Color)   = (1,1,1,1)
    }

    SubShader
    {
        // make sure URP knows this is transparent
        Tags
        {
            "RenderType"     = "Transparent"
            "Queue"          = "Transparent"
            "RenderPipeline" = "UniversalPipeline"
        }

        // (Optional) Your normal forward pass to draw the object
        Pass
        {
            Name "UniversalForward"
            Tags { "LightMode"="UniversalForward" }
            Blend SrcAlpha OneMinusSrcAlpha
            ZWrite Off

            HLSLPROGRAM
            #pragma vertex Vert
            #pragma fragment Frag
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"

            struct Attributes
            {
                float4 positionOS : POSITION;
                float2 uv         : TEXCOORD0;
            };
            struct Varyings
            {
                float4 positionCS : SV_POSITION;
                float2 uv         : TEXCOORD0;
            };

            Varyings Vert(Attributes IN)
            {
                Varyings OUT;
                OUT.positionCS = TransformObjectToHClip(IN.positionOS.xyz);
                OUT.uv         = IN.uv;
                return OUT;
            }

            half4 Frag(Varyings IN) : SV_Target
            {
                half4 col = tex2D(_MainTex, IN.uv) * _Color;
                return col;
            }
            ENDHLSL
        }

        // --- THIS IS ALL YOU NEED TO CAST SHADOWS ---

        // Pull in URP's built-in ShadowCaster pass:
        UsePass "Universal Render Pipeline/Lit/ShadowCaster"

        // (Optional) DepthOnly can help if you have a depth pre-pass:
        UsePass "Universal Render Pipeline/Lit/DepthOnly"
    }
}

Key points:

UsePass "Universal Render Pipeline/Lit/ShadowCaster"
This injects URP’s entire ShadowCaster pass (LightMode=“ShadowCaster”), so your mesh will write its depth into the shadow map exactly like a Lit material would.
UsePass "Universal Render Pipeline/Lit/DepthOnly" (optional)
If you’re using depth pre-passes (e.g. for screen-space effects), this ensures your transparent object also contributes to the depth buffer.

You don’t have to write any HLSL yourself for shadow casting—URP’s built-in passes handle everything (shadow type, bias, cascade, etc.) and stay SRP-Batcher–compatible.