Split Comparison: host-injected output dimensions

D2D pads pixel-shader intermediates to atlas allocation sizes (typically
4096x4096) when an effect output has multiple downstream consumers, so
HLSL `Texture2D::GetDimensions()` returns the atlas size rather than the
true output rect. The previous Split Comparison fix (TRIVIAL_SAMPLING)
got `uv0` into output coordinates, but `GetDimensions()` was still
reporting 4096x4096 -- so the recentering math `uv0 - (W*0.5, H*0.5)`
landed the pivot at (2048, 2048), placing the wipe seam at the bottom
edge of a 3840x2160 video.

Reproducer that I missed last round: two branches forking from the same
upstream effect (e.g. video -> HDR Tone Map -> {Gamut Highlight, Gamut
Highlight}) feeding the two Split inputs. With a single branch
(video -> tone map -> split, with video also direct -> split), D2D
doesn't atlas-pad and GetDimensions matches the rect, so the pivot was
correct. The user's full graph has the fork pattern, exposing the bug.

Fix: dont rely on GetDimensions. Add `OutputW` / `OutputH` (float)
hidden cbuffer fields to the Split shader, and have GraphEvaluator's
pixel-shader EvaluateNode case populate them each frame from the
upstream input's `GetImageLocalBounds`. Generic mechanism: any pixel
shader that declares `OutputW` / `OutputH` parameters gets host-injected
dimensions automatically, gated on the parameter declaration so other
effects pay no per-frame cost.

Bumped Split Comparison effectVersion 4 -> 5.

Also added /render/image-bounds MCP route to expose the raw pre-clamp
GetImageLocalBounds for debugging rect-bloat issues that the capture-node
maxDim clamp would otherwise hide.

Verified: white line at y=1080 of a 2160-tall video output (was at the
bottom edge before). 154/154 tests pass.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: Spruill-1

Effects/ShaderLabEffects.cpp

@@ -2392,6 +2392,11 @@ cbuffer Constants : register(b0)
     float Angle;           // degrees; 0 = horizontal wipe (vertical line),
                            // 90 = vertical wipe (horizontal line),
                            // 45 = top-left-to-bottom-right diagonal
+    float OutputW;         // host-injected: actual output rect width in
+                           // pixels. Cant use Texture2D::GetDimensions()
+                           // because D2D pads intermediates to atlas
+                           // allocation sizes (typically 4096x4096).
+    float OutputH;         // host-injected: actual output rect height.
 };
 
 float4 main(
@@ -2401,23 +2406,18 @@ float4 main(
     float4 a = ImageA.Load(int3(uv0.xy, 0));
     float4 b = ImageB.Load(int3(uv0.xy, 0));
 
-    uint w, h;
-    ImageA.GetDimensions(w, h);
-    float W = float(w);
-    float H = float(h);
+    // Use the host-supplied output dimensions, not GetDimensions(), since
+    // D2D pads input textures to atlas allocation sizes (e.g. 4096x4096
+    // when the actual output rect is 3840x2160). uv0 is in true pixel
+    // coords thanks to D2D1_PIXEL_OPTIONS_TRIVIAL_SAMPLING; we just need
+    // the matching output-rect dimensions to recenter on.
+    float W = max(OutputW, 1.0);
+    float H = max(OutputH, 1.0);
 
     // Direction vector along which we project pixel positions.
     float radians = Angle * 3.14159265 / 180.0;
     float2 dir = float2(cos(radians), sin(radians));
 
-    // For an effect with inputs (Split has 2), `uv0` (TEXCOORD0) is the
-    // scene/pixel-space position the inputs are sampled at, so it
-    // matches the output rect 1:1. SV_POSITION isnt reliable here --
-    // for some D2D draw configurations its in clip space, not pixel
-    // space, and recentering on (W*0.5, H*0.5) lands the pivot in
-    // the wrong place. (Source-like effects without inputs *can* use
-    // SV_POSITION reliably, but thats a separate code path.)
-    //
     // Project the pixel coord (relative to image center) onto dir.
     // SplitPosition = 0..1 sweeps the wipe across the full extent of
     // the image *along* the dir vector, with 0.5 always pivoting on
@@ -2443,7 +2443,7 @@ float4 main(
 
             ShaderLabEffectDescriptor desc;
             desc.name = L"Split Comparison";
-            desc.effectId = L"Split Comparison"; desc.effectVersion = 4;
+            desc.effectId = L"Split Comparison"; desc.effectVersion = 5;
             desc.category = L"Analysis";
             desc.subcategory = L"Comparison";
             desc.shaderType = Graph::CustomShaderType::PixelShader;
@@ -2453,6 +2453,10 @@ float4 main(
                 { L"SplitPosition", L"float",   0.5f,    0.0f,   1.0f,  0.01f },
                 { L"LineWidth",     L"float",   2.0f,    0.0f,  10.0f,  0.5f },
                 { L"Angle",         L"float",   0.0f, -360.0f, 360.0f,  1.0f },
+                // Hidden: host writes actual output-rect dimensions
+                // each frame (see GraphEvaluator's pixel-shader eval).
+                Graph::ParameterDefinition{ L"OutputW", L"float", 1.0f, 1.0f, 16384.0f, 1.0f, {}, L"", true },
+                Graph::ParameterDefinition{ L"OutputH", L"float", 1.0f, 1.0f, 16384.0f, 1.0f, {}, L"", true },
             };
             m_effects.push_back(std::move(desc));
         }

Engine/Mcp/EngineMcpRoutes.cpp

@@ -1138,6 +1138,40 @@ namespace ShaderLab::Mcp
                     });
                 });
         }
