webgpu 1.2.4.dev0__py3-none-any.whl → 1.2.7__py3-none-any.whl

webgpu/__init__.py

@@ -2,6 +2,8 @@ from .clipping import Clipping
 from .colormap import Colormap, Colorbar
 from .font import Font
 from .gizmo import CoordinateAxes, NavigationCube
+from .export.format import Interaction
+from .gui_param import GuiParam
 from .renderer import Renderer
 from .scene import Scene
 from .labels import Labels

webgpu/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.2.4.dev0'
-__version_tuple__ = version_tuple = (1, 2, 4, 'dev0')
+__version__ = version = '1.2.7'
+__version_tuple__ = version_tuple = (1, 2, 7)
 
-__commit_id__ = commit_id = 'ge3c4870ec'
+__commit_id__ = commit_id = 'g255121a87'

webgpu/camera.py

@@ -1,7 +1,7 @@
 import numpy as np
 
 from .uniforms import BaseBinding, Binding, UniformBase, ct
-from .utils import read_shader_file
+from .utils import read_shader_file, Lock
 
 
 class CameraUniforms(UniformBase):
@@ -21,6 +21,70 @@ class CameraUniforms(UniformBase):
         ("padding", ct.c_uint32),
     ]
 
+    def update(self, transform, canvas):
+        """Recompute projection/model-view matrices from transform and canvas dimensions.
+
+        Returns (model_view_proj, model_view) matrices, or (None, None) if canvas is unavailable.
+        """
+        if canvas is None or canvas.height == 0:
+            return None, None
+
+        near = 0.1
+        far = 10
+        fov = 45
+        aspect = canvas.width / canvas.height
+
+        zoom = 1.0
+        top = near * (np.tan(np.radians(fov) / 2)) * zoom
+        height = 2 * top
+        width = aspect * height
+        left = -0.5 * width
+        right = left + width
+        bottom = top - height
+
+        x = 2 * near / (right - left)
+        y = 2 * near / (top - bottom)
+
+        a = (right + left) / (right - left)
+        b = (top + bottom) / (top - bottom)
+
+        c = -far / (far - near)
+        d = (-far * near) / (far - near)
+
+        proj_mat = np.array(
+            [
+                [x, 0, a, 0],
+                [0, y, b, 0],
+                [0, 0, c, d],
+                [0, 0, -1, 0],
+            ]
+        )
+
+        view_mat = np.array([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, -3], [0, 0, 0, 1]])
+        model_view = view_mat @ transform.mat
+        model_view_proj = proj_mat @ model_view
+        normal_mat = np.linalg.inv(model_view)
+
+        self.aspect = aspect
+        self.view[:] = view_mat.transpose().flatten()
+        self.model_view[:] = model_view.transpose().flatten()
+        self.model_view_projection[:] = model_view_proj.transpose().flatten()
+        self.normal_mat[:] = normal_mat.flatten()
+
+        # Extract pure rotation from model_view (upper-left 3x3, normalize columns to remove scale)
+        mv33 = model_view[:3, :3]
+        col_norms = np.linalg.norm(mv33, axis=0)
+        col_norms[col_norms == 0] = 1.0
+        rot33 = mv33 / col_norms
+        rot_mat4 = np.identity(4)
+        rot_mat4[:3, :3] = rot33
+        self.rot_mat[:] = rot_mat4.transpose().flatten()
+        self.width = canvas.width
+        self.height = canvas.height
+        self.update_buffer()
+
+        return model_view_proj, model_view
+
 
 class Transform:
     """3D transform with translation/rotation/scale around a configurable center."""
@@ -143,95 +207,121 @@ class Transform:
     def _centering(self, center):
         return self._CenteringContext(self, center)
 
+
 class Camera:
-    """Interactive camera that maps a 3D scene to clip space and updates GPU uniforms."""
+    """Interactive camera that holds a transform and notifies registered observers on change."""
 
     def __init__(self):
-        self.uniforms = None
-        self.canvas = None
         self.transform = Transform()
-        self._render_function = None
-        self._get_position_function = None
+        self._observers = []
+        self._observers_lock = Lock()
         self._is_moving = False
         self._is_rotating = False
+        self._registered_handlers = {}
 
     def __setstate__(self, state):
         """Restore pickled camera state (only the transform)."""
         self.transform = state["transform"]
-        self.canvas = None
-        self.uniforms = None
-        self._render_function = None
-        self._get_position_function = None
+        self._observers = []
+        self._observers_lock = Lock()
         self._is_moving = False
         self._is_rotating = False
