fix: address Copilot review — DS UV split, .metal source, changelog

- Fix default inputFrame UV split for DeSmuME2015 (bufferSize=2048×2048):
  the old 0–0.5 split sampled the full texture width/height, but the valid
  DS content only occupies the top-left 256×384 region; now normalises by
  DS native dimensions (256×192 per screen) so UVs land on correct texels
  for both padded (2048×2048) and native-size (256×384) textures
- Add dual_screen_blit.metal to PVShaders/Blitters as the canonical source
  of the dual-screen shaders; add comment in PVMetalViewController+DualScreen
  explaining why the inline copy is used at runtime (cross-bundle access)
- Drop trailing period from .changelog/3509.md to match project style

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: github-actions[bot]

.changelog/3509.md

@@ -1,5 +1,5 @@
 ### Added
-- **DS Dual-Screen Metal Rendering** — Nintendo DS games with a DeltaSkin active now render both screens as GPU-side sub-rectangle blits in a single Metal render pass. The combined 256×384 DS framebuffer is split into top (rows 0–191) and bottom (rows 192–383) viewports that match the skin's screen layout, supporting portrait (stacked) and landscape (side-by-side) configurations
+- **DS Dual-Screen Metal Rendering** — Nintendo DS games with a DeltaSkin active now render both screens as GPU-side sub-rectangle blits in a single Metal render pass; the combined 256×384 DS framebuffer is split into top (rows 0–191) and bottom (rows 192–383) viewports that match the skin's screen layout, supporting portrait (stacked) and landscape (side-by-side) configurations
 
 ### Changed
 - **melonDS / DeSmuME skin support** — `supportsSkins` is now `true` for both DS cores, enabling DeltaSkin overlays and controller layouts when a compatible skin is installed

PVShaders/Sources/PVShaders/Resources/Metal/Blitters/dual_screen_blit.metal

@@ -0,0 +1,51 @@
+// dual_screen_blit.metal
+// PVShaders
+//
+// Canonical Metal shaders for the dual-screen sub-rectangle renderer.
+//
+// These functions are the authoritative source for the shaders used in
+// PVMetalViewController+DualScreen.  The identical source is also embedded
+// as the inline string `PVMetalViewController.dualScreenShaderSource` so
+// that it can be compiled at runtime via `device.makeLibrary(source:)` on
+// any device regardless of bundle access.
+//
+// Vertex input: buffer(0) holds an array of float4 where
+//   .xy = clip-space (NDC) position
+//   .zw = texture UV coordinate
+//
+// A four-vertex triangle strip draws one screen quad per draw call.
+
+#include <metal_stdlib>
+using namespace metal;
+
+struct DSVSOut {
+    float4 position [[position]];
+    float2 texCoord;
+};
+
+/// Pass-through vertex shader: unpacks (NDC.xy, UV.zw) from a flat float4 array.
+vertex DSVSOut dual_screen_vs(
+    uint             vid      [[vertex_id]],
+    constant float4 *vertices [[buffer(0)]])
+{
+    DSVSOut out;
+    out.position = float4(vertices[vid].xy, 0.0f, 1.0f);
+    out.texCoord = vertices[vid].zw;
+    return out;
+}
+
+/// Fragment shader: samples the combined DS framebuffer texture at the UV
+/// interpolated by the vertex shader.  A constexpr sampler with linear
+/// filtering and clamp-to-edge is used so there are no sampler bindings
+/// required from the host.
+fragment half4 dual_screen_ps(
+    DSVSOut         in     [[stage_in]],
+    texture2d<half> source [[texture(0)]])
+{
+    constexpr sampler s(coord::normalized,
+                        address::clamp_to_edge,
+                        filter::linear);
+    half4 c = source.sample(s, in.texCoord);
+    c.a = 1.0h;
+    return c;
+}

PVUI/Sources/PVUIBase/PVEmulatorVC/PVEmulatorViewController+MetalDualScreen.swift

@@ -131,9 +131,18 @@ extension PVEmulatorViewController {
                                  width: inFrame.width  / texW,
                                  height: inFrame.height / texH)
             } else {
-                // Default: split the framebuffer into equal vertical halves.
-                let halfH: CGFloat = 0.5
-                srcRect = CGRect(x: 0, y: CGFloat(index) * halfH, width: 1, height: halfH)
+                // Default: split the framebuffer based on DS native screen dimensions.
+                // DS native: 256 px wide, 192 px per screen, 384 px combined height.
+                // Some emulators (e.g. DeSmuME2015) report a large padded bufferSize
+                // (2048×2048) where the valid DS content sits only in the top-left
+                // 256×384 region.  Normalising by texW/texH ensures the UVs land on
+                // the correct texels rather than always splitting the full 0–1 range.
+                let dsNativeW: CGFloat = 256  // DS screen width in native pixels
+                let dsNativeH: CGFloat = 192  // DS per-screen height in native pixels
+                srcRect = CGRect(x: 0,
+                                 y: CGFloat(index) * (dsNativeH / texH),
+                                 width:  dsNativeW / texW,
+                                 height: dsNativeH / texH)
             }
 
             // --- Destination (view-space points) ---

PVUI/Sources/PVUIBase/PVGLViewController/PVMetalViewController+DualScreen.swift

@@ -55,8 +55,13 @@ extension PVMetalViewController {
 
     /// Metal source for the dual-screen sub-rectangle blit shaders.
     ///
-    /// Compiled at runtime via `makeLibrary(source:)` — the same pattern used
-    /// elsewhere in PVMetalViewController for inline shaders.
+    /// The canonical source lives in
+    /// `PVShaders/Sources/PVShaders/Resources/Metal/Blitters/dual_screen_blit.metal`.
+    /// That file is compiled into the PVShaders bundle's metallib during the Xcode
+    /// build, but loading it at runtime requires explicit bundle access across the
+    /// module boundary.  To avoid that coupling (and to match the pattern used by
+    /// every other shader in PVMetalViewController) we embed an identical copy here
+    /// and compile it at runtime via `device.makeLibrary(source:)`.
     static let dualScreenShaderSource = """
     #include <metal_stdlib>
     using namespace metal;