Stencil portal effect

2025-11-06 12:32 UTC gpt-5-thinking Open in ChatGPT ↗

How to enable my custom renderer feature + pass to read the stencil buffer and do the classic operations (Equal, Not Equal etc) in order to achieve a portal effect

using System; using UnityEngine; using UnityEngine.Rendering; using UnityEngine.Rendering.Universal; using UnityEngine.Rendering.RenderGraphModule;

public class MaterialOverlayRenderFeature : ScriptableRendererFeature { private MaterialOverlayPass materialOverlayPass;

[Serializable]
public class Settings
{
    [Header("Injection")]
    public RenderPassEvent injectionPoint = RenderPassEvent.AfterRenderingOpaques;

    /*[Header("Output / Sharing")]
    public Color clearColor = Color.black;
    public bool setGlobalTexture = true;
    public string globalTextureName = "_OverrideOpaquesTex";
    public bool copyBackToCamera = false;   // optional composite*/
}

[Serializable]
public struct OverrideGroup {
    public string name;
    public LayerMask layerMask;
    public Material material;
    public int materialPass;
}

public Settings settings = new Settings();
public OverrideGroup[] _groups;

/// <inheritdoc/>
public override void Create()
{
    // Create the render pass that draws the objects, and pass in the override material
    materialOverlayPass = new MaterialOverlayPass(settings, _groups);

    // Insert render passes after URP's post-processing render pass
    materialOverlayPass.renderPassEvent = materialOverlayPass.injectionPoint;// RenderPassEvent.AfterRenderingOpaques;


    // You can request URP color texture and depth buffer as inputs by uncommenting the line below,
    // URP will ensure copies of these resources are available for sampling before executing the render pass.
    // Only uncomment it if necessary, it will have a performance impact, especially on mobiles and other TBDR GPUs where it will break render passes.
    //m_ScriptablePass.ConfigureInput(ScriptableRenderPassInput.Color | ScriptableRenderPassInput.Depth);

    // You can request URP to render to an intermediate texture by uncommenting the line below.
    // Use this option for passes that do not support rendering directly to the backbuffer.
    // Only uncomment it if necessary, it will have a performance impact, especially on mobiles and other TBDR GPUs where it will break render passes.
    //m_ScriptablePass.requiresIntermediateTexture = true;
}

// Here you can inject one or multiple render passes in the renderer.
// This method is called when setting up the renderer once per-camera.
public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData)
{
    renderer.EnqueuePass(materialOverlayPass);
}


class MaterialOverlayPass : ScriptableRenderPass
{
    readonly Settings s;
    public RenderPassEvent injectionPoint;
    private readonly OverrideGroup[] groups;

    public MaterialOverlayPass( Settings settings, OverrideGroup[] overrideGroups/*Material overrideMaterial*/)
    {
        s = settings;
        groups = overrideGroups;
        injectionPoint = s.injectionPoint;

    }

    // This class stores the data needed by the RenderGraph pass.
    // It is passed as a parameter to the delegate function that executes the RenderGraph pass.
    private class PassData
    {
        // Create a field to store the list of objects to draw
        //public RendererListHandle rendererListHandle;
        public RendererListHandle[] lists;
        //public TextureHandle colorOut;
        public Color clearColor;
        public TextureHandle cameraColor;
    }

    // This static method is passed as the RenderFunc delegate to the RenderGraph render pass.
    // It is used to execute draw commands.
    static void ExecutePass(PassData data, RasterGraphContext context)
    {

    }