+        self._registered_handlers = {}
 
     def __getstate__(self):
         """Return a minimal picklable representation of the camera."""
         return {"transform": self.transform}
 
+    def register_observer(self, callback):
+        """Register a callback to be called when the camera transform changes.
+        
+        Idempotent: registering the same callback twice has no additional effect.
+        """
+        with self._observers_lock:
+            if callback not in self._observers:
+                self._observers.append(callback)
+
+    def unregister_observer(self, callback):
+        """Remove a previously registered observer callback."""
+        with self._observers_lock:
+            old_len = len(self._observers)
+            self._observers = [cb for cb in self._observers if cb is not callback]
+
+    def _notify_observers(self):
+        """Notify all registered observers that the transform has changed."""
+        with self._observers_lock:
+            observers = list(self._observers)
+        for cb in observers:
+            cb()
+
     def reset(self, pmin, pmax):
-        """Fit the camera to the axis-aligned box [pmin, pmax] and update uniforms."""
+        """Fit the camera to the axis-aligned box [pmin, pmax] and notify observers."""
         self.transform.init(pmin, pmax)
-        self._update_uniforms()
+        self._notify_observers()
 
     def reset_xy(self, flip: bool = False):
-        """Reset to a top-down XY view of the current center and update uniforms."""
+        """Reset to a top-down XY view and notify observers."""
         self.transform.reset_xy(flip)
-        self._update_uniforms()
+        self._notify_observers()
 
     def reset_xz(self, flip: bool = False):
-        """Reset to an XZ view of the current center and update uniforms."""
+        """Reset to an XZ view and notify observers."""
         self.transform.reset_xz(flip)
-        self._update_uniforms()
+        self._notify_observers()
 
     def reset_yz(self, flip: bool = False):
-        """Reset to a YZ view of the current center and update uniforms."""
+        """Reset to a YZ view and notify observers."""
         self.transform.reset_yz(flip)
-        self._update_uniforms()
-
-    def set_canvas(self, canvas):
-        """Attach the camera to a canvas, register resize handling, and allocate uniforms."""
-        self.canvas = canvas
-        canvas.on_resize(self._update_uniforms)
-        if self.uniforms is None:
-            self.uniforms = CameraUniforms()
-        self._update_uniforms()
-
-    def get_bindings(self) -> list[BaseBinding]:
-        return self.uniforms.get_bindings()
+        self._notify_observers()
 
     def get_shader_code(self):
         return read_shader_file("camera.wgsl")
 
-    def __del__(self):
-        del self.uniforms
-
-    def set_render_functions(self, redraw_function, get_position_function=None):
-        """Install callbacks for triggering redraws and mapping screen to world positions."""
-        self._render_function = redraw_function
-        self._get_position_function = get_position_function
-
-    def register_callbacks(self, input_handler):
-        input_handler.on_mousedown(self._on_mousedown, ctrl=False, shift=False, alt=False)
-        input_handler.on_mouseup(self._on_mouseup, ctrl=False, shift=False, alt=False)
-        input_handler.on_mouseout(self._on_mouseup, ctrl=False, shift=False, alt=False)
-        input_handler.on_mousemove(self._on_mousemove, ctrl=False, shift=False, alt=False)
-        input_handler.on_dblclick(self._on_dblclick, ctrl=False, shift=False, alt=False)
-        input_handler.on_wheel(self._on_wheel, ctrl=False, shift=False, alt=False)
+    def register_callbacks(self, input_handler, get_position_fn=None):
+        """Register mouse/wheel handlers on the given input_handler.
+        
+        Idempotent: unregisters existing handlers for this input_handler first.
+        get_position_fn is used for dblclick center-on-point (per-canvas).
+        """
+        # Unregister first to avoid duplicates
+        self.unregister_callbacks(input_handler)
+
+        def on_dblclick(ev):
+            if get_position_fn:
+                p = get_position_fn(ev["canvasX"], ev["canvasY"])
+                if p is not None:
+                    self.transform.set_center(p)
+                    self._notify_observers()
+
+        handlers = {
+            'mousedown': self._on_mousedown,
+            'mouseup': self._on_mouseup,
+            'mouseout': self._on_mouseup,
+            'mousemove': self._on_mousemove,
+            'wheel': self._on_wheel,
+            'dblclick': on_dblclick,
+        }
+        self._registered_handlers[id(input_handler)] = handlers
+
+        input_handler.on_mousedown(handlers['mousedown'], ctrl=False, shift=False, alt=False)
+        input_handler.on_mouseup(handlers['mouseup'], ctrl=False, shift=False, alt=False)
+        input_handler.on_mouseout(handlers['mouseout'], ctrl=False, shift=False, alt=False)
+        input_handler.on_mousemove(handlers['mousemove'], ctrl=False, shift=False, alt=False)
+        input_handler.on_dblclick(handlers['dblclick'], ctrl=False, shift=False, alt=False)
+        input_handler.on_wheel(handlers['wheel'], ctrl=False, shift=False, alt=False)
 
     def unregister_callbacks(self, input_handler):
