labels adjust to light/dark mode

Author: ChrLackner

webgpu/engine/engine.js

@@ -8,6 +8,8 @@ const LIGHT_CLEAR_COLOR = Object.freeze({ r: 1.0, g: 1.0, b: 1.0, a: 1.0 });
 const DARK_CLEAR_COLOR  = Object.freeze({ r: 0.8078, g: 0.8392, b: 0.8667, a: 1.0 });
 const LIGHT_CANVAS_BG = '#ffffff';
 const DARK_CANVAS_BG  = '#ced6dd';
+const LIGHT_LABEL_COLOR = Object.freeze([0.0, 0.0, 0.0]);
+const DARK_LABEL_COLOR  = Object.freeze([0.9, 0.9, 0.9]);
 const DEPTH_FORMAT = 'depth24plus';
 // Object-id / pick texture format. Matches Python canvas.select_format. The
 // select pass renders into a host-owned texture of this format (non-MSAA).
@@ -1414,6 +1416,16 @@ class RenderEngine {
         this.device.queue.writeBuffer(buf, 16, new Float32Array([c.r, c.g, c.b]));
       }
     }
+    if (this.scene && this.scene.theme && Array.isArray(this.scene.theme.label_buffers)) {
+      const c = this.clearColor;
+      const lum = 0.2126 * c.r + 0.7152 * c.g + 0.0722 * c.b;
+      const labelColor = Float32Array.from(lum < 0.5 ? DARK_LABEL_COLOR : LIGHT_LABEL_COLOR);
+      for (const lb of this.scene.theme.label_buffers) {
+        if (!lb || !lb.buffer_id) continue;
+        const buf = this.buffers && this.buffers.get(lb.buffer_id);
+        if (buf) this.device.queue.writeBuffer(buf, lb.offset | 0, labelColor);
+      }
+    }
   }
 
   _setupThemeObserver() {

webgpu/export/capture.py

@@ -116,13 +116,27 @@ def _capture_renderer(obj, options, registry, render_passes, compute_passes):
 
 
 def _export_theme(scene, registry) -> dict:
-    """Find any renderer's buffer for theme color updates."""
-    from ..renderer import Renderer
+    """Find renderer buffers that the engine should update on theme changes.
+
+    ``buffer_id`` is the (optional) colorbar background buffer. ``label_buffers``
+    lists font-color targets for labels that left their color at the default, so
+    the engine can pick a theme-appropriate text color (black on a light canvas,
+    off-white on a dark one).
+    """
+    theme = {}
     for obj in scene.render_objects:
         buf_id = _find_theme_buffer(obj, registry)
         if buf_id:
-            return {"buffer_id": buf_id}
-    return {}
+            theme["buffer_id"] = buf_id
+            break
+
+    label_targets = []
+    seen = set()
+    for obj in scene.render_objects:
+        _collect_theme_label_targets(obj, registry, label_targets, seen)
+    if label_targets:
+        theme["label_buffers"] = label_targets
+    return theme
 
 
 def _find_theme_buffer(obj, registry) -> str | None:
@@ -137,6 +151,24 @@ def _find_theme_buffer(obj, registry) -> str | None:
     return None
 
 
+def _collect_theme_label_targets(obj, registry, out, seen):
+    """Recursively gather font-color targets for theme-defaulted labels."""
+    if obj is None or id(obj) in seen:
+        return
+    seen.add(id(obj))
+    if hasattr(obj, 'get_theme_label_target'):
+        target = obj.get_theme_label_target(registry)
+        if target and target["buffer_id"] not in {t["buffer_id"] for t in out}:
+            out.append(target)
+    if hasattr(obj, 'render_objects'):
+        for child in obj.render_objects:
+            _collect_theme_label_targets(child, registry, out, seen)
+    if hasattr(obj, 'gpu_objects'):
+        for child in obj.gpu_objects:
+            if child is not obj:
+                _collect_theme_label_targets(child, registry, out, seen)
+
+
 def _export_camera(camera, options, registry) -> dict:
     """Export camera state and identify the camera buffer."""
     t = camera.transform

webgpu/labels.py

@@ -68,6 +68,33 @@ def text_color(self, value):
         if self.font is not None and self._text_color is not None:
             self.font.set_color(self._text_color)
 
+    def get_theme_label_target(self, registry):
+        """Expose the font color uniform for theme-dependent defaulting.
+
+        When the app left the label color at the default (neither per-label
+        ``colors`` nor ``text_color`` were set), the engine should pick a color
+        based on the canvas background so the text stays legible: black on a
+        light background, off-white on a dark one. Returns the buffer id and
+        byte offset of the color field, or ``None`` when a color was set
+        explicitly (in which case the app's choice is respected).
+        """
+        if self.colors is not None or self._text_color is not None:
+            return None
+        if self.font is None or self.font.uniforms is None:
+            return None
+        buf = self.font.uniforms._buffer
+        if buf is None:
+            return None
+        key = id(buf)
+        if key not in registry._buffers:
+            return None
+        from .font import FontUniforms
+
+        return {
+            "buffer_id": registry._buffers[key][0],
+            "offset": FontUniforms.color.offset,
+        }
+
     def update(self, options: RenderOptions):
         n_chars = sum(len(label) for label in self.labels)
         n_labels = len(self.labels)