webgpu 1.2.1.dev0__py3-none-any.whl → 1.2.3.dev0__py3-none-any.whl

webgpu/__init__.py

@@ -1,6 +1,7 @@
 from .clipping import Clipping
 from .colormap import Colormap, Colorbar
 from .font import Font
+from .gizmo import CoordinateAxes, NavigationCube
 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.1.dev0'
-__version_tuple__ = version_tuple = (1, 2, 1, 'dev0')
+__version__ = version = '1.2.3.dev0'
+__version_tuple__ = version_tuple = (1, 2, 3, 'dev0')
 
-__commit_id__ = commit_id = 'g7d909a7c5'
+__commit_id__ = commit_id = 'g3663824c4'

webgpu/camera.py

@@ -97,10 +97,10 @@ class Transform:
 
     def reset_xy(self, flip: bool = False):
         """Reset to a view looking along +Z onto the XY plane, optionally flipped."""
-        pos = self.map_point(self._center)
+        s = np.linalg.norm(self._mat[:3, :3], axis=0)[0]  # current uniform scale
         self._mat = np.identity(4)
         self.translate(-self._center[0], -self._center[1], -self._center[2])
-        self.translate(pos[0], pos[1], pos[2])
+        self.scale(s)
         if flip:
             self.rotate(0, 180)
 
@@ -212,12 +212,12 @@ class Camera:
         self._get_position_function = get_position_function
 
     def register_callbacks(self, input_handler):
-        input_handler.on_mousedown(self._on_mousedown)
-        input_handler.on_mouseup(self._on_mouseup)
-        input_handler.on_mouseout(self._on_mouseup)
-        input_handler.on_mousemove(self._on_mousemove)
-        input_handler.on_dblclick(self._on_dblclick)
-        input_handler.on_wheel(self._on_wheel, shift=None)
+        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 unregister_callbacks(self, input_handler):
         input_handler.unregister("mousedown", self._on_mousedown)
@@ -326,7 +326,14 @@ class Camera:
         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()
-        # self.uniforms.rot_mat[:] = self.transform._rot_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()

webgpu/canvas.py

@@ -8,80 +8,183 @@ import pathlib
 from . import platform
 from .utils import get_device, read_texture, Lock
 from .webgpu_api import *
+from functools import wraps
 
 _TARGET_FPS = 60
 
 
-@dataclass
-class _DebounceData:
-    t_last: float | None = None
-    timer: threading.Timer | None = None
-
-
-def debounce(arg=None):
-    def decorator(func):
-        # Render only once every 1/_TARGET_FPS seconds
-        @functools.wraps(func)
-        def debounced(obj, *args, **kwargs):
-            if not hasattr(obj, "_debounce_data"):
-                obj._debounce_data = {}
-
-            fname = func.__name__
-            if obj._debounce_data.get(fname, None) is None:
-                obj._debounce_data[fname] = _DebounceData(None, None)
-
-            data = obj._debounce_data[fname]
-
-            # 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:
+# @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
+
+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
 
-            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)
+                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:
-                    data.t_last = t
-                    func(obj, *args, **kwargs)
+                    pending = (args, kwargs)
+                    run_now = False
 
-            if data.timer is not None:
-                return
+                    if timer is None:
+                        schedule(max(0.0, interval - elapsed))
 
-            if data.t_last is None:
-                # first call -> just call the function immediately
-                data.t_last = time.time()
-                f()
-                return
+            if run_now:
+                fn(*args, **kwargs)
 
-            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())
-            else:
-                data.timer = threading.Timer(t_wait, f)
-                data.timer.start()
-
-        debounced._original = func
-        return debounced
+        return wrapper
 
     if callable(arg):