-        input_handler.unregister("mousedown", self._on_mousedown)
-        input_handler.unregister("mouseup", self._on_mouseup)
-        input_handler.unregister("mouseout", self._on_mouseup)
-        input_handler.unregister("mousemove", self._on_mousemove)
-        input_handler.unregister("dblclick", self._on_dblclick)
-        input_handler.unregister("wheel", self._on_wheel)
-
-    def _on_dblclick(self, ev):
-        p = self._get_event_position(ev["canvasX"], ev["canvasY"])
-        if p is not None:
-            self.transform.set_center(p)
-            self._render()
+        """Remove previously registered handlers from the given input_handler."""
+        key = id(input_handler)
+        handlers = self._registered_handlers.pop(key, None)
+        if handlers is None:
+            return
+        input_handler.unregister("mousedown", handlers['mousedown'])
+        input_handler.unregister("mouseup", handlers['mouseup'])
+        input_handler.unregister("mouseout", handlers['mouseout'])
+        input_handler.unregister("mousemove", handlers['mousemove'])
+        input_handler.unregister("dblclick", handlers['dblclick'])
+        input_handler.unregister("wheel", handlers['wheel'])
 
     def _on_mousedown(self, ev):
         if ev["button"] == 0:
@@ -242,15 +332,10 @@ class Camera:
     def _on_mouseup(self, _):
         self._is_moving = False
         self._is_rotating = False
-        self._is_zooming = False
 
     def _on_wheel(self, ev):
-        if ev["shiftKey"]:
-            p = self._get_event_position(ev["canvasX"], ev["canvasY"])
-        else:
-            p = self.transform._center
-        self.transform.scale(1 - ev["deltaY"] / 1000, p)
-        self._render()
+        self.transform.scale(1 - ev["deltaY"] / 1000, self.transform._center)
+        self._notify_observers()
         if hasattr(ev, "preventDefault"):
             ev.preventDefault()
 
@@ -258,82 +343,8 @@ class Camera:
         if self._is_rotating:
             s = 0.3
             self.transform.rotate(s * ev["movementY"], s * ev["movementX"])
-            self._render()
-        if self._is_moving:
+            self._notify_observers()
+        elif self._is_moving:
             s = 0.01
             self.transform.translate(s * ev["movementX"], -s * ev["movementY"])
-            self._render()
-
-    def _render(self):
-        self._update_uniforms()
-        if self._render_function:
-            self._render_function()
-
-    def _get_event_position(self, x, y):
-        if self._get_position_function:
-            return self._get_position_function(x, y)
-        return None
-
-    def _update_uniforms(self):
-        """Recompute projection/model-view matrices and write them into the GPU uniforms."""
-        if self.canvas is None:
-            return
-        if self.uniforms is None:
-            self.uniforms = CameraUniforms()
-        near = 0.1
-        far = 10
-        fov = 45
-        if self.canvas.height == 0:
-            aspect = 800 / 600
-        else:
-            aspect = self.canvas.width / self.canvas.height
-
-        zoom = 1.0
-        top = near * (np.tan(np.radians(fov) / 2)) * zoom
-        height = 2 * top
-        width = aspect * height
-        left = -0.5 * width
-        right = left + width
-        bottom = top - height
-
-        x = 2 * near / (right - left)
-        y = 2 * near / (top - bottom)
-
-        a = (right + left) / (right - left)
-        b = (top + bottom) / (top - bottom)
-
-        c = -far / (far - near)
-        d = (-far * near) / (far - near)
-
-        proj_mat = np.array(
-            [
-                [x, 0, a, 0],
-                [0, y, b, 0],
-                [0, 0, c, d],
-                [0, 0, -1, 0],
-            ]
-        )
-
-        view_mat = np.array([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, -3], [0, 0, 0, 1]])
-        model_view = view_mat @ self.transform.mat
-        model_view_proj = proj_mat @ model_view
-        self.model_view = model_view
-        normal_mat = np.linalg.inv(model_view)
-        self.model_view_proj = model_view_proj
-
-        self.uniforms.aspect = aspect
-        self.uniforms.view[:] = view_mat.transpose().flatten()
-        self.uniforms.model_view[:] = model_view.transpose().flatten()
-        self.uniforms.model_view_projection[:] = model_view_proj.transpose().flatten()
-        self.uniforms.normal_mat[:] = normal_mat.flatten()
-        # Extract pure rotation from model_view (upper-left 3x3, normalize columns to remove scale)
-        mv33 = model_view[:3, :3]
-        col_norms = np.linalg.norm(mv33, axis=0)
-        col_norms[col_norms == 0] = 1.0
-        rot33 = mv33 / col_norms
-        rot_mat4 = np.identity(4)
-        rot_mat4[:3, :3] = rot33
-        self.uniforms.rot_mat[:] = rot_mat4.transpose().flatten()
-        self.uniforms.width = self.canvas.width
-        self.uniforms.height = self.canvas.height
-        self.uniforms.update_buffer()
+            self._notify_observers()