    // RecordRenderGraph is where the RenderGraph handle can be accessed, through which render passes can be added to the graph.
    // FrameData is a context container through which URP resources can be accessed and managed.
    public override void RecordRenderGraph(RenderGraph renderGraph, ContextContainer frameData)
    {
        if (groups == null || groups.Length == 0) return;

        var camData = frameData.Get<UniversalCameraData>();
        var urpData = frameData.Get<UniversalRenderingData>();
        var light   = frameData.Get<UniversalLightData>();
        var res = frameData.Get<UniversalResourceData>();

        // Off-screen color + private depth (same as before)
        var colorDesc = camData.cameraTargetDescriptor;
        colorDesc.msaaSamples = 1;
        colorDesc.depthBufferBits = 0;
        var colorTex  = UniversalRenderer.CreateRenderGraphTexture(renderGraph, colorDesc, "_RG_MultiOverrideColor", false);

        var depthDesc = colorDesc;
        depthDesc.graphicsFormat = UnityEngine.Experimental.Rendering.GraphicsFormat.None;
        depthDesc.depthBufferBits = 32;
        var depthTex  = UniversalRenderer.CreateRenderGraphTexture(renderGraph, depthDesc, "_RG_MultiOverrideDepth", false);

        // Build a renderer list per group (opaque range + opaque sorting)
        //var tag   = new ShaderTagId("UniversalForward");
        var shaderTags = new System.Collections.Generic.List<ShaderTagId>
        {
            new ShaderTagId("UniversalForward"),       // URP Lit
            new ShaderTagId("UniversalForwardOnly"),   // common SG/Lit variants
            new ShaderTagId("SRPDefaultUnlit")         // SG Unlit
        };
        var sort  = camData.defaultOpaqueSortFlags; // CommonOpaque
        var lists = new System.Collections.Generic.List<RendererListHandle>(groups.Length);

        foreach (var g in groups)
        {
            if (g.material == null) continue;

            var draw = RenderingUtils.CreateDrawingSettings(shaderTags, urpData, camData, light, sort);
            draw.overrideMaterial          = g.material;
            draw.overrideMaterialPassIndex = g.materialPass;

            var filter = new FilteringSettings(RenderQueueRange.opaque, g.layerMask);
            var rlp    = new RendererListParams(urpData.cullResults, draw, filter);
            lists.Add(renderGraph.CreateRendererList(rlp ));
        }

        // One raster pass: bind attachments once, draw all lists
        using (var builder = renderGraph.AddRasterRenderPass<PassData>("Multi-Override Opaques (RG)", out var pass))
        {
            // Fill the data object that RG will pass to your render function
            pass.lists = lists.ToArray();     // 'lists' is your List<RendererListHandle>
            pass.clearColor = Color.black;
            pass.cameraColor = res.activeColorTexture;

            // Declare resources
            foreach (var rl in pass.lists) builder.UseRendererList(rl);
            builder.UseTexture(pass.cameraColor, AccessFlags.Read);         // <-- read camera color (has sky)
            builder.SetRenderAttachment(colorTex, 0, AccessFlags.Write);          // our off-screen color
            builder.SetRenderAttachmentDepth(depthTex, AccessFlags.Write);        // private depth


            builder.SetRenderFunc((PassData data, RasterGraphContext ctx) =>
            {

                // 1) Prefill our off-screen RT with the current camera color (which already includes the sky)
                Blitter.BlitTexture(ctx.cmd, data.cameraColor, new Vector4(1,1,0,0), 0, false);

                // 2) Clear only DEPTH (keep color we just copied)
                ctx.cmd.ClearRenderTarget(true, false, data.clearColor);

                // 3) Draw all opaque objects with your override materials
                foreach (var rl in data.lists)
                    ctx.cmd.DrawRendererList(rl);
            });
        }

        using (var builder = renderGraph.AddRasterRenderPass<PassData>(
                   "Multi-Override → Camera (RG)", out var copy))
        {
            // pass fields not needed here; just read + write
            builder.UseTexture(colorTex, AccessFlags.Read);
            builder.SetRenderAttachment(res.activeColorTexture, 0, AccessFlags.Write);

            builder.SetRenderFunc((PassData _, RasterGraphContext ctx) =>
            {
                Blitter.BlitTexture(ctx.cmd, colorTex, new Vector4(1,1,0,0), 0, false);
            });
        }


    }
}

}

