pycodecad 1.0.0__py3-none-any.whl

pycodecad/viewcube.py

@@ -0,0 +1,120 @@
+"""The view cube in the corner of the 3D view: where its faces land on screen for a camera, and which
+view a click on it asks for. Pure geometry; ui.py draws it with ImGui.
+
+The cube spans -1..1 on each axis, turned like the scene. Each face is split in 3 x 3 cells: the
+centre looks from that face, a side cell from that edge and a corner cell from that corner (the
+corner at +X -Y +Z is the iso view). A cell's direction is where the camera goes, e.g. (0, -1, 1).
+"""
+from __future__ import annotations
+
+from itertools import product
+from typing import Annotated, Literal
+
+from pytypehint import Max, Min, immutable
+
+from . import camera as cam
+
+Point = tuple[float, float]
+Quad = tuple[Point, Point, Point, Point]
+Step = Annotated[int, Min(-1), Max(1)]
+Direction = tuple[Step, Step, Step]
+Label = Literal["RIGHT", "LEFT", "FRONT", "BACK", "TOP", "BOTTOM"]
+
+FACES: tuple[tuple[Direction, Label], ...] = (
+    ((1, 0, 0), "RIGHT"), ((-1, 0, 0), "LEFT"), ((0, -1, 0), "FRONT"), ((0, 1, 0), "BACK"),
+    ((0, 0, 1), "TOP"), ((0, 0, -1), "BOTTOM"))
+NORMALS = {label: normal for normal, label in FACES}
+EDGE = 0.62  # the centre cell spans -EDGE..EDGE of a face; beyond are the edge and corner cells
+BOUNDS = ((-1.0, -EDGE, -1), (-EDGE, EDGE, 0), (EDGE, 1.0, 1))  # (from, to, direction) along a face axis
+
+
+def _cell_directions(normal: Direction) -> frozenset[Direction]:
+    """The 9 directions of a face's cells: its normal, plus -1, 0 or 1 along each other axis."""
+    return frozenset((normal[0] or x, normal[1] or y, normal[2] or z) for x, y, z in product((-1, 0, 1), repeat=3))
+
+
+CELL_DIRECTIONS = {label: _cell_directions(normal) for normal, label in FACES}
+
+
+@immutable
+class Face:
+    label: Label
+    normal: Direction  # the label's own, a unit axis direction
+    facing: float  # above 0 (seen edge-on) .. 1 (seen straight on)
+    light: Annotated[float, Min(0.0), Max(1.0)]  # lit from the upper left of the screen, so neighbouring faces differ
+    quad: Quad  # on screen
+    center: Point
+    cells: tuple[tuple[Direction, Quad], ...]  # (direction, quad on screen): the face's 9 cells
+
+    def __post_init__(self) -> None:
+        if self.label not in NORMALS:
+            raise ValueError(f"unknown face {self.label!r}")
+        if self.normal != NORMALS[self.label]:
+            raise ValueError(f"face {self.label}: normal {self.normal} is not {NORMALS[self.label]}")
+        if not 0.0 < self.facing <= 1.0:
+            raise ValueError(f"face {self.label}: facing {self.facing} not in (0, 1]")
+        directions = [direction for direction, _ in self.cells]
+        if len(directions) != 9 or set(directions) != CELL_DIRECTIONS[self.label]:
+            raise ValueError(f"face {self.label}: cells {directions} are not its 9 directions")
+
+
+def faces(camera: cam.Camera, center: Point, radius: float) -> list[Face]:
+    """The faces the camera sees, for a cube of half-size radius (pixels) drawn around center."""
+    right, up, back = cam.basis(camera)
+    lamp = [-0.35 * r + 0.75 * u + 0.56 * b for r, u, b in zip(right, up, back)]  # about unit length
+
+    def screen(point) -> Point:
+        return (center[0] + sum(p * r for p, r in zip(point, right)) * radius,
+                center[1] - sum(p * u for p, u in zip(point, up)) * radius)
+
+    result = []
+    for normal, label in FACES:
+        facing = min(1.0, sum(n * b for n, b in zip(normal, back)))
+        if facing <= 1e-6:
+            continue
+        axis = next(i for i in range(3) if normal[i])
+        first, second = [i for i in range(3) if i != axis]
+
+        def at(u: float, v: float):
+            point = [0.0, 0.0, 0.0]
+            point[axis], point[first], point[second] = normal[axis], u, v
+            return screen(point)
+
+        cells = []
+        for u0, u1, du in BOUNDS:
+            for v0, v1, dv in BOUNDS:
+                direction = [0, 0, 0]
+                direction[axis], direction[first], direction[second] = normal[axis], du, dv
+                cells.append((tuple(direction), (at(u0, v0), at(u1, v0), at(u1, v1), at(u0, v1))))
+        light = max(0.0, min(1.0, sum(n * l for n, l in zip(normal, lamp))))
+        result.append(Face(label=label, normal=normal, facing=facing, light=light,
+                           quad=(at(-1, -1), at(1, -1), at(1, 1), at(-1, 1)), center=at(0, 0), cells=tuple(cells)))
+    return result
+
+
+def inside(point: Point, quad) -> bool:
+    """Whether point is in a convex quad (either winding), borders included."""
+    signs = set()
+    for (x0, y0), (x1, y1) in zip(quad, quad[1:] + quad[:1]):
+        cross = (x1 - x0) * (point[1] - y0) - (y1 - y0) * (point[0] - x0)
+        if abs(cross) > 1e-9:
+            signs.add(cross > 0)
+    return len(signs) <= 1
+
+
+def hit(visible: list[Face], point: Point) -> Direction | None:
+    """The direction of the cell under point (visible faces never overlap), or None."""
+    for face in visible:
+        for direction, quad in face.cells:
+            if inside(point, quad):
+                return direction
+    return None
+
+
+def name(direction: Direction) -> str:
+    """'Front', 'Top front', 'Top front right (iso)'..."""
+    x, y, z = direction
+    words = [word for value, word in ((z, "top" if z > 0 else "bottom"), (y, "back" if y > 0 else "front"),
+                                      (x, "right" if x > 0 else "left")) if value]
+    text = " ".join(words).capitalize()
+    return text + " (iso)" if direction == (1, -1, 1) else text

