Additional lights index stability

2025-10-22 09:23 UTC gpt-5-thinking Open in ChatGPT ↗

I am in Unity 6.2 and trying to get the additiuonal lights in a custom light shader using this script

#ifndef UNIVERSAL_REALTIME_LIGHTS_INCLUDED #define UNIVERSAL_REALTIME_LIGHTS_INCLUDED

#include “Packages/com.unity.render-pipelines.universal/ShaderLibrary/AmbientOcclusion.hlsl” #include “Packages/com.unity.render-pipelines.universal/ShaderLibrary/Input.hlsl” #include “Packages/com.unity.render-pipelines.universal/ShaderLibrary/Shadows.hlsl” #include “Packages/com.unity.render-pipelines.universal/ShaderLibrary/LightCookie/LightCookie.hlsl” #include “Packages/com.unity.render-pipelines.universal/ShaderLibrary/Clustering.hlsl”

// Abstraction over Light shading data. struct Light { half3 direction; half3 color; float distanceAttenuation; // full-float precision required on some platforms half shadowAttenuation; uint layerMask; };

#if USE_CLUSTER_LIGHT_LOOP && defined(LIGHTMAP_ON) && defined(LIGHTMAP_SHADOW_MIXING) #define CLUSTER_LIGHT_LOOP_SUBTRACTIVE_LIGHT_CHECK if (_AdditionalLightsColor[lightIndex].a > 0.0h) continue; #else #define CLUSTER_LIGHT_LOOP_SUBTRACTIVE_LIGHT_CHECK #endif

#if USE_CLUSTER_LIGHT_LOOP #define LIGHT_LOOP_BEGIN(lightCount) {
uint lightIndex;
ClusterIterator _urp_internal_clusterIterator = ClusterInit(inputData.normalizedScreenSpaceUV, inputData.positionWS, 0);
[loop] while (ClusterNext(_urp_internal_clusterIterator, lightIndex)) {
lightIndex += URP_FP_DIRECTIONAL_LIGHTS_COUNT;
CLUSTER_LIGHT_LOOP_SUBTRACTIVE_LIGHT_CHECK #define LIGHT_LOOP_END } } #else #define LIGHT_LOOP_BEGIN(lightCount)
for (uint lightIndex = 0u; lightIndex < lightCount; ++lightIndex) { #define LIGHT_LOOP_END } #endif

/////////////////////////////////////////////////////////////////////////////// // Attenuation Functions / ///////////////////////////////////////////////////////////////////////////////

// Matches Unity Vanilla HINT_NICE_QUALITY attenuation // Attenuation smoothly decreases to light range. float DistanceAttenuation(float distanceSqr, half2 distanceAttenuation) { // We use a shared distance attenuation for additional directional and puctual lights // for directional lights attenuation will be 1 float lightAtten = rcp(distanceSqr); float2 distanceAttenuationFloat = float2(distanceAttenuation);

// Use the smoothing factor also used in the Unity lightmapper.
half factor = half(distanceSqr * distanceAttenuationFloat.x);
half smoothFactor = saturate(half(1.0) - factor * factor);
smoothFactor = smoothFactor * smoothFactor;

return lightAtten * smoothFactor;

}

half AngleAttenuation(half3 spotDirection, half3 lightDirection, half2 spotAttenuation) { // Spot Attenuation with a linear falloff can be defined as // (SdotL - cosOuterAngle) / (cosInnerAngle - cosOuterAngle) // This can be rewritten as // invAngleRange = 1.0 / (cosInnerAngle - cosOuterAngle) // SdotL * invAngleRange + (-cosOuterAngle * invAngleRange) // SdotL * spotAttenuation.x + spotAttenuation.y

// If we precompute the terms in a MAD instruction
half SdotL = dot(spotDirection, lightDirection);
half atten = saturate(SdotL * spotAttenuation.x + spotAttenuation.y);
return atten * atten;

}

/////////////////////////////////////////////////////////////////////////////// // Light Abstraction // ///////////////////////////////////////////////////////////////////////////////

Light GetMainLight() { Light light; light.direction = half3(_MainLightPosition.xyz); #if USE_CLUSTER_LIGHT_LOOP #if defined(LIGHTMAP_ON) && defined(LIGHTMAP_SHADOW_MIXING) light.distanceAttenuation = _MainLightColor.a; #else light.distanceAttenuation = 1.0; #endif #else light.distanceAttenuation = unity_LightData.z; // unity_LightData.z is 1 when not culled by the culling mask, otherwise 0. #endif light.shadowAttenuation = 1.0; light.color = _MainLightColor.rgb;

light.layerMask = _MainLightLayerMask;

return light;

}

Light GetMainLight(float4 shadowCoord) { Light light = GetMainLight(); light.shadowAttenuation = MainLightRealtimeShadow(shadowCoord); return light; }

Light GetMainLight(float4 shadowCoord, float3 positionWS, half4 shadowMask) { Light light = GetMainLight(); light.shadowAttenuation = MainLightShadow(shadowCoord, positionWS, shadowMask, _MainLightOcclusionProbes);

#if defined(_LIGHT_COOKIES)
    real3 cookieColor = SampleMainLightCookie(positionWS);
    light.color *= cookieColor;
#endif

return light;

}

Light GetMainLight(InputData inputData, half4 shadowMask, AmbientOcclusionFactor aoFactor) { Light light = GetMainLight(inputData.shadowCoord, inputData.positionWS, shadowMask);

#if defined(_SCREEN_SPACE_OCCLUSION) && !defined(_SURFACE_TYPE_TRANSPARENT)
if (IsLightingFeatureEnabled(DEBUGLIGHTINGFEATUREFLAGS_AMBIENT_OCCLUSION))
{
    light.color *= aoFactor.directAmbientOcclusion;
}
#endif

return light;

}

// Fills a light struct given a perObjectLightIndex Light GetAdditionalPerObjectLight(int perObjectLightIndex, float3 positionWS) { // Abstraction over Light input constants #if USE_STRUCTURED_BUFFER_FOR_LIGHT_DATA float4 lightPositionWS = _AdditionalLightsBuffer[perObjectLightIndex].position; half3 color = _AdditionalLightsBuffer[perObjectLightIndex].color.rgb; half4 distanceAndSpotAttenuation = _AdditionalLightsBuffer[perObjectLightIndex].attenuation; half4 spotDirection = _AdditionalLightsBuffer[perObjectLightIndex].spotDirection; uint lightLayerMask = _AdditionalLightsBuffer[perObjectLightIndex].layerMask; #else float4 lightPositionWS = _AdditionalLightsPosition[perObjectLightIndex]; half3 color = _AdditionalLightsColor[perObjectLightIndex].rgb; half4 distanceAndSpotAttenuation = _AdditionalLightsAttenuation[perObjectLightIndex]; half4 spotDirection = _AdditionalLightsSpotDir[perObjectLightIndex]; uint lightLayerMask = asuint(_AdditionalLightsLayerMasks[perObjectLightIndex]); #endif

// Directional lights store direction in lightPosition.xyz and have .w set to 0.0.
// This way the following code will work for both directional and punctual lights.
float3 lightVector = lightPositionWS.xyz - positionWS * lightPositionWS.w;
float distanceSqr = max(dot(lightVector, lightVector), HALF_MIN);

half3 lightDirection = half3(lightVector * rsqrt(distanceSqr));
// full-float precision required on some platforms
float attenuation = DistanceAttenuation(distanceSqr, distanceAndSpotAttenuation.xy) * AngleAttenuation(spotDirection.xyz, lightDirection, distanceAndSpotAttenuation.zw);

Light light;
light.direction = lightDirection;
light.distanceAttenuation = attenuation;
light.shadowAttenuation = 1.0; // This value can later be overridden in GetAdditionalLight(uint i, float3 positionWS, half4 shadowMask)
light.color = color;
light.layerMask = lightLayerMask;

return light;

}