You’re super close! The missing piece is: you’re allocating your own depth texture, so you’ve lost access to the camera’s stencil that earlier passes (or your own mask pass) would write into. Stencil tests only work against the depth/stencil attachment that’s currently bound for the raster pass—you can’t “sample” stencil like a texture.

Below is a compact, drop-in way to wire this up in URP + RenderGraph:

What we need to do

Write the portal mask to the camera’s stencil
Draw your portal geometry (or a quad) to camera depth/stencil, with ColorMask 0 and a stencil write like Ref 1, Pass Replace. You can do this with:
- a tiny “mask” material/shader (recommended), and
- a RenderStateBlock that enables stencil writes.
In your overlay pass, bind the camera depth/stencil (not a private one)
Use res.activeDepthTexture as the depth attachment, so your draws can do classic stencil tests (Equal, NotEqual, etc.) against the mask you wrote.
Clear depth only (if you want) but do NOT clear stencil
ctx.cmd.ClearRenderTarget(clearDepth:true, clearColor:false, …) doesn’t touch stencil, so your mask survives.
Apply the stencil test per “group”
Build a RenderStateBlock with an enabled StencilState + stencilReference, and pass it into RendererListParams so every object in that list uses the same stencil compare op.

Minimal code changes

1) Add stencil settings per group (so you can choose Equal, NotEqual, etc.)

[Serializable]
public struct OverrideGroup
{
    public string name;
    public LayerMask layerMask;
    public Material material;
    public int materialPass;

    // Stencil test config
    public UnityEngine.Rendering.CompareFunction stencilComp; // e.g. Equal, NotEqual
    public int stencilRef;          // e.g. 1
    public byte stencilReadMask;    // usually 0xFF
    public bool isMaskWriter;       // set true for the group that WRITES the stencil
}

Tip: For your mask writer group, set isMaskWriter = true, stencilRef = 1, and use a material/shader that has ColorMask 0 so it won’t touch color.

2) Use camera depth/stencil, not a private depth

Replace your private depthTex with the active camera one:

var depthTex = res.activeDepthTexture; // <- camera depth+stencil

3) Build two kinds of renderer lists: one to write the stencil, and the others to test it

// Build “mask writer” list first (if any)
RendererListHandle? maskList = null;
{
    var shaderTags = new System.Collections.Generic.List<ShaderTagId>
    {
        new ShaderTagId("UniversalForward"),
        new ShaderTagId("UniversalForwardOnly"),
        new ShaderTagId("SRPDefaultUnlit")
    };
    var sort = camData.defaultOpaqueSortFlags;

    foreach (var g in groups)
    {
        if (!g.isMaskWriter || g.material == null) continue;

        var draw = RenderingUtils.CreateDrawingSettings(shaderTags, urpData, camData, light, sort);
        draw.overrideMaterial = g.material;
        draw.overrideMaterialPassIndex = g.materialPass;

        var filter = new FilteringSettings(RenderQueueRange.opaque, g.layerMask);

        // Enable stencil WRITE (Replace). ReadMask isn’t used when writing; WriteMask defaults to 0xFF.
        var state = new StencilState(
            enabled: true,
            readMask: 0xFF,
            writeMask: 0xFF,
            compareFunctionFront: CompareFunction.Always,
            passOperationFront: StencilOp.Replace,
            failOperationFront: StencilOp.Keep,
            zFailOperationFront: StencilOp.Keep,
            compareFunctionBack: CompareFunction.Always,
            passOperationBack: StencilOp.Replace,
            failOperationBack: StencilOp.Keep,
            zFailOperationBack: StencilOp.Keep
        );

        var rsb = new RenderStateBlock(RenderStateMask.Stencil)
        {
            stencilReference = g.stencilRef,
            stencilState = state
        };

        var rlp = new RendererListParams(urpData.cullResults, draw, filter, rsb);
        maskList = renderGraph.CreateRendererList(rlp);
        break; // only one writer group expected
    }
}

