1. tuned arrow mesh drawing

2. centralixzed arrow config in layout.py
3. seperate mesh render and display resolution to speed up (~40 fps)

examples/gui/widgets/mesh_viewport.py

@@ -2,10 +2,13 @@
 
 from __future__ import annotations
 
+import sys
+
 from pipeline.frame import FingerFrameView
 from viz.offscreen_mesh import OffscreenFingerMeshRenderer
 
 from ..layout import DashboardLayout, LAYOUT
+from ..mesh_render_worker import MeshRenderWorker
 from .qt_pixmap import ndarray_to_pixmap
 from .image_panel import ImagePanel
 
@@ -16,14 +19,15 @@ class MeshViewportWidget(ImagePanel):
     def __init__(self, parent=None, *, layout: DashboardLayout = LAYOUT):
         self._layout = layout
         self._renderer: OffscreenFingerMeshRenderer | None = None
+        self._mesh_worker: MeshRenderWorker | None = None
         self._mesh_map = "depth"
         self._threshold = 0.0
         self._enable_3d = True
-        slot = layout.top_slot("mesh")
+        display_w, display_h = layout.mesh_display_size()
         super().__init__(
             title=layout.mesh_panel_title,
             object_name="meshViewport",
-            default_side=min(slot.width_px, slot.height_px),
+            default_side=min(display_w, display_h),
             parent=parent,
         )
 
@@ -31,6 +35,7 @@ class MeshViewportWidget(ImagePanel):
         self._mesh_map = pipeline.config.mesh_map
         self._threshold = pipeline.config.flow_threshold
         self._enable_3d = pipeline.config.enable_3d and pipeline.uv_mesh is not None
+        self._stop_worker()
         if self._renderer is not None:
             self._renderer.close()
             self._renderer = None
@@ -42,28 +47,58 @@ class MeshViewportWidget(ImagePanel):
             return
         self.label.setText("")
         self._init_renderer(pipeline)
+        if self._layout.mesh_async_render and sys.platform != "win32":
+            self._mesh_worker = MeshRenderWorker(self)
+            self._mesh_worker.rgb_ready.connect(self._on_rgb_ready)
+            self._mesh_worker.set_renderer(self._renderer)
 
     def _init_renderer(self, pipeline) -> None:
         if not self._enable_3d or pipeline.uv_mesh is None:
             return
-        side = self.side_length
+        render_w, render_h = self._layout.mesh_render_size()
         self._renderer = OffscreenFingerMeshRenderer(
             pipeline.uv_mesh,
-            width=side,
-            height=side,
+            width=render_w,
+            height=render_h,
             threshold=self._threshold,
             color_mode=self._mesh_map,
             world_to_cam=pipeline.world_to_cam,
             lookat=pipeline.mesh_lookat,
+            mesh_lighting=self._layout.mesh_lighting,
+            contact_arrow_style=self._layout.mesh_contact_arrow,
         )
 
-    def on_side_length_changed(self, side: int) -> None:
-        if self._renderer is not None:
-            self._renderer.resize(side, side)
+    def _stop_worker(self) -> None:
+        if self._mesh_worker is not None:
+            self._mesh_worker.stop_worker()
+            self._mesh_worker = None
 
-    def update_frame(self, frame: FingerFrameView) -> None:
+    def on_side_length_changed(self, side: int) -> None:
+        """Display widget resized; offscreen render size stays on layout.mesh_render_*."""
+        del side  # display size only; ImagePanel upscales the pixmap to fit the label
+
+    def _on_rgb_ready(self, rgb) -> None:
+        self.set_source_pixmap(ndarray_to_pixmap(rgb, bgr=False))
+
+    def update_frame(self, frame: FingerFrameView, *, async_render: bool | None = None) -> float:
+        """Update mesh colors. Returns render wall time (0 when async submit only)."""
         if not self._enable_3d or self._renderer is None:
-            return
+            return 0.0
+
+        use_async = self._layout.mesh_async_render if async_render is None else async_render
+        if use_async and self._mesh_worker is not None:
+            self._mesh_worker.submit(
+                flow=frame.flow,
+                scalar_map=frame.depth_map,
+                centroid=frame.centroid,
+                centroid_found=frame.centroid_found,
+                fnormal=frame.fnormal,
+            )
+            return 0.0
+
+        import time
+
+        t0 = time.perf_counter()
         rgb = self._renderer.render(
             flow=frame.flow,
             scalar_map=frame.depth_map,
@@ -72,8 +107,10 @@ class MeshViewportWidget(ImagePanel):
             fnormal=frame.fnormal,
         )
         self.set_source_pixmap(ndarray_to_pixmap(rgb, bgr=False))
+        return (time.perf_counter() - t0) * 1000.0
 
     def close_renderer(self) -> None:
+        self._stop_worker()
         if self._renderer is not None:
             self._renderer.close()
             self._renderer = None