uint GetPerObjectLightIndexOffset() { #if USE_STRUCTURED_BUFFER_FOR_LIGHT_DATA return uint(unity_LightData.x); #else return 0; #endif }

// Returns a per-object index given a loop index. // This abstract the underlying data implementation for storing lights/light indices int GetPerObjectLightIndex(uint index) { ///////////////////////////////////////////////////////////////////////////////////////////// // Structured Buffer Path / // / // Lights and light indices are stored in StructuredBuffer. We can just index them. / // Currently all non-mobile platforms take this path :( / // There are limitation in mobile GPUs to use SSBO (performance / no vertex shader support) / ///////////////////////////////////////////////////////////////////////////////////////////// #if USE_STRUCTURED_BUFFER_FOR_LIGHT_DATA uint offset = uint(unity_LightData.x); return _AdditionalLightsIndices[offset + index];

///////////////////////////////////////////////////////////////////////////////////////////// // UBO path / // / // We store 8 light indices in half4 unity_LightIndices[2]; / // Due to memory alignment unity doesn’t support int[] or float[] / // Even trying to reinterpret cast the unity_LightIndices to float[] won’t work / // it will cast to float4[] and create extra register pressure. :( / ///////////////////////////////////////////////////////////////////////////////////////////// #else // since index is uint shader compiler will implement // div & mod as bitfield ops (shift and mask).

// TODO: Can we index a float4? Currently compiler is
// replacing unity_LightIndicesX[i] with a dp4 with identity matrix.
// u_xlat16_40 = dot(unity_LightIndices[int(u_xlatu13)], ImmCB_0_0_0[u_xlati1]);
// This increases both arithmetic and register pressure.
//
// NOTE: min16float4 bug workaround.
// Take the "vec4" part into float4 tmp variable in order to force float4 math.
// It appears indexing half4 as min16float4 on DX11 can fail. (dp4 {min16f})
float4 tmp = unity_LightIndices[index / 4];
return int(tmp[index % 4]);

#endif }

// Fills a light struct given a loop i index. This will convert the i // index to a perObjectLightIndex Light GetAdditionalLight(uint i, float3 positionWS) { #if USE_CLUSTER_LIGHT_LOOP int lightIndex = i; #else int lightIndex = GetPerObjectLightIndex(i); #endif return GetAdditionalPerObjectLight(lightIndex, positionWS); }

Light GetAdditionalLight(uint i, float3 positionWS, half4 shadowMask) { #if USE_CLUSTER_LIGHT_LOOP int lightIndex = i; #else int lightIndex = GetPerObjectLightIndex(i); #endif Light light = GetAdditionalPerObjectLight(lightIndex, positionWS);

#if USE_STRUCTURED_BUFFER_FOR_LIGHT_DATA half4 occlusionProbeChannels = _AdditionalLightsBuffer[lightIndex].occlusionProbeChannels; #else half4 occlusionProbeChannels = _AdditionalLightsOcclusionProbes[lightIndex]; #endif light.shadowAttenuation = AdditionalLightShadow(lightIndex, positionWS, light.direction, shadowMask, occlusionProbeChannels); #if defined(_LIGHT_COOKIES) real3 cookieColor = SampleAdditionalLightCookie(lightIndex, positionWS); light.color *= cookieColor; #endif

return light;

}

Light GetAdditionalLight(uint i, InputData inputData, half4 shadowMask, AmbientOcclusionFactor aoFactor) { Light light = GetAdditionalLight(i, inputData.positionWS, shadowMask);

#if defined(_SCREEN_SPACE_OCCLUSION) && !defined(_SURFACE_TYPE_TRANSPARENT)
if (IsLightingFeatureEnabled(DEBUGLIGHTINGFEATUREFLAGS_AMBIENT_OCCLUSION))
{
    light.color *= aoFactor.directAmbientOcclusion;
}
#endif

return light;

}

int GetAdditionalLightsCount() { #if USE_CLUSTER_LIGHT_LOOP // Counting the number of lights in clustered requires traversing the bit list, and is not needed up front. return 0; #else // TODO: we need to expose in SRP api an ability for the pipeline cap the amount of lights // in the culling. This way we could do the loop branch with an uniform // This would be helpful to support baking exceeding lights in SH as well return int(min(_AdditionalLightsCount.x, unity_LightData.y)); #endif }

half4 CalculateShadowMask(InputData inputData) { // To ensure backward compatibility we have to avoid using shadowMask input, as it is not present in older shaders #if defined(SHADOWS_SHADOWMASK) && defined(LIGHTMAP_ON) half4 shadowMask = inputData.shadowMask; // Shadowmask was sampled from lightmap #elif !defined(LIGHTMAP_ON) && (defined(PROBE_VOLUMES_L1) || defined(PROBE_VOLUMES_L2)) half4 shadowMask = inputData.shadowMask; // Shadowmask (probe occlusion) was sampled from APV #elif !defined (LIGHTMAP_ON) half4 shadowMask = unity_ProbesOcclusion; // Sample shadowmask (probe occlusion) from legacy probes #else half4 shadowMask = half4(1, 1, 1, 1); // Fallback shadowmask, fully unoccluded #endif

return shadowMask;

}

#endif

I am just wondering how is the additional light index calculated internally because I see that as i move my camera around the order of additional light changes and I am trying to figure out a way to address that so I can be sure I turn on and off the correct light at all times

Short answer: the index isn’t stable—by design. 🙂

Here’s what’s going on in URP (Unity 6.2 / URP 16-ish) for additional lights and why the order changes as you move the camera.

How the index is produced (two code paths)

Your file already supports both URP paths:

Forward+ / Clustered (USE_CLUSTER_LIGHT_LOOP)

The loop is driven by:

ClusterIterator it = ClusterInit(inputData.normalizedScreenSpaceUV, inputData.positionWS, 0);
while (ClusterNext(it, lightIndex)) {
    lightIndex += URP_FP_DIRECTIONAL_LIGHTS_COUNT; // note the offset
    ...
}

Each frame, URP builds a per-screen-cluster list of lights that intersect that cluster.
As your object (or camera) moves, it falls into different clusters or different subsets of the same cluster, and the order inside that list is not guaranteed. It’s implementation-dependent and may vary with culling results, light type, etc.
Bottom line: in Forward+, i is just “the ith light in this cluster today”—not a persistent ID.

Classic Forward (non-clustered)

The loop uses a per-object light list:

int GetPerObjectLightIndex(uint i) {
    float4 packed = unity_LightIndices[i / 4];
    return int(packed[i % 4]);
}

URP assembles that list during culling for each renderer. It picks the lights that affect the object (culling mask, rendering layers, range, spot cone), then sorts them by an internal “importance” (typically distance / influence, maybe shadows), and truncates to the pipeline limits.
Move the camera or the object, and the set and order of “most relevant” lights for that renderer can change—so indices shift.

In both paths, there is no stable mapping from i to a specific Light across frames.

Don’t key logic off the index — use a stable identifier

Since you can’t rely on i, pick a criterion that is stable:

1) Rendering Layers (recommended, built-in)

URP already passes a per-light rendering layer mask to shaders; you’re even copying it:

uint lightLayerMask = ...; // _AdditionalLightsLayerMasks[...] or from buffer
light.layerMask = lightLayerMask;

Use that to select the lights you care about:

// Material property you set from C#: which light layers should affect this shader?
CBUFFER_START(UnityPerMaterial)
    uint _WantedLightLayers; // e.g., (1u << 8) | (1u << 12)
CBUFFER_END

bool LightMatches(uint lightMask, uint wanted) { return (lightMask & wanted) != 0u; }

// In your light loop:
if (!LightMatches(light.layerMask, _WantedLightLayers)) continue;

// (Optional) also require the light to match the object’s rendering layers:
if ((light.layerMask & inputData.renderingLayers) == 0u) continue;

From C#, assign your special lights to specific Rendering Layer bits (per-Light: Rendering Layer Mask) and set _WantedLightLayers on materials (or via a global for a whole pass). Those bits don’t change with the camera, so you’re always targeting the same lights regardless of index order.

2) Per-light grouping via LayerMasks + per-material filters

