Shader Graph Additional Lights

2025-09-10 08:53 UTC gpt-5-thinking Open in ChatGPT ↗

I ama writing this custom hlsl shader to calculate the contribution of additional lights on Unity URP.

#ifndef CUSTOM_LIGHT_SHADOWS_INCLUDED #define CUSTOM_LIGHT_SHADOWS_INCLUDED

#include “Packages/com.unity.render-pipelines.universal/ShaderLibrary/RealtimeLights.hlsl” #include “Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl” #include “Packages/com.unity.render-pipelines.core/ShaderLibrary/CommonMaterial.hlsl”

// Enable additional lights in the vertex or fragment shader stage #pragma multi_compile _ _ADDITIONAL_LIGHTS_VERTEX _ADDITIONAL_LIGHTS

// Enable support for clustered lighting (used in Forward+) #pragma multi_compile _ _CLUSTER_LIGHT_LOOP

// Enable shadow attenuation for additional lights #pragma multi_compile_fragment _ _ADDITIONAL_LIGHT_SHADOWS

// ----------------------------------------------------------------------------- // Custom Lighting and Shadow Utility Functions // -----------------------------------------------------------------------------

// Calculates a basic lighting contribution from a light source, // factoring in color and shadow attenuation. float EvaluateLightShadowContribution(Light light) { // This returns the red channel of the light’s color * shadow factor. // In real usage, you’d usually apply all color channels. return (light.color * light.shadowAttenuation).r; }

float EvaluateAdditionalLightContribution(float3 normalWS, Light light) { float NdotL = dot(normalWS, normalize(light.direction)); NdotL = (NdotL + 1) * 0.5; return saturate(NdotL) * light.color * light.distanceAttenuation * light.shadowAttenuation; }

// Computes custom lighting contribution from a specific additional light // at world-space position positionWS, using the light at lightIndex. // // This function outputs a lighting value (as a float), which can be used // for effects like custom shadow coloring, inverse shadowing, etc. // // Parameters: // - positionWS: World-space position of the shaded point // - lightIndex: Index of the additional light to query // - lighting: Output float holding the computed light contribution void ComputeAdditionalLightContribution_float( float3 positionWS, const int lightIndex, out float lighting) { // Sample the additional light at the given index Light light = GetAdditionalLight(lightIndex, positionWS, half4(1, 1, 1, 1));

// Output a simple inverted lighting value based on shadow attenuation
// (You can modify this to suit your needs — e.g., multiply by color, etc.)
lighting = 1.0 - EvaluateLightShadowContribution(light);

}

