meltygui 0.1.0__py3-none-any.whl

meltygui/core/graphics/scene_target.py

@@ -0,0 +1,180 @@
+"""The fp16 scene target and the presentation pass.
+
+Every frame renders into ONE offscreen target instead of the window's
+default framebuffer: RGBA16F colour (linear scRGB, negatives and values
+above 1 kept — see hdr_color.py) plus a D24S8 renderbuffer (the split
+renderer's per-window stencil masks need it). Everything that used to say
+"framebuffer 0" — the studio's clear, imgui, the tile-cache snapshot, the
+filters, the corner pass — asks `Melty.default_framebuffer()` and gets the
+scene while a frame is open.
+
+`present()` is the last GL work before the swap: it binds the real default
+framebuffer and encodes the scene for the swapchain — `Toggles.HDR.output`
+"srgb" for an untagged SDR window, "pq" (BT.2020 + ST 2084) for a surface
+tagged PQ. The swapchain is 8-bit on this driver (NVIDIA egl-wayland offers
+no 10-bit / fp16 window configs), so the encode is where HDR is quantized;
+an fp16 dmabuf swapchain replaces this pass with a copy.
+
+Module-level GL state survives hotswap (`globals().get`), like titlebar.py.
+"""
+from __future__ import annotations
+
+import OpenGL.GL as gl
+
+from meltygui.core.graphics.gl_state import GLState
+from meltygui.core.graphics.gl_state import GLTexture
+from meltygui.core.graphics.gl_state import is_gl_thread
+from meltygui.hdr_color import GLSL_ENCODE
+from meltygui.core.graphics.shader_func import shader_func
+
+_STATE = globals().get("_STATE", {
+    "fbo": 0, "tex": None, "rbo": None, "size": (0, 0), "active": False, "gl": None,
+})
+
+
+def active() -> bool:
+    return bool(_STATE["active"])
+
+
+def framebuffer() -> int:
+    """The framebuffer a frame's draws go to: the scene while one is open, else 0."""
+    return int(_STATE["fbo"]) if _STATE["active"] else 0
+
+
+def texture() -> GLTexture | None:
+    return _STATE["tex"]
+
+
+def _release():
+    if _STATE["fbo"]:
+        gl.glDeleteFramebuffers(1, [int(_STATE["fbo"])])
+    if _STATE["rbo"]:
+        gl.glDeleteRenderbuffers(1, [int(_STATE["rbo"])])
+    if _STATE["tex"] is not None:
+        gl.glDeleteTextures([_STATE["tex"].texture_id])
+    _STATE.update(fbo=0, tex=None, rbo=None, size=(0, 0))
+
+
+def _ensure(width: int, height: int) -> None:
+    width, height = max(1, int(width)), max(1, int(height))
+    if _STATE["fbo"] and _STATE["size"] == (width, height):
+        return
+    _release()
+    tex = int(gl.glGenTextures(1))
+    gl.glBindTexture(gl.GL_TEXTURE_2D, tex)
+    gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGBA16F, width, height, 0,
+                    gl.GL_RGBA, gl.GL_HALF_FLOAT, None)
+    gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_NEAREST)
+    gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_NEAREST)
+    gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_S, gl.GL_CLAMP_TO_EDGE)
+    gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_T, gl.GL_CLAMP_TO_EDGE)
+    gl.glBindTexture(gl.GL_TEXTURE_2D, 0)
+    rbo = int(gl.glGenRenderbuffers(1))
+    gl.glBindRenderbuffer(gl.GL_RENDERBUFFER, rbo)
+    gl.glRenderbufferStorage(gl.GL_RENDERBUFFER, gl.GL_DEPTH24_STENCIL8, width, height)
+    gl.glBindRenderbuffer(gl.GL_RENDERBUFFER, 0)
+    fbo = int(gl.glGenFramebuffers(1))
+    gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, fbo)
+    gl.glFramebufferTexture2D(gl.GL_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT0, gl.GL_TEXTURE_2D, tex, 0)
+    gl.glFramebufferRenderbuffer(gl.GL_FRAMEBUFFER, gl.GL_DEPTH_STENCIL_ATTACHMENT, gl.GL_RENDERBUFFER, rbo)
+    status = gl.glCheckFramebufferStatus(gl.GL_FRAMEBUFFER)
+    if status != gl.GL_FRAMEBUFFER_COMPLETE:
+        gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
+        gl.glDeleteFramebuffers(1, [fbo])
+        gl.glDeleteRenderbuffers(1, [rbo])
+        gl.glDeleteTextures([tex])
+        raise RuntimeError(f"scene target incomplete: 0x{status:04X} ({width}x{height})")
+    _STATE.update(fbo=fbo, rbo=rbo, size=(width, height),
+                  tex=GLTexture(tex, gl.GL_TEXTURE_2D, (height, width), gl.GL_RGBA16F))
+
+
+def begin(width: int, height: int) -> int:
+    """Frame start (LSDStudio.render, before the clear): size the scene to
+    the REAL framebuffer and bind it. Returns the framebuffer bound."""
+    if not is_gl_thread():
+        return 0
+    _ensure(width, height)
+    _STATE["active"] = True
+    gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, int(_STATE["fbo"]))
+    return int(_STATE["fbo"])
+
+
+_PRESENT_FRAG = """
+#version 330 core
+uniform sampler2D scene;
+in vec2 uv;
+out vec4 FragColor;
+""" + GLSL_ENCODE + """
+void main() {
+    vec4 c = texture(scene, uv);
+    // The scene is premultiplied in LINEAR light; the swapchain is
+    // premultiplied in ENCODED (electrical) values — what Wayland assumes
+    // without a wp_color_representation alpha mode, so the compositor
+    // divides the stored value by alpha before decoding. Encoding a*c as
+    // it stood read back as pq(a*c)/a: far above pq(c) at the dark end
+    // (PQ and sRGB are steepest there), so every translucent pixel — the
+    // shadow margin, the rounded corners' anti-aliased edge — came out
+    // much brighter than the scene held, the shadow beside the content a
+    // bright blue rim over a black desktop (09-09). Un-premultiply, encode
+    // the straight colour, multiply back. Opaque pixels are unchanged.
+    float a = clamp(c.a, 0.0, 1.0);
+    vec3 rgb = a > 0.0 ? c.rgb / a : vec3(0.0);
+    vec3 encoded;
+    if (pq_output == 1) {
+        // Linear scRGB -> BT.2020 -> PQ. reference_nits is what 1.0 shows
+        // as (the desktop's SDR reference), so SDR content matches an
+        // untagged window and white(4) lands at 4x that.
+        // Convert primaries FIRST, clamp after: a P3 / wide colour is
+        // scRGB with NEGATIVE components (p3(1,0,0) = (1.22, -0.04, -0.02)
+        // linear) and clamping them before the matrix collapses it back to
+        // the sRGB gamut. BT.2020 contains P3, so the result is non-negative.
+        vec3 nits = max(MELTY_SRGB_TO_BT2020 * rgb, 0.0) * reference_nits;
+        encoded = melty_pq_encode(nits);
+    } else {
+        encoded = melty_linear_to_srgb(rgb);
+    }
+    FragColor = vec4(encoded * a, a);
+}
+"""
+
+
+@shader_func(fragment=_PRESENT_FRAG)
+def _present_pass(gl_state: GLState = None, scene=None, pq_output=0, reference_nits=250.0, **kwargs):
+    gl.glBindVertexArray(gl_state.vao("fs_triangle"))
+    gl.glDrawArrays(gl.GL_TRIANGLES, 0, 3)
+
+
+def present(width: int, height: int) -> bool:
+    """Frame end (Melty.post_frame, after the corner pass): encode the scene
+    into the default framebuffer. The scene stays intact for readbacks."""
+    if not _STATE["active"] or not is_gl_thread():
+        return False
+    from meltygui.core.runtime.toggles import Toggles
+    _STATE["active"] = False
+    if _STATE["gl"] is None:
+        _STATE["gl"] = GLState()
+    gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
+    gl.glViewport(0, 0, int(width), int(height))
+    gl.glDisable(gl.GL_SCISSOR_TEST)
+    gl.glDisable(gl.GL_DEPTH_TEST)
+    gl.glDisable(gl.GL_STENCIL_TEST)
+    gl.glDisable(gl.GL_BLEND)
+    gl.glColorMask(gl.GL_TRUE, gl.GL_TRUE, gl.GL_TRUE, gl.GL_TRUE)
+    # PQ only once the surface actually carries the tag (wayland_color.sync):
+    # an untagged app is sRGB to the compositor, whatever the toggle says.
+    import meltygui.core.graphics.wayland_color as wayland_color
+    pq = wayland_color.resolved_output() == "pq" and (wayland_color.applied() == "pq" or not wayland_color.available())
+    # 1.0 = the desktop's SDR white: the reference the applied PQ tag carries
+    # (wayland_color.desired_reference - the compositor's preferred
+    # description, else Toggles.HDR.pq_reference_nits).
+    reference = wayland_color.reference_nits() or wayland_color.desired_reference()
+    _present_pass(_STATE["gl"], scene=_STATE["tex"], pq_output=1 if pq else 0,
+                  reference_nits=float(reference))
+    gl.glBindVertexArray(0)
+    return True
+
+
+def shutdown() -> None:
+    if is_gl_thread():
+        _release()
+    _STATE["active"] = False