Same idea as above, but you expose several masks (e.g., _KeyLightLayers, _FillLightLayers) so the shader can treat groups differently.

3) Custom buffers (advanced)

If you truly need a specific Unity Light (e.g., “the lantern with instance ID X”) in the shader:

From C#, build your own StructuredBuffer of the exact lights you care about (positions, colors, and a stable identifier you choose).
Sample that in the shader in addition to URP’s lighting, or replace URP’s additional loop for your effect path.
This guarantees a stable order because you own the list.

Don’t try to “reverse map” URP’s lightIndex to an engine Light reliably—it’s intentionally abstracted and can be reordered or culled at any step.

A tiny pattern you can drop in today

// Per-material bitmask of the lights this material should react to
CBUFFER_START(UnityPerMaterial)
    uint _ActiveLightLayers; // set from script
CBUFFER_END

half3 accum = 0;

LIGHT_LOOP_BEGIN(GetAdditionalLightsCount())
{
    Light L = GetAdditionalLight(lightIndex, inputData, CalculateShadowMask(inputData), aoFactor);

    // Keep only our intended lights
    if ((L.layerMask & _ActiveLightLayers) == 0u)
        continue;

    // (optional) also make sure light matches the object’s rendering layers
    if ((L.layerMask & inputData.renderingLayers) == 0u)
        continue;

    // …do your BRDF…
    accum += L.color * L.shadowAttenuation * L.distanceAttenuation * max(0, dot(N, L.direction));
}
LIGHT_LOOP_END