webgpu/canvas.py

@@ -22,73 +22,111 @@ _TARGET_FPS = 60
 #     running: bool = False
 #     pending: bool = False
 
+class _InstanceDebounce:
+    """Descriptor that creates per-instance debounced methods.
+
+    When used as a decorator on a method, each instance gets its own
+    debounce state (lock, timer, last_call, pending) so that calls on
+    different instances never interfere with each other.
+    """
+
+    def __init__(self, fn, rate_hz=60):
+        self._fn = fn
+        self._rate_hz = rate_hz
+        self._attr = f"_debounce_{fn.__name__}"
+        functools.update_wrapper(self, fn)
+
+    def __set_name__(self, owner, name):
+        self._attr = f"_debounce_{name}"
+
+    def __get__(self, obj, objtype=None):
+        if obj is None:
+            return self
+        # Return a bound debounced callable for this instance
+        state = getattr(obj, self._attr, None)
+        if state is None:
+            state = _DebounceState(self._fn, obj, self._rate_hz)
+            object.__setattr__(obj, self._attr, state)
+        return state
+
+
+class _DebounceState:
+    """Per-instance debounce state and callable."""
+
+    __slots__ = ("_fn", "_obj", "_interval", "_lock", "_last_call", "_timer", "_pending")
+
+    def __init__(self, fn, obj, rate_hz):
+        self._fn = fn
+        self._obj = obj
+        self._interval = 1.0 / rate_hz
+        self._lock = threading.RLock()
+        self._last_call = 0.0
+        self._timer = None
+        self._pending = None
+
+    def _original(self, *args, **kwargs):
+        """Bypass debounce and call the underlying function immediately."""
+        return self._fn(self._obj, *args, **kwargs)
+
+    def _schedule(self, delay):
+        self._timer = threading.Timer(delay, self._run_pending)
+        self._timer.daemon = True
+        self._timer.start()
+
+    def _run_pending(self):
+        with self._lock:
+            if self._pending is None:
+                self._timer = None
+                return
+
+            args, kwargs = self._pending
+            self._pending = None
+            self._last_call = time.monotonic()
+
+        self._fn(self._obj, *args, **kwargs)
+
+        with self._lock:
+            self._timer = None
+            if self._pending is not None:
+                delay = max(0.0, self._interval - (time.monotonic() - self._last_call))
+                self._schedule(delay)
+
+    def __call__(self, *args, **kwargs):
+        with self._lock:
+            now = time.monotonic()
+            elapsed = now - self._last_call
+            if elapsed >= self._interval and self._timer is None:
+                self._last_call = now
+                run_now = True
+            else:
+                self._pending = (args, kwargs)
+                run_now = False
+
+                if self._timer is None:
+                    self._schedule(max(0.0, self._interval - elapsed))
+
+        if run_now:
+            self._fn(self._obj, *args, **kwargs)
+
+
 def debounce(arg=None, *, rate_hz=60):
 