+        // ---- POST /render/image-bounds — return raw GetImageLocalBounds -----
+        // Body: { nodeId }. Returns { width, height } at 96 DPI in pixels.
+        // Useful for diagnosing rect-bloat issues that the capture-node
+        // route hides via its maxDim clamp.
+        void RegisterImageBounds(McpHttpServer& server, IEngineCommandSink& sink)
+        {
+            server.AddRoute(L"POST", L"/render/image-bounds",
+                [&sink](const std::wstring&, const std::string& body) -> McpHttpServer::Response
+                {
+                    return sink.Dispatch([&body](EngineContext& ctx) -> McpHttpServer::Response {
+                        WDJ::JsonObject jo{ nullptr };
+                        if (!WDJ::JsonObject::TryParse(winrt::to_hstring(body), jo))
+                            return Json(400, R"({"error":"Invalid JSON body"})");
+                        if (!jo.HasKey(L"nodeId"))
+                            return Json(400, R"({"error":"'nodeId' is required"})");
+                        uint32_t nodeId = static_cast<uint32_t>(jo.GetNamedNumber(L"nodeId"));
+                        if (ctx.renderFrame) ctx.renderFrame();
+                        auto* node = ctx.graph->FindNode(nodeId);
+                        if (!node || !node->cachedOutput)
+                            return Json(404, R"({"error":"Node not ready"})");
+                        float oldDpiX = 0, oldDpiY = 0;
+                        ctx.dc->GetDpi(&oldDpiX, &oldDpiY);
+                        ctx.dc->SetDpi(96.0f, 96.0f);
+                        D2D1_RECT_F bounds{};
+                        ctx.dc->GetImageLocalBounds(node->cachedOutput, &bounds);
+                        ctx.dc->SetDpi(oldDpiX, oldDpiY);
+                        return Json(200, std::format(
+                            R"({{"left":{},"top":{},"right":{},"bottom":{},"width":{},"height":{}}})",
+                            bounds.left, bounds.top, bounds.right, bounds.bottom,
+                            bounds.right - bounds.left, bounds.bottom - bounds.top));
+                    });
+                });
+        }
+
         // ---- POST /render/capture-node — render any node to PNG ------------
         // Body: { nodeId, inline?:bool }. Saves PNG to %TEMP%; returns
         // path + size. If inline=true, also returns a base64 PNG payload.
@@ -1599,6 +1633,7 @@ namespace ShaderLab::Mcp
         RegisterGetGraph(server, sink);
         RegisterCustomEffects(server, sink);
         RegisterAnalysisOutput(server, sink);
+        RegisterImageBounds(server, sink);
         RegisterCaptureNode(server, sink);
         RegisterCompileEffect(server, sink);
         RegisterGetDisplayProfiles(server, sink);

Rendering/GraphEvaluator.cpp

@@ -538,6 +538,59 @@ namespace ShaderLab::Rendering
                     bool bindingsChanged = ResolveBindings(*node, graph, effectiveProps);
                     bool wasDirty = node->dirty || bindingsChanged;
 
+                    // Inject host-driven output dimensions for shaders that
+                    // declare OutputW / OutputH cbuffer fields. D2D pads input
+                    // textures to atlas allocation sizes (typically 4096x4096),
+                    // so HLSL `Texture2D::GetDimensions()` is unreliable for
+                    // anything that needs the true output rect (e.g. Split
+                    // Comparisons center-of-image pivot). The shader uses
+                    // these values instead.
+                    bool declaresOutputDims = false;
+                    if (node->customEffect->shaderType == Graph::CustomShaderType::PixelShader)
+                    {
+                        for (const auto& p : node->customEffect->parameters)
+                        {
+                            if (p.name == L"OutputW" || p.name == L"OutputH")
+                            { declaresOutputDims = true; break; }
+                        }
+                    }
+                    if (declaresOutputDims)
+                    {
+                        auto inputs = graph.GetInputEdges(nodeId);
+                        if (!inputs.empty())
+                        {
+                            auto* srcNode = graph.FindNode(inputs[0]->sourceNodeId);
+                            if (srcNode && srcNode->cachedOutput && dc)
+                            {
+                                float oldDpiX = 0, oldDpiY = 0;
+                                dc->GetDpi(&oldDpiX, &oldDpiY);
+                                dc->SetDpi(96.0f, 96.0f);
+                                D2D1_RECT_F bounds{};
+                                dc->GetImageLocalBounds(srcNode->cachedOutput, &bounds);
+                                dc->SetDpi(oldDpiX, oldDpiY);
+                                float w = bounds.right - bounds.left;
+                                float h = bounds.bottom - bounds.top;
+                                if (w > 0 && h > 0)
+                                {
+                                    auto wIt = effectiveProps.find(L"OutputW");
+                                    auto hIt = effectiveProps.find(L"OutputH");
+                                    bool changed =
+                                        (wIt == effectiveProps.end() ||
+                                         !std::holds_alternative<float>(wIt->second) ||
+                                         std::get<float>(wIt->second) != w) ||
+                                        (hIt == effectiveProps.end() ||
+                                         !std::holds_alternative<float>(hIt->second) ||
+                                         std::get<float>(hIt->second) != h);
+                                    effectiveProps[L"OutputW"] = w;
+                                    effectiveProps[L"OutputH"] = h;
+                                    node->properties[L"OutputW"] = w;
+                                    node->properties[L"OutputH"] = h;
+                                    if (changed) wasDirty = true;
+                                }
+                            }
+                        }
+                    }
+
                     // Write resolved binding values back to node properties
                     // so the node graph UI shows live bound values.
                     if (bindingsChanged)