From C#:

// Choose stable bits to tag your lights
const uint KeyLightBit = 1u << 10;
const uint RimLightBit = 1u << 11;

// Assign lights once (stable across frames)
keyLight.renderingLayerMask |= KeyLightBit;
rimLight.renderingLayerMask |= RimLightBit;

// Tell the material which lights to use
material.SetInt("_ActiveLightLayers", (int)(KeyLightBit | RimLightBit));

TL;DR

The index changes because URP constantly rebuilds and (re)orders the additional-light lists per cluster (Forward+) or per object (Forward) based on relevance.
Never depend on i mapping to a particular Light.
Use Rendering Layers (or your own light buffer) to create a stable, camera-independent selection and then filter in-shader.

Great—since you’re already calling GetAdditionalLight(...) from a Shader Graph Custom Function, you can swap the “index” input for a Rendering Layer mask and filter inside the light loop. Below are two drop-in HLSL variants:

1) Pick the first light that matches a Rendering Layer mask

Use this if you want “the” key light tagged with a specific layer bit.

#ifndef ADDITIONAL_LIGHT_BY_LAYER_FIRST_INCLUDED
#define ADDITIONAL_LIGHT_BY_LAYER_FIRST_INCLUDED

#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Input.hlsl"
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/RealtimeLights.hlsl" // for GetAdditionalLight, GetAdditionalLightsCount, LIGHT_LOOP_BEGIN/END