// Build TEST lists for the overlay groups
var testLists = new System.Collections.Generic.List<(RendererListHandle rl, RenderStateBlock rsb)>();
{
    var shaderTags = new System.Collections.Generic.List<ShaderTagId>
    {
        new ShaderTagId("UniversalForward"),
        new ShaderTagId("UniversalForwardOnly"),
        new ShaderTagId("SRPDefaultUnlit")
    };
    var sort = camData.defaultOpaqueSortFlags;

    foreach (var g in groups)
    {
        if (g.isMaskWriter || g.material == null) continue;

        var draw = RenderingUtils.CreateDrawingSettings(shaderTags, urpData, camData, light, sort);
        draw.overrideMaterial = g.material;
        draw.overrideMaterialPassIndex = g.materialPass;

        var filter = new FilteringSettings(RenderQueueRange.opaque, g.layerMask);

        var state = new StencilState(
            enabled: true,
            readMask: g.stencilReadMask == 0 ? (byte)0xFF : g.stencilReadMask,
            writeMask: 0x00, // not writing here
            compareFunctionFront: g.stencilComp,
            passOperationFront: StencilOp.Keep,
            failOperationFront: StencilOp.Keep,
            zFailOperationFront: StencilOp.Keep,
            compareFunctionBack: g.stencilComp,
            passOperationBack: StencilOp.Keep,
            failOperationBack: StencilOp.Keep,
            zFailOperationBack: StencilOp.Keep
        );

        var rsb = new RenderStateBlock(RenderStateMask.Stencil)
        {
            stencilReference = g.stencilRef,
            stencilState = state
        };

        var rlp = new RendererListParams(urpData.cullResults, draw, filter, rsb);
        var rl = renderGraph.CreateRendererList(rlp);
        testLists.Add((rl, rsb));
    }
}

4) Do three RG passes (copy color, mask, overlay)

Keep your color flow as you already have it (off-screen color), but:
Bind depthTex = res.activeDepthTexture on both the mask and overlay passes
Clear depth only before overlay draws (stencil remains)

// A) Prefill off-screen color with camera color (same as your code)
using (var builder = renderGraph.AddRasterRenderPass<PassData>("Prefill Color (RG)", out var pass))
{
    pass.cameraColor = res.activeColorTexture;
    builder.UseTexture(pass.cameraColor, AccessFlags.Read);
    builder.SetRenderAttachment(colorTex, 0, AccessFlags.Write);
    builder.SetRenderAttachmentDepth(depthTex, AccessFlags.ReadWrite); // bind camera depth+stencil

    builder.SetRenderFunc((PassData data, RasterGraphContext ctx) =>
    {
        Blitter.BlitTexture(ctx.cmd, data.cameraColor, new Vector4(1,1,0,0), 0, false);
    });
}

// B) (Optional but recommended) draw the portal MASK into stencil
if (maskList.HasValue)
{
    using (var builder = renderGraph.AddRasterRenderPass<PassData>("Portal Mask → Stencil (RG)", out var pass))
    {
        builder.SetRenderAttachment(colorTex, 0, AccessFlags.Write); // color bound, but mask material should ColorMask 0
        builder.SetRenderAttachmentDepth(depthTex, AccessFlags.ReadWrite);

        builder.UseRendererList(maskList.Value);

        builder.SetRenderFunc((PassData _, RasterGraphContext ctx) =>
        {
            // No clears here – we want whatever depth exists.
            ctx.cmd.DrawRendererList(maskList.Value);
        });
    }
}