void ComputeAdditionalLightContributionFull_float( float3 positionWS, float3 normalWS, const int lightIndex, out float shadowmask, out float lighting) { #if SHADERGRAPH_PREVIEW lighting = 0; shadowmask = 0; #else

// Sample the additional light at the given index
Light light = GetAdditionalLight(lightIndex, positionWS, half4(1, 1, 1, 1));

// Output a simple inverted lighting value based on shadow attenuation
// (You can modify this to suit your needs — e.g., multiply by color, etc.)
shadowmask = 1.0 - EvaluateLightShadowContribution(light);
lighting = EvaluateAdditionalLightContribution(normalWS, light);

#endif }

#endif // CUSTOM_LIGHT_SHADOWS_INCLUDED

however whan i use a custom function in shaderGraph and call ComputeAdditionalLightContributionFull. Although i get both the lighting and shadowmask results without bugs when i try to connect them to any other component in the graph (for example a simple Multiply) i get an error saying

_AdditionalLightsPosition implicit array missing initial value

what can this be? Am im issing something?

Short answer: your #pragma lines inside the included HLSL file don’t take effect in Shader Graph. Shader Graph puts your file inside the generated pass, and pragmas are only honored at the pass level, not inside includes. As a result, the URP arrays for additional lights (like _AdditionalLightsPosition) are declared without a size (because the keywords that define MAX_VISIBLE_LIGHTS / the Forward+ buffers never got compiled in), and the compiler throws:

_AdditionalLightsPosition implicit array missing initial value

How to fix it

Do one (or more) of the following:

Use a Lit Shader Graph target (not Unlit).
- In the Graph Inspector, set the target to Universal > Lit.
- In the URP Asset, make sure Additional Lights and (optionally) Additional Lights Shadows are enabled.
- You don’t need to add any #pragma for additional lights in your include; the Lit pass already brings the right keywords and buffers.

Don’t put #pragma in your include.
Remove these lines from your HLSL file:

#pragma multi_compile _ _ADDITIONAL_LIGHTS_VERTEX _ADDITIONAL_LIGHTS
#pragma multi_compile _ _CLUSTER_LIGHT_LOOP
#pragma multi_compile_fragment _ _ADDITIONAL_LIGHT_SHADOWS

They won’t be respected from an include when used via Shader Graph.

Guard your calls (optional but safe): Wrap your additional-light code so the graph still compiles if a pass without additional lights gets generated:

void ComputeAdditionalLightContributionFull_float(
    float3 positionWS, float3 normalWS, const int lightIndex,
    out float shadowmask, out float lighting)
{
#if SHADERGRAPH_PREVIEW
    lighting = 0;
    shadowmask = 0;
#else
#if defined(_ADDITIONAL_LIGHTS)
    Light light = GetAdditionalLight(lightIndex, positionWS, half4(1,1,1,1));
    shadowmask = 1.0 - EvaluateLightShadowContribution(light);
    lighting    = EvaluateAdditionalLightContribution(normalWS, light);
#else
    shadowmask = 0;
    lighting   = 0;
#endif
#endif
}

If you must stay on Unlit Shader Graph:
Unlit targets don’t bring the additional-lights arrays/keywords. You’d need a custom shader (not Shader Graph) or a SubShader with the correct passes/keywords. In Shader Graph, stick to Lit when you call GetAdditionalLight.

Other small checks

Keep the includes minimal and rely on the ones the Lit pass brings:

#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/RealtimeLights.hlsl"
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/CommonMaterial.hlsl"

Make sure your URP Renderer isn’t a 2D Renderer (it doesn’t support additional 3D lights).
If you’re using Forward+ (Clustered), ensure it’s enabled in the URP Asset; otherwise don’t rely on _CLUSTER_LIGHT_LOOP.

Once you switch the graph to Lit (and remove the pragmas from the include), your node outputs should connect to Multiply or anything else without that array-size error.

Gotcha—you want to stay Unlit and keep full control. The problem isn’t your math; it’s where the multi_compile keywords live. In Unlit Shader Graph, the generated pass doesn’t include the additional-lights/light-shadow variants, and pragmas inside your include won’t be picked up. That’s why the URP arrays like _AdditionalLightsPosition end up “unsized,” leading to:

_AdditionalLightsPosition implicit array missing initial value

What this means concretely

Shader Graph Unlit target does not compile with _ADDITIONAL_LIGHTS, _ADDITIONAL_LIGHT_SHADOWS, or _CLUSTER_LIGHT_LOOP.
Including RealtimeLights.hlsl in a Custom Function doesn’t help, because the pass didn’t compile those variants.
Therefore, calling GetAdditionalLight (or any additional-light API) from Unlit SG will fail.

Your viable paths (while staying Unlit in look/behavior)

Option A — Write a tiny custom Unlit URP shader (no Shader Graph)

Keep the surface “Unlit,” but own the pass so you can add the needed pragmas. You can still keep your current helper functions untouched. Here’s a minimal template you can drop in and start calling your functions from (supports additional lights + shadows on URP):

Shader "Universal Render Pipeline/Unlit Additional Lights (Custom)"
{
    Properties
    {
        _BaseColor("Base Color", Color) = (1,1,1,1)
    }
    SubShader
    {
        Tags{ "RenderType"="Opaque" "RenderPipeline"="UniversalPipeline" "Queue"="Geometry" }

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

            HLSLPROGRAM
            // ------------------------------------------------------------------
            // Required URP pragmas for additional lights in this pass:
            #pragma vertex   Vert
            #pragma fragment Frag

            // IMPORTANT: these must be at PASS level (not in includes)
            #pragma multi_compile _ _ADDITIONAL_LIGHTS_VERTEX _ADDITIONAL_LIGHTS
            #pragma multi_compile_fragment _ _ADDITIONAL_LIGHT_SHADOWS
            #pragma multi_compile _ _CLUSTER_LIGHT_LOOP

            // Common URP switches
            #pragma multi_compile _ _MAIN_LIGHT_SHADOWS
            #pragma multi_compile _ _MAIN_LIGHT_SHADOWS_CASCADE
            #pragma multi_compile_fragment _ _SHADOWS_SOFT

            // Includes
            #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/RealtimeLights.hlsl"
            #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/CommonMaterial.hlsl"

            // Your helper header (the one you posted)
            #include "CustomLightShadows.hlsl"

            CBUFFER_START(UnityPerMaterial)
            float4 _BaseColor;
            CBUFFER_END

            struct Attributes
            {
                float4 positionOS : POSITION;
                float3 normalOS   : NORMAL;
            };

            struct Varyings
            {
                float4 positionCS : SV_POSITION;
                float3 positionWS : TEXCOORD0;
                float3 normalWS   : TEXCOORD1;
            };

            Varyings Vert (Attributes IN)
            {
                Varyings OUT;
                VertexPositionInputs vpi = GetVertexPositionInputs(IN.positionOS.xyz);
                OUT.positionCS = vpi.positionCS;
                OUT.positionWS = vpi.positionWS;

                VertexNormalInputs vni   = GetVertexNormalInputs(IN.normalOS);
                OUT.normalWS = NormalizeNormalPerPixel(vni.normalWS);

                return OUT;
            }

            half4 Frag (Varyings IN) : SV_Target
            {
                float3 N = normalize(IN.normalWS);

                // Example: accumulate your custom “unlit” contribution from additional lights
                float3 accum = 0;
            #if defined(_ADDITIONAL_LIGHTS)
                // Per-pixel loop
                uint lightCount = GetAdditionalLightsCount();
                [loop] for (uint i = 0; i < lightCount; i++)
                {
                    float shadowmask, lighting;
                    ComputeAdditionalLightContributionFull_float(IN.positionWS, N, i, shadowmask, lighting);

                    // You control how to combine these; here's a simple mix:
                    accum += lighting * (1.0 - shadowmask);
                }
            #endif

                return half4(_BaseColor.rgb + accum, _BaseColor.a);
            }
            ENDHLSL
        }
    }
}