// Returns the FIRST additional light whose Rendering Layer mask matches `wantedLayers`
void AdditionalLightByLayer_First_float(
    float3 positionWS,
    uint   wantedLayers,
    out float3 Direction,
    out float3 Color,
    out float  DistanceAtten,
    out float  ShadowAtten,
    out uint   Found)
{
#if SHADERGRAPH_PREVIEW
    Direction      = float3(0.5, 0.5, 0);
    Color          = 1;
    DistanceAtten  = 1;
    ShadowAtten    = 1;
    Found          = 1;
#else
    Direction      = 0;
    Color          = 0;
    DistanceAtten  = 0;
    ShadowAtten    = 1;
    Found          = 0;

    // Neutral shadow mask (we’re not sampling LM/APV here)
    const half4 shadowMask = half4(1,1,1,1);

    // Works for both classic forward and clustered (Forward+) because of the macros:
    LIGHT_LOOP_BEGIN(GetAdditionalLightsCount())
    {
        Light L = GetAdditionalLight(lightIndex, positionWS, shadowMask);

        // Filter by Rendering Layers (stable across frames)
        if ( (L.layerMask & wantedLayers) == 0u )
            continue;

        // If you also want to ensure the light matches the OBJECT's rendering layers, uncomment:
        // if ( (L.layerMask & inputData.renderingLayers) == 0u ) continue;

        Direction     = L.direction;
        Color         = L.color;
        DistanceAtten = L.distanceAttenuation;
        ShadowAtten   = L.shadowAttenuation;
        Found         = 1u;
        break; // take the first match
    }
    LIGHT_LOOP_END
#endif
}

#endif

Shader Graph hookup

Create a Custom Function node (File mode) pointing at AdditionalLightByLayer_First.hlsl.
Inputs:
- positionWS (Float3) → feed the Position (World Space) node.
- wantedLayers (Vector1 → will be cast to uint) → expose a material property _WantedLightLayers.
Outputs: Direction, Color, DistanceAtten, ShadowAtten, Found.

2) Accumulate all matching lights (most common)

Use this when you want normal lighting but only from lights on particular layers.

#ifndef ADDITIONAL_LIGHTS_BY_LAYER_ACCUMULATE_INCLUDED
#define ADDITIONAL_LIGHTS_BY_LAYER_ACCUMULATE_INCLUDED

#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Input.hlsl"
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/RealtimeLights.hlsl"

void AdditionalLightsByLayer_Accumulate_float(
    float3 positionWS,
    float3 normalWS,
    uint   wantedLayers,
    out float3 AccumColor,
    out uint   Count)
{
#if SHADERGRAPH_PREVIEW
    AccumColor = 1;
    Count      = 1;
#else
    AccumColor = 0;
    Count      = 0;

    // Ensure N is normalized
    half3 N = normalize(half3(normalWS));
    const half4 shadowMask = half4(1,1,1,1);

    LIGHT_LOOP_BEGIN(GetAdditionalLightsCount())
    {
        Light L = GetAdditionalLight(lightIndex, positionWS, shadowMask);
        if ( (L.layerMask & wantedLayers) == 0u )
            continue;

        // Simple Lambert; replace with your BRDF
        half  NdotL   = saturate(dot(N, L.direction));
        half3 contrib = L.color * (L.distanceAttenuation * L.shadowAttenuation) * NdotL;

        AccumColor += contrib;
        Count++;
    }
    LIGHT_LOOP_END
#endif
}
#endif

Shader Graph hookup

Inputs:
- positionWS → Position (World).
- normalWS → Normal (World).
- wantedLayers → _WantedLightLayers (Vector1/Integer).
Output: AccumColor (plug into your lighting), Count (optional debug).

How to set Rendering Layers

In the Light Inspector

Set Rendering Layer Mask to tag your light(s) with specific bits.
- e.g., check bit 10 for a “KeyLight” tag.

Rendering Layers are not the same as Physics/Editor Layers. They’re a separate 32-bit mask used purely for rendering.

In material / graph

Expose an integer property _WantedLightLayers and feed it to the Custom Function.
- Example values:
  - Only bit 10: 1 << 10 → 1024
  - Bits 10 and 11: (1 << 10) | (1 << 11) → 3072

From C# (optional, to keep it tidy and stable)

public static class RenderLayerBits
{
    public const uint KeyLight = 1u << 10;
    public const uint RimLight = 1u << 11;
}

// Tag your lights once (stable, camera-independent)
keyLight.renderingLayerMask |= RenderLayerBits.KeyLight;
rimLight.renderingLayerMask |= RenderLayerBits.RimLight;

// Tell the material which lights to use
material.SetInt("_WantedLightLayers", (int)(RenderLayerBits.KeyLight | RenderLayerBits.RimLight));

Notes & gotchas

Clustered vs Forward: The LIGHT_LOOP_BEGIN/END macro and GetAdditionalLight handle both paths; you don’t have to branch. In clustered, GetAdditionalLightsCount() returns 0, but the macro’s internal iterator still yields lights—so keep using the macro exactly like above.
Object rendering layers (optional): If you want a light to affect only objects that also carry the same layer bit, add a Rendering Layers node in Shader Graph (or access inputData.renderingLayers inside a surface function) and check (L.layerMask & objectLayers) != 0u as well.
Preview: Shader Graph preview doesn’t run URP light loops, so the code has a preview fallback.