// C) Draw overlay groups with stencil tests
using (var builder = renderGraph.AddRasterRenderPass<PassData>("Multi-Override Opaques (RG)", out var pass))
{
    pass.clearColor = Color.black;
    // declare resources
    foreach (var (rl, _) in testLists) builder.UseRendererList(rl);
    builder.UseTexture(colorTex, AccessFlags.ReadWrite);                 // we’re writing on top of our off-screen color
    builder.SetRenderAttachment(colorTex, 0, AccessFlags.Write);
    builder.SetRenderAttachmentDepth(depthTex, AccessFlags.ReadWrite);   // camera depth+stencil

    builder.SetRenderFunc((PassData data, RasterGraphContext ctx) =>
    {
        // Clear DEPTH only; stencil remains intact
        ctx.cmd.ClearRenderTarget(true, false, data.clearColor);

        foreach (var (rl, _) in testLists)
            ctx.cmd.DrawRendererList(rl);
    });
}

// D) Blit result back to camera color (same as your code)
using (var builder = renderGraph.AddRasterRenderPass<PassData>("Multi-Override → Camera (RG)", out var copy))
{
    builder.UseTexture(colorTex, AccessFlags.Read);
    builder.SetRenderAttachment(res.activeColorTexture, 0, AccessFlags.Write);
    builder.SetRenderFunc((PassData _, RasterGraphContext ctx) =>
    {
        Blitter.BlitTexture(ctx.cmd, colorTex, new Vector4(1,1,0,0), 0, false);
    });
}

Tiny unlit “mask writer” shader (recommended)

This writes Ref 1 into stencil wherever your portal geometry is, without touching color:

Shader "Hidden/PortalMask"
{
    SubShader
    {
        Tags { "RenderType"="Opaque" "Queue"="Geometry" }
        ZWrite On
        ZTest LEqual
        ColorMask 0

        Stencil
        {
            Ref 1
            Comp Always
            Pass Replace
            Fail Keep
            ZFail Keep
            ReadMask 255
            WriteMask 255
        }

        Pass
        {
            HLSLPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            struct appdata { float4 vertex : POSITION; };
            struct v2f { float4 pos : SV_POSITION; };
            v2f vert(appdata v) { v2f o; o.pos = UnityObjectToClipPos(v.vertex); return o; }
            half4 frag(v2f i) : SV_Target { return 0; } // never written due to ColorMask 0
            ENDHLSL
        }
    }
}

Assign this material to the group with isMaskWriter = true.

Usage examples

Mask pass group:
isMaskWriter = true, stencilRef = 1 (Comp is ignored for writing).
Objects visible only inside portal:
isMaskWriter = false, stencilComp = CompareFunction.Equal, stencilRef = 1.
Objects visible only outside portal:
isMaskWriter = false, stencilComp = CompareFunction.NotEqual, stencilRef = 1.

Gotchas / notes

Don’t allocate your own depth if you need the camera’s stencil. Bind res.activeDepthTexture as your depth attachment.
Clearing depth only is fine; it won’t clear stencil. If you ever need to clear stencil, you’d have to do it explicitly (don’t do that for portals).
If you instead bake the stencil test into the override materials, you can skip the RenderStateBlock, but the code-side approach keeps the materials reusable.
On tiled/tiling GPUs (mobile), avoid unnecessary intermediate textures; your current two-pass color is okay, but keep an eye on bandwidth.

That’s it—write the mask to camera stencil, bind camera depth/stencil in your pass, and apply the stencil test via RenderStateBlock (or shader). Your portal effect will fall into place.

Short answer: yes—and there are two meanings of “two lightmaps” that Unity supports:

1) Multiple lightmap atlases at the same time (normal)

A single scene can (and usually does) use many baked lightmap textures simultaneously. Each Renderer has a lightmapIndex and lightmapScaleOffset, so different objects can live on different atlases in the same scene. Unity manages this automatically after a bake.

2) Two different baked sets you can switch between (A/B lighting)

If you mean “two alternative bakes” (e.g., Day vs Night) and you want to swap at runtime, that’s also supported. You swap the global lighting assets:

LightmapSettings.lightmaps (array of LightmapData)
LightmapSettings.lightmapsMode
LightmapSettings.lightProbes
RenderSettings bits (ambient, skybox, fog) if they differ
Reflection probe baked cubemaps if you baked them per scenario

Minimal swapper example

