Luce packages
LuceLuce BaseLuciaOS

dymokomi/luced-3d

Source of release 0.11.9

0.11.9 / src / geometry_sheet.luc

## Virtualized geometry inspection. Reads the selected node, not just display.
## Rows live in Base (sheet_rows) and are rebuilt only when drawn or read and
## their mesh, filter, sort or shown selection changed; refresh stays cheap.
from luce_ui.ui import Widget, Layout, Constraints, Size, Painter, Event
from luce_gpu.gpu import RenderTarget, Rect
from luce_geocore.geocore import Mesh, GeometrySet
from luce_window.input import EventKind, ScrollUnit
from workspace import Workspace
from luce_geocore.geocore import Selection
from sheet_rows import SheetRows, sheet_value
from luce_std import math
import theme
import selection_commands

pub class Column:
    pub let title: str
    pub let attribute: int
    pub let component: int
    ## A detail attribute of the set itself (not of its mesh), by name.
    pub var detail: str = ""
    ## How its cells read: "number", "array" ([1, 2, 3]) or "text".
    pub var form: str = "number"
    pub func init(self, title: str, attribute: int, component: int = 0):
        self.title = title
        self.attribute = attribute
        self.component = component

pub class GeometrySheet: Widget:
    let box: Layout
    let workspace: Workspace
    pub var domain: int = 0
    pub var mesh: Mesh? = none
    ## The node's whole set: its own detail attributes show under Detail,
    ## with or without a mesh (Edit Sketch's plane).
    var geometry: GeometrySet? = none
    pub var columns: list[Column]
    let rows: SheetRows
    var rows_key: str = ""
    ## The selection the rows were built for (its key; 0 for none).
    var rows_selection: int = 0
    ## Row rebuilds so far; refreshes that change nothing must not add any.
    pub var builds: int = 0
    pub var pinned: int = -1
    pub var selected_only: bool = false
    var node_id: int = -1
    var title: str = ""
    var failure: str = ""
    var scroll_x: float = 0.0
    var scroll_y: float = 0.0
    var hovered: int = -1
    var descending: bool = false
    var sort_column: int = -1
    var attribute_filter: str = ""
    var row_filter: str = ""

    pub func init(self, workspace: Workspace) -> unit!:
        self.workspace = workspace
        self.box = Layout()
        self.box.set_flex()
        self.box.set_interactive(true)
        self.box.set_focusable(true)
        self.box.set_takes_scroll(true)
        self.columns = []
        self.rows = SheetRows()

    pub func layout(self) -> Layout:
        return self.box
    pub func measure(self, available: Constraints) -> Size!:
        return Size(460.0, 190.0)

    pub func refresh(self) -> unit!:
        let w = self.workspace
        let id = self.pinned if self.pinned >= 0 else w.network.selected
        self.failure = ""
        self.mesh = none
        self.geometry = none
        self.columns = []
        if w.network.find(id) == none:
            self.title = "No node" if self.pinned < 0 else "Pinned node was deleted"
            self.node_id = -1
            self.box.invalidate()
            return
        let node = w.network.find(id) else return
        if self.node_id != id:
            self.scroll_x = 0.0
            self.scroll_y = 0.0
        self.node_id = id
        self.title = node.name + (" / pinned" if self.pinned >= 0 else " / selected node")
        let data = w.network.evaluate_data(id) catch failure:
            self.failure = failure.message
            self.box.invalidate()
            return
        self.mesh = data.mesh
        self.geometry = data.geometry
        if data.has_cad() or data.instance_count() > 0:
            self.title += " / " + data.description()
        self.box.invalidate()
        if self.domain == 3:
            self.add_set_details(data.geometry)
        let mesh = self.mesh else return
        let names = ["P.x", "P.y", "P.z"] if self.domain == 0 else (["point", "primitive"] if self.domain == 1 else (["vertices", "N.x", "N.y", "N.z"] if self.domain == 2 else ["points", "vertices", "primitives", "edges"]))
        for index in 0..<names.length:
            if self.attribute_filter == "" or names[index].contains(self.attribute_filter):
                self.columns.append(Column(names[index], -1, index))
        for attribute in 0..<mesh.attribute_count():
            if mesh.attribute_domain(attribute) != self.domain:
                continue
            let width = mesh.attribute_width(attribute)
            if self.attribute_filter != "" and not mesh.attribute_name(attribute).contains(self.attribute_filter):
                continue
            # Arrays and texts take one column, shown as text.
            if mesh.attribute_is_array(attribute) or mesh.attribute_string_count(attribute) > 0:
                let whole = Column(mesh.attribute_name(attribute), attribute, 0)
                whole.form = "array" if mesh.attribute_is_array(attribute) else "text"
                self.columns.append(whole)
                continue
            for component in 0..<width:
                let suffix = ("." + ["x", "y", "z", "w"][component]) if width > 1 else ""
                self.columns.append(Column(mesh.attribute_name(attribute) + suffix, attribute, component))
        if self.sort_column >= self.columns.length:
            self.sort_column = -1

    ## The set's own detail attributes as columns (after the mesh's).
    func add_set_details(self, geometry: GeometrySet) -> unit!:
        for index in 0..<geometry.detail_count():
            let name = geometry.detail_name(index)
            if self.attribute_filter != "" and not name.contains(self.attribute_filter):
                continue
            let width = geometry.detail_width(name)
            for component in 0..<width:
                let column = Column(name + (("." + ["x", "y", "z", "w"][component]) if width > 1 else ""), -1, component)
                column.detail = name
                self.columns.append(column)

    ## Rows for the current mesh, filter, sort and (for "Selected") selection.
    ## Cheap when none of them changed: one identity compare and a key.
    func ensure_rows(self) -> unit!:
        let changed = self.rows.retarget(self.mesh)
        # Detail is one row: the mesh's counts and details, and the set's.
        if self.domain == 3:
            self.rows.all(1 if self.mesh != none or self.columns.length > 0 else 0)
            return
        if self.mesh == none:
            self.rows.all(0)
            return
        let mesh = self.mesh else return
        let column = self.columns[self.sort_column] if self.sort_column >= 0 else Column("", -1, 0)
        let key = f"{self.domain}|{self.row_filter}|{self.sort_column >= 0}|{column.attribute}|{column.component}|{self.descending}|{self.selected_only}|{self.node_id == self.workspace.network.display}|{self.workspace.component_mode}"
        let chosen = self.shown_selection() if self.selected_only else none
        var selection_key = 0
        if let shown = chosen: selection_key = shown.key()
        if not changed and key == self.rows_key and selection_key == self.rows_selection:
            return
        self.rows_key = key
        self.rows_selection = selection_key
        self.builds += 1
        let expression = self.row_filter
        if self.selected_only:
            if let shown = chosen:
                self.rows.selected(mesh, shown, expression, self.domain)
            else:
                self.rows.all(0)
        elif expression == "" or expression == "*":
            self.rows.all(mesh.domain_count(self.domain))
        elif expression.starts_with("@"):
            let attribute = mesh.find_attribute(expression[1..<expression.length], self.domain)
            if attribute < 0:
                self.failure = "Group attribute does not exist on this domain"
                self.rows.all(0)
                self.rows_key = ""
                return
            self.rows.nonzero(mesh, self.domain, attribute)
        else:
            self.rows.select(mesh, expression, self.domain) catch failure:
                self.failure = failure.message
                self.rows.all(0)
                self.rows_key = ""
                return
        if self.sort_column >= 0 or self.descending:
            self.rows.sort(mesh, self.domain, column.attribute, column.component, self.sort_column < 0, self.descending)

    pub func row_count(self) -> int!:
        self.ensure_rows()
        return self.rows.count()

    ## The shown row IDs in order. Tests and small tools only: O(rows) Luce list.
    pub func row_ids(self) -> list[int]!:
        self.ensure_rows()
        let result: list[int] = []
        for at in 0..<self.rows.count():
            result.append(self.rows.row(at))
        return result

    pub func set_domain(self, domain: int) -> unit!:
        self.domain = domain
        self.scroll_x = 0.0
        self.scroll_y = 0.0
        self.refresh()

    pub func filter_attributes(self, text: str) -> unit!:
        self.attribute_filter = text.trim()
        self.sort_column = -1
        self.refresh()

    pub func filter_rows(self, text: str) -> unit!:
        self.row_filter = text.trim()
        self.refresh()

    ## The viewport's selection when it indexes this sheet's rows: the
    ## displayed node's, on the sheet's domain.
    func shown_selection(self) -> Selection?:
        if self.node_id != self.workspace.network.display:
            return none
        let chosen = self.workspace.selection else return none
        return chosen if chosen.domain() == self.domain else none

    func row_selected(self, row: int) -> bool!:
        let chosen = self.shown_selection() else return false
        return chosen.contains(row)

    pub func value(self, row: int, column: int) -> float!:
        let field = self.columns[column]
        if field.detail != "":
            let geometry = self.geometry else return 0.0
            return geometry.detail_value(field.detail, field.component)
        let mesh = self.mesh else return 0.0
        return sheet_value(mesh, self.domain, field.attribute, field.component, row)

    ## Cell (row, column) as shown: a number, an array or a text.
    pub func label(self, row: int, column: int) -> str!:
        let field = self.columns[column]
        if field.form != "number":
            let mesh = self.mesh else return ""
            let text = mesh.attribute_array_text(field.attribute, row) if field.form == "array" else mesh.attribute_text(field.attribute, row)
            # One line: a text may hold anything.
            return text.replace("\n", " ").replace("\t", " ")
        let value = self.value(row, column)
        return f"{math.floor(value * 10000.0 + 0.5) / 10000.0}" if math.abs(value) < 1.0e10 else f"{value}"

    pub func draw(self, target: RenderTarget) -> unit!:
        let size = target.size()
        self.ensure_rows()
        self.clamp_scroll()
        let total = self.rows.count()
        let p = Painter(target)
        p.rectangle(Rect(0.0, 0.0, size.width, size.height), theme.backdrop())
        for domain in 0..<4:
            let x = 6.0 + float(domain) * 84.0
            p.rounded_rectangle(Rect(x, 5.0, 80.0, 26.0), theme.accent() if domain == self.domain else theme.surface(), 3.0)
            p.text(["Points", "Vertices", "Faces", "Detail"][domain], x + 5.0, 10.0, theme.grey(0.0) if domain == self.domain else theme.text())
        p.rounded_rectangle(Rect(346.0, 5.0, 45.0, 26.0), theme.accent() if self.pinned >= 0 else theme.surface(), 3.0)
        p.text("Pin", 354.0, 10.0, theme.grey(0.0) if self.pinned >= 0 else theme.text())
        if size.width >= 490.0:
            p.rounded_rectangle(Rect(397.0, 5.0, 85.0, 26.0), theme.accent() if self.selected_only else theme.surface(), 3.0)
            p.text("Selected", 402.0, 10.0, theme.grey(0.0) if self.selected_only else theme.text())
        p.text(self.failure if self.failure != "" else self.title + f" / {total} rows", 8.0, 39.0, theme.accent() if self.failure != "" else theme.text_muted())
        let first = int(self.scroll_y / 24.0)
        let visible = int(math.max(0.0, size.height - 88.0) / 24.0) + 2
        for at in first..<int(math.min(float(total), float(first + visible))):
            let row = self.rows.row(at)
            let y = 88.0 + float(at) * 24.0 - self.scroll_y
            if y < 64.0:
                continue
            p.rectangle(Rect(0.0, y, size.width, 23.0), theme.surface() if self.row_selected(row) else (theme.surface_raised() if self.hovered == row else (theme.tab_strip() if at % 2 == 0 else theme.backdrop())))
            for column in 0..<self.columns.length:
                let x = 70.0 + float(column) * 110.0 - self.scroll_x
                if x < 60.0 or x > size.width:
                    continue
                let label = self.label(row, column)
                p.text(label[0..<int(math.min(12.0, float(label.length)))], x + 6.0, y + 4.0, theme.text())
            p.rectangle(Rect(0.0, y, 66.0, 23.0), theme.surface())
            p.text(f"{row}", 8.0, y + 4.0, theme.accent() if self.row_selected(row) else theme.text_muted())
        p.rectangle(Rect(0.0, 62.0, size.width, 26.0), theme.surface())
        p.text(("ID ↓" if self.descending else "ID ↑") if self.sort_column < 0 else "ID", 8.0, 68.0, theme.text())
        for column in 0..<self.columns.length:
            let x = 70.0 + float(column) * 110.0 - self.scroll_x
            if x < 60.0 or x > size.width:
                continue
            let title = self.columns[column].title + ((" ↓" if self.descending else " ↑") if self.sort_column == column else "")
            p.text(title[0..<int(math.min(13.0, float(title.length)))], x + 6.0, 68.0, theme.text())
        p.close()

    func clamp_scroll(self):
        let size = self.box.bounds()
        self.scroll_y = math.max(0.0, math.min(self.scroll_y, float(self.rows.count()) * 24.0 - math.max(0.0, size.height - 88.0)))
        self.scroll_x = math.max(0.0, math.min(self.scroll_x, float(self.columns.length) * 110.0 + 70.0 - size.width))

    pub func event(self, event: Event) -> unit!:
        # A pointer move draws only when it lights another row.
        let lit = self.hovered
        if event.kind == EventKind.scroll:
            let factor = 1.0 if event.scroll_unit == ScrollUnit.points else 24.0
            self.scroll_y -= event.scroll_y * factor if not event.shift else 0.0
            self.scroll_x -= (event.scroll_y if event.shift else event.scroll_x) * factor
            self.clamp_scroll()
        elif event.kind == EventKind.pointer_down and event.button == 0 and event.inside:
            if event.y >= 5.0 and event.y <= 31.0:
                if event.x >= 6.0 and event.x < 342.0:
                    self.set_domain(int((event.x - 6.0) / 84.0))
                elif event.x >= 346.0 and event.x <= 391.0:
                    self.pinned = self.node_id if self.pinned < 0 else -1
                    self.refresh()
                elif event.x >= 397.0 and event.x <= 482.0:
                    self.selected_only = not self.selected_only
                    self.refresh()
            elif event.y >= 62.0 and event.y < 88.0:
                let column = -1 if event.x < 66.0 else int((event.x - 70.0 + self.scroll_x) / 110.0)
                self.descending = not self.descending if column == self.sort_column else false
                self.sort_column = column
                self.refresh()
            elif event.y >= 88.0 and self.workspace.selecting() and self.node_id == self.workspace.network.display:
                let index = int((event.y - 88.0 + self.scroll_y) / 24.0)
                if index >= 0 and index < self.row_count() and self.domain != 3:
                    # Rows select components of their own domain (vertices are corners).
                    selection_commands.set_mode(self.workspace, self.workspace.level_of(self.domain))
                    selection_commands.choose_component(self.workspace, self.rows.row(index), event.shift)
                    self.refresh()
        elif event.kind == EventKind.pointer_moved:
            let index = int((event.y - 88.0 + self.scroll_y) / 24.0)
            self.hovered = self.rows.row(index) if event.inside and event.y >= 88.0 and index >= 0 and index < self.row_count() else -1
        elif event.kind == EventKind.pointer_left:
            self.hovered = -1
        if event.kind != EventKind.pointer_moved or self.hovered != lit:
            self.box.invalidate()