This swap gets you off unstable per-frame indices and onto stable, authorable tags. Plug either function into your graph, set your bits, and you’re good.

Short answer: you can do that, but it won’t make the shader indices stable—and it’s a pretty brittle signal.

Why:

URP builds the additional-light list per cluster (Forward+) or per object (Forward) and can reorder it any frame. A camera-side sort you do in C# won’t change how URP orders lights inside the shader loop, so GetAdditionalLight(i, …) can still point at a different light next frame.
“Can the camera see the light’s transform?” isn’t the same as “does this light matter for the pixel?” A light can be off-screen or its emitter blocked but still brightly illuminate a visible surface. Conversely, your ray to the light can be unoccluded while the light→surface path is blocked (shadows).
It doesn’t generalize: directional lights have no point to raycast to; area lights too. And tiny occluders near the camera will cause jitter in your order.

That said, if you still want to use camera→light visibility as a heuristic to pick your own stable set of lights, do it in C#, create your own stable mapping, and stop relying on URP’s per-frame index. Two practical ways:

Option A (recommended): use Rendering Layers as your “IDs”

In C#, choose the k lights you want (using any heuristic—raycast, frustum, distance).
Assign them fixed Rendering Layer bits (e.g., bit 10 = slot0, bit 11 = slot1, …).
In your shader/Shader Graph, filter additional lights by those bits (as in my previous message).
This gives you deterministic selection regardless of URP’s internal ordering.

// Example: pick two lights most “visible” to the camera
static readonly uint Slot0 = 1u << 10;
static readonly uint Slot1 = 1u << 11;

void PickLights(Camera cam, LayerMask occluders, Material mat) {
    var lights = FindObjectsOfType<Light>();
    var camPos = cam.transform.position;
    var planes = GeometryUtility.CalculateFrustumPlanes(cam);

    // Build scored list
    var scored = new List<(Light L, float score, bool visible)>(lights.Length);
    foreach (var L in lights) {
        if (!L.enabled || L.intensity <= 0f) continue;
        if (L.type == LightType.Directional) { // always candidate, no raycast
            scored.Add((L, float.MaxValue, true));
            continue;
        }

        // Frustum check (cheap)
        var b = new Bounds(L.transform.position, Vector3.one * (L.range * 2f));
        if (!GeometryUtility.TestPlanesAABB(planes, b)) continue;

        // Raycast from camera to light position (heuristic)
        var dir = (L.transform.position - camPos);
        var dist = dir.magnitude;
        bool blocked = Physics.Raycast(camPos, dir / dist, dist, occluders, QueryTriggerInteraction.Ignore);
        float score = (blocked ? 0.5f : 1f) / Mathf.Max(1e-3f, dist); // prefer unblocked & closer
        scored.Add((L, score, !blocked));
    }

    // Stable sort: by score, then by instance ID for determinism
    scored.Sort((a, b) => {
        int c = b.score.CompareTo(a.score);
        return c != 0 ? c : a.L.GetInstanceID().CompareTo(b.L.GetInstanceID());
    });

    // Clear old tags, then tag winners with fixed bits
    foreach (var s in scored) s.L.renderingLayerMask &= ~(uint)(Slot0 | Slot1);
    if (scored.Count > 0) scored[0].L.renderingLayerMask |= Slot0;
    if (scored.Count > 1) scored[1].L.renderingLayerMask |= Slot1;

    // Tell the material which bits to accept
    mat.SetInt("_WantedLightLayers", (int)(Slot0 | Slot1));
}

Pros: simple, deterministic, works with your current Shader Graph via a small Custom Function that filters by layer bits.
Cons: still a heuristic—but your selection is stable; URP’s internal indices can shuffle and it won’t matter.

Option B (advanced): push your own light array to the shader

Instead of using GetAdditionalLight(i, …), build a small ComputeBuffer/StructuredBuffer with positions/colors/etc of the exact lights you pick and read that in the shader. Then you’re 100% in control of order and count. (Useful if you need slots like “key/fill/rim” with guaranteed indices.)

If you insist on keeping `GetAdditionalLight(i, …)`

Raycasting won’t fix index flips. If you absolutely must address “the correct light” in a specific slot:

Don’t use indices from URP.
Tag the light with a Rendering Layer bit (Option A), and find it at runtime in the loop by matching L.layerMask & wantedBits and breaking on the first match. That gives you a stable “slot” without caring about the loop order.

Practical tips for your raycast heuristic (if used)

Ignore triggers, and choose a sensible occluder mask (skip transparent FX layers).
Use a stable tiebreaker (e.g., GetInstanceID()) to prevent micro-wobble when scores are nearly equal.
Limit N (e.g., test max 32 lights) to keep CPU cost sane.
Don’t raycast for directional lights; treat them as always visible.
Cache per-frame; don’t allocate lists each Update in hot paths.

