meltygui 0.1.2__tar.gz → 0.1.3__tar.gz

{meltygui-0.1.2 → meltygui-0.1.3}/.gitignore

@@ -6,5 +6,5 @@ dist/
 build/
 *.egg-info/
 .melty/
-
+.DS_Store
 .idea/

{meltygui-0.1.2 → meltygui-0.1.3}/PKG-INFO

@@ -1,10 +1,11 @@
 Metadata-Version: 2.5
 Name: meltygui
-Version: 0.1.2
+Version: 0.1.3
 Summary: Immediate-mode Python UI, live inspection, HDR and tensor visualization
 License-Expression: Apache-2.0
 License-File: LICENSE
 Classifier: Development Status :: 3 - Alpha
+Classifier: Operating System :: MacOS :: MacOS X
 Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: POSIX :: Linux
 Classifier: Programming Language :: Python :: 3.11
@@ -60,11 +61,13 @@ MeltyGUI is capable of rendering tensors exceeding 64GB in size. The primary cha
 MeltyGUI is not yet published to PyPI. For now, install from a checkout using
 [the setup guide](docs/DEVELOPMENT.md#setup).
 
-The current setup targets Linux x86-64 with Python 3.11, 3.12 or 3.13 and a
-working OpenGL 4.3 context. CUDA tensor rendering also requires PyTorch, an
+Linux x86-64 uses Python 3.11, 3.12 or 3.13 and OpenGL 4.3. The UI and editor
+also run on Apple Silicon macOS with Python 3.12, OpenGL 4.1 and Retina
+rendering. CUDA tensor rendering requires PyTorch, an
 NVIDIA GPU, a CUDA toolkit, and MeltyGUI's GL-enabled CUDA binding. The native
 bindings install as prebuilt wheels on those targets; elsewhere installers
 compile them, see [when no wheel matches](docs/SUPPORT_WHEELS.md#when-no-wheel-matches).
+CUDA rendering is unavailable on macOS.
 
 ## Visualize a tensor
 

{meltygui-0.1.2 → meltygui-0.1.3}/README.md

@@ -13,11 +13,13 @@ MeltyGUI is capable of rendering tensors exceeding 64GB in size. The primary cha
 MeltyGUI is not yet published to PyPI. For now, install from a checkout using
 [the setup guide](docs/DEVELOPMENT.md#setup).
 
-The current setup targets Linux x86-64 with Python 3.11, 3.12 or 3.13 and a
-working OpenGL 4.3 context. CUDA tensor rendering also requires PyTorch, an
+Linux x86-64 uses Python 3.11, 3.12 or 3.13 and OpenGL 4.3. The UI and editor
+also run on Apple Silicon macOS with Python 3.12, OpenGL 4.1 and Retina
+rendering. CUDA tensor rendering requires PyTorch, an
 NVIDIA GPU, a CUDA toolkit, and MeltyGUI's GL-enabled CUDA binding. The native
 bindings install as prebuilt wheels on those targets; elsewhere installers
 compile them, see [when no wheel matches](docs/SUPPORT_WHEELS.md#when-no-wheel-matches).
+CUDA rendering is unavailable on macOS.
 
 ## Visualize a tensor
 

{meltygui-0.1.2 → meltygui-0.1.3}/docs/DEVELOPMENT.md

@@ -7,16 +7,25 @@ remaining migration work and deliberate deferrals.
 
 ## Setup
 
-Supported targets are Linux x86-64 with CPython 3.11, 3.12 or 3.13 and a working
-OpenGL 4.3 context. MeltyGUI itself is not on PyPI yet, so install it from a
-checkout; its native support packages (`meltygui-imgui`, `meltygui-pycuda`) come
-from PyPI as prebuilt wheels:
+Linux x86-64 uses CPython 3.11, 3.12 or 3.13 and OpenGL 4.3. macOS on Apple
+Silicon is tested with CPython 3.12 and Apple's OpenGL 4.1 core context,
+including Retina font atlases and cached tiles. CUDA rendering requires an
+NVIDIA system and is unavailable on macOS.
+
+MeltyGUI itself is not on PyPI yet, so install it from a checkout. Native
+support packages come from PyPI; `meltygui-imgui` builds from source on macOS
+when no matching wheel is available, using Xcode Command Line Tools:
 
 ```sh
 uv venv --python 3.12
 uv pip install --python .venv/bin/python -e . --group dev
 ```
 
+On macOS, install `uv` with `brew install uv` if needed. Install Xcode Command
+Line Tools with `xcode-select --install` if they are not already available.
+The first native ImGui build can take a few minutes. No local `dist/release`
+directory is required.
+
 To use MeltyGUI from another project, add the checkout as a path dependency:
 
 ```sh
@@ -65,6 +74,13 @@ python3 tools/torch_matrix.py --window-smoke   # also opens the README example:
 Run apps with the environment's Python. The native Wayland and GLFW backends
 share the same render functions.
 
+macOS native resizing redraws through GLFW's window-refresh callback while
+Cocoa holds the event loop. The app only permits those frames during its OS
+event dispatch, restores the interrupted window's graphics contexts, and
+defers recursive refreshes and native window creation/destruction to the loop.
+When checking this path, drag the actual window border: programmatic size
+changes alone do not exercise Cocoa's live-resize loop.
+
 ```sh
 .venv/bin/pytest
 .venv/bin/python examples/tensor_live.py

{meltygui-0.1.2 → meltygui-0.1.3}/meltygui/core/cache/mask_batch.py

@@ -92,6 +92,7 @@ def batches(stamps):
 class MaskBatch:
     def __init__(self):
         self.program = self.vao = self.vbo = None
+        self.flat_texture = None
         self.source = None
         self.multi_bind = False
         self.fb_location = self.textures_location = None
@@ -103,6 +104,9 @@ class MaskBatch:
             gl.glDeleteBuffers(1, [self.vbo])
         if self.vao is not None:
             gl.glDeleteVertexArrays(1, [self.vao])
+        if getattr(self, 'flat_texture', None) is not None:
+            gl.glDeleteTextures([self.flat_texture])
+        self.flat_texture = None
         self.program = self.vao = self.vbo = None
         self.source = None
 
@@ -155,10 +159,18 @@ class MaskBatch:
                 gl.glBufferData(gl.GL_ARRAY_BUFFER, len(data), data, gl.GL_STREAM_DRAW)
             first_instance = 0
             for textures, data, count in packed:
-                # Populate unused slots with a valid source, avoiding feedback
-                # from a texture attached to the current framebuffer. Zero is
-                # bound to GL_TEXTURE_2D explicitly (bulk zero unbinds ALL targets).
-                bank = textures + [textures[0]] * (TEXTURES_PER_BATCH - len(textures)) if textures else [0] * TEXTURES_PER_BATCH
+                # Apple requires complete samplers even for the flat branch.
+                # Own a tiny source for that case; never sample the destination.
+                if not textures and self.flat_texture is None:
+                    self.flat_texture = int(gl.glGenTextures(1))
+                    gl.glActiveTexture(gl.GL_TEXTURE0)
+                    gl.glBindTexture(gl.GL_TEXTURE_2D, self.flat_texture)
+                    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.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGBA8, 1, 1, 0,
+                                    gl.GL_RGBA, gl.GL_UNSIGNED_BYTE, bytes(4))
+                bank = (textures + [textures[0]] * (TEXTURES_PER_BATCH - len(textures))
+                        if textures else [self.flat_texture] * TEXTURES_PER_BATCH)
                 if self.multi_bind and textures:
                     gl.glBindTextures(0, TEXTURES_PER_BATCH, bank)
                 else:

{meltygui-0.1.2 → meltygui-0.1.3}/meltygui/core/cache/tile_cache.py

@@ -130,6 +130,19 @@ def _tile_alloc(t) -> Tuple[int, int]:
     return getattr(t, "alloc_size", None) or t.size
 
 
+def _pixel_rect(rect, scale):
+    """Window-point bounds to integer texel bounds, including fractional DPI."""
+    x, y, w, h = rect
+    sx, sy = scale
+    left, bottom = snap_int(x * sx), snap_int(y * sy)
+    return left, bottom, snap_int((x + w) * sx) - left, snap_int((y + h) * sy) - bottom
+
+
+def _tile_pixel_size(tile, *, allocated=False):
+    size = _tile_alloc(tile) if allocated else tile.size
+    return _pixel_rect((0, 0, *size), tile.pixel_scale)[2:]
+
+
 def _tile_uv_rect(t) -> Tuple[float, float, float, float]:
     """uUVRect (xy scale, zw offset) mapping a 0..1 dest-rect UV onto the
     top-anchored logical subrect of a bucket-padded tile texture."""
@@ -150,7 +163,8 @@ class Tile:
     mask_tex: int  # Cached subtree mask for this tile
     rbo: Optional[int]
     size: Tuple[int, int]  # LOGICAL view size; the texture may be larger (alloc_size)
-    alloc_size: Optional[Tuple[int, int]] = None  # bucketed texture dims, None = same as size
+    alloc_size: Optional[Tuple[int, int]] = None  # bucketed window-point dims, None = same as size
+    pixel_scale: Tuple[float, float] = (1.0, 1.0)  # physical texels per window point
     dirty: bool = True
     last_clean_frame: int = -1
     last_invalidated_frame: int = 3
@@ -364,7 +378,8 @@ def _clear_mask_regions(mask_tex: int, rects) -> None:
         gl.glClear(gl.GL_COLOR_BUFFER_BIT)
 
 
-def _ensure_tile(existing: Optional[Tile], w: int, h: int, frame_id: int = 0, draw_state=None, tile_id=None) -> \
+def _ensure_tile(existing: Optional[Tile], w: int, h: int, frame_id: int = 0, draw_state=None, tile_id=None,
+                 pixel_scale=(1.0, 1.0)) -> \
         Optional[Tile]:
     # Layout occasionally hands us fractional or negative dims (e.g. a
     # midline is 0.333... width). glTexImage2D coerces those to int and lands on
@@ -374,7 +389,8 @@ def _ensure_tile(existing: Optional[Tile], w: int, h: int, frame_id: int = 0, dr
     h = int(h) if h and h > 0 else 0
     if w <= 0 or h <= 0:
         return None
-    if existing and existing.size == (w, h):
+    same_scale = existing is not None and existing.pixel_scale == pixel_scale
+    if same_scale and existing.size == (w, h):
         return existing
 
     aw = _bucket(w)
@@ -390,7 +406,7 @@ def _ensure_tile(existing: Optional[Tile], w: int, h: int, frame_id: int = 0, dr
         aw = max(aw, snap_int(eaw))
         ah = max(ah, snap_int(eah))
 
-    if existing and _tile_alloc(existing) == (aw, ah):
+    if same_scale and _tile_alloc(existing) == (aw, ah):
         # Same bucket: update the logical size in place - no GL realloc, no
         # crop-blit (top-anchored content keeps the screen-top-left corner on
         # the same texels). Returning the SAME object is the caller's signal
@@ -424,6 +440,7 @@ def _ensure_tile(existing: Optional[Tile], w: int, h: int, frame_id: int = 0, dr
                 # one) would leave stale G/B/A inside the new logical rect.
                 gl.glColorMask(gl.GL_TRUE, gl.GL_TRUE, gl.GL_TRUE, gl.GL_TRUE)
                 gl.glClearColor(0, 0, 0, 0.0)
+                bands = [_pixel_rect(rect, pixel_scale) for rect in bands]
                 for x, y, cw, ch in bands:
                     gl.glScissor(int(x), int(y), int(cw), int(ch))
                     gl.glClear(gl.GL_COLOR_BUFFER_BIT)
@@ -480,7 +497,8 @@ def _ensure_tile(existing: Optional[Tile], w: int, h: int, frame_id: int = 0, dr
     except Exception:
         pass
     try:
-        new_tex = _create_color_tex(aw, ah)
+        pixel_aw, pixel_ah = _pixel_rect((0, 0, aw, ah), pixel_scale)[2:]
+        new_tex = _create_color_tex(pixel_aw, pixel_ah)
     except Exception as e:
         existing_size = existing.size if existing else None
         reset = "\033[0m"
@@ -490,13 +508,13 @@ def _ensure_tile(existing: Optional[Tile], w: int, h: int, frame_id: int = 0, dr
               f"\nCurrent size {existing_size}\n{'=' * 10}{reset}")
         return None
 
-    new_mask_tex = _create_mask_tex(aw, ah)
+    new_mask_tex = _create_mask_tex(pixel_aw, pixel_ah)
     # No depth-stencil renderbuffer: tiles are only ever written by the PASS 3
     # copy shader and the crop-blit, neither of which depth/stencil-tests, and
     # the D24S8 attachment was 4 B/px of VRAM plus the slowest part of the
     # create/destroy/delete cycle. Tile.rbo stays None; the guarded delete
     # sites will free RBOs on tiles created before this change.
-    new_fbo, new_rbo = _create_fbo_with_tex(new_tex, False, aw, ah)
+    new_fbo, new_rbo = _create_fbo_with_tex(new_tex, False, pixel_aw, pixel_ah)
 
     if existing:
         st = _GLState()
@@ -533,13 +551,15 @@ def _ensure_tile(existing: Optional[Tile], w: int, h: int, frame_id: int = 0, dr
                 cw = max(0, min(ow, w))
                 ch = max(0, min(oh, h))
             if cw > 0 and ch > 0:
+                src_x, src_y, src_w, src_h = _pixel_rect((0, old_ah - ch, cw, ch), existing.pixel_scale)
+                dst_x, dst_y, dst_w, dst_h = _pixel_rect((0, ah - ch, cw, ch), pixel_scale)
                 gl.glBlitFramebuffer(
-                    0, snap_int(old_ah) - ch, cw, snap_int(old_ah),  # src (old FBO, top-left in screen)
-                    0, ah - ch, cw, ah,  # dst (new FBO, same screen corner)
+                    src_x, src_y, src_x + src_w, src_y + src_h,
+                    dst_x, dst_y, dst_x + dst_w, dst_y + dst_h,
                     gl.GL_COLOR_BUFFER_BIT,
                     gl.GL_NEAREST,  # No scaling -> NEAREST is exact and cheap
                 )
-            _clear_mask_regions(new_mask_tex, [(0, 0, aw, ah)])
+            _clear_mask_regions(new_mask_tex, [(0, 0, pixel_aw, pixel_ah)])
         finally:
             st.restore()
 
@@ -562,12 +582,12 @@ def _ensure_tile(existing: Optional[Tile], w: int, h: int, frame_id: int = 0, dr
                 gl.glColorMask(gl.GL_TRUE, gl.GL_TRUE, gl.GL_TRUE, gl.GL_TRUE)
                 gl.glClearColor(0, 0, 0, 0.0)
                 gl.glClear(gl.GL_COLOR_BUFFER_BIT)
-                _clear_mask_regions(new_mask_tex, [(0, 0, aw, ah)])
+                _clear_mask_regions(new_mask_tex, [(0, 0, pixel_aw, pixel_ah)])
             finally:
                 st.restore()
 
     t = Tile(draw_state=draw_state, fbo=new_fbo, tex=new_tex, mask_tex=new_mask_tex, rbo=new_rbo, size=(w, h),
-             alloc_size=(aw, ah), dirty=True)
+             alloc_size=(aw, ah), pixel_scale=pixel_scale, dirty=True)
     # Seed filled_bbox to what the crop-copy above covered (in tile-local
     # top-left coords). On a shrink it's the whole tile -> tile reads are fully
     # covered and the scroll-invalidate gate stops early; on a grow it's
@@ -1194,6 +1214,9 @@ void main() { oColor = uColor; }
 # Main class
 # ==============================
 class TileCacheMasked:
+    # Existing live caches acquire per-window backing scale on their next
+    # frame after a hotswap; unscaled caches retain their previous behavior.
+    _pixel_scale = (1.0, 1.0)
     def __init__(self):
         self.initial_value = {}
         self.did_deviate = {}
@@ -1260,6 +1283,7 @@ class TileCacheMasked:
         self.all_keys = set()
 
         self._fb_size: Tuple[int, int] = (0, 0)
+        self._pixel_scale = (1.0, 1.0)
         # Allocated dims of the four co-sized internal surfaces (_mask,
         # _sub_mask, _full_sub_mask, snapshot). For monitor only, grow-only.
         # _fb_size stays the LOGICAL framebuffer size everywhere.
@@ -1537,10 +1561,10 @@ class TileCacheMasked:
         fl, ft, fr, fb = t.filled_bbox
         return fl > vl + 0.5 or ft > vt + 0.5 or fr < vr - 0.5 or fb < vb - 0.5
 
-    @staticmethod
-    def _oversized(size: Optional[Tuple[int, int]]) -> bool:
+    def _oversized(self, size: Optional[Tuple[int, int]]) -> bool:
         """True if a view this size is too large to back with an offscreen tile."""
-        return size is not None and (size[0] > MAX_TILE_DIM or size[1] > MAX_TILE_DIM)
+        return size is not None and (size[0] * self._pixel_scale[0] > MAX_TILE_DIM
+                                     or size[1] * self._pixel_scale[1] > MAX_TILE_DIM)
 
     def _discard_tile(self, key: str) -> None:
         """Drop a tile and free its GL resources (e.g. a view grew too large to cache)."""
@@ -2245,8 +2269,13 @@ class TileCacheMasked:
                     key = self.key_to_parent_key.get(key)
         self._resize_input_keys = keys
 
-    def mask_begin_frame(self, framebuffer_size: Tuple[int, int]) -> None:
+    def mask_begin_frame(self, framebuffer_size: Tuple[int, int], pixel_scale=None) -> None:
         fb_w, fb_h = map(int, framebuffer_size)
+        if pixel_scale is not None and tuple(pixel_scale) != getattr(self, '_pixel_scale', (1.0, 1.0)):
+            self._pixel_scale = tuple(pixel_scale)
+            # A move between displays changes the backing resolution once.
+            # Wake cached ancestors as well as leaves so every tile recaptures.
+            self.invalidate_all(other_windows=False)
         self._note_frame_stats()
         self._refresh_resize_input_keys()
         self._frame_id += 1
@@ -3186,7 +3215,7 @@ class TileCacheMasked:
                     (ix0, iy0, ix1 - ix0, iy1 - iy0),
                     (d_and_l[0] * rank_scale, d_and_l[1] * rank_scale,
                      d_and_l[2] * rank_scale, d_and_l[3] * rank_scale,
-                     cr if cr > 0 else 0.0, margin))
+                     max(0.0, cr) * s_x, margin * s_x))
             _, ix0, iy0, ix1, iy1, own_clip, _owner, inset, rect4, tail6 = base
             if ix1 <= ix0 or iy1 <= iy0:
                 continue
@@ -3222,8 +3251,9 @@ class TileCacheMasked:
             gl.glUseProgram(self._prog_shadow_batch)
             _win_tex = getattr(self, "_win_mask_tex", None)
             gl.glActiveTexture(gl.GL_TEXTURE1)
-            gl.glBindTexture(gl.GL_TEXTURE_2D,
-                             _win_tex if (win_gate and _win_tex) else 0)
+            # WinZ=1 disables occlusion for tile bakes. The sampler still
+            # needs a complete texture on Apple even when that branch is off.
+            gl.glBindTexture(gl.GL_TEXTURE_2D, _win_tex or 0)
             gl.glActiveTexture(gl.GL_TEXTURE0)
             gl.glUniform1i(self._loc_sb_uWinMask, 1)
             gl.glUniform2f(self._loc_sb_uFBSize,
@@ -3313,8 +3343,7 @@ class TileCacheMasked:
         gl.glUseProgram(self._prog_shadow_grad)
         _win_tex = getattr(self, "_win_mask_tex", None)
         gl.glActiveTexture(gl.GL_TEXTURE1)
-        gl.glBindTexture(gl.GL_TEXTURE_2D,
-                         _win_tex if (win_gate and _win_tex) else 0)
+        gl.glBindTexture(gl.GL_TEXTURE_2D, _win_tex or 0)
         gl.glActiveTexture(gl.GL_TEXTURE0)
         gl.glUniform1i(self._loc_sg_uWinMask, 1)
         _fbw, _fbh = self._fb_size
@@ -3431,8 +3460,8 @@ class TileCacheMasked:
                            float(d_and_l[2]) / 65535.5,
                            float(d_and_l[3]) / 65535.5)
             gl.glUniform2f(self._loc_sg_uRectSize, float(iw), float(ih))
-            gl.glUniform1f(self._loc_sg_uCornerRadius, max(0.0, cr))
-            gl.glUniform1f(self._loc_sg_uMargin, margin)
+            gl.glUniform1f(self._loc_sg_uCornerRadius, max(0.0, cr) * s_x)
+            gl.glUniform1f(self._loc_sg_uMargin, margin * s_x)
             gl.glDrawArrays(gl.GL_TRIANGLES, 0, 3)
         gl.glDisable(gl.GL_SCISSOR_TEST)
         gl.glBlendEquation(gl.GL_FUNC_ADD)
@@ -3505,7 +3534,7 @@ class TileCacheMasked:
             gl.glUniform2f(self._loc_maskr_uRectSize, float(iw), float(ih))
             gl.glUniform1f(self._loc_maskr_uCornerRadius,
                            max(0.0, float(getattr(wds, "corner_radius", 6.0)
-                                          or 0.0)))
+                                          or 0.0)) * s_x)
             gl.glDrawArrays(gl.GL_TRIANGLES, 0, 3)
         gl.glColorMask(gl.GL_TRUE, gl.GL_TRUE, gl.GL_TRUE, gl.GL_TRUE)
 
@@ -3726,10 +3755,10 @@ class TileCacheMasked:
         right texels, and fb_h is the REAL height for the y flip."""
         dd = imgui.get_draw_data()
         dp_x, dp_y = dd.display_pos
-        s_x, s_y = 1, 1
+        s_x, s_y = imgui.get_io().display_fb_scale
         ox, oy = getattr(Melty, "frame_origin", None) or (0, 0)
-        dp_x -= int(ox)
-        dp_y -= int(oy)
+        dp_x -= int(ox) / s_x
+        dp_y -= int(oy) / s_y
         real = getattr(Melty, "framebuffer_size", None)
         if real:
             fb_w, fb_h = snap_int(real[0]), snap_int(real[1])
@@ -3841,7 +3870,8 @@ class TileCacheMasked:
         if key in getattr(self, '_resize_input_keys', ()):
             return False
         tile = self._tiles.get(key)
-        if tile is None or not tile.tex or tile.last_clean_frame < 0:
+        if (tile is None or not tile.tex or tile.last_clean_frame < 0
+                or tile.pixel_scale != self._pixel_scale):
             return False
         if key in self._frozen_served:
             return True
@@ -4149,6 +4179,7 @@ class TileCacheMasked:
             bands.append((0, ah - ch, cw, ch - h))
         if cw > w:  # right band: screen cols [w, cw), full content height
             bands.append((w, ah - ch, cw - w, ch))
+        bands = [_pixel_rect(rect, t.pixel_scale) for rect in bands]
         st = _GLState()
         try:
             gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, t.fbo)
@@ -4257,6 +4288,7 @@ class TileCacheMasked:
             if t is not None and getattr(t, 'content_stale', False):
                 self._scrub_stale_content(t, draw_state)
             use_image = (t and has_area
+                         and t.pixel_scale == self._pixel_scale
                          and (t.size == (size[0], size[1]))
                          and (not self._is_dirty(t))
                          and (not draw_state.size_change))
@@ -4276,6 +4308,7 @@ class TileCacheMasked:
             dragging = Melty.resize_gesture_live()
             frozen = False
             if (draw_state.freeze_resize and t is not None and has_area and dragging
+                    and t.pixel_scale == self._pixel_scale
                     and rkey not in getattr(self, '_resize_input_keys', ())
                     and (t.size != (size[0], size[1])
                          or Melty.resize_press_frame == Melty.frame_count
@@ -4600,7 +4633,8 @@ class TileCacheMasked:
                     and not imgui.is_mouse_down(1) and not imgui.is_mouse_down(2)
                     and not Melty.space_mouse_drag):
                 old_t = t
-                t = _ensure_tile(t, ctx.size[0], ctx.size[1], frame_id=self._frame_id, draw_state=ctx.draw_state)
+                t = _ensure_tile(t, ctx.size[0], ctx.size[1], frame_id=self._frame_id,
+                                 draw_state=ctx.draw_state, pixel_scale=self._pixel_scale)
 
                 if t is not None and t is old_t:
                     # Within-bucket logical resize: the tile was updated in
@@ -4854,8 +4888,8 @@ class TileCacheMasked:
             gl.glUseProgram(self._prog_mask_rounded)
             gl.glUniform1f(self._loc_maskr_uRankNorm, rank_norm)
             gl.glUniform2f(self._loc_maskr_uRectSize, float(iw), float(ih))
-            gl.glUniform1f(self._loc_maskr_uCornerRadius, r.corner_radius)
-            gl.glUniform1f(self._loc_maskr_uMargin, shadow_margin)
+            gl.glUniform1f(self._loc_maskr_uCornerRadius, r.corner_radius * s_x)
+            gl.glUniform1f(self._loc_maskr_uMargin, shadow_margin * s_x)
 
         else:
             gl.glUseProgram(self._prog_mask)
@@ -4920,15 +4954,15 @@ class TileCacheMasked:
             gl.glBindTexture(gl.GL_TEXTURE_2D, t.mask_tex)
             gl.glUniform1i(self._loc_texr_uTex, 0)
             gl.glUniform2f(self._loc_texr_uRectSize, float(iw), float(ih))
-            gl.glUniform1f(self._loc_texr_uCornerRadius, r.corner_radius)
-            gl.glUniform1f(self._loc_texr_uMargin, shadow_margin)
+            gl.glUniform1f(self._loc_texr_uCornerRadius, r.corner_radius * s_x)
+            gl.glUniform1f(self._loc_texr_uMargin, shadow_margin * s_x)
 
         else:
             gl.glUseProgram(self._prog_mask_rounded)
             gl.glUniform1f(self._loc_maskr_uRankNorm, float(r.layer) * INV_65535)
             gl.glUniform2f(self._loc_maskr_uRectSize, float(iw), float(ih))
-            gl.glUniform1f(self._loc_maskr_uCornerRadius, r.corner_radius)
-            gl.glUniform1f(self._loc_maskr_uMargin, shadow_margin)
+            gl.glUniform1f(self._loc_maskr_uCornerRadius, r.corner_radius * s_x)
+            gl.glUniform1f(self._loc_maskr_uMargin, shadow_margin * s_x)
 
         gl.glDrawArrays(gl.GL_TRIANGLES, 0, 3)
 
@@ -5122,8 +5156,8 @@ class TileCacheMasked:
                             gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, p.tile.fbo)
                             # Write into the top-anchored logical subrect of the
                             # (possibly bucket-padded) texture.
-                            t_lw, t_lh = snap_int(p.tile.size[0]), snap_int(p.tile.size[1])
-                            t_ah = snap_int(_tile_alloc(p.tile)[1])
+                            t_lw, t_lh = _tile_pixel_size(p.tile)
+                            t_ah = _tile_pixel_size(p.tile, allocated=True)[1]
                             gl.glViewport(0, t_ah - t_lh, t_lw, t_lh)
 
                             # Pre-tint: multiplicative blending drifts stale pixels toward blue
@@ -5341,8 +5375,8 @@ class TileCacheMasked:
                                 iw,
                                 ih,
                                 offset,
-                                r.corner_radius,
-                                r.draw_state.shadow_margin if r.draw_state is not None else 0.0,
+                                r.corner_radius * s_x,
+                                r.draw_state.shadow_margin * s_x if r.draw_state is not None else 0.0,
                                 uv_rect=_tile_uv_rect(t_child),
                             )
                         else:
@@ -5357,9 +5391,9 @@ class TileCacheMasked:
                                 gl.glUseProgram(self._prog_mask_rounded)
                                 gl.glUniform1f(self._loc_maskr_uRankNorm, rank_norm)
                                 gl.glUniform2f(self._loc_maskr_uRectSize, float(iw), float(ih))
-                                gl.glUniform1f(self._loc_maskr_uCornerRadius, r.corner_radius)
+                                gl.glUniform1f(self._loc_maskr_uCornerRadius, r.corner_radius * s_x)
                                 shadow_margin = r.draw_state.shadow_margin if r.draw_state is not None else 0.0
-                                gl.glUniform1f(self._loc_maskr_uMargin, shadow_margin)
+                                gl.glUniform1f(self._loc_maskr_uMargin, shadow_margin * s_x)
 
                             else:
                                 gl.glUseProgram(self._prog_mask)
@@ -5402,8 +5436,8 @@ class TileCacheMasked:
 
                         # Dst is the top-anchored logical subrect of the (possibly
                         # bucket-ized) mask texture, mirroring PASS 3's viewport.
-                        m_lw, m_lh = int(p.tile.size[0]), int(p.tile.size[1])
-                        m_ah = int(_tile_alloc(p.tile)[1])
+                        m_lw, m_lh = _tile_pixel_size(p.tile)
+                        m_ah = _tile_pixel_size(p.tile, allocated=True)[1]
                         gl.glBlitFramebuffer(
                             int(x0),
                             int(y0),
@@ -5488,13 +5522,13 @@ class TileCacheMasked:
 
                         mask_stamps.append((t.mask_tex, (ix0, iy0, iw, ih),
                                             (clip_ix0, clip_iy0, clip_iw, clip_ih),
-                                            _tile_uv_rect(t), offset, r.corner_radius, shadow_margin))
+                                            _tile_uv_rect(t), offset, r.corner_radius * s_x, shadow_margin * s_x))
                     else:
                         clip = (clip_ix0, clip_iy0, clip_iw, clip_ih)
                         shadow_margin = r.draw_state.shadow_margin if r.draw_state is not None else 0.0
                         mask_stamps.append((None, clip, clip, (1, 1, 0, 0),
                                             float(depth_and_layer) / 65535.5,
-                                            r.corner_radius, shadow_margin))
+                                            r.corner_radius * s_x, shadow_margin * s_x))
 
                 if getattr(self, "_mask_batch", None) is None:
                     from meltygui.core.cache.mask_batch import MaskBatch

{meltygui-0.1.2 → meltygui-0.1.3}/meltygui/core/graphics/overlay_renderer.py

@@ -829,7 +829,8 @@ class SplitOverlayRenderer(WindowRenderer):
             from OpenGL.GL import shaders
             return shaders.compileProgram(
                 shaders.compileShader(self._STYLE_CONTEXT_VERT, gl.GL_VERTEX_SHADER),
-                shaders.compileShader(self._STYLE_CONTEXT_FRAG, gl.GL_FRAGMENT_SHADER))
+                shaders.compileShader(self._STYLE_CONTEXT_FRAG, gl.GL_FRAGMENT_SHADER),
+                validate=False)  # The VAO is constructed below, after linking.
         program = self._style_gl.get('style_context_program', build_program, gl.glDeleteProgram)
 
         def build_vao():
@@ -880,7 +881,10 @@ class SplitOverlayRenderer(WindowRenderer):
         """Texture unit 1 = StyleContext for the whole command render."""
         gl.glActiveTexture(gl.GL_TEXTURE1)
         previous = int(gl.glGetIntegerv(gl.GL_TEXTURE_BINDING_2D))
-        gl.glBindTexture(gl.GL_TEXTURE_2D, int(texture_id))
+        # Even an unused sampler must name a complete texture on Apple's
+        # driver. The atlas is already resident; DynamicStyles=0 prevents
+        # sampling it as a background when no context texture is needed.
+        gl.glBindTexture(gl.GL_TEXTURE_2D, int(texture_id or self.io.fonts.texture_id))
         gl.glActiveTexture(gl.GL_TEXTURE0)
         return previous
 

{meltygui-0.1.2 → meltygui-0.1.3}/meltygui/core/graphics/screenshot.py

@@ -396,6 +396,7 @@ def _capture_tile(name):
     import OpenGL.GL as gl
     from PIL import Image
     from meltygui.core.melty import Melty
+    from meltygui.core.cache.tile_cache import _tile_pixel_size
 
     mw = _find_window(name)
     if mw is None:
@@ -409,7 +410,7 @@ def _capture_tile(name):
     tile = tiles.get(tile_id)
     if tile is None:
         return None
-    w, h = tile.size
+    w, h = _tile_pixel_size(tile)
     if not w or not h or tile.fbo in (None, -1):
         return None
 
@@ -418,7 +419,7 @@ def _capture_tile(name):
     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]
+    alloc_h = _tile_pixel_size(tile, allocated=True)[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)

{meltygui-0.1.2 → meltygui-0.1.3}/meltygui/core/melty.py

@@ -613,10 +613,19 @@ class FileWatch:
         return cls._self_write_text.get(resolved)
 
     @classmethod
-    def shutdown(cls):
+    def stop(cls):
+        """Join native file callbacks before the Python runtime goes away.
+
+        Standalone apps own their save policy and need this resource cleanup
+        without importing the code stack or flushing edits from a failed frame.
+        """
+        cls.observer.stop()
         if cls.observer.is_alive():
-            cls.observer.stop()
             cls.observer.join()
+
+    @classmethod
+    def shutdown(cls):
+        cls.stop()
         from meltygui.code.libcst_conversion import shutdown_jedi_pool
         from meltygui.code.libcst_conversion import shutdown_symbol_index_daemon
         shutdown_jedi_pool()
@@ -2300,8 +2309,13 @@ class Melty:
 
         if cls.font_mgr is None:
             return
-        if cls.font_mgr.scale != cls.ui_scale:
-            if not cls.font_mgr.rebuild(cls.ui_scale, impl):
+        io = imgui.get_io()
+        # Surfaces share one atlas. Keep the highest backing density seen so
+        # windows on different displays cannot continually rebuild each other.
+        pixel_scale = max(cls.font_mgr.pixel_scale, *io.display_fb_scale)
+        io.font_global_scale = 1.0 / pixel_scale
+        if cls.font_mgr.scale != cls.ui_scale or cls.font_mgr.pixel_scale != pixel_scale:
+            if not cls.font_mgr.rebuild(cls.ui_scale, impl, pixel_scale=pixel_scale):
                 return
         # Lazy fonts: bake whatever last-frame's get()s queued (fonts
         # are seeded minimally at boot - see FontManager.prewarm). Same
@@ -2965,7 +2979,7 @@ class Melty:
         cls.display_size = (fb_w, fb_h)
         # Masks/tiles cover the WHOLE framebuffer (shadow margin included).
         real_fb = cls.framebuffer_size or (fb_w, fb_h)
-        cls.cache.mask_begin_frame((int(real_fb[0]), int(real_fb[1])))
+        cls.cache.mask_begin_frame((int(real_fb[0]), int(real_fb[1])), imgui.get_io().display_fb_scale)
 
         # Channel-split the foreground/overlay draw list the same way as the
         # window draw list (max_depth channels) so per-window overlays can be
@@ -5058,8 +5072,8 @@ class Melty:
                 # Glow rects as light sources: hand the composite the low-res
                 # glow buffer (add_glow marks, stamped in finalize_captures
                 # PASS 6). glow_strength=0 skips the path in the shader, so an
-                # empty/absent glow costs nothing; texture 0 is a legal
-                # placeholder bind for the sampler in that case.
+                # empty/absent glow costs nothing. Still bind a complete
+                # texture for Apple's driver, even when the branch is off.
                 _glow_tex = (Melty.cache.glow_tex
                              if Melty.cache.glow_active else None)
                 _glow_on = _glow_tex is not None and Toggles.glow
@@ -5083,7 +5097,7 @@ class Melty:
                     shadow_size=(float(composite_shadow_size[0]),
                                  float(composite_shadow_size[1])),
                     depth_sharpness=float(Toggles.shadow_edge_sharpness),
-                    glow_map=_glow_tex if _glow_on else 0,
+                    glow_map=_glow_tex if _glow_on else shadow_raw,
                     glow_strength=(float(Toggles.glow_strength)
                                    if _glow_on else 0.0),
                     glow_shadow_cut=float(Toggles.glow_shadow_cut),