Why this works: you’re still visually “Unlit,” but the pass declares the same URP light buffers/keywords the Lit target would. Your existing ComputeAdditionalLightContributionFull_float will now compile and run.

Option B — Keep Shader Graph, but host it inside a custom pass you own

If you really want to keep using nodes for other parts, a common pattern is:

Build a Shader Graph that outputs textures/parameters you care about (no additional-light calls).
Create a small custom URP shader/pass (like above) that:
- Has the required #pragma multi_compile ... for additional lights.
- Samples the SG outputs as inputs (via properties/textures).
- Does the additional-light loop and your custom shading in HLSL.

This lets you design content in SG while still having full control over lighting in your pass.

Option C — Custom SRP/Target (advanced)

You can implement a custom Shader Graph Target (via code) that mirrors Unlit but injects the additional-lights pragmas into the generated pass. This is robust, but it’s an editor extension task, not just shader code.

Quick checklist so it compiles first try

Put the multi_compile lines at the pass level (not in includes).
Include RealtimeLights.hlsl (for GetAdditionalLight, counts, etc.).
URP Asset: Additional Lights (Per Pixel or Per Vertex) enabled; Additional Lights Shadows enabled if you use them.
If you use Forward+ (clustered), enable it in the URP asset to match _CLUSTER_LIGHT_LOOP.

If you want, paste the exact way you want to combine lighting and shadowmask, and I’ll wire that into the fragment above, or help you wrap your Shader Graph into Option B’s “host pass.”

ok I have figured out a way to bypass this but I am now running into a new bug. My new hlsl file is like this

#ifndef CUSTOM_LIGHT_UTILS_INCLUDED #define CUSTOM_LIGHT_UTILS_INCLUDED