Bottom line: Your raycast idea is “legit” as a selection heuristic, but it won’t stabilize URP’s additional-light indices. The robust fix is to stop depending on indices and use Rendering Layers (or your own buffer) to make the mapping stable.

Got it—your setup (3 scene lights, a C# “master controller,” Shader Graph driving on/off by an Index + Activation value) will keep flipping because URP’s additional-light index is not stable. The clean way to keep your timeline sliders in charge is:

give each slot (A/B/C) a Rendering Layer bit,
tag the corresponding Unity Light with that bit from your controller,
in the shader, ignore indices and filter the additional-light loop by those bits, multiplied by your activation sliders.

Below is an end-to-end drop-in.

1) C# controller – assign stable “slot bits” to your 3 lights

Pick three bits you won’t use elsewhere (example: 10–12):

public static class LightSlots
{
    public const uint SlotA = 1u << 10;
    public const uint SlotB = 1u << 11;
    public const uint SlotC = 1u << 12;
}

[System.Serializable]
public class AdditionalLightEntry
{
    public Light light;       // scene Light
    public Color color = Color.white;
    public float intensity = 1f;
    public int index;         // 0=A, 1=B, 2=C  (your UI field)
    public float activation;  // your slider value 0..1 sent to shader
}

public class AdditionalLightsController : MonoBehaviour
{
    public Material targetMaterial;          // the material that your Shader Graph uses
    public AdditionalLightEntry[] entries;   // size 3

    static uint SlotBitFromIndex(int idx)
    {
        switch (idx)
        {
            case 0: return LightSlots.SlotA;
            case 1: return LightSlots.SlotB;
            case 2: return LightSlots.SlotC;
            default: return 0u;
        }
    }

    void LateUpdate()
    {
        // Clear our three bits from every listed light first (prevents stale tags)
        foreach (var e in entries)
        {
            if (!e.light) continue;
            e.light.renderingLayerMask &= ~(LightSlots.SlotA | LightSlots.SlotB | LightSlots.SlotC);
        }

        // Apply color/intensity and (re)tag each light with the desired slot bit
        foreach (var e in entries)
        {
            if (!e.light) continue;

            e.light.color = e.color;
            e.light.intensity = e.intensity;

            uint bit = SlotBitFromIndex(e.index);
            e.light.renderingLayerMask |= bit;
        }

        // Send the **activation sliders** to the material (these are what you animate on a Timeline)
        float actA = 0f, actB = 0f, actC = 0f;
        foreach (var e in entries)
        {
            switch (e.index)
            {
                case 0: actA = e.activation; break;
                case 1: actB = e.activation; break;
                case 2: actC = e.activation; break;
            }
        }
        targetMaterial.SetFloat("_AL_activation_A", actA);
        targetMaterial.SetFloat("_AL_activation_B", actB);
        targetMaterial.SetFloat("_AL_activation_C", actC);
    }
}

Notes

You can keep reassigning which physical light is A/B/C by changing index—the controller just moves the rendering-layer bit to that light.
Your Timeline only needs to keyframe the three activation floats and (optionally) the index integers.

2) Shader Graph Custom Function – accumulate only the lights with our bits

Create a file (e.g., AdditionalLights_Slots.hlsl) and point a Custom Function node (File mode) to it.

#ifndef ADDITIONAL_LIGHTS_SLOTS_INCLUDED
#define ADDITIONAL_LIGHTS_SLOTS_INCLUDED

#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Input.hlsl"
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/RealtimeLights.hlsl"

// Choose the same bits as the C# controller
static const uint SLOT_A = (1u << 10);
static const uint SLOT_B = (1u << 11);
static const uint SLOT_C = (1u << 12);

// Accumulates contribution from lights tagged as A/B/C,
// multiplied by your Activation sliders (0..1).
void AdditionalLights_Slots_float(
    float3 positionWS,
    float3 normalWS,
    float  AL_activation_A,
    float  AL_activation_B,
    float  AL_activation_C,
    out float3 OutColor)
{
#if SHADERGRAPH_PREVIEW
    OutColor = 0;
#else
    half3 N = normalize((half3)normalWS);
    const half4 shadowMask = half4(1,1,1,1);

    half3 accum = 0;

    LIGHT_LOOP_BEGIN(GetAdditionalLightsCount())
    {
        Light L = GetAdditionalLight(lightIndex, positionWS, shadowMask);

        // Find which slot this light is in
        uint lm = L.layerMask;
        half weight = 0;

        if ((lm & SLOT_A) != 0u)      weight = (half)AL_activation_A;
        else if ((lm & SLOT_B) != 0u) weight = (half)AL_activation_B;
        else if ((lm & SLOT_C) != 0u) weight = (half)AL_activation_C;
        else                          continue; // not one of our three slots

        // Simple Lambert; keep your own BRDF if needed
        half NdotL = saturate(dot(N, L.direction));
        half3 contrib = L.color * (L.distanceAttenuation * L.shadowAttenuation) * NdotL;

        accum += contrib * weight;
    }
    LIGHT_LOOP_END

    OutColor = accum;
#endif
}