Bake each scenario and store references to its textures/probes (via inspector or a ScriptableObject). Then:

using UnityEngine;

[System.Serializable]
public class LightmapScenario
{
    public LightmapData[] lightmaps;      // drag your baked lightmaps here
    public LightProbes lightProbes;       // optional: baked probes asset
    public Material skybox;               // optional: if skybox differs
    public Color ambientColor = Color.black;
}

public class LightmapSwitcher : MonoBehaviour
{
    public LightmapScenario day;
    public LightmapScenario night;
    public bool startWithDay = true;

    void Start()
    {
        Apply(startWithDay ? day : night);
    }

    public void Apply(LightmapScenario s)
    {
        if (s.skybox) RenderSettings.skybox = s.skybox;
        RenderSettings.ambientMode = UnityEngine.Rendering.AmbientMode.Flat;
        RenderSettings.ambientLight = s.ambientColor;

        LightmapSettings.lightmaps = s.lightmaps ?? System.Array.Empty<LightmapData>();
        LightmapSettings.lightProbes = s.lightProbes;

        // If you changed skybox/ambient, update environment
        DynamicGI.UpdateEnvironment();
    }
}

Notes & gotchas

Same geometry = easiest swaps. If the renderers didn’t change (same order and count), their lightmapIndex + lightmapScaleOffset stay valid across scenarios. If geometry changes, you may need to remap indices.
Bundle reflection probes if you rely on baked reflections; swap their textures or load the scene that contains them.
Additive scenes option: You can keep Day and Night as separate additive scenes, each with its own Lighting Data Asset, and load/unload one or the other.
Memory: Two full sets means roughly 2× VRAM for lightmaps/probes while both are loaded. Use streaming/Addressables if needed.
Blend/fade: To cross-fade, lerp skybox/ambient and screen-blend between two lightmapped renders (or progressively swap albedo/indirect via custom shaders). Unity doesn’t blend lightmap sets automatically.

So, whether you mean “several atlases at once” (default) or “two alternative bakes you can toggle,” Unity can do both.

Yep—you can absolutely blend between two baked lightmaps in Shader Graph, but Unity only binds one official lightmap set at a time. So for a shader-side crossfade you need to bring your other bake in as your own textures and sample them using the lightmap UVs (UV2) and the renderer’s scale/offset—the same way Unity samples its bound lightmap.

Here are two solid ways to do it:

Option A (quickest): swap globally (no custom shader)

Just assign different sets to:

LightmapSettings.lightmaps
LightmapSettings.lightProbes
(plus skybox/ambient/reflection probes if needed)

This is the simplest “day/night” toggle, but you can’t blend the two.

Option B (your case): blend two bakes in Shader Graph

What you’ll do

Keep Unity’s bound lightmap as one input (or ignore it).
Provide your second bake as regular textures (or, better, a Texture2DArray) to the shader.
Sample with UV2 transformed by each renderer’s lightmapScaleOffset.
Lerp the two results.

⚠️ Packing matters: Atlas layout (per-renderer lightmapIndex and lightmapScaleOffset) can change across bakes. For robust blending, build a Texture2DArray per atlas index and set the slice index per renderer. That way you don’t rely on material instances per atlas.

Shader Graph setup

Properties

DayArray : Texture2DArray
NightArray : Texture2DArray
_LMIndex : Vector1 (Per-Renderer Data) — which slice to sample
_LMST : Vector4 (Per-Renderer Data) — scale/offset (x,y,z,w)
_Blend : Vector1 (0–1)

UV math

Use TexCoord node with channel 1 (UV2), or the Lightmap UV node.
uv = uv2 * _LMST.xy + _LMST.zw

Sampling

Sample Texture 2D Array (DayArray, uv, slice=_LMIndex)
Sample Texture 2D Array (NightArray, uv, slice=_LMIndex)
lerp(day, night, _Blend)

Plug into your custom lighting

If your graph is Unlit + custom lighting, treat the sampled value(s) as your baked indirect.