pycodecad/viewer.py

@@ -0,0 +1,70 @@
+"""The 3D view as an ImGui component: a camera of its own, the view cube, Fit and the display toggles
+(experimental in 1.0, see docs/embedding.md)."""
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+from . import camera as cam, ui, window
+from .cad import Shown
+from .renderer import Display, Renderer, png_bytes
+
+
+class Viewer:
+    """Draws the objects it is given (e.g. `Workspace.shown`) into the current ImGui window, between
+    `Window.frame()` calls. Left drag orbits, right/middle (or Shift+left) drag pans, the wheel
+    zooms, a double click fits. It fits the first objects it gets, and again after a large change."""
+
+    def __init__(self) -> None:
+        self.camera = cam.Camera()
+        self.display = Display()
+        self.size = (1, 1)  # pixels of the last drawn picture
+        self.fit_pending = True
+        self.objects: list[Shown] = []  # what the renderer holds
+        self.renderer: Renderer | None = None  # created at the first draw, on the window's GL context
+        window.components.add(self)
+
+    def draw(self, objects: Sequence[Shown], size: tuple[float, float] | None = None) -> None:
+        """Draw the objects at size (ImGui units), by default the available region."""
+        if self.renderer is None:
+            self.renderer = Renderer(window.active().ctx)
+        if len(objects) != len(self.objects) or any(a is not b for a, b in zip(objects, self.objects)):
+            before = self.bbox()
+            self.objects = list(objects)
+            self.renderer.set_meshes([(obj.color, obj.mesh, obj.matrix) for obj in self.objects])
+            bbox = self.bbox()
+            if bbox and (self.fit_pending or cam.needs_fit(before, bbox)):
+                self.fit(bbox)
+        ui.view(self, size or ui.region())
+
+    def bbox(self) -> cam.BBox | None:
+        return cam.scene_bbox([obj.bbox() for obj in self.objects])
+
+    def fit(self, bbox: cam.BBox | None = None) -> None:
+        bbox = bbox or self.bbox()
+        if bbox:
+            self.camera = cam.fit(self.camera, bbox)
+            self.fit_pending = False
+
+    def look_from(self, direction: cam.Vec) -> None:
+        """Turn the camera to look from a direction (a view cube click) and fit the view."""
+        self.camera = cam.look_from(self.camera, direction)
+        self.fit()
+
+    def texture(self, width: int, height: int) -> int:
+        """Render at this size (pixels); returns the ImGui texture id (the OpenGL texture name)."""
+        assert self.renderer is not None
+        self.size = (width, height)
+        return self.renderer.draw(self.camera, self.display, width, height).glo
+
+    def picture(self) -> bytes:
+        """A PNG of the view as last drawn."""
+        assert self.renderer is not None
+        self.renderer.draw(self.camera, self.display, *self.size)
+        return png_bytes(self.renderer.read_image())
+
+    def close(self) -> None:
+        """Free the GL resources (Window.close() does it for every open Viewer)."""
+        window.components.discard(self)
+        if self.renderer is not None:
+            self.renderer.release()
+            self.renderer = None

pycodecad/window.py