#endif

Shader Graph wiring

Inputs:
- positionWS → Position (World Space).
- normalWS → Normal (World Space).
- AL_activation_A/B/C → expose 3 float properties with those exact names.
Output:
- OutColor → blend into your lighting/emission as you like.

What changes in your UI?

Keep your Color and Intensity sliders exactly as you have; they still go straight to the Light components.
Keep your Index per entry, but now it only decides which slot bit the light carries (A/B/C), not a shader “array index.”
Animate AL_activation_A/B/C in Timeline. Those drive on/off in the shader for the three slots, independent of URP’s changing internal ordering.

Why this works (and your animation stays deterministic)

URP may reorder additional lights internally every frame; we don’t care anymore.
Each light you care about is tagged with a unique, stable Rendering Layer bit (A/B/C).
The shader loops all additional lights (in any order) and picks the ones with those bits, multiplying by your animated Activation values.
Changing which physical light is A/B/C is as simple as flipping the index in your controller—it updates the renderingLayerMask on that light, and the shader “finds” it automatically.

If you want, I can adapt the HLSL to return three separate colors (one per slot) instead of a single accumulated color—handy if you need different BRDF or routing per slot.

Totally—here’s the 101 on Rendering Layers in URP and how they help with lights.

What Rendering Layers are

A separate 32-bit mask used only by the renderer (URP/HDRP) to control how lights/decals/shadows affect renderers.
Not the same as Unity “Layers” (physics/culling) and not the same as GameObject tags.
Think of them as light routing bits. Each Light has a mask; each Renderer (MeshRenderer, SkinnedMeshRenderer, etc.) has a mask. URP treats a light as affecting a renderer only if their masks overlap.

Formally: a light contributes to an object if
(light.renderingLayerMask & renderer.renderingLayerMask) != 0.

Where you set them

On Lights: Inspector → Rendering Layer Mask (under Additional Settings).
On Renderers: Inspector → Rendering Layer Mask (under Additional Settings).
URP Asset: You can give the 32 bits nice names: Project Settings → URP Asset → Rendering Layers.

By default, everything is on the same default bit so all lights affect all objects.

Why they’re perfect for your case

You need stable “slots” (A/B/C) that you can animate from Timeline and that don’t change when URP reorders additional lights. Rendering Layer bits are stable and authorable:

Pick three bits (e.g., A=bit10, B=bit11, C=bit12).
Your controller tags whichever physical lights should be A/B/C by setting those bits on the Light components.
In the shader you ignore indices and simply check a light’s layerMask to see if it’s A/B/C, then multiply by your animated activation sliders.

Even if URP shuffles the internal list, the shader still finds “the A light” because of the bit, not the index.

Accessing Rendering Layers in code & shaders

C#

// Tagging a Light as “slot A”
const uint SlotA = 1u << 10;  // choose any unused bit
light.renderingLayerMask |= SlotA;

// Making an object only receive lights from A or B:
const uint SlotB = 1u << 11;
renderer.renderingLayerMask = SlotA | SlotB;

Shader Graph / HLSL

URP passes:

Per-light mask as light.layerMask inside the additional-light loop.
Per-object mask as inputData.renderingLayers (you can also get it with the Shader Graph node Rendering Layers).

Typical checks:

// Keep lights that are tagged as slot A/B/C
if ((L.layerMask & SLOT_A) == 0u) continue;      // only slot A

// If you ALSO want to require the object to opt-in:
if ((L.layerMask & inputData.renderingLayers) == 0u) continue;

You don’t have to filter by the object’s mask for your “slot control” use case. If you want the A/B/C lights to affect everything, just test the light’s mask.

Common uses (so you have intuition)

Per-character lighting: put “hero fill light” on a custom bit and give only the hero’s renderers that bit.
Decals: project decals only on vehicles by matching bits.
Shadows: you can restrict which objects cast/receive via rendering-layer aware passes.

Limits & notes

You get 32 bits total. Use a few high bits for your slots to avoid collisions with other team features.
Names in the URP asset are cosmetic—changing a name doesn’t affect the bit values you’ve already set.
Works in both classic Forward and Forward+ (clustered). The per-light layerMask is still available in the clustered loop.
Shader Graph lacks bitwise nodes; do these checks in a Custom Function (as shown earlier).
Doesn’t affect camera culling or physics—only lighting/decals/shadows.

If you want, I can show a minimal “hello world” Shader Graph node that returns three separate colors (A/B/C) using these bits, so your Timeline sliders can drive each independently.