lsurf 1.0.0__py3-none-any.whl

lsurf/gui/views/viewport_3d.py

@@ -0,0 +1,555 @@
+# The Clear BSD License
+#
+# Copyright (c) 2026 Tobias Heibges
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted (subject to the limitations in the disclaimer
+# below) provided that the following conditions are met:
+#
+#      * Redistributions of source code must retain the above copyright notice,
+#      this list of conditions and the following disclaimer.
+#
+#      * Redistributions in binary form must reproduce the above copyright
+#      notice, this list of conditions and the following disclaimer in the
+#      documentation and/or other materials provided with the distribution.
+#
+#      * Neither the name of the copyright holder nor the names of its
+#      contributors may be used to endorse or promote products derived from this
+#      software without specific prior written permission.
+#
+# NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED BY
+# THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+# CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+# PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+# BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
+# IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
+"""3D Viewport - renders the scene using Dear PyGui's drawing API.
+
+Uses manual 3D projection to render surfaces, sources, and rays
+in a 2D drawlist with orbit/pan/zoom camera controls.
+"""
+
+from typing import TYPE_CHECKING
+
+import numpy as np
+
+if TYPE_CHECKING:
+    from ..core.scene import Scene, SceneObject
+
+import dearpygui.dearpygui as dpg
+
+
+class Camera:
+    """Orbit camera for 3D viewport."""
+
+    def __init__(self) -> None:
+        self.position = np.array([30.0, -50.0, 30.0], dtype=np.float32)
+        self.target = np.array([0.0, 0.0, 0.0], dtype=np.float32)
+        self.up = np.array([0.0, 0.0, 1.0], dtype=np.float32)
+        self.fov = 45.0
+        self.near = 0.1
+        self.far = 10000.0
+
+        # Interaction state
+        self._last_mouse_pos = None
+        self._orbit_sensitivity = 0.01
+        self._pan_sensitivity = 0.05
+        self._zoom_sensitivity = 0.1
+
+    def get_view_matrix(self) -> np.ndarray:
+        """Compute view matrix (camera transformation)."""
+        forward = self.target - self.position
+        forward = forward / np.linalg.norm(forward)
+
+        right = np.cross(forward, self.up)
+        right = right / np.linalg.norm(right)
+
+        up = np.cross(right, forward)
+
+        view = np.eye(4, dtype=np.float32)
+        view[0, :3] = right
+        view[1, :3] = up
+        view[2, :3] = -forward
+        view[:3, 3] = -np.array(
+            [
+                np.dot(right, self.position),
+                np.dot(up, self.position),
+                np.dot(-forward, self.position),
+            ]
+        )
+
+        return view
+
+    def get_projection_matrix(self, aspect: float) -> np.ndarray:
+        """Compute perspective projection matrix."""
+        fov_rad = np.radians(self.fov)
+        f = 1.0 / np.tan(fov_rad / 2)
+
+        proj = np.zeros((4, 4), dtype=np.float32)
+        proj[0, 0] = f / aspect
+        proj[1, 1] = f
+        proj[2, 2] = (self.far + self.near) / (self.near - self.far)
+        proj[2, 3] = (2 * self.far * self.near) / (self.near - self.far)
+        proj[3, 2] = -1
+
+        return proj
+
+    def orbit(self, dx: float, dy: float) -> None:
+        """Orbit camera around target."""
+        # Convert to spherical coordinates relative to target
+        offset = self.position - self.target
+        r = np.linalg.norm(offset)
+
+        if r < 1e-6:
+            return
+
+        # Current angles
+        theta = np.arctan2(offset[1], offset[0])  # Azimuth
+        phi = np.arccos(np.clip(offset[2] / r, -1, 1))  # Elevation
+
+        # Update angles
+        theta -= dx * self._orbit_sensitivity
+        phi = np.clip(phi - dy * self._orbit_sensitivity, 0.01, np.pi - 0.01)
+
+        # Convert back to Cartesian
+        self.position = self.target + r * np.array(
+            [
+                np.sin(phi) * np.cos(theta),
+                np.sin(phi) * np.sin(theta),
+                np.cos(phi),
+            ],
+            dtype=np.float32,
+        )
+
+    def pan(self, dx: float, dy: float) -> None:
+        """Pan camera (move target and position)."""
+        forward = self.target - self.position
+        forward = forward / np.linalg.norm(forward)
+        right = np.cross(forward, self.up)
+        right = right / np.linalg.norm(right)
+        up = np.cross(right, forward)
+
+        offset = (-dx * right + dy * up) * self._pan_sensitivity
+        self.position += offset
+        self.target += offset
+
+    def zoom(self, delta: float) -> None:
+        """Zoom camera (move toward/away from target)."""
+        direction = self.target - self.position
+        distance = np.linalg.norm(direction)
+
+        # Prevent getting too close or too far
+        new_distance = distance * (1 - delta * self._zoom_sensitivity)
+        new_distance = np.clip(new_distance, 1.0, 1000.0)
+
+        if distance > 1e-6:
+            direction = direction / distance
+            self.position = self.target - direction * new_distance
+
+    def fit_to_bounds(self, min_bounds: np.ndarray, max_bounds: np.ndarray) -> None:
+        """Adjust camera to fit bounds in view."""
+        center = (min_bounds + max_bounds) / 2
+        size = np.linalg.norm(max_bounds - min_bounds)
+        distance = max(size * 1.5, 10.0)
+
+        self.target = center.astype(np.float32)
+        self.position = center + np.array(
+            [distance * 0.5, -distance * 0.7, distance * 0.5], dtype=np.float32
+        )
+
+    def set_preset(self, preset: str) -> None:
+        """Set camera to a preset view."""
+        distance = np.linalg.norm(self.position - self.target)
+
+        if preset == "top":
+            self.position = self.target + np.array([0, 0, distance], dtype=np.float32)
+            self.up = np.array([0, 1, 0], dtype=np.float32)
+        elif preset == "front":
+            self.position = self.target + np.array([0, -distance, 0], dtype=np.float32)
+            self.up = np.array([0, 0, 1], dtype=np.float32)
+        elif preset == "side":
+            self.position = self.target + np.array([distance, 0, 0], dtype=np.float32)
+            self.up = np.array([0, 0, 1], dtype=np.float32)
+        elif preset == "isometric":
+            d = distance / np.sqrt(3)
+            self.position = self.target + np.array([d, -d, d], dtype=np.float32)
+            self.up = np.array([0, 0, 1], dtype=np.float32)
+
+
+class Viewport3D:
+    """3D viewport panel using Dear PyGui drawing API."""
+
+    def __init__(self, scene: "Scene") -> None:
+        self.scene = scene
+        self.camera = Camera()
+
+        # UI state
+        self._drawlist_tag: int | None = None
+        self._window_tag: int | None = None
+        self._width = 1200  # Larger initial size
+        self._height = 800
+
+        # Interaction state
+        self._dragging = False
+        self._drag_button = None
+        self._last_mouse_pos = (0, 0)
+
+        # Colors
+        self._grid_color = (80, 80, 80, 100)
+        self._axis_colors = {
+            "x": (200, 50, 50, 200),
+            "y": (50, 200, 50, 200),
+            "z": (50, 50, 200, 200),
+        }
+
+    def create(self, parent: int | str) -> int:
+        """Create the viewport UI elements.
+
+        Args:
+            parent: Parent container tag
+
+        Returns:
+            The window tag
+        """
+        self._parent_tag = parent
+
+        # Toolbar
+        with dpg.group(horizontal=True, parent=parent):
+            dpg.add_button(
+                label="Fit",
+                callback=self._on_fit_to_scene,
+            )
+            dpg.add_button(
+                label="Top",
+                callback=lambda: self._on_preset("top"),
+            )
+            dpg.add_button(
+                label="Front",
+                callback=lambda: self._on_preset("front"),
+            )
+            dpg.add_button(
+                label="Side",
+                callback=lambda: self._on_preset("side"),
+            )
+            dpg.add_button(
+                label="Iso",
+                callback=lambda: self._on_preset("isometric"),
+            )
+
+        # Child window to contain the drawlist (allows size tracking)
+        # resizable_y allows dragging the bottom edge to resize viewport/results split
+        with dpg.child_window(
+            parent=parent,
+            tag="viewport_drawlist_container",
+            height=-120,  # Leave space for results panel below
+            border=False,
+            no_scrollbar=True,
+            resizable_y=True,
+        ) as self._window_tag:
+            # Drawing canvas
+            self._drawlist_tag = dpg.add_drawlist(
+                width=self._width,
+                height=self._height,
+                tag="viewport_drawlist",
+            )
+        # Register scene change callback
+        self.scene.on_change(self.refresh)
+
+        return self._window_tag
+
+    def register_handlers(self) -> None:
+        """Register mouse handlers for camera control. Must be called outside container context."""
+        with dpg.handler_registry():
+            dpg.add_mouse_drag_handler(
+                button=dpg.mvMouseButton_Left,
+                callback=self._on_mouse_drag,
+            )
+            dpg.add_mouse_drag_handler(
+                button=dpg.mvMouseButton_Middle,
+                callback=self._on_mouse_drag,
+            )
+            dpg.add_mouse_drag_handler(
+                button=dpg.mvMouseButton_Right,
+                callback=self._on_mouse_drag,
+            )
+            dpg.add_mouse_wheel_handler(callback=self._on_mouse_wheel)
+
+    def refresh(self) -> None:
+        """Redraw the viewport."""
+        if self._drawlist_tag is None:
+            return
+
+        # Update size based on container
+        if self._window_tag and dpg.does_item_exist(self._window_tag):
+            # Get actual rendered size of the container
+            try:
+                rect = dpg.get_item_rect_size(self._window_tag)
+                if rect and rect[0] > 50 and rect[1] > 50:
+                    new_width = max(int(rect[0]) - 10, 100)
+                    new_height = max(int(rect[1]) - 10, 100)
+
+                    # Update if size changed
+                    if new_width != self._width or new_height != self._height:
+                        self._width = new_width
+                        self._height = new_height
+                        dpg.configure_item(
+                            self._drawlist_tag, width=self._width, height=self._height
+                        )
+            except Exception:
+                pass
+
+        # Clear previous drawing
+        dpg.delete_item(self._drawlist_tag, children_only=True)
+
+        # Draw background
+        dpg.draw_rectangle(
+            (0, 0),
+            (self._width, self._height),
+            fill=(30, 30, 35, 255),
+            parent=self._drawlist_tag,
+        )
+
+        # Compute view-projection matrix
+        aspect = self._width / max(self._height, 1)
+        view = self.camera.get_view_matrix()
+        proj = self.camera.get_projection_matrix(aspect)
+        vp = proj @ view
+
+        # Draw grid
+        self._draw_grid(vp)
+
+        # Draw axes
+        self._draw_axes(vp)
+
+        # Draw scene objects
+        visible_objects = self.scene.get_visible_objects()
+        for obj in visible_objects:
+            self._draw_object(obj, vp)
+
+    def _project(
+        self, points: np.ndarray, vp: np.ndarray
+    ) -> tuple[np.ndarray, np.ndarray]:
+        """Project 3D points to 2D screen coordinates.
+
+        Args:
+            points: (N, 3) array of 3D points
+            vp: View-projection matrix (4x4)
+
+        Returns:
+            (screen_coords, visible_mask) where screen_coords is (N, 2)
+        """
+        if len(points) == 0:
+            return np.zeros((0, 2), dtype=np.float32), np.zeros(0, dtype=bool)
+
+        # Homogeneous coordinates
+        n = len(points)
+        homogeneous = np.ones((n, 4), dtype=np.float32)
+        homogeneous[:, :3] = points
+
+        # Transform
+        clip = (vp @ homogeneous.T).T
+
+        # Perspective divide
+        w = clip[:, 3]
+        visible = w > 0.01  # Behind camera check
+
+        # Avoid division by zero
+        w[~visible] = 1.0
+        ndc = clip[:, :3] / w[:, np.newaxis]
+
+        # Convert to screen coordinates
+        screen = np.zeros((n, 2), dtype=np.float32)
+        screen[:, 0] = (ndc[:, 0] + 1) * 0.5 * self._width
+        screen[:, 1] = (1 - ndc[:, 1]) * 0.5 * self._height  # Flip Y
+
+        # Clip check
+        visible &= (ndc[:, 0] >= -2) & (ndc[:, 0] <= 2)
+        visible &= (ndc[:, 1] >= -2) & (ndc[:, 1] <= 2)
+        visible &= (ndc[:, 2] >= -1) & (ndc[:, 2] <= 1)
+
+        return screen, visible
+
+    def _draw_grid(self, vp: np.ndarray) -> None:
+        """Draw a reference grid on the XY plane."""
+        grid_size = 50
+        grid_step = 5
+        lines = []
+
+        for i in range(-grid_size, grid_size + 1, grid_step):
+            lines.append(([i, -grid_size, 0], [i, grid_size, 0]))
+            lines.append(([-grid_size, i, 0], [grid_size, i, 0]))
+
+        for start, end in lines:
+            points = np.array([start, end], dtype=np.float32)
+            screen, visible = self._project(points, vp)
+            if visible.all():
+                dpg.draw_line(
+                    tuple(screen[0]),
+                    tuple(screen[1]),
+                    color=self._grid_color,
+                    parent=self._drawlist_tag,
+                )
+
+    def _draw_axes(self, vp: np.ndarray) -> None:
+        """Draw coordinate axes at origin."""
+        axis_length = 5.0
+        origin = np.array([[0, 0, 0]], dtype=np.float32)
+
+        axes = [
+            (
+                np.array([[axis_length, 0, 0]], dtype=np.float32),
+                self._axis_colors["x"],
+                "X",
+            ),
+            (
+                np.array([[0, axis_length, 0]], dtype=np.float32),
+                self._axis_colors["y"],
+                "Y",
+            ),
+            (
+                np.array([[0, 0, axis_length]], dtype=np.float32),
+                self._axis_colors["z"],
+                "Z",
+            ),
+        ]
+
+        origin_screen, origin_visible = self._project(origin, vp)
+
+        for end_point, color, label in axes:
+            end_screen, end_visible = self._project(end_point, vp)
+            if origin_visible[0] and end_visible[0]:
+                dpg.draw_line(
+                    tuple(origin_screen[0]),
+                    tuple(end_screen[0]),
+                    color=color,
+                    thickness=2,
+                    parent=self._drawlist_tag,
+                )
+                dpg.draw_text(
+                    tuple(end_screen[0]),
+                    label,
+                    color=color,
+                    size=24,
+                    parent=self._drawlist_tag,
+                )
+
+    def _draw_object(self, obj: "SceneObject", vp: np.ndarray) -> None:
+        """Draw a scene object."""
+
+        if obj.vertices is None or len(obj.vertices) == 0:
+            return
+
+        vertices = obj.vertices
+        indices = obj.indices
+
+        # Project vertices
+        screen, visible = self._project(vertices, vp)
+
+        # Convert color to 0-255 range
+        color = tuple(int(c * 255) for c in obj.color[:3]) + (int(obj.color[3] * 255),)
+
+        # Highlight if selected
+        if obj.selected:
+            color = (255, 255, 100, 255)
+
+        if indices is None or len(indices) == 0:
+            return
+
+        draw_count = 0
+        if obj.wireframe:
+            # Draw as lines (pairs of indices)
+            for i in range(0, len(indices) - 1, 2):
+                i0, i1 = indices[i], indices[i + 1]
+                if i0 < len(visible) and i1 < len(visible):
+                    if visible[i0] and visible[i1]:
+                        dpg.draw_line(
+                            tuple(screen[i0]),
+                            tuple(screen[i1]),
+                            color=color,
+                            thickness=2,
+                            parent=self._drawlist_tag,
+                        )
+                        draw_count += 1
+        else:
+            # Draw as triangles (triplets of indices)
+            for i in range(0, len(indices) - 2, 3):
+                i0, i1, i2 = indices[i], indices[i + 1], indices[i + 2]
+                if i0 < len(visible) and i1 < len(visible) and i2 < len(visible):
+                    if visible[i0] and visible[i1] and visible[i2]:
+                        dpg.draw_triangle(
+                            tuple(screen[i0]),
+                            tuple(screen[i1]),
+                            tuple(screen[i2]),
+                            fill=color,
+                            parent=self._drawlist_tag,
+                        )
+                        draw_count += 1
+
+    def _on_mouse_drag(self, sender, app_data) -> None:
+        """Handle mouse drag for camera control."""
+        # app_data = (button, dx, dy)
+        button, dx, dy = app_data
+
+        # Check if mouse is over viewport
+        if not self._is_mouse_over_viewport():
+            return
+
+        if button == dpg.mvMouseButton_Left:
+            # Orbit
+            self.camera.orbit(dx, dy)
+        elif button == dpg.mvMouseButton_Middle:
+            # Pan
+            self.camera.pan(dx, dy)
+        elif button == dpg.mvMouseButton_Right:
+            # Zoom (vertical drag)
+            self.camera.zoom(dy * 0.01)
+
+        self.refresh()
+
+    def _on_mouse_wheel(self, sender, app_data) -> None:
+        """Handle mouse wheel for zoom."""
+        if not self._is_mouse_over_viewport():
+            return
+
+        self.camera.zoom(app_data)
+        self.refresh()
+
+    def _is_mouse_over_viewport(self) -> bool:
+        """Check if mouse is over the viewport."""
+        if self._drawlist_tag is None:
+            return False
+
+        mouse_pos = dpg.get_mouse_pos(local=False)
+        if not dpg.does_item_exist(self._drawlist_tag):
+            return False
+
+        # Get drawlist screen position
+        try:
+            item_pos = dpg.get_item_pos(self._drawlist_tag)
+            item_rect = dpg.get_item_rect_size(self._drawlist_tag)
+
+            return (
+                item_pos[0] <= mouse_pos[0] <= item_pos[0] + item_rect[0]
+                and item_pos[1] <= mouse_pos[1] <= item_pos[1] + item_rect[1]
+            )
+        except Exception:
+            return False
+
+    def _on_fit_to_scene(self) -> None:
+        """Fit camera to scene bounds."""
+        min_bounds, max_bounds = self.scene.get_bounds()
+        self.camera.fit_to_bounds(min_bounds, max_bounds)
+        self.refresh()
+
+    def _on_preset(self, preset: str) -> None:
+        """Set camera to preset view."""
+        self.camera.set_preset(preset)
+        self.refresh()