@@ -0,0 +1,129 @@
+"""A GLFW window with Dear ImGui drawn by pycodecad's backend: the frame loop that Workspaces and Viewers
+draw in (experimental in 1.0, see docs/embedding.md). One Window per process."""
+from __future__ import annotations
+
+import weakref
+from pathlib import Path
+
+import glfw
+import moderngl
+import numpy as np
+
+from . import ui
+from .imgui_backend import ImguiBackend
+from .renderer import png_bytes
+
+IDLE, BUSY = 0.25, 0.05  # seconds a frame waits for input (BUSY: while a script runs)
+
+current: Window | None = None  # the window whose frame is being built
+components: weakref.WeakSet = weakref.WeakSet()  # open Workspaces and Viewers: Window.close() closes them
+
+
+def active() -> Window:
+    if current is None:
+        raise RuntimeError("pycodecad components draw between Window.frame() calls")
+    return current
+
+
+class Window:
+    """handle: a GLFW window whose OpenGL 3.3 core context is current. pycodecad installs its ImGui
+    backend on it (an ImGui context, fonts, style, the window's input callbacks; close() puts back
+    the callbacks it replaced). ctx: the host's moderngl context on it, if it has one (close() never
+    releases it); else the Window makes its own. owns: close() also destroys the window and
+    terminates GLFW (create_window's windows)."""
+
+    def __init__(self, handle, ctx: moderngl.Context | None = None, owns: bool = False) -> None:
+        self.handle, self.owns, self.owns_ctx = handle, owns, ctx is None
+        self.ctx = moderngl.create_context() if ctx is None else ctx
+        self.gui = ImguiBackend(handle, self.ctx)
+        ui.apply_style()
+        self.events: list = []  # typed text and key presses of this frame (see ImguiBackend.events)
+        self.timeout = 0.0  # how long the next frame() waits for input; the first one does not
+        self.close_requested = False  # the user asked to close while frame(keep_open=True)
+        self.drawing = False  # between frame() and the next one
+        self.picture: str | None = None
+        self.title = ""
+        self.closed = False
+
+    def frame(self, keep_open: bool = False) -> bool:
+        """Show the frame built since the last call, wait for input and begin the next ImGui frame.
+        False when the window closes. keep_open (e.g. unsaved changes): a close request only sets
+        close_requested, and the frames go on."""
+        global current
+        if self.drawing:
+            self.finish()
+        glfw.wait_events_timeout(self.timeout)
+        self.timeout = IDLE
+        if glfw.window_should_close(self.handle):
+            if not keep_open:
+                current = None
+                return False
+            glfw.set_window_should_close(self.handle, False)
+            self.close_requested = True
+        self.events = self.gui.input_events()
+        self.gui.new_frame()
+        self.drawing, current = True, self
+        return True
+
+    def finish(self) -> None:
+        width, height = glfw.get_framebuffer_size(self.handle)
+        self.ctx.screen.use()
+        self.ctx.viewport = (0, 0, width, height)
+        self.ctx.clear(*ui.BACKGROUND[:3])
+        self.gui.render()
+        self.drawing = False
+        if self.picture:
+            pixels = self.ctx.screen.read(viewport=(0, 0, width, height), components=3, alignment=1)
+            image = np.flipud(np.frombuffer(pixels, dtype=np.uint8).reshape(height, width, 3))
+            Path(self.picture).write_bytes(png_bytes(image))
+            self.picture = None
+        glfw.swap_buffers(self.handle)
+
+    def screenshot(self, path: str) -> None:
+        """Save this frame as a PNG when it is shown (at the next frame())."""
+        self.picture = path
+
+    def set_title(self, title: str) -> None:
+        if title != self.title:
+            self.title = title
+            glfw.set_window_title(self.handle, title)
+
+    def request_close(self) -> None:
+        """Close as if the user did (frame(keep_open=True) still keeps it open)."""
+        glfw.set_window_should_close(self.handle, True)
+
+    def close(self) -> None:
+        """Close the open Workspaces and Viewers, then pycodecad's ImGui backend (and the window it owns)."""
+        global current
+        if self.closed:
+            return
+        self.closed, current = True, None
+        for component in list(components):
+            component.close()
+        self.gui.shutdown()
+        if self.owns_ctx:
+            self.ctx.release()
+        if self.owns:
+            glfw.destroy_window(self.handle)
+            glfw.terminate()
+
+
+def create_window(title: str = "pycodecad", size: tuple[int, int] = (1440, 880), visible: bool = True) -> Window:
+    """A new GLFW window with an OpenGL 3.3 context, ready for ImGui. visible False: a hidden window
+    (tests, screenshots)."""
+    if not glfw.init():
+        raise RuntimeError("Could not initialize GLFW")
+    glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 3)
+    glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 3)
+    glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
+    glfw.window_hint(glfw.OPENGL_FORWARD_COMPAT, True)
+    glfw.window_hint(glfw.VISIBLE, visible)
+    handle = glfw.create_window(*size, title, None, None)
+    if not handle:
+        glfw.terminate()
+        raise RuntimeError("Could not create an OpenGL 3.3 window")
+    glfw.make_context_current(handle)
+    glfw.swap_interval(1 if visible else 0)  # a hidden window never gets vsync frames
+    window = Window(handle, owns=True)
+    window.title = title
+    return window