GraphEvaluator: fix dispatch heuristic + 0-as-passthrough for OutputW/H

Two related bugs surfaced when wiring the new ShaderLab Scale effect
through the bridge:

1) "Fixed-size viewer" detection treated *any* effect declaring
   OutputWidth/OutputHeight as a single-group scatter shader and
   dispatched (1,1,1). That was correct for CIE Histogram-style
   shaders that use [numthreads(32,32,1)] and iterate the whole
   source image inside one group, but wrong for per-pixel-tile
   shaders like the new Scale that use [numthreads(8,8,1)] and need
   (W/8, H/8, 1). With (1,1,1) only 64 threads ran -- painting an
   8x8 corner of the output and leaving everything else as the cleared
   zeros from the UAV clear (= black).

   Replace the parameter-name discriminator with a thread-group-size
   one: groups >= 256 threads are treated as single-group scatter
   shaders; smaller groups tile per-pixel. The legacy
   DiagramSize / OutputSize parameter check stays as a belt-and-
   suspenders fallback for any future descriptor that intentionally
   uses a small group with single-group dispatch (none today).

2) OutputWidth = 0 / OutputHeight = 0 (= "pass through at source
   dims") was being floored at 64 by max(*f, 64.0f). Pass-through
   needs to fall through to the upstream-bounds path so the output
   texture matches the source.

   Drop the floor in the explicitW / explicitH read; treat 0 as
   "not set" and let later passes (DiagramSize fallback, then source
   bounds fallback) decide. The shaders own per-pixel guard
   (`if (dtid.x >= outW) return`) handles the actual size.

Verified: ShaderLab Scale at 0.5x on a 4K HDR video source now
produces correct 1920x1080 Lanczos-3 output (sample center pixel
matches source content, full frame visible).

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

Author: Spruill-1

Rendering/GraphEvaluator.cpp

@@ -1150,16 +1150,16 @@ namespace ShaderLab::Rendering
                 if (key == L"OutputWidth")
                 {
                     if (auto* f = std::get_if<float>(&val))
-                        explicitW = static_cast<UINT32>((std::max)(*f, 64.0f));
+                        explicitW = (*f >= 1.0f) ? static_cast<UINT32>(*f) : 0;
                     else if (auto* u = std::get_if<uint32_t>(&val))
-                        explicitW = (std::max)(*u, 64u);
+                        explicitW = *u;
                 }
                 else if (key == L"OutputHeight")
                 {
                     if (auto* f = std::get_if<float>(&val))
-                        explicitH = static_cast<UINT32>((std::max)(*f, 64.0f));
+                        explicitH = (*f >= 1.0f) ? static_cast<UINT32>(*f) : 0;
                     else if (auto* u = std::get_if<uint32_t>(&val))
-                        explicitH = (std::max)(*u, 64u);
+                        explicitH = *u;
                 }
             }
             if (explicitW > 0 && explicitH > 0)
@@ -1336,13 +1336,22 @@ namespace ShaderLab::Rendering
         if (hasImageOutput && imageOutW > 0 && imageOutH > 0 &&
             def.threadGroupX > 0 && def.threadGroupY > 0)
         {
-            bool isFixedSizeViewer = false;
+            // Discriminator: single-group scatter shaders use a large
+            // thread group (commonly 32x32 = 1024) and dispatch (1,1,1);
+            // per-pixel-tile shaders use a small group (commonly 8x8 = 64)
+            // and dispatch (W/tx, H/ty, 1). Threshold at 256 cleanly
+            // separates the two conventions in the current catalog.
+            //
+            // The DiagramSize / OutputSize parameter names ALSO mark fixed-
+            // output viewers (CIE Histogram, etc.) that pre-date the
+            // generic threshold; keep that check for descriptors that use
+            // an 8x8 group but still want single-group dispatch (none
+            // exist today, but the check is cheap and safe).
+            const bool largeGroup = (def.threadGroupX * def.threadGroupY) >= 256;
+            bool isFixedSizeViewer = largeGroup;
             for (const auto& p : def.parameters)
             {
-                if (p.name == L"DiagramSize"  ||
-                    p.name == L"OutputSize"   ||
-                    p.name == L"OutputWidth"  ||
-                    p.name == L"OutputHeight")
+                if (p.name == L"DiagramSize" || p.name == L"OutputSize")
                 {
                     isFixedSizeViewer = true;
                     break;