//#include “Packages/com.unity.render-pipelines.universal/ShaderLibrary/RealtimeLights.hlsl” //#include “Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl” //#include “Packages/com.unity.render-pipelines.core/ShaderLibrary/CommonMaterial.hlsl”

// Enable additional lights in the vertex or fragment shader stage //#pragma multi_compile _ _ADDITIONAL_LIGHTS_VERTEX _ADDITIONAL_LIGHTS

// Enable support for clustered lighting (used in Forward+) //#pragma multi_compile _ _CLUSTER_LIGHT_LOOP

// Enable shadow attenuation for additional lights //#pragma multi_compile_fragment _ _ADDITIONAL_LIGHT_SHADOWS

void AdditionalLightByIndex_float(float3 positionWS, const int lightIndex,out float3 Direction, out float3 Color, out float DistanceAtten, out float ShadowAtten) { #if SHADERGRAPH_PREVIEW Direction = float3(0.5, 0.5, 0); Color = 1; DistanceAtten = 1; ShadowAtten = 1; #else Light light = GetAdditionalLight(lightIndex, positionWS, half4(1, 1, 1, 1)); Color = light.color; Direction = light.direction; ShadowAtten = light.shadowAttenuation; DistanceAtten = light.distanceAttenuation; #endif }

#endif // CUSTOM_LIGHT_SHADOWS_INCLUDED

but when i try to add with a custom function within a subgraph although it does work I am getting an error message saying

undeclared identifier ‘AdditionalLightByIndex_half’ where did that come from?

That error is just a precision-mismatch from Shader Graph’s Custom Function conventions.

Shader Graph will call either YourFunc_float or YourFunc_half depending on the graph/subgraph/node precision.
Your file only defines:

void AdditionalLightByIndex_float(...)

…but your subgraph (or the node itself) is set to Half precision, so the generated code tries to call:

AdditionalLightByIndex_half(...)

which doesn’t exist → undeclared identifier 'AdditionalLightByIndex_half'.

Fix it (pick one)

A) Add a `_half` overload (quick & safe)

Either duplicate the body with half types, or just wrap the float version:

void AdditionalLightByIndex_float(float3 positionWS, const int lightIndex,
                                  out float3 Direction, out float3 Color,
                                  out float DistanceAtten, out float ShadowAtten)
{
#if SHADERGRAPH_PREVIEW
    Direction     = float3(0.5, 0.5, 0);
    Color         = float3(1, 1, 1);
    DistanceAtten = 1.0;
    ShadowAtten   = 1.0;
#else
    Light light   = GetAdditionalLight(lightIndex, positionWS, half4(1,1,1,1));
    Color         = light.color;
    Direction     = light.direction;
    ShadowAtten   = light.shadowAttenuation;
    DistanceAtten = light.distanceAttenuation;
#endif
}

void AdditionalLightByIndex_half(half3 positionWS, const int lightIndex,
                                 out half3 Direction, out half3 Color,
                                 out half DistanceAtten, out half ShadowAtten)
{
    // Simple wrapper to avoid code duplication
    float3 fDir, fCol;
    float  fDist, fShad;
    AdditionalLightByIndex_float((float3)positionWS, lightIndex, fDir, fCol, fDist, fShad);
    Direction     = (half3)fDir;
    Color         = (half3)fCol;
    DistanceAtten = (half)fDist;
    ShadowAtten   = (half)fShad;
}

B) Force the node/graph to use Float precision

In the Sub Graph Inspector set Precision = Float (or “Graph” and make the parent graph Float).
Or on the Custom Function Node itself, set Precision Override = Float.

Then SG will call _float and your existing function will work.

Small extras

In your preview branch, return float3(1,1,1) (you did, good) rather than a scalar, to keep types explicit.
Your include guard comment says // CUSTOM_LIGHT_SHADOWS_INCLUDED while the macro is CUSTOM_LIGHT_UTILS_INCLUDED — not a bug, just tidy it up later.

That’s it—either add the _half wrapper or switch the node’s precision to Float and the error will disappear.