-    def _rate_limited(fn, rate_hz):
-        interval = 1.0 / rate_hz
-        lock = threading.RLock()
-        last_call = 0.0
-        timer = None
-        pending = None
-
-        def schedule(delay):
-            nonlocal timer
-            timer = threading.Timer(delay, run_pending)
-            timer.daemon = True
-            timer.start()
-
-        def run_pending():
-            nonlocal last_call, timer, pending
-
-            with lock:
-                if pending is None:
-                    timer = None
-                    return
-
-                args, kwargs = pending
-                pending = None
-                # print("call frequency = ", 1.0 / (time.monotonic() - last_call))
-                last_call = time.monotonic()
-
-            fn(*args, **kwargs)
-
-            with lock:
-                timer = None
-                if pending is not None:
-                    delay = max(0.0, interval - (time.monotonic() - last_call))
-                    schedule(delay)
-
-        @wraps(fn)
-        def wrapper(*args, **kwargs):
-            nonlocal last_call, pending
-
-            with lock:
-                now = time.monotonic()
-                elapsed = now - last_call
-                if elapsed >= interval and timer is None:
-                    # print("call frequency = ", 1.0 / elapsed if elapsed > 0 else float('inf'))
-                    last_call = now
-                    run_now = True
-                else:
-                    pending = (args, kwargs)
-                    run_now = False
-
-                    if timer is None:
-                        schedule(max(0.0, interval - elapsed))
-
-            if run_now:
-                fn(*args, **kwargs)
-
-        return wrapper
+    if platform.is_pyodide:
+      if callable(arg):
+        return arg
+      def _rate_limited(fn, *args, **kwargs):
+        return fn
+
+      return _rate_limited
 
     if callable(arg):
-        return _rate_limited(arg, rate_hz)
+        return _InstanceDebounce(arg, rate_hz)
 
     if arg is not None:
         rate_hz = arg
 
     def decorate(fn):
-        return _rate_limited(fn, rate_hz)
+        return _InstanceDebounce(fn, rate_hz)
     return decorate
 
 
@@ -217,6 +255,7 @@ class Canvas:
 
         self._on_resize_callbacks = []
         self._on_update_html_canvas = []
+        self._on_visibility_callbacks = []
 
         self._resize_observer = None
         self._intersection_observer = None
@@ -281,8 +320,7 @@ class Canvas:
                     "device": self.device.handle,
                     "format": self.format,
                     "alphaMode": "premultiplied",
-                    "sampleCount": self.multisample.count,
-                    "usage": TextureUsage.RENDER_ATTACHMENT | TextureUsage.COPY_DST,
+                    "usage": TextureUsage.RENDER_ATTACHMENT | TextureUsage.COPY_DST | TextureUsage.COPY_SRC,
                 }
             )
 
@@ -293,6 +331,8 @@ class Canvas:
                 if observer_entry[0].isIntersecting:
                     for func in self._on_resize_callbacks:
                         func()
+                for func in self._on_visibility_callbacks:
+                    func(observer_entry[0].isIntersecting)
 
             if self._resize_observer is not None:
                 self._resize_observer.disconnect()
@@ -322,6 +362,10 @@ class Canvas:
     def on_resize(self, func: Callable):
         self._on_resize_callbacks.append(func)
 
+    def on_visibility(self, func: Callable):
+        """Register callback for visibility changes. Called with True/False."""
+        self._on_visibility_callbacks.append(func)
+
     def on_update_html_canvas(self, func: Callable):
         self._on_update_html_canvas.append(func)
 
@@ -359,8 +403,9 @@ class Canvas:
             if canvas is None:
                 return
             rect = canvas.getBoundingClientRect()
-            width = int(rect.width)
-            height = int(rect.height)
+            dpr = getattr(platform.js.window, 'devicePixelRatio', 1) or 1
+            width = round(rect.width * dpr)
+            height = round(rect.height * dpr)
 
             if width == self.width and height == self.height:
                 for func in self._on_resize_callbacks:

webgpu/clipping.py

@@ -79,20 +79,8 @@ class Clipping(BaseRenderer):
         return None
 
     def __del__(self):
-        if hasattr(self, "uniforms"):
-            self.uniforms._buffer.destroy()
-
-    def add_options_to_gui(self, gui):
-        if gui is None:
-            return
-        folder = gui.folder("Clipping", closed=True)
-        folder.checkbox("enabled", self.mode != self.Mode.DISABLED, self.enable_clipping)
-        folder.value("x", self.center[0], self.set_x_value)
-        folder.value("y", self.center[1], self.set_y_value)
-        folder.value("z", self.center[2], self.set_z_value)
-        folder.value("nx", self.normal[0], self.set_nx_value)
-        folder.value("ny", self.normal[1], self.set_ny_value)
-        folder.value("nz", self.normal[2], self.set_nz_value)
+        # Do NOT auto-destroy: the JS engine may still reference this buffer.
+        pass
 
     def render(self, options: RenderOptions):
         pass