-        target_fps = _TARGET_FPS
-        return decorator(arg)
-    else:
-        target_fps = arg
-        return decorator
+        return _rate_limited(arg, rate_hz)
+
+    if arg is not None:
+        rate_hz = arg
+
+    def decorate(fn):
+        return _rate_limited(fn, rate_hz)
+    return decorate
+
+
+
+# def debounce(arg=None):
+#     def decorator(func):
+#         # Render only once every 1/_TARGET_FPS seconds
+#         @functools.wraps(func)
+#         def debounced(obj, *args, **kwargs):
+#             if not hasattr(obj, "_debounce_data"):
+#                 obj._debounce_data = {}
+
+#             fname = func.__name__
+#             if obj._debounce_data.get(fname, None) is None:
+#                 obj._debounce_data[fname] = _DebounceData(0, 0, None, Lock())
+
+#             data = obj._debounce_data[fname]
+#             frame_time = 1.0 / target_fps
+
+#             def run():
+#                 while True:
+#                     # Call func OUTSIDE the lock to avoid deadlocks
+#                     func(obj, *args, **kwargs)
+
+#                     with data.lock:
+#                         if not data.pending:
+#                             data.running = False
+#                             return
+#                         data.pending = False
+#                         elapsed = time.time() - data.t_last_frame
+#                         t_wait = frame_time - elapsed
+#                         if t_wait > 0:
+#                             # Schedule deferred re-run to respect frame rate
+#                             if platform.is_pyodide:
+#                                 import asyncio
+#                                 async def _rerun():
+#                                     await asyncio.sleep(t_wait)
+#                                     with data.lock:
+#                                         data.t_last_frame = time.time()
+#                                     run()
+#                                 asyncio.create_task(_rerun())
+#                             else:
+#                                 def _deferred():
+#                                     with data.lock:
+#                                         data.t_last_frame = time.time()
+#                                     run()
+#                                 data.timer = threading.Timer(t_wait, _deferred)
+#                                 data.timer.start()
+#                             return
+#                         data.t_last_frame = time.time()
+
+#             def f():
+#                 with data.lock:
+#                     if t_call != data.t_last_call and t_call - data.t_last_frame < frame_time:
+#                         return
+#                     if data.running:
+#                         data.pending = True
+#                         return
+#                     data.running = True
+#                     data.t_last_frame = time.time()
+
+#                 run()
+
+#             with data.lock:
+#                 t_call = time.time()
+#                 data.t_last_call = t_call
+#                 t_wait = frame_time - (t_call - data.t_last_frame)
+
+#                 if t_wait <= 0:
+#                     if data.running:
+#                         data.pending = True
+#                         return
+#                     data.running = True
+#                     data.t_last_frame = time.time()
+#                     if data.timer is not None:
+#                         data.timer.cancel()
+#                         data.timer = None
+#                 else:
+#                     if data.timer is not None:
+#                         data.timer.cancel()
+#                     if platform.is_pyodide:
+#                         import asyncio
+#                         async def _runner():
+#                             await asyncio.sleep(t_wait)
+#                             f()
+#                         asyncio.create_task(_runner())
+#                     else:
+#                         data.timer = threading.Timer(t_wait, f)
+#                         data.timer.start()
+#                     return
+
+#             run()
+
+#         debounced._original = func
+#         return debounced
+
 
 
 def init_webgpu(html_canvas):
@@ -147,10 +250,12 @@ class Canvas:
         self.update_html_canvas(canvas)
 
     def __del__(self):
-        if self._resize_observer is not None:
-            self._resize_observer.disconnect()
-        if self._intersection_observer is not None:
-            self._intersection_observer.disconnect()
+        disconnect = getattr(self._resize_observer, "disconnect", None)
+        if callable(disconnect):
+            disconnect()
+        disconnect = getattr(self._intersection_observer, "disconnect", None)
+        if callable(disconnect):
+            disconnect()
 
     def update_html_canvas(self, html_canvas):
         """Reconfigure the canvas with the current HTML canvas element. This is necessary when the HTML canvas element changes, disappears (e.g. when switching a tab) and appears again."""

webgpu/gizmo.py