Directional lightmaps: if you baked Directional, you have two textures per atlas (color + directionality). You’d mirror the above with two arrays per scenario (ColorArray + DirArray) and apply Unity’s directional decode in your lighting function. If you baked Non-Directional, it’s just the color.

Feeding per-renderer data (C#)

Mark _LMIndex and _LMST as Per-Renderer Data in Shader Graph. Then:

// Editor/Setup step after bake OR at runtime init
void PushLightmapPerRendererData(Renderer r)
{
    var mpb = new MaterialPropertyBlock();
    r.GetPropertyBlock(mpb);

    // slice index = renderer.lightmapIndex
    mpb.SetFloat("_LMIndex", r.lightmapIndex);

    // scale/offset = renderer.lightmapScaleOffset
    mpb.SetVector("_LMST", r.lightmapScaleOffset);

    r.SetPropertyBlock(mpb);
}

Run this for all lightmapped renderers (and whenever indices change).

Building the Texture2DArrays (Editor utility)

After you bake Day and Night:

using UnityEditor;
using UnityEngine;

public static class LightmapArrayBuilder
{
    public static void BuildArrays(Texture2D[] dayAtlases, Texture2D[] nightAtlases,
                                   out Texture2DArray dayArray, out Texture2DArray nightArray)
    {
        // assume both sets have same count/sizes/format (best: enforce same bake settings)
        var w = dayAtlases[0].width;
        var h = dayAtlases[0].height;
        var fmt = dayAtlases[0].format;
        int slices = dayAtlases.Length;

        dayArray = new Texture2DArray(w, h, slices, fmt, /*mipChain*/ true, /*linear*/ true);
        nightArray = new Texture2DArray(w, h, slices, fmt, true, true);

        for (int i = 0; i < slices; i++)
        {
            var day = dayAtlases[i];
            var night = nightAtlases[i];

            // Make sure they’re readable or use Graphics.CopyTexture
            for (int m = 0; m < day.mipmapCount; m++)
            {
                Graphics.CopyTexture(day, 0, m, dayArray, i, m);
                Graphics.CopyTexture(night, 0, m, nightArray, i, m);
            }
        }

        dayArray.Apply(false, true);
        nightArray.Apply(false, true);

        AssetDatabase.CreateAsset(dayArray, "Assets/DayLightmaps.asset");
        AssetDatabase.CreateAsset(nightArray, "Assets/NightLightmaps.asset");
        AssetDatabase.SaveAssets();
    }
}

You can get the atlases from LightmapSettings.lightmaps (LightmapData.lightmapColor and, for directional, lightmapDir). Build one array per channel you need.

Blending

Drive _Blend from code/animation/timeline to crossfade.

Common pitfalls & tips

Atlas mismatch: If a rebake changes atlas count/order/packing, your _LMIndex and _LMST will differ between day/night, breaking per-pixel correspondence. Using per-index Texture2DArray keeps everything consistent as long as both scenarios have the same atlas count and sizes. If they differ, build a mapping between the two sets or rebuild arrays so slice i always corresponds to the same renderer set.
Gamma/linear: Make sure your arrays use the same color space as your project/bake (usually linear). Use Graphics.CopyTexture (no CPU readback) to preserve formats/mips.
Directional bakes: You need to sample both color and directional maps and apply the directional decode in your custom lighting. If you don’t need anisotropy from the sun direction, bake Non-Directional to simplify.
Per-Renderer Data: Don’t forget to tick “Per-Renderer Data” on _LMIndex and _LMST. Otherwise you’ll get one value shared by all objects.
SRP Batcher: Works fine with per-renderer properties; keep property names consistent across materials.

Bottom line

Yes, you can sample two baked lightmaps in Shader Graph and blend them—just treat your extra bake(s) as your own textures (ideally Texture2DArray), and sample with UV2 transformed by each renderer’s lightmap scale/offset.
If you don’t need an actual blend, swapping LightmapSettings.lightmaps is far simpler and memory-lighter.