meltygui/core/graphics/screenshot.py

@@ -0,0 +1,439 @@
+"""Per-window screenshots of the live Melty studio.
+
+The launcher MCP server runs in the same process as the studio (the studio
+renders on a worker thread), but the GL context is only current on that render
+thread. So capture is a hand-off:
+
+  * request_capture(name)  — called from the MCP thread; enqueues a request,
+    wakes the render loop, and blocks until it's fulfilled.
+  * process_captures(window) — called once per frame from Melty.post_frame on
+    the render thread (just before swap, so GL_BACK holds the finished frame);
+    reads the named window's sub-rectangle and writes a PNG.
+
+Capturing one window keeps the image small and legible (the real display can be
+an ultra-wide spanning many windows).
+"""
+
+import threading
+import time
+from pathlib import Path
+
+from meltygui.core.runtime.paths import cache_root
+SHOT_DIR = cache_root() / "screenshots"
+
+_pending = []
+_lock = threading.Lock()
+
+
+def _shot_dir():
+    """Output directory for screenshots — `Toggles.screenshots` (expanded),
+    falling back to the in-repo `.melty/screenshots` if it can't be read."""
+    try:
+        from meltygui.core.runtime.toggles import Toggles
+        configured = Toggles.screenshots
+        if configured:
+            return Path(configured).expanduser()
+    except Exception:
+        pass
+    return SHOT_DIR
+
+
+def list_window_names():
+    """Names of currently-registered top-level windows (for error messages)."""
+    from meltygui.core.melty import Melty
+    return [mw.name for mw in Melty.registered_windows.values()
+            if getattr(mw, "name", None) and getattr(mw, "draw_state", None) is not None]
+
+
+# Frames to wait after fronting a window before reading pixels. apply_move_to_front
+# runs in end_frame, and the bumped layer only affects the *next* frame's draw, so
+# a couple of frames must render before the window is actually composited on top.
+_SETTLE_FRAMES = 3
+
+
+def _submit(req, timeout):
+    """Enqueue `req`, wake the render loop, and block until it's fulfilled or
+    `timeout` elapses. Returns (path, error); one is None."""
+    with _lock:
+        _pending.append(req)
+    _nudge()
+    if not req["event"].wait(timeout):
+        with _lock:
+            if req in _pending:
+                _pending.remove(req)
+        return None, (f"timed out after {timeout:.0f}s — is a studio session "
+                      f"running and rendering? windows: {list_window_names()}")
+    return req["path"], req["error"]
+
+
+def request_capture(name, timeout=8.0):
+    """Request a capture of window `name`. Returns (path, error); one is None.
+
+    Safe to call off the render thread — blocks until the render thread fronts
+    the window, lets it composite, captures it, or `timeout` elapses.
+    """
+    req = {"name": name, "stage": "front", "frames_left": 0,
+           "path": None, "error": None, "event": threading.Event()}
+    return _submit(req, timeout)
+
+
+def request_tile_capture(name, timeout=8.0):
+    """Like `request_capture`, but reads the window's cached offscreen blit tile
+    straight from its FBO instead of the on-screen framebuffer.
+
+    The tile holds the window's own composited pixels, so the capture is
+    immune to whatever else is stacked on top of the window on screen (no
+    fronting/settling needed). Falls back to `request_capture`'s
+    front -> settle -> framebuffer-read flow if the window has no usable tile.
+
+    Safe to call off the render thread.
+    """
+    req = {"name": name, "stage": "tile", "frames_left": 0,
+           "path": None, "error": None, "event": threading.Event()}
+    return _submit(req, timeout)
+
+
+def _nudge():
+    try:
+        from meltygui.core.windowing.glfw_utils import request_render
+        request_render()  # force the loop to render the next frame
+    except Exception:
+        pass
+
+
+def process_captures(window):
+    """Advance pending captures one frame. Call from the render thread
+    (post_frame), before swap_buffers, with the GL context current.
+
+    Each request walks: front (raise the window) -> settle (let it composite)
+    -> capture. We pump one frame per step via request_render.
+    """
+    with _lock:
+        if not _pending:
+            return
+        reqs = _pending[:]
+        _pending.clear()
+
+    from meltygui.core.melty import Melty
+    unfinished = []
+    for req in reqs:
+        try:
+            if req["stage"] == "tile":
+                path = _capture_tile(req["name"])
+                if path is not None:
+                    req["path"] = path
+                    req["event"].set()
+                else:
+                    # No cached tile for this window -> fall back to the on-screen
+                    # front -> settle -> framebuffer-read flow.
+                    req["stage"] = "front"
+                    unfinished.append(req)
+                continue
+            if req["stage"] == "front":
+                mw = _find_window(req["name"])
+                if mw is None:
+                    req["error"] = (f"no window named {req['name']!r}; "
+                                    f"available: {list_window_names()}")
+                    req["event"].set()
+                    continue
+                # A closed window early-returns from its render (draw None),
+                # so open it. Clear both the draw_state flag and the stored
+                # window_args, since the renderer re-applies kwargs["closed"]
+                # each frame.
+                mw.draw_state.closed = False
+                if isinstance(mw.window_args, dict):
+                    mw.window_args["closed"] = False
+                Melty.move_window_to_front(mw.draw_state)
+                req["stage"] = "settle"
+                req["frames_left"] = _SETTLE_FRAMES
+                unfinished.append(req)
+            elif req["stage"] == "settle":
+                req["frames_left"] -= 1
+                if req["frames_left"] <= 0:
+                    req["stage"] = "capture"
+                unfinished.append(req)
+            elif req["stage"] == "capture":
+                req["path"] = _capture(window, req["name"])
+                req["event"].set()
+        except Exception as e:
+            req["error"] = str(e)
+            req["event"].set()
+
+    if unfinished:
+        with _lock:
+            _pending.extend(unfinished)
+        _nudge()  # keep frames coming while staged requests advance
+
+
+_view_pending = []
+
+
+def request_view_capture(draw_state, requested_frame, reopen_menu_ds=None,
+                         on_captured=None):
+    """Queue a deferred framebuffer capture of a single VIEW (any draw_state's
+    on-screen rect), not a whole window. Serviced by process_take_screenshot_flags
+    after `_SETTLE_FRAMES` -- enough frames for the window front-move to composite
+    and the closed context menu to clear from the framebuffer.
+
+    `requested_frame` is Melty.frame_count at request time. `reopen_menu_ds`, if
+    given, is the context menu's draw_state to reopen once the shot lands.
+    `on_captured`, if given, is called with the saved PNG path on the render
+    thread once the shot lands (not called if the capture fails).
+    Call on the render thread (from the menu's render).
+    """
+    _view_pending.append({
+        "draw_state": draw_state,
+        "requested_frame": requested_frame,
+        "reopen_menu_ds": reopen_menu_ds,
+        "on_captured": on_captured,
+    })
+    _nudge()
+
+
+_region_pending = []
+
+
+def request_region_capture(left, top, w, h, requested_frame, name="screenshot",
+                           on_captured=None):
+    """Queue a deferred framebuffer capture of an arbitrary on-screen box
+    (window points) — the region screenshot tool's drag rectangle. Serviced
+    by process_take_screenshot_flags after `_SETTLE_FRAMES`, so the frame the
+    box was drawn on (crosshair / selection overlay) has cleared before the
+    pixels are read. `on_captured(path)` runs on the render thread once the
+    PNG is written. Call on the render thread."""
+    _region_pending.append({
+        "rect": (left, top, w, h), "requested_frame": requested_frame,
+        "name": name, "on_captured": on_captured,
+    })
+    _nudge()
+
+
+def _process_region_captures(window):
+    if not _region_pending:
+        return
+    from meltygui.core.melty import Melty
+    still = []
+    for req in _region_pending:
+        if Melty.frame_count - int(req["requested_frame"]) < _SETTLE_FRAMES:
+            still.append(req)
+            continue
+        path = None
+        try:
+            path = _capture_points(window, *req["rect"], req["name"])
+        except Exception as e:
+            print(f"Screenshot (region) failed: {e}")
+        if path is not None and req.get("on_captured") is not None:
+            try:
+                req["on_captured"](path)
+            except Exception as e:
+                print(f"Screenshot on_captured callback failed: {e}")
+    _region_pending[:] = still
+    if still:
+        _nudge()
+
+
+def process_take_screenshot_flags(window):
+    """Service deferred per-view screenshots queued from the context menu (and
+    the region tool's drag boxes — _process_region_captures). Call from the
+    render thread (post_frame), with the GL context current.
+
+    The context-menu screenshot button fronts the window, queues the view via
+    request_view_capture, and closes the menu -- all during one frame's draw. We
+    then wait `_SETTLE_FRAMES` so the front-move composites the window on top and
+    the closed menu has cleared, then grab the view's rect and reopen the menu.
+    Pumps frames while waiting.
+    """
+    _process_region_captures(window)
+    if not _view_pending:
+        return
+    from meltygui.core.melty import Melty
+    still = []
+    for req in _view_pending:
+        if Melty.frame_count - int(req["requested_frame"]) < _SETTLE_FRAMES:
+            still.append(req)  # not settled yet
+            continue
+        ds = req["draw_state"]
+        path = None
+        try:
+            path = _capture_view(window, ds)
+        except Exception as e:
+            name = getattr(ds, "name", None) or "view"
+            print(f"Screenshot (view) failed for {name!r}: {e}")
+        if path is not None and req.get("on_captured") is not None:
+            try:
+                req["on_captured"](path)
+            except Exception as e:
+                print(f"Screenshot on_captured callback failed: {e}")
+        _reopen_context_menu_ds(req.get("reopen_menu_ds"))
+    _view_pending[:] = still
+    if still:
+        _nudge()  # keep frames coming until the window is fronted & menu gone
+
+
+def _reopen_context_menu_ds(menu_ds):
+    """Reopen a context menu after its screenshot lands. The menu set `_reopen`
+    on its own draw_state. Reopening means flipping the owning view's
+    `context_menu_open` back on (its source of truth) and clearing the menu's
+    `closed`, then re-rendering the owner."""
+    if menu_ds is None or not getattr(menu_ds, "_reopen", False):
+        return
+    menu_ds._reopen = False
+    menu_ds.closed = False
+    owner = getattr(menu_ds, "_raw_input_value", None)  # the view that owns the menu
+    if owner is not None:
+        owner.context_menu_open = True
+        try:
+            owner.invalidate_up(max_depth=5)
+        except Exception:
+            pass
+    _nudge()
+
+
+def _find_window(name):
+    from meltygui.core.melty import Melty
+    wins = [mw for mw in Melty.registered_windows.values()
+            if getattr(mw, "name", None) and getattr(mw, "draw_state", None) is not None]
+    # Prefer an exact name; fall back to case-insensitive substring. In both
+    # cases the last match is the most-recently-fronted window.
+    exact = [mw for mw in wins if mw.name == name]
+    if exact:
+        return exact[-1]
+    sub = [mw for mw in wins if name.lower() in mw.name.lower()]
+    if sub:
+        return sub[-1]
+    return None
+
+
+def _capture(window, name):
+    """Grab a whole window's on-screen rect to a PNG (the MCP/window path)."""
+    mw = _find_window(name)
+    if mw is None:
+        raise ValueError(f"no window named {name!r}; available: {list_window_names()}")
+    return _capture_rect(window, mw.draw_state, mw.name)
+
+
+def _capture_view(window, draw_state):
+    """Grab a single VIEW's on-screen rect to a PNG. Same framebuffer read as
+    `_capture`, but bounded to the given draw_state's rect rather than a whole
+    top-level window -- so the context menu can shoot just the view it's for."""
+    name = getattr(draw_state, "name", None) or "view"
+    return _capture_rect(window, draw_state, name)
+
+
+def _capture_rect(window, ds, name):
+    """Read draw_state `ds`'s on-screen rect from GL_BACK and save it as a PNG
+    named after `name`. The draw_state supplies the rect (left/top/width/height
+    in window points); shared by the window and per-view capture paths."""
+    left, top, w, h = ds.left, ds.top, ds.width, ds.height
+    if not w or not h:
+        raise ValueError(f"{name!r} has no size ({w}x{h}); is it open?")
+    return _capture_points(window, left, top, w, h, name)
+
+
+def _capture_points(window, left, top, w, h, name):
+    """Read the on-screen rect (left/top/width/height in WINDOW POINTS) from
+    GL_BACK and save it as a PNG named after `name`. The one framebuffer
+    reader: window / view captures pass a draw_state's box, the region tool
+    passes the user's drag box."""
+    import meltygui.core.windowing.window_api as glfw
+    import numpy as np
+    import OpenGL.GL as gl
+    from PIL import Image
+
+    from meltygui.core.melty import Melty
+
+    fb_w, fb_h = glfw.get_framebuffer_size(window)
+    win_w, win_h = glfw.get_window_size(window)
+    scale = (fb_w / win_w) if win_w else 1.0
+    # Window points are CONTENT coordinates: in the transparent frameless
+    # window the content sits inset by the shadow margin inside the
+    # framebuffer (Melty.frame_origin, framebuffer px - the same offset the
+    # masks / tile captures apply), so a box at the top of the screen read
+    # the transparent margin above the content without this.
+    origin_x, origin_y = (int(v) for v in (Melty.frame_origin or (0, 0)))
+
+    # Rect in framebuffer pixels, clamped to the framebuffer.
+    x0 = max(0, min(int(round(left * scale)) + origin_x, fb_w))
+    y_top = max(0, min(int(round(top * scale)) + origin_y, fb_h))
+    pw = max(1, min(int(round(w * scale)), fb_w - x0))
+    ph = max(1, min(int(round(h * scale)), fb_h - y_top))
+    y_bottom = fb_h - (y_top + ph)  # GL origin is bottom-left
+
+    gl.glPixelStorei(gl.GL_PACK_ALIGNMENT, 1)
+    gl.glReadBuffer(gl.GL_BACK)
+    data = gl.glReadPixels(x0, y_bottom, pw, ph, gl.GL_RGBA, gl.GL_UNSIGNED_BYTE)
+
+    if isinstance(data, bytes):
+        arr = np.frombuffer(data, dtype=np.uint8)
+    else:
+        arr = np.asarray(data, dtype=np.uint8).ravel()
+    arr = arr.reshape(ph, pw, 4)
+    arr = np.flipud(arr)  # bottom-left -> top-left origin
+
+    path = _shot_path(name)
+    Image.fromarray(arr, "RGBA").save(path)
+    return str(path)
+
+
+def _shot_path(window_name):
+    """A fresh timestamped PNG path under the configured shot dir (created)."""
+    shot_dir = _shot_dir()
+    shot_dir.mkdir(parents=True, exist_ok=True)
+    safe = "".join(c if c.isalnum() else "_" for c in window_name)[:40] or "window"
+    return shot_dir / f"{safe}_{int(time.time())}.png"
+
+
+def _capture_tile(name):
+    """Read window `name`'s cached offscreen blit tile straight from its FBO and
+    save a PNG. Returns the path, or None if the window has no usable tile (the
+    caller then falls back to the framebuffer capture).
+
+    Reading the tile sidesteps window-overlay artifacts: the tile holds the
+    window's own composited pixels regardless of what's stacked on top of it on
+    screen. Must run on the render thread with the GL context current.
+    """
+    import numpy as np
+    import OpenGL.GL as gl
+    from PIL import Image
+    from meltygui.core.melty import Melty
+
+    mw = _find_window(name)
+    if mw is None:
+        return None
+    ds = getattr(mw, "draw_state", None)
+    cache = getattr(Melty, "cache", None)
+    tile_id = getattr(ds, "_tile_id", None) if ds is not None else None
+    tiles = getattr(cache, "_tiles", None) if cache is not None else None
+    if tile_id is None or tiles is None:
+        return None
+    tile = tiles.get(tile_id)
+    if tile is None:
+        return None
+    w, h = tile.size
+    if not w or not h or tile.fbo in (None, -1):
+        return None
+
+    gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, tile.fbo)
+    gl.glReadBuffer(gl.GL_COLOR_ATTACHMENT0)
+    gl.glPixelStorei(gl.GL_PACK_ALIGNMENT, 1)
+    # Content is top-anchored in a possibly bottom-padded texture: the logical
+    # w x h pixels live in the texture rows [alloc_h - h, alloc_h), not at y=0.
+    alloc_h = (getattr(tile, "alloc_size", None) or tile.size)[1]
+    # Tiles hold LINEAR scRGB (fp16, hdr_color.py): read floats and sRGB-encode
+    # for the PNG the way the presentation pass does for the screen.
+    data = gl.glReadPixels(0, int(alloc_h) - int(h), int(w), int(h), gl.GL_RGBA, gl.GL_FLOAT)
+    gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, Melty.default_framebuffer())  # restore main frame's target
+
+    lin = np.asarray(data, dtype=np.float32).reshape(-1, 4)
+    rgb = np.clip(lin[:, :3], 0.0, 1.0)
+    enc = np.where(rgb <= 0.0031308, rgb * 12.92, 1.055 * np.power(rgb, 1.0 / 2.4) - 0.055)
+    arr = np.empty((lin.shape[0], 4), dtype=np.uint8)
+    arr[:, :3] = np.round(enc * 255.0)
+    arr[:, 3] = np.round(np.clip(lin[:, 3], 0.0, 1.0) * 255.0)
+    arr = arr.ravel()
+    arr = arr.reshape(int(h), int(w), 4)
+    arr = np.flipud(arr)  # GL origin is bottom-left -> top-left
+
+    path = _shot_path(mw.name)
+    Image.fromarray(arr, "RGBA").save(path)
+    return str(path)