allow setting background color and font color dynamically

Author: ChrLackner

webgpu/background.py

@@ -58,8 +58,21 @@ def __init__(self, position=(0, 0), width=1, height=0.05):
         self._position = position
         self._width = width
         self._height = height
+        self._bg_color = (1.0, 1.0, 1.0)
         self.uniforms = None
 
+    @property
+    def bg_color(self):
+        return self._bg_color
+
+    @bg_color.setter
+    def bg_color(self, value):
+        self._bg_color = tuple(value[:3])
+        if self.uniforms is not None:
+            self.uniforms.bg_color = self._bg_color
+            self.uniforms.update_buffer()
+        self.set_needs_update()
+
     @property
     def position(self):
         return self._position
@@ -108,7 +121,7 @@ def update(self, options: RenderOptions):
             self.uniforms.position = self.position
             self.uniforms.width = self.width
             self.uniforms.height = self.height
-            self.uniforms.bg_color = (1.0, 1.0, 1.0)
+            self.uniforms.bg_color = self._bg_color
         self.uniforms.update_buffer()
 
     def create_render_pipeline(self, options: RenderOptions) -> None:

webgpu/canvas.py

@@ -10,15 +10,14 @@
 
 _TARGET_FPS = 60
 
+_default_clear_color = None
+
+
+def set_default_clear_color(color):
+    """Set the clear color used by Canvas instances created afterwards."""
+    global _default_clear_color
+    _default_clear_color = color
 
-# @dataclass
-# class _DebounceData:
-#     t_last_frame: float = 0
-#     t_last_call: float = 0
-#     timer: threading.Timer | None = None
-#     lock: Lock = None
-#     running: bool = False
-#     pending: bool = False
 
 class _InstanceDebounce:
     """Descriptor that creates per-instance debounced methods.
@@ -291,8 +290,9 @@ def __init__(self, device, canvas, multisample_count=4):
 
         self.dpr = 1.0  # updated in resize(); kept as attribute for camera uniforms
 
-        # Background clear color of the scene (opaque white by default).
-        self.clear_color = Color(1, 1, 1, 1)
+        self.clear_color = (
+            Color(1, 1, 1, 1) if _default_clear_color is None else _default_clear_color
+        )
 
         self.update_html_canvas(canvas)
 

webgpu/colormap.py

@@ -385,6 +385,74 @@ def set_max(self, maxval):
 
 
 _colormaps = {
+    "turbo": [
+        [48, 18, 59],
+        [57, 42, 115],
+        [64, 64, 162],
+        [68, 86, 199],
+        [71, 110, 230],
+        [70, 130, 248],
+        [65, 150, 255],
+        [53, 171, 248],
+        [37, 192, 231],
+        [26, 210, 210],
+        [24, 224, 189],
+        [34, 235, 170],
+        [60, 245, 142],
+        [89, 251, 115],
+        [121, 254, 89],
+        [150, 254, 68],
+        [175, 250, 55],
+        [195, 241, 52],
+        [215, 229, 53],
+        [231, 215, 57],
+        [245, 197, 58],
+        [252, 179, 54],
+        [254, 158, 47],
+        [252, 135, 37],
+        [246, 108, 25],
+        [237, 85, 16],
+        [226, 67, 10],
+        [212, 51, 5],
+        [193, 35, 2],
+        [172, 23, 1],
+        [149, 13, 1],
+        [122, 4, 3],
+    ],
+    "rainbow": [
+        [13, 59, 221],
+        [11, 76, 222],
+        [9, 94, 224],
+        [7, 111, 225],
+        [5, 128, 227],
+        [3, 145, 228],
+        [0, 163, 230],
+        [4, 170, 214],
+        [9, 175, 194],
+        [14, 180, 174],
+        [19, 184, 154],
+        [24, 189, 134],
+        [29, 194, 114],
+        [51, 198, 96],
+        [83, 200, 79],
+        [116, 203, 62],
+        [148, 205, 44],
+        [181, 208, 27],
+        [213, 210, 10],
+        [234, 207, 0],
+        [238, 195, 0],
+        [242, 183, 0],
+        [245, 171, 0],
+        [249, 159, 0],
+        [252, 148, 0],
+        [254, 135, 1],
+        [249, 117, 6],
+        [245, 100, 11],
+        [240, 83, 16],
+        [235, 66, 21],
+        [231, 48, 26],
+        [226, 31, 31],
+    ],
     "viridis": [
         [68, 1, 84],
         [71, 13, 96],

webgpu/font.py

@@ -31,7 +31,7 @@ class FontUniforms(UniformBase):
         ("size_scaling", ct.c_float),
         ("advance", ct.c_float),
         ("font_size", ct.c_float),
-        ("padding", ct.c_float * 3),
+        ("color", ct.c_float * 3),
     ]
 
 
@@ -202,6 +202,11 @@ def set_font_size(self, font_size: float):
         self.uniforms.size = font_size
         self._update()
 
+    def set_color(self, color):
+        """Set the text color as an (r, g, b) tuple in [0, 1]."""
+        self.uniforms.color = tuple(color[:3])
+        self.uniforms.update_buffer()
+
     def update(self):
         self.uniforms.update_buffer()
 

webgpu/labels.py

@@ -53,10 +53,21 @@ def __init__(
         self.buffer = None
         self._overlay_buf = None
         self.font = None
+        self._text_color = None  # (r,g,b) for the default (non-per-label) path
 
         if colors is not None:
             self.fragment_entry_point = "fragmentFontColor"
 
+    @property
+    def text_color(self):
+        return self._text_color
+
+    @text_color.setter
+    def text_color(self, value):
+        self._text_color = None if value is None else tuple(value[:3])
+        if self.font is not None and self._text_color is not None:
+            self.font.set_color(self._text_color)
+
     def update(self, options: RenderOptions):
         n_chars = sum(len(label) for label in self.labels)
         n_labels = len(self.labels)
@@ -93,6 +104,8 @@ def update(self, options: RenderOptions):
             self.font = Font(options.canvas, self.font_size)
         else:
             self.font.set_font_size(self.font_size)
+        if self._text_color is not None:
+            self.font.set_color(self._text_color)
 
         char_map = self.font.atlas.char_map
 

webgpu/shaders/font.wgsl

@@ -10,6 +10,9 @@ struct FontUniforms {
   size_scaling: f32,
   advance: f32,
   font_size: f32,
+  color_r: f32,
+  color_g: f32,
+  color_b: f32,
 };
 
 @group(0) @binding(2) var<uniform> u_font : FontUniforms;
@@ -82,7 +85,8 @@ fn fragmentFont(@location(0) tex_coord: vec2<f32>) -> @location(0) vec4<f32> {
       discard;
     }
 
-    return vec4(0., 0., 0., alpha);
+    let color = vec3f(u_font.color_r, u_font.color_g, u_font.color_b);
+    return vec4(color * alpha, alpha);
 }
 
 fn fontCalc(char: u32, position: vec4<f32>, vertexId: u32) -> FontFragmentInput {