@@ -0,0 +1,304 @@
+"""Coordinate axes (3D arrows) and navigation cube renderers.
+
+Both render in fixed screen corners, rotated by the camera's rotation matrix.
+Uses the Labels renderer for text (overlay mode) and minimal custom renderers
+for the mesh and edge geometry.
+"""
+
+import numpy as np
+
+from .labels import Labels
+from .renderer import MultipleRenderer, Renderer, RenderOptions
+from .utils import (
+    BufferBinding,
+    UniformBinding,
+    buffer_from_array,
+    uniform_from_array,
+    read_shader_file,
+)
+from .webgpu_api import PrimitiveTopology
+
+# ---------------------------------------------------------------------------
+# Geometry helpers
+# ---------------------------------------------------------------------------
+
+
+def _rotation_to_direction(direction):
+    """3x3 rotation mapping +Z to *direction*."""
+    z = np.asarray(direction, dtype=np.float64)
+    z = z / np.linalg.norm(z)
+    up = np.array([1, 0, 0]) if abs(z[0]) < 0.9 else np.array([0, 1, 0])
+    x = np.cross(up, z)
+    x /= np.linalg.norm(x)
+    y = np.cross(z, x)
+    return np.column_stack([x, y, z])
+
+
+def _cylinder_tris(segs, r, z0, z1, rot):
+    verts, norms = [], []
+    angles = np.linspace(0, 2 * np.pi, segs, endpoint=False)
+    for i in range(segs):
+        j = (i + 1) % segs
+        c0, s0 = np.cos(angles[i]), np.sin(angles[i])
+        c1, s1 = np.cos(angles[j]), np.sin(angles[j])
+        p00 = rot @ [r * c0, r * s0, z0]
+        p10 = rot @ [r * c1, r * s1, z0]
+        p01 = rot @ [r * c0, r * s0, z1]
+        p11 = rot @ [r * c1, r * s1, z1]
+        n0 = rot @ [c0, s0, 0.0]
+        n1 = rot @ [c1, s1, 0.0]
+        verts += [p00, p10, p01, p10, p11, p01]
+        norms += [n0, n1, n0, n1, n1, n0]
+    return verts, norms
+
+
+def _cone_tris(segs, r, z0, z1, rot):
+    verts, norms = [], []
+    angles = np.linspace(0, 2 * np.pi, segs, endpoint=False)
+    tip = rot @ [0, 0, z1]
+    slope = r / (z1 - z0)
+    base_center = rot @ [0, 0, z0]
+    base_n = rot @ [0, 0, -1.0]
+    for i in range(segs):
+        j = (i + 1) % segs
+        c0, s0 = np.cos(angles[i]), np.sin(angles[i])
+        c1, s1 = np.cos(angles[j]), np.sin(angles[j])
+        p0 = rot @ [r * c0, r * s0, z0]
+        p1 = rot @ [r * c1, r * s1, z0]
+        raw0 = np.array([c0, s0, slope])
+        raw1 = np.array([c1, s1, slope])
+        n0 = rot @ raw0 / np.linalg.norm(raw0)
+        n1 = rot @ raw1 / np.linalg.norm(raw1)
+        nt = (n0 + n1)
+        nt /= np.linalg.norm(nt)
+        verts += [p0, p1, tip]
+        norms += [n0, n1, nt]
+        verts += [base_center, p1, p0]
+        norms += [base_n, base_n, base_n]
+    return verts, norms
+
+
+def _generate_arrows():
+    """Return (positions, normals, colors) flat float32 arrays for 3 arrows."""
+    axes = [
+        ([1, 0, 0], [0.85, 0.20, 0.20, 1.0]),
+        ([0, 1, 0], [0.20, 0.75, 0.20, 1.0]),
+        ([0, 0, 1], [0.25, 0.35, 0.90, 1.0]),
+    ]
+    segs = 12
+    shaft_r, shaft_len = 0.018, 0.65
+    head_r, head_len = 0.055, 0.28
+    all_v, all_n, all_c = [], [], []
+    for d, col in axes:
+        rot = _rotation_to_direction(d)
+        sv, sn = _cylinder_tris(segs, shaft_r, 0, shaft_len, rot)
+        cv, cn = _cone_tris(segs, head_r, shaft_len, shaft_len + head_len, rot)
+        n = len(sv) + len(cv)
+        all_v += sv + cv
+        all_n += sn + cn
+        all_c += [col] * n
+    return (
+        np.array(all_v, dtype=np.float32).flatten(),
+        np.array(all_n, dtype=np.float32).flatten(),
+        np.array(all_c, dtype=np.float32).flatten(),
+    )
+
+
+def _generate_cube_faces(h=0.45):
+    """Return (positions, normals, colors) for 6 coloured cube faces."""
+    face_defs = [
+        ([[h, -h, -h], [h, h, -h], [h, h, h], [h, -h, h]], [1, 0, 0], [0.82, 0.55, 0.55, 1.0]),
+        ([[-h, -h, h], [-h, h, h], [-h, h, -h], [-h, -h, -h]], [-1, 0, 0], [0.58, 0.40, 0.40, 1.0]),
+        ([[-h, h, -h], [h, h, -h], [h, h, h], [-h, h, h]], [0, 1, 0], [0.55, 0.82, 0.55, 1.0]),
+        ([[h, -h, -h], [-h, -h, -h], [-h, -h, h], [h, -h, h]], [0, -1, 0], [0.40, 0.58, 0.40, 1.0]),
+        ([[-h, -h, h], [h, -h, h], [h, h, h], [-h, h, h]], [0, 0, 1], [0.55, 0.55, 0.82, 1.0]),
+        ([[h, -h, -h], [-h, -h, -h], [-h, h, -h], [h, h, -h]], [0, 0, -1], [0.40, 0.40, 0.58, 1.0]),
+    ]
+    all_v, all_n, all_c = [], [], []
+    for corners, normal, color in face_defs:
+        c = [np.array(p, dtype=np.float64) for p in corners]
+        all_v += [c[0], c[1], c[2], c[0], c[2], c[3]]
+        all_n += [normal] * 6
+        all_c += [color] * 6
+    return (
+        np.array(all_v, dtype=np.float32).flatten(),
+        np.array(all_n, dtype=np.float32).flatten(),
+        np.array(all_c, dtype=np.float32).flatten(),
+    )
+
+
+def _generate_cube_edges(h=0.45):
+    """Return flat float32 array of edge pairs (p1 xyz, p2 xyz) x 12 edges."""
+    v = [
+        [-h, -h, -h], [h, -h, -h], [h, h, -h], [-h, h, -h],
+        [-h, -h, h], [h, -h, h], [h, h, h], [-h, h, h],
+    ]
+    edges = [
+        (0, 1), (1, 2), (2, 3), (3, 0),
+        (4, 5), (5, 6), (6, 7), (7, 4),
+        (0, 4), (1, 5), (2, 6), (3, 7),
+    ]
+    data = []
+    for a, b in edges:
+        data += v[a] + v[b]
+    return np.array(data, dtype=np.float32)
+
+
+# ---------------------------------------------------------------------------
+# Renderers
+# ---------------------------------------------------------------------------
+
+
+class GizmoMeshRenderer(Renderer):
+    """Renders a triangle mesh in a fixed corner, rotated by camera."""
+
+    select_entry_point: str = ""
+
+    def __init__(self, positions, normals, colors, corner, scale, label="GizmoMesh"):
+        super().__init__(label=label)
+        self._raw_pos = positions
+        self._raw_nrm = normals
+        self._raw_col = colors
+        self._corner = corner
+        self._scale = scale
+        self._pos_buf = None
+        self._nrm_buf = None
+        self._col_buf = None
+        self._uni_buf = None
+
+    def update(self, options: RenderOptions):
+        self.n_vertices = len(self._raw_pos) // 3
+        self._pos_buf = buffer_from_array(self._raw_pos, label="gizmo_pos", reuse=self._pos_buf)
+        self._nrm_buf = buffer_from_array(self._raw_nrm, label="gizmo_nrm", reuse=self._nrm_buf)
+        self._col_buf = buffer_from_array(self._raw_col, label="gizmo_col", reuse=self._col_buf)
+        uni = np.array([self._corner[0], self._corner[1], self._scale, 0], dtype=np.float32)
+        self._uni_buf = uniform_from_array(uni, label="gizmo_uni", reuse=self._uni_buf)
+
+    def get_shader_code(self):
+        return read_shader_file("gizmo_mesh.wgsl")
+
+    def get_bindings(self):
+        return [
+            BufferBinding(90, self._pos_buf),
+            BufferBinding(91, self._nrm_buf),
+            BufferBinding(92, self._col_buf),
+            UniformBinding(93, self._uni_buf),
+        ]
+
+    def get_bounding_box(self):
+        return None
+
+
+class GizmoEdgesRenderer(Renderer):
+    """Renders thick lines in a fixed corner, rotated by camera."""
+
+    n_vertices: int = 4
+    topology: PrimitiveTopology = PrimitiveTopology.triangle_strip
+    select_entry_point: str = ""
+
+    def __init__(self, edge_data, corner, scale, thickness=0.003, label="GizmoEdges"):
+        super().__init__(label=label)
+        self._raw_edges = edge_data
+        self._corner = corner
+        self._scale = scale
+        self._thickness = thickness
+        self._edge_buf = None
+        self._uni_buf = None
+
+    def update(self, options: RenderOptions):
+        self.n_instances = len(self._raw_edges) // 6
+        self._edge_buf = buffer_from_array(self._raw_edges, label="gizmo_edges", reuse=self._edge_buf)
+        uni = np.array([self._corner[0], self._corner[1], self._scale, self._thickness], dtype=np.float32)
+        self._uni_buf = uniform_from_array(uni, label="gizmo_edge_uni", reuse=self._uni_buf)
+
+    def get_shader_code(self):
+        return read_shader_file("gizmo_edges.wgsl")
+
+    def get_bindings(self):
+        return [
+            BufferBinding(90, self._edge_buf),
+            UniformBinding(93, self._uni_buf),
+        ]
+
+    def get_bounding_box(self):
+        return None
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+_ARROW_COLORS = [
+    [0.85, 0.20, 0.20, 1.0],
+    [0.20, 0.75, 0.20, 1.0],
+    [0.25, 0.35, 0.90, 1.0],
+]
+
+_AXES_CORNER = (-0.78, -0.78)
+_AXES_SCALE = 0.15
+_CUBE_CORNER = (0.78, -0.78)
+_CUBE_SCALE = 0.13
+
+
+class CoordinateAxes(MultipleRenderer):
+    """3D arrows with X/Y/Z labels in the bottom-left corner."""
+
+    def __init__(self):
+        pos, nrm, col = _generate_arrows()
+        tip_offset = 1.12
+        self.arrows = GizmoMeshRenderer(pos, nrm, col, _AXES_CORNER, _AXES_SCALE, "Arrows")
+        self.labels = Labels(
+            labels=["X", "Y", "Z"],
+            positions=[[tip_offset, 0, 0], [0, tip_offset, 0], [0, 0, tip_offset]],
+            colors=_ARROW_COLORS,
+            overlay={"corner": _AXES_CORNER, "scale": _AXES_SCALE},
+            h_align="center",
+            v_align="center",
+            font_size=16,
+        )
+        super().__init__([self.arrows, self.labels])
+
+    def get_bounding_box(self):
+        return None
+
+
+class NavigationCube(MultipleRenderer):
+    """Coloured orientation cube with edge wireframe and face labels."""
+
+    FACE_VIEWS = ["yz", "yz_flip", "xz", "xz_flip", "xy", "xy_flip"]
+
+    def __init__(self):
+        h = 0.45
+        fp, fn, fc = _generate_cube_faces(h)
+        edges = _generate_cube_edges(h)
+        self.faces = GizmoMeshRenderer(fp, fn, fc, _CUBE_CORNER, _CUBE_SCALE, "CubeFaces")
+        self.faces.select_entry_point = "fragment_select"
+        self.edges = GizmoEdgesRenderer(edges, _CUBE_CORNER, _CUBE_SCALE, thickness=0.003, label="CubeEdges")
+
+        label_offset = h + 0.08
+        self.labels = Labels(
+            labels=["X", "x", "Y", "y", "Z", "z"],
+            positions=[
+                [label_offset, 0, 0], [-label_offset, 0, 0],
+                [0, label_offset, 0], [0, -label_offset, 0],
+                [0, 0, label_offset], [0, 0, -label_offset],
+            ],
+            normals=[
+                [1, 0, 0], [-1, 0, 0],
+                [0, 1, 0], [0, -1, 0],
+                [0, 0, 1], [0, 0, -1],
+            ],
+            colors=[
+                [0.75, 0.15, 0.15, 1.0], [0.45, 0.25, 0.25, 1.0],
+                [0.15, 0.65, 0.15, 1.0], [0.25, 0.45, 0.25, 1.0],
+                [0.15, 0.25, 0.80, 1.0], [0.25, 0.25, 0.45, 1.0],
+            ],
+            overlay={"corner": _CUBE_CORNER, "scale": _CUBE_SCALE},
+            h_align="center",
+            v_align="center",
+            font_size=14,
+        )
+        super().__init__([self.faces, self.edges, self.labels])
+
+    def get_bounding_box(self):
+        return None