Merge branch 'picker_improvements'

Author: mhochsteger

webgpu/canvas.py

@@ -14,8 +14,10 @@
 
 @dataclass
 class _DebounceData:
-    t_last: float | None = None
+    t_last_frame: float = 0
+    t_last_call: float = 0
     timer: threading.Timer | None = None
+    lock: Lock = None
 
 
 def debounce(arg=None):
@@ -28,50 +30,37 @@ def debounced(obj, *args, **kwargs):
 
             fname = func.__name__
             if obj._debounce_data.get(fname, None) is None:
-                obj._debounce_data[fname] = _DebounceData(None, None)
+                obj._debounce_data[fname] = _DebounceData(0, 0, None, Lock())
 
             data = obj._debounce_data[fname]
+            t_call = time.time()
+            data.t_last_call = t_call
 
-            # check if we already have a render scheduled
-            if platform.is_pyodide:
-                if data.timer is not None and not data.timer.done():
-                    return
-            else:
-                if data.timer is not None:
-                    return
+            frame_time = 1.0 / target_fps
 
             def f():
-                # clear the timer, so we can schedule a new one with the next function call
-                t = time.time()
-                data.timer = None
-                if platform.is_pyodide:
-                    # due to async nature, we need to update t_last before calling func
-                    data.t_last = t
-                    func(obj, *args, **kwargs)
-                else:
-                    data.t_last = t
+                with data.lock:
+                    if t_call != data.t_last_call and t_call - data.t_last_frame < frame_time:
+                        return
+
+                    data.t_last_frame = time.time()
                     func(obj, *args, **kwargs)
 
-            if data.timer is not None:
-                return
+            t_wait = frame_time - (t_call - data.t_last_frame)
 
-            if data.t_last is None:
-                # first call -> just call the function immediately
-                data.t_last = time.time()
+            if t_wait <= 0:
                 f()
                 return
 
-            t_wait = max(1 / target_fps - (time.time() - data.t_last), 0)
             if platform.is_pyodide:
                 import asyncio
                 async def _runner():
                     if t_wait > 0:
                         await asyncio.sleep(t_wait)
                     f()
-                data.timer = asyncio.create_task(_runner())
+                asyncio.create_task(_runner())
             else:
-                data.timer = threading.Timer(t_wait, f)
-                data.timer.start()
+                threading.Timer(t_wait, f).start()
 
         debounced._original = func
         return debounced

webgpu/scene.py

@@ -233,17 +233,19 @@ def select(self, x: int, y: int):
             return ev
 
     # @print_communications
-    def _render_objects(self, to_canvas=True):
+    def _render_objects(self, to_canvas=True, update_pipelines=True):
         """Update pipelines and render all active objects, optionally copying to the canvas."""
         if self.canvas is None:
             return
-        self._select_buffer_valid = False
         options = self.options
-        for obj in self.render_objects:
-            if obj.active:
-                obj._update_and_create_render_pipeline(options)
-                if obj.needs_update:
-                    print("warning: object still needs update after update was done:", obj)
+
+        if update_pipelines:
+            self._select_buffer_valid = False
+            for obj in self.render_objects:
+                if obj.active:
+                    obj._update_and_create_render_pipeline(options)
+                    if obj.needs_update:
+                        print("warning: object still needs update after update was done:", obj)
 
         options.command_encoder = self.device.createCommandEncoder()
         for obj in self.render_objects:
@@ -276,6 +278,21 @@ def _render_objects(self, to_canvas=True):
         self.device.queue.submit([options.command_encoder.finish()])
         options.command_encoder = None
 
+    def _render_highlight(self):
+        """Fast re-render for highlight-only uniform changes.
+
+        Skips pipeline rebuild and select buffer invalidation.
+        Caller must already hold _render_mutex.
+        """
+        if self.canvas is None or self.canvas.height == 0:
+            return
+        self._render_objects(to_canvas=False, update_pipelines=False)
+        platform.js.patchedRequestAnimationFrame(
+            self.canvas.device.handle,
+            self.canvas.context,
+            self.canvas.target_texture,
+        )
+
     def redraw(self, blocking=False, fps=10):
         """Request a redraw, either blocking immediately or debounced on the event loop."""
         self.options.timestamp = time.time()