fix more interactions

Author: ChrLackner

ngsolve_webgpu/cf.py

@@ -622,15 +622,18 @@ def component(self, value):
             self.uniform.update_buffer()
 
 
-def _complex_phase_export_interactions(uniforms_with_mode, registry, label="Complex Animation"):
-    """Build a generic gui ExportInteraction for complex phase animation.
+def _complex_phase_export_interactions(uniforms_with_mode, registry, label="Complex"):
+    """Build a generic gui ExportInteraction for complex visualization.
 
     uniforms_with_mode: iterable of (uniform_obj, has_mode_field).
-    has_mode_field=True for ComplexUniform (mode at offset 0, phase at offset 4),
-    False for ShapeComplexUniform (phase at offset 0, no mode).
+    has_mode_field=True for ComplexUniform (mode @ offset 0, phase @ 4),
+    False for ShapeComplexUniform (phase @ 0, no mode).
+
+    Emits: Mode dropdown (if any mode-carrying uniform), Phase slider,
+    Animate checkbox, Speed slider.
     """
     from webgpu.export.gui import (
-        gui_interaction, Checkbox, Slider, Write, Target,
+        gui_interaction, Checkbox, Slider, Dropdown, Write, Target,
     )
 
     phase_targets = []
@@ -651,28 +654,99 @@ def _complex_phase_export_interactions(uniforms_with_mode, registry, label="Comp
     if not phase_targets:
         return []
 
-    controls = [
-        Checkbox(var="animate", name="Animate", default=False),
-        Slider(var="speed", name="Speed", default=1.0, min=0.1, max=5.0, step=0.1),
-    ]
-    writes = [
-        Write(
-            targets=phase_targets,
-            expr="(t*speed*2*Math.PI) % (2*Math.PI)",
-            when="animate",
-        ),
-    ]
+    controls = []
+    writes = []
     if mode_targets:
-        # Force PHASE_ROTATE mode whenever animation is toggled on.
+        # 0=Real (PHASE_ROTATE,phase=0), 1=Imag (PHASE_ROTATE,phase=-pi/2),
+        # 2=Abs (mode=ABS), 3=Arg (mode=ARG).
+        controls.append(Dropdown(
+            var="cmode", name="Mode",
+            options={"Real": 0, "Imag": 1, "Abs": 2, "Arg": 3},
+            default=0,
+        ))
+        # Map cmode -> shader mode: 0,1 -> 0; 2 -> 1; 3 -> 2.
         writes.append(Write(
             targets=mode_targets,
-            value=0,
-            when="animate",
-            trigger="animate",
-            ))
+            expr="cmode <= 1 ? 0 : (cmode - 1)",
+            trigger="cmode",
+        ))
+        # Real/Imag set fixed phase (only when not animating).
+        writes.append(Write(
+            targets=phase_targets,
+            expr="cmode == 1 ? -Math.PI/2 : 0",
+            when="cmode <= 1 && !animate",
+            trigger="cmode",
+        ))
+
+    controls.append(Slider(var="phase", name="Phase",
+                          default=0.0, min=0.0, max=6.283, step=0.01))
+    writes.append(Write(
+        targets=phase_targets, expr="phase",
+        when="!animate", trigger="phase",
+    ))
+
+    controls.append(Checkbox(var="animate", name="Animate", default=False))
+    controls.append(Slider(var="speed", name="Speed",
+                          default=1.0, min=0.1, max=5.0, step=0.1))
+    writes.append(Write(
+        targets=phase_targets,
+        expr="(t*speed*2*Math.PI) % (2*Math.PI)",
+        when="animate",
+    ))
+    if mode_targets:
+        # Force PHASE_ROTATE mode while animating.
+        writes.append(Write(
+            targets=mode_targets, value=0,
+            when="animate", trigger="animate",
+        ))
     return [gui_interaction(label, controls, writes)]
 
 
+def _component_export_interactions(uniform, dim, registry, label="Function"):
+    """Dropdown to select the active component (i32 at offset 0)."""
+    from webgpu.export.gui import gui_interaction, Dropdown, Write, Target
+
+    if uniform is None or dim <= 1:
+        return []
+    buf = getattr(uniform, "_buffer", None)
+    if buf is None:
+        return []
+    key = id(buf)
+    if key not in registry._buffers:
+        return []
+    buf_id = registry._buffers[key][0]
+    options = {"Norm": -1}
+    for d in range(dim):
+        options[str(d)] = d
+    return [gui_interaction(
+        label,
+        [Dropdown(var="component", name="Component", options=options, default=-1)],
+        [Write(targets=[Target(buf_id, offset=0, dtype="i32")],
+               expr="component", trigger="component")],
+    )]
+
+
+def _shrink_export_interactions(uniform, registry, label="3D Elements", offset=4):
+    """Slider for the shrink field (f32) of a uniform buffer."""
+    from webgpu.export.gui import gui_interaction, Slider, Write, Target
+
+    if uniform is None:
+        return []
+    buf = getattr(uniform, "_buffer", None)
+    if buf is None:
+        return []
+    key = id(buf)
+    if key not in registry._buffers:
+        return []
+    buf_id = registry._buffers[key][0]
+    return [gui_interaction(
+        label,
+        [Slider(var="shrink", name="Shrink", default=1.0, min=0.0, max=1.0, step=0.01)],
+        [Write(targets=[Target(buf_id, offset=offset, dtype="f32")],
+               expr="shrink", trigger="shrink")],
+    )]
+
+
 class ComplexUniform(UniformBase):
     _binding = Binding.COMPLEX_SETTINGS
     _fields_ = [
@@ -818,7 +892,10 @@ def on_component_change(self, callback):
         self._on_component_change.append(callback)
 
     def get_bounding_box(self):
-        return self.data.get_bounding_box()
+        bbox = self.data.get_bounding_box()
+        if self.symmetry:
+            bbox = self.symmetry.expand_bbox(bbox)
+        return bbox
 
     def add_options_to_gui(self, gui):
         if gui is None:
@@ -914,6 +991,9 @@ def get_bindings(self):
 
     def get_export_interactions(self, options, buffer_registry):
         out = list(super().get_export_interactions(options, buffer_registry))
+        out += _component_export_interactions(
+            self.gpu_objects.settings.uniform, self.data.cf.dim, buffer_registry,
+        )
         if self.data.cf.is_complex:
             out += _complex_phase_export_interactions(
                 [(self.gpu_objects.complex_settings.uniform, True)],

ngsolve_webgpu/clipping.py

@@ -10,7 +10,7 @@
 
 import numpy as np
 
-from .cf import FunctionData, FunctionSettings, ComplexSettings, PhaseAnimation, _complex_phase_export_interactions
+from .cf import FunctionData, FunctionSettings, ComplexSettings, PhaseAnimation, _complex_phase_export_interactions, _component_export_interactions
 from .cf import Binding as CFBinding
 
 from .mesh import MeshElements3d, ElType
@@ -123,7 +123,10 @@ def update(self, options: RenderOptions):
             self.shader_defines["SYMMETRY"] = "1"
 
     def get_bounding_box(self):
-        return self.data.get_bounding_box()
+        bbox = self.data.get_bounding_box()
+        if self.symmetry:
+            bbox = self.symmetry.expand_bbox(bbox)
+        return bbox
 
     def get_shader_code(self):
         return read_shader_file("ngsolve/clipping/render.wgsl")
@@ -190,12 +193,25 @@ def _set_speed_from_gui(self, value):
             self._phase_animation.speed = value
 
     def get_export_interactions(self, options, buffer_registry):
+        from webgpu.export.gui import gui_interaction, Checkbox, Write, Target
         out = list(super().get_export_interactions(options, buffer_registry))
+        out += _component_export_interactions(
+            self.gpu_objects.settings.uniform, self.data.cf.dim, buffer_registry,
+        )
         if self.data.cf.is_complex:
             out += _complex_phase_export_interactions(
                 [(self.gpu_objects.complex_settings.uniform, True)],
                 buffer_registry,
             )
+        # Toggle the clipping function render pass on/off.
+        out.append(gui_interaction(
+            "Clipping Function",
+            [Checkbox(var="enabled", name="Enabled", default=True)],
+            [Write(
+                targets=[Target(f"render_{self._id}", dtype="pass_enable")],
+                expr="enabled ? 1 : 0", trigger="enabled",
+            )],
+        ))
         return out
 
     def add_options_to_gui(self, gui):

ngsolve_webgpu/facet_cf.py

@@ -341,3 +341,16 @@ def get_bindings(self):
             *self.gpu_objects.settings.get_bindings(),
             *self.gpu_objects.complex_settings.get_bindings(),
         ]
+
+    def get_export_interactions(self, options, buffer_registry):
+        from .cf import _complex_phase_export_interactions, _component_export_interactions
+        out = list(super().get_export_interactions(options, buffer_registry))
+        out += _component_export_interactions(
+            self.gpu_objects.settings.uniform, self.cf.dim, buffer_registry,
+        )
+        if self.cf.is_complex:
+            out += _complex_phase_export_interactions(
+                [(self.gpu_objects.complex_settings.uniform, True)],
+                buffer_registry,
+            )
+        return out

ngsolve_webgpu/geometry.py

@@ -62,7 +62,10 @@ def __init__(self, geo, clipping, symmetry=None):
         self._buffers = {}
 
     def get_bounding_box(self):
-        return self.bounding_box
+        bbox = self.bounding_box
+        if self.symmetry:
+            bbox = self.symmetry.expand_bbox(bbox)
+        return bbox
 
     def set_colors(self, colors):
         """colors is numpy float32 array with 4 times number indices entries"""

ngsolve_webgpu/mesh.py

@@ -713,7 +713,10 @@ def update(self, options: RenderOptions):
             self.shader_defines["SYMMETRY"] = "1"
 
     def get_bounding_box(self):
-        return self.data.get_bounding_box()
+        bbox = self.data.get_bounding_box()
+        if self.symmetry:
+            bbox = self.symmetry.expand_bbox(bbox)
+        return bbox
 
     def get_bindings(self):
         from .cf import FunctionData
@@ -956,7 +959,10 @@ def shrink(self, value):
             self.uniforms.update_buffer()
 
     def get_bounding_box(self) -> tuple[list[float], list[float]] | None:
-        return self.data.get_bounding_box()
+        bbox = self.data.get_bounding_box()
+        if self.symmetry:
+            bbox = self.symmetry.expand_bbox(bbox)
+        return bbox
 
     def update(self, options: RenderOptions):
         if self.uniforms is None:
@@ -1013,6 +1019,12 @@ def set_shrink(value):
             label="Shrink", value=self.uniforms.shrink, min=0.0, max=1.0, step=0.01, func=set_shrink
         )
 
+    def get_export_interactions(self, options, buffer_registry):
+        from .cf import _shrink_export_interactions
+        out = list(super().get_export_interactions(options, buffer_registry))
+        out += _shrink_export_interactions(self.uniforms, buffer_registry)
+        return out
+
     def get_bindings(self):
         bindings = [
             *self.clipping.get_bindings(),

ngsolve_webgpu/symmetry.py

@@ -72,6 +72,35 @@ def n_copies(self):
         """Number of symmetry copies (including original)."""
         return len(self._get_transforms())
 
+    def expand_bbox(self, bbox):
+        """Return a bbox enclosing all symmetry copies of the input bbox.
+
+        Applies every transform matrix to the 8 corners of ``bbox`` and takes
+        the union. Returns ``None`` if ``bbox`` is ``None``.
+        """
+        if bbox is None:
+            return None
+        pmin = np.array(bbox[0], dtype=float)
+        pmax = np.array(bbox[1], dtype=float)
+        corners = np.array([
+            [pmin[0], pmin[1], pmin[2], 1.0],
+            [pmax[0], pmin[1], pmin[2], 1.0],
+            [pmin[0], pmax[1], pmin[2], 1.0],
+            [pmax[0], pmax[1], pmin[2], 1.0],
+            [pmin[0], pmin[1], pmax[2], 1.0],
+            [pmax[0], pmin[1], pmax[2], 1.0],
+            [pmin[0], pmax[1], pmax[2], 1.0],
+            [pmax[0], pmax[1], pmax[2], 1.0],
+        ])
+        new_min = pmin.copy()
+        new_max = pmax.copy()
+        for mat, _, _ in self._get_transforms():
+            transformed = corners @ mat.T
+            pts = transformed[:, :3]
+            new_min = np.minimum(new_min, pts.min(axis=0))
+            new_max = np.maximum(new_max, pts.max(axis=0))
+        return ([float(x) for x in new_min], [float(x) for x in new_max])
+
     def _add_generator(self, matrix):
         self._generators.append(matrix)
         self._transforms = None  # invalidate cache

ngsolve_webgpu/vectors.py

@@ -97,7 +97,10 @@ def set_grid_size(self, grid_size: float):
             )
 
     def get_bounding_box(self):
-        return self.function_data.mesh_data.get_bounding_box()
+        bbox = self.function_data.mesh_data.get_bounding_box()
+        if self.symmetry:
+            bbox = self.symmetry.expand_bbox(bbox)
+        return bbox
 
     def generate_shape(self):
         cyl = generate_cylinder(8, 0.05, 0.5, bottom_face=True)