dymokomi/luced-3d
Source of release 0.11.1
0.11.1 / src / network_view.luc
from luce_ui.ui import Widget, Layout, Constraints, Size, Event, Painter, Point, Font
from luce_gpu.gpu import RenderTarget, Rect
from luce_window.input import EventKind, Key, ScrollUnit
from network import Node
from workspace import Workspace
from actions import Actions
from luce_std import math
import theme
import time
from tool_icons import draw_icon
from edit_kinds import is_edit
import node_commands
pub let node_width: float = 96.0
pub let node_height: float = 40.0
pub class NetworkView: Widget:
let box: Layout
let workspace: Workspace
let actions: Actions
let base_font: Font
var font: Font
pub var zoom: float = 1.0
pub var pan_x: float = 0.0
pub var pan_y: float = 0.0
pub var pointer_x: float = 100.0
pub var pointer_y: float = 70.0
pub var on_search: func() -> unit!? = none
pub var on_inspect: func(int) -> unit!? = none
var mode: str = ""
var moving: int = -1
var wire_node: int = -1
var wire_port: int = -1
var from_output: bool = true
var start_x: float = 0.0
var start_y: float = 0.0
var last_x: float = 0.0
var last_y: float = 0.0
var node_x: float = 0.0
var node_y: float = 0.0
var space: bool = false
var hovered: int = -1
var last_click: int = 0
var last_node: int = -1
pub func reset_scope(self) -> unit!:
self.mode = ""
self.hovered = -1
self.pan_x = 20.0
self.pan_y = 20.0
self.zoom = 1.0
self.last_node = -1
self.box.invalidate()
pub func init(self, workspace: Workspace, actions: Actions, font: Font) -> unit!:
self.workspace = workspace
self.actions = actions
self.base_font = font
self.font = font
self.box = Layout()
self.box.set_flex()
self.box.set_interactive(true)
self.box.set_focusable(true)
self.box.set_accepts_tab(true)
pub func layout(self) -> Layout:
return self.box
pub func measure(self, available: Constraints) -> Size!:
return Size(460.0, 220.0)
pub func to_graph(self, x: float, y: float) -> Point:
return Point((x - self.pan_x) / self.zoom, (y - self.pan_y) / self.zoom)
pub func to_screen(self, x: float, y: float) -> Point:
return Point(x * self.zoom + self.pan_x, y * self.zoom + self.pan_y)
pub func port_point(self, node: Node, output: bool, port: int = 0) -> Point:
return self.to_screen(node.x + (node_width * 0.5 if output else node_width * float(port + 1) / float(node.inputs.length + 1)), node.y + (node_height if output else 0.0))
pub func zoom_about(self, factor: float, x: float, y: float):
let before = self.to_graph(x, y)
self.zoom = math.max(0.3, math.min(2.5, self.zoom * factor))
self.pan_x = x - before.x * self.zoom
self.pan_y = y - before.y * self.zoom
self.box.invalidate()
pub func frame_all(self) -> unit!:
let nodes = self.workspace.network.local_nodes()
if nodes.length == 0:
return
var left = nodes[0].x
var top = nodes[0].y
var right = left + node_width + 170.0
var bottom = top + node_height
for node in nodes:
left = math.min(left, node.x)
top = math.min(top, node.y)
right = math.max(right, node.x + node_width + 170.0)
bottom = math.max(bottom, node.y + node_height)
let bounds = self.box.bounds()
self.zoom = math.max(0.3, math.min(1.4, math.min((bounds.width - 80.0) / (right - left), (bounds.height - 70.0) / (bottom - top))))
self.pan_x = (bounds.width - (right - left) * self.zoom) * 0.5 - left * self.zoom
self.pan_y = (bounds.height - (bottom - top) * self.zoom) * 0.5 - top * self.zoom
self.box.invalidate()
pub func draw(self, target: RenderTarget) -> unit!:
let size = target.size()
let p = Painter(target)
p.rectangle(Rect(0.0, 0.0, size.width, size.height), theme.backdrop())
let step = 32.0 * self.zoom
var x = self.pan_x - math.floor(self.pan_x / step) * step
while x < size.width:
var y = self.pan_y - math.floor(self.pan_y / step) * step
while y < size.height:
p.rectangle(Rect(x, y, 1.0, 1.0), theme.border())
y += step
x += step
let wanted = float(int(math.max(8.0, self.base_font.size() * self.zoom)))
if wanted != self.font.size():
self.font = self.base_font if wanted == self.base_font.size() else Font(wanted)
let graph = self.workspace.network
let exposed: list[int] = []
for node in graph.outputs(graph.scope):
exposed.append(node.id)
for node in graph.local_nodes():
for port in 0..<node.inputs.length:
if let source = graph.find(node.inputs[port]):
self.wire(p, self.port_point(source, true), self.port_point(node, false, port))
for node in graph.local_nodes():
let at = self.to_screen(node.x, node.y)
let w = node_width * self.zoom
let h = node_height * self.zoom
if at.x + w + 170.0 * self.zoom < 0.0 or at.x > size.width or at.y + h < 0.0 or at.y > size.height:
continue
let selected = node.id == graph.selected
let radius = 10.0 * self.zoom if node.kind in ["Cube", "Grid", "Sphere", "Cylinder", "Cone", "Torus"] else 3.0 * self.zoom
p.rounded_rectangle(Rect(at.x - 1.5, at.y - 1.5, w + 3.0, h + 3.0), theme.accent() if selected else (theme.text_muted() if self.hovered == node.id else theme.grey(78.0)), radius + 1.0)
p.rounded_rectangle(Rect(at.x, at.y, w, h), theme.grey(64.0) if node.enabled else theme.tab_strip(), radius)
if node.computing:
p.rectangle(Rect(at.x, at.y + h - 3.0, w * math.max(0.02, math.min(1.0, node.progress)), 3.0), theme.accent())
draw_icon(p, node.kind, at.x + 36.0 * self.zoom, at.y + 8.0 * self.zoom, 24.0 * self.zoom, theme.text() if node.enabled else theme.text_muted())
let caption = node.name[0..<24] + "…" if node.name.length > 24 else node.name
p.text(caption, at.x + 109.0 * self.zoom, at.y + (1.0 if self.zoom >= 0.65 else 10.0) * self.zoom, theme.text() if node.enabled else theme.text_muted(), self.font)
let detail = (f"{node.phase} {int(node.progress * 100.0)}%" if node.progress > 0.0 else node.phase) if node.computing else ("ERROR" if node.failure != "" else ("WARNING" if node.warning != "" else ("bypassed" if not node.enabled else (f"{node.edits.length} edits" if is_edit(node.kind) else "geometry"))))
if self.zoom >= 0.65:
let shown = node.computing or node.failure != "" or node.warning != "" or not node.enabled or is_edit(node.kind)
let ink = theme.accent() if node.failure != "" or node.computing else (theme.warning() if node.warning != "" else theme.text_muted())
p.text(detail if shown else node.kind, at.x + 109.0 * self.zoom, at.y + 22.0 * self.zoom, ink, self.font)
# Two distinct flags, with matching commands in the inspector.
p.rectangle(Rect(at.x + 84.0 * self.zoom, at.y + 5.0 * self.zoom, 9.0 * self.zoom, 30.0 * self.zoom), theme.accent() if node.id in exposed else theme.border())
p.rectangle(Rect(at.x + 3.0 * self.zoom, at.y + 5.0 * self.zoom, 9.0 * self.zoom, 30.0 * self.zoom), theme.accent() if not node.enabled else theme.border())
if not node.enabled:
p.line(Point(at.x + 18.0 * self.zoom, at.y + 31.0 * self.zoom), Point(at.x + 78.0 * self.zoom, at.y + 9.0 * self.zoom), 1.0, theme.text_muted())
for port in 0..<node.inputs.length:
self.draw_port(p, self.port_point(node, false, port), node.inputs[port] >= 0)
self.draw_port(p, self.port_point(node, true), true)
if self.mode == "wire":
if let node = graph.find(self.wire_node):
let port = self.port_point(node, self.from_output, self.wire_port)
let pointer = Point(self.pointer_x, self.pointer_y)
self.wire(p, port if self.from_output else pointer, pointer if self.from_output else port)
if self.hovered >= 0 and self.mode == "":
if let node = graph.find(self.hovered):
let at = self.to_graph(self.pointer_x, self.pointer_y)
let hint = "Bypass (B)" if at.x < node.x + 15.0 else ("Out (O)" if at.x > node.x + 81.0 else node.kind + " / geometry")
p.text(hint, 12.0, size.height - 24.0, theme.text_muted())
let screen = self.to_screen(node.x, node.y)
# Fixed screen-size hover controls keep flags usable zoomed out.
for flag in 0..<3:
let flag_x = screen.x - 26.0 if flag == 0 else (screen.x + node_width * self.zoom + 6.0 if flag == 1 else screen.x + node_width * self.zoom * 0.5 - 10.0)
let flag_y = screen.y + node_height * self.zoom * 0.5 - 10.0 if flag != 2 else screen.y - 27.0
p.rounded_rectangle(Rect(flag_x, flag_y, 20.0, 20.0), theme.surface(), 4.0)
p.text(["B", "O", "i"][flag], flag_x + 5.0, flag_y + 2.0, theme.accent() if (flag == 0 and not node.enabled) or (flag == 1 and node.id in exposed) else theme.text())
p.close()
func draw_port(self, p: Painter, at: Point, connected: bool) -> unit!:
let width = math.max(8.0, 14.0 * self.zoom)
let height = math.max(3.0, 4.0 * self.zoom)
p.rounded_rectangle(Rect(at.x - width * 0.5, at.y - height * 0.5, width, height), theme.text() if connected else theme.grey(90.0), 1.5)
func wire(self, p: Painter, a: Point, b: Point) -> unit!:
let reach = math.max(35.0, math.abs(b.y - a.y) * 0.5)
var previous = a
for step in 1..<21:
let t = float(step) / 20.0
let u = 1.0 - t
let point = Point(u * u * u * a.x + 3.0 * u * u * t * a.x + 3.0 * u * t * t * b.x + t * t * t * b.x,
u * u * u * a.y + 3.0 * u * u * t * (a.y + reach) + 3.0 * u * t * t * (b.y - reach) + t * t * t * b.y)
p.line(previous, point, math.max(1.0, 1.5 * self.zoom), theme.grey(150.0))
previous = point
## [node ID, port index, output flag]. Port hit radius stays usable zoomed out.
pub func hit_port(self, x: float, y: float) -> list[int]:
for node in self.workspace.network.local_nodes().reversed():
let output = self.port_point(node, true)
if math.abs(output.x - x) <= 10.0 and math.abs(output.y - y) <= 10.0:
return [node.id, 0, 1]
for port in 0..<node.inputs.length:
let input = self.port_point(node, false, port)
if math.abs(input.x - x) <= 10.0 and math.abs(input.y - y) <= 10.0:
return [node.id, port, 0]
return []
pub func event(self, event: Event) -> unit!:
self.pointer_x = event.x if event.kind == EventKind.pointer_moved or event.kind == EventKind.pointer_down else self.pointer_x
self.pointer_y = event.y if event.kind == EventKind.pointer_moved or event.kind == EventKind.pointer_down else self.pointer_y
if event.cancelled or event.kind == EventKind.focus_lost or event.kind == EventKind.overflow:
if self.mode == "move":
self.workspace.cancel()
self.mode = ""
self.space = false
elif event.kind == EventKind.key_down:
if event.key == Key.space:
self.space = true
elif event.key == Key.tab:
if let search = self.on_search:
search()
elif event.key == Key.delete or event.key == Key.backspace:
self.actions.delete.trigger()
elif event.key == Key.home:
self.frame_all()
elif event.key == Key.enter:
if self.workspace.selected() != none:
node_commands.enter_group(self.workspace, self.workspace.network.selected)
elif event.key == Key.escape:
if self.mode == "move":
self.workspace.cancel()
self.mode = ""
elif event.kind == EventKind.key_up and event.key == Key.space:
self.space = false
elif event.kind == EventKind.magnify:
self.zoom_about(math.max(0.1, 1.0 + event.scroll_y), event.x, event.y)
elif event.kind == EventKind.scroll:
if event.scroll_unit == ScrollUnit.points and not event.control and not event.meta:
self.pan_x += event.scroll_x
self.pan_y += event.scroll_y
else:
self.zoom_about(math.exp(event.scroll_y * (0.01 if event.scroll_unit == ScrollUnit.points else 0.12)), event.x, event.y)
elif event.kind == EventKind.pointer_down and event.inside:
if event.button == 1:
self.mode = ""
if let search = self.on_search:
search()
return
if event.button == 0 and self.mode == "" and self.hovered >= 0:
if let node = self.workspace.network.find(self.hovered):
let screen = self.to_screen(node.x, node.y)
for flag in 0..<3:
let x = screen.x - 26.0 if flag == 0 else (screen.x + node_width * self.zoom + 6.0 if flag == 1 else screen.x + node_width * self.zoom * 0.5 - 10.0)
let y = screen.y + node_height * self.zoom * 0.5 - 10.0 if flag != 2 else screen.y - 27.0
if event.x >= x and event.x <= x + 20.0 and event.y >= y and event.y <= y + 20.0:
node_commands.select_node(self.workspace, node.id)
if flag == 0:
self.actions.enabled.trigger()
elif flag == 1:
self.actions.output.trigger()
elif let inspect = self.on_inspect:
inspect(node.id)
self.box.invalidate()
return
self.last_x = event.x
self.last_y = event.y
self.start_x = event.x
self.start_y = event.y
if event.button == 2 or self.space:
self.mode = "pan"
elif self.mode == "wire":
let port = self.hit_port(event.x, event.y)
self.finish_wire(port)
self.mode = ""
else:
let port = self.hit_port(event.x, event.y)
if port.length > 0:
if event.alt and port[2] == 0:
node_commands.disconnect(self.workspace, port[0], port[1])
else:
self.mode = "wire"
self.wire_node = port[0]
self.wire_port = port[1]
self.from_output = port[2] == 1
else:
let at = self.to_graph(event.x, event.y)
self.mode = "pan"
for node in self.workspace.network.local_nodes().reversed():
if at.x >= node.x and at.x <= node.x + node_width and at.y >= node.y and at.y <= node.y + node_height:
node_commands.select_node(self.workspace, node.id)
if at.x <= node.x + 15.0:
self.actions.enabled.trigger()
self.mode = ""
elif at.x >= node.x + 81.0:
self.actions.output.trigger()
self.mode = ""
else:
let now = time.now()
if node.kind == "Group" and self.last_node == node.id and now - self.last_click < 400000000:
self.mode = ""
self.last_node = -1
node_commands.enter_group(self.workspace, node.id)
return
self.last_node = node.id
self.last_click = now
self.mode = "move"
self.moving = node.id
self.node_x = node.x
self.node_y = node.y
self.workspace.begin("Move node")
break
elif event.kind == EventKind.pointer_moved:
var retained = -1
if let node = self.workspace.network.find(self.hovered):
let screen = self.to_screen(node.x, node.y)
if event.inside and event.x >= screen.x - 30.0 and event.x <= screen.x + node_width * self.zoom + 30.0 and event.y >= screen.y - 30.0 and event.y <= screen.y + node_height * self.zoom + 12.0:
retained = node.id
self.hovered = retained
if event.inside:
let at = self.to_graph(event.x, event.y)
for node in self.workspace.network.local_nodes().reversed():
if at.x >= node.x and at.x <= node.x + node_width and at.y >= node.y and at.y <= node.y + node_height:
self.hovered = node.id
break
if self.mode == "pan":
self.pan_x += event.x - self.last_x
self.pan_y += event.y - self.last_y
elif self.mode == "move" and (event.x != self.start_x or event.y != self.start_y):
node_commands.move_node(self.workspace, self.moving, self.node_x + (event.x - self.start_x) / self.zoom, self.node_y + (event.y - self.start_y) / self.zoom)
self.last_x = event.x
self.last_y = event.y
elif event.kind == EventKind.pointer_up:
if self.mode == "move":
self.workspace.commit()
elif self.mode == "wire":
let port = self.hit_port(event.x, event.y)
# A click starts a persistent wire; a drag connects on release.
if port.length > 0 and port[0] == self.wire_node and (port[2] == 1) == self.from_output:
self.box.invalidate()
return
self.finish_wire(port)
self.mode = ""
elif event.kind == EventKind.pointer_left:
self.hovered = -1
self.box.invalidate()
func finish_wire(self, port: list[int]) -> unit!:
if port.length > 0 and (port[2] == 1) != self.from_output:
if self.from_output:
node_commands.connect(self.workspace, self.wire_node, port[0], port[1])
else:
node_commands.connect(self.workspace, port[0], self.wire_node, self.wire_port)