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()