dymokomi/luced-3d
Source of release 0.11.4
## The editor's window: the viewport, network, inspector, spreadsheet,
## outliner, render view and takes docked together, with the status line,
## the node search, the shading menu, the sketch's value and text boxes
## and the tool bar; it routes refreshes and the frame's poll to them.
from luce_ui.ui import VStack, HStack, Text, TextField, Font, Button, Spacer, DStack, Panel, DockPosition, Size, ScrollView, Menu, TextPrompt
from dock_layout import DockLayout
from project_session import ProjectSession
from node_menu import NodeMenu
from interop import Connection
from workspace import Workspace
from view import SceneViewport
from network_view import NetworkView
from inspector import Inspector
from actions import Actions
from network import kinds
from geometry_sheet import GeometrySheet
from outliner import Outliner
from shading_menu import ShadingMenu
from sketch_value import SketchValue
from tool_bar import ToolBar
from timeline_pane import TimelinePane
from luce_gpu.gpu import Rect
import sketch_commands
from render_view import RenderView
from takes_pane import TakesList
import node_commands
import take_commands
pub class Panels:
pub let body: VStack
pub let view: SceneViewport
pub let graph: NetworkView
pub let inspector: Inspector
pub let spreadsheet: GeometrySheet
pub let outliner: Outliner
pub let render_view: RenderView
pub let takes: TakesList
let take_name: TextField
let path: Text
pub let search: NodeMenu
pub let shading: ShadingMenu
## A new sketch dimension's value box.
pub let sketch_value: SketchValue
## The Edit node's last tool step's parameters, along the viewport's bottom.
pub let tool_bar: ToolBar
## The timeline along the bottom.
pub let timeline: TimelinePane
## What the sketch's Text tool says.
pub let sketch_text: TextPrompt
pub let actions: Actions
pub let dock: DStack
pub let dock_layout: DockLayout
pub let projects: ProjectSession
pub let status: Text
pub let workspace: Workspace
let connections: list[Connection]
var shown_revision: int = -1
var shown_scope: int = -2
var add_x: float = 70.0
var add_y: float = 70.0
## The node menu was opened over the viewport: its Group groups the
## objects picked there, even one.
var from_viewport: bool = false
pub func init(self, workspace: Workspace, font: Font) -> unit!:
self.workspace = workspace
self.connections = []
self.actions = Actions(workspace)
self.view = SceneViewport(workspace, self.actions)
self.graph = NetworkView(workspace, self.actions, font)
self.projects = ProjectSession(workspace, self.graph, self.actions, font)
self.projects.refreshed = self.refresh
self.graph.on_search = self.open_search
self.graph.on_inspect = self.inspect_node
self.inspector = Inspector(workspace, self.actions, font)
self.spreadsheet = GeometrySheet(workspace)
self.outliner = Outliner(workspace, font)
self.render_view = RenderView()
self.takes = TakesList(workspace, font)
self.take_name = TextField("", font = font, placeholder = "Take name", cells = 12.0)
self.search = NodeMenu(self.actions.add)
self.shading = ShadingMenu(workspace)
self.view.on_shading = self.open_shading
self.sketch_value = SketchValue(workspace, font)
self.tool_bar = ToolBar(workspace, font)
self.timeline = TimelinePane(workspace, self.actions, font)
self.sketch_text = TextPrompt(font)
self.connections.append(self.sketch_text.on_submit(self.view.sketch.editor.place_text))
self.view.sketch.editor.on_text = func () -> unit!: self.sketch_text.open("Sketch text", accept = "Place")
self.view.sketch.editor.on_ask = self.ask_sketch_value
self.view.sketch.editor.on_value = self.open_sketch_value
self.view.sketch.editor.on_click = self.sketch_value.dismiss
self.view.on_search = self.open_viewport_search
self.view.on_add = self.add_from_viewport
let types = kinds()
for index in 0..<types.length:
let kind = types[index]
self.connections.append(self.actions.add[index].on_trigger(func () -> unit!:
# Group with nodes picked (two, or any over the viewport)
# groups them; otherwise it adds an empty Group.
let picked = workspace.network.selection().length
if kind == "Group" and (picked >= 2 or (self.from_viewport and picked >= 1)):
node_commands.group_selected(workspace)
else:
node_commands.add_node(workspace, kind, self.add_x, self.add_y)
self.refresh()))
let add = Button("Add node / Tab", font = font)
let fit = Button("Frame nodes", font = font)
self.connections.append(add.on_click(self.open_search))
self.connections.append(fit.on_click(self.graph.frame_all))
let header = HStack([
Text("LUCED 3D", font = font),
Menu("File", [self.actions.new_project, self.actions.open_project, self.actions.save, self.actions.save_as, self.actions.millimeters, self.actions.inches], font = font),
Menu("Window", [self.actions.reset_layout], font = font),
Button(action = self.actions.undo, font = font), Button(action = self.actions.redo, font = font), Spacer(), self.projects.caption
], spacing = 4.0, padding = 4.0)
let viewport = Panel("Viewport", self.view, minimum = Size(440.0, 270.0), closable = false, id = "viewport")
let parameters = Panel("Parameters", ScrollView(self.inspector.body), minimum = Size(330.0, 180.0), closable = false, id = "parameters")
self.path = Text("/ scene", font = font, muted = true)
let network_header = HStack([Button(action = self.actions.parent, font = font), Button(action = self.actions.group, font = font), self.path, Spacer(), add, fit], spacing = 4.0, padding = 4.0)
let network_body = VStack([network_header, self.graph], spacing = 0.0)
network_body.layout().set_flex()
let network = Panel("Network", network_body, minimum = Size(460.0, 250.0), closable = false, id = "network")
self.dock = DStack([viewport], font = font)
self.dock.add(parameters, viewport, DockPosition.right)
self.dock.set_fraction(viewport, 0.75)
let rendered = Panel("Render", self.render_view, minimum = Size(440.0, 270.0), closable = false, id = "render")
self.dock.add(rendered, viewport, DockPosition.tab)
self.dock.select(viewport)
self.dock.add(network, viewport, DockPosition.bottom)
self.dock.set_fraction(viewport, 0.63)
let outliner = Panel("Outliner", self.outliner, minimum = Size(260.0, 150.0), closable = false, id = "outliner")
self.dock.add(outliner, parameters, DockPosition.top)
self.dock.set_fraction(outliner, 0.32)
let new_take = Button("New", font = font)
let delete_take = Button("Delete", font = font)
self.connections.append(self.take_name.on_commit(func (name: str) -> unit!: take_commands.rename_take(workspace, name)))
self.connections.append(new_take.on_click(func () -> unit!: take_commands.add_take(workspace)))
self.connections.append(delete_take.on_click(func () -> unit!: take_commands.remove_take(workspace)))
let takes_body = VStack([HStack([self.take_name, Spacer(), new_take, delete_take], spacing = 4.0, padding = 4.0), self.takes], spacing = 0.0)
takes_body.layout().set_flex()
let takes = Panel("Takes", takes_body, minimum = Size(260.0, 150.0), closable = false, id = "takes")
self.dock.add(takes, outliner, DockPosition.tab)
self.dock.select(outliner)
let attributes = TextField("", font = font, placeholder = "Filter attributes", cells = 12.0)
let rows = TextField("", font = font, placeholder = "Rows: * / 0-8 / @group", cells = 16.0)
self.connections.append(attributes.on_commit(self.spreadsheet.filter_attributes))
self.connections.append(rows.on_commit(self.spreadsheet.filter_rows))
let sheet_body = VStack([HStack([attributes, rows], spacing = 4.0, padding = 4.0), self.spreadsheet], spacing = 0.0)
sheet_body.layout().set_flex()
let spreadsheet = Panel("Geometry Spreadsheet", sheet_body, minimum = Size(460.0, 200.0), closable = false, id = "geometry_spreadsheet")
self.dock.add(spreadsheet, network, DockPosition.tab)
self.dock.select(network)
self.dock_layout = DockLayout(self.dock, [viewport, rendered, parameters, outliner, takes, network, spreadsheet])
self.connections.append(self.actions.reset_layout.on_trigger(self.dock_layout.reset))
self.dock.layout().set_flex()
self.status = Text("", font = font, muted = true)
let footer = HStack([self.status], padding = 6.0)
self.body = VStack([header, self.dock, self.timeline.body, footer, self.search, self.shading, self.sketch_value.body, self.tool_bar.body, self.sketch_text, self.projects.confirm], spacing = 0.0)
self.body.layout().set_flex()
self.refresh()
## The node menu over the viewport, at its pointer; nodes it adds go
## below the network's selected node.
pub func open_viewport_search(self) -> unit!:
self.from_viewport = true
if let node = self.workspace.selected():
self.add_x = node.x
self.add_y = node.y + 110.0
let view_bounds = self.view.layout().bounds()
let body_bounds = self.body.layout().bounds()
self.search.open(view_bounds.x - body_bounds.x + self.view.pointer_x, view_bounds.y - body_bounds.y + self.view.pointer_y, self.workspace.network.context())
## A marking menu's node `kind`: added below the selected node (wired
## to it), as the viewport's Tab menu adds.
pub func add_from_viewport(self, kind: str) -> unit!:
self.from_viewport = true
if let node = self.workspace.selected():
self.add_x = node.x
self.add_y = node.y + 110.0
let index = kinds().index_of(kind) else return
self.actions.add[index].trigger()
pub func open_search(self) -> unit!:
self.from_viewport = false
let at = self.graph.to_graph(self.graph.pointer_x, self.graph.pointer_y)
self.add_x = at.x
self.add_y = at.y
# Repeated additions at an unchanged cursor should not bury a node.
for node in self.workspace.network.local_nodes():
if self.add_x >= node.x - 96.0 and self.add_x <= node.x + 260.0 and self.add_y >= node.y - 40.0 and self.add_y <= node.y + 60.0:
self.add_x = node.x
self.add_y = node.y + 110.0
let graph_bounds = self.graph.layout().bounds()
let body_bounds = self.body.layout().bounds()
self.search.open(graph_bounds.x - body_bounds.x + self.graph.pointer_x, graph_bounds.y - body_bounds.y + self.graph.pointer_y, self.workspace.network.context())
## A sketch tool asks for a length: the value box opens at the pointer.
func ask_sketch_value(self, label: str, value: float, answer: func(float) -> unit!) -> unit!:
let bounds = self.view.layout().bounds()
let root = self.body.layout().bounds()
let e = self.view.sketch.editor
self.sketch_value.ask(label, value, bounds.x - root.x + e.pointer_x + 16.0, bounds.y - root.y + e.pointer_y + 16.0, answer)
## Sketch Dimension placed dimension `constraint` at (`x`, `y`) of the
## viewport: its value box opens there.
func open_sketch_value(self, constraint: int, x: float, y: float) -> unit!:
let node = self.workspace.selected() else return
let bounds = self.view.layout().bounds()
let root = self.body.layout().bounds()
for d in sketch_commands.dimensions(node.texts[0]):
if d.constraint == constraint:
self.sketch_value.open(node.id, constraint, d.name, d.value, d.angle, bounds.x - root.x + x, bounds.y - root.y + y)
func open_shading(self, held: bool) -> unit!:
let bounds = self.view.layout().bounds()
let root = self.body.layout().bounds()
self.shading.open(bounds.x - root.x + bounds.width - 282.0, bounds.y - root.y + 42.0, held)
pub func inspect_node(self, id: int) -> unit!:
node_commands.select_node(self.workspace, id)
self.spreadsheet.pinned = -1
if let panel = self.dock.find("geometry_spreadsheet"):
self.dock.select(panel)
self.refresh()
## Render the selected Render node's input in the Render panel.
pub func render(self) -> unit!:
let node = self.workspace.selected() else return
if node.kind != "Render":
return
let data = self.workspace.network.evaluate_data(node.id) catch failure:
self.report_error(failure.message)
return
self.render_view.start(data, node.values, node.texts) catch failure:
self.report_error(f"Render: {failure.message}")
return
if let panel = self.dock.find("render"):
self.dock.select(panel)
self.refresh()
pub func refresh(self) -> unit!:
self.projects.refresh()
self.path.set_text(self.workspace.network.path())
self.outliner.refresh()
self.takes.refresh()
if not self.take_name.layout().is_focused():
self.take_name.set_text(self.workspace.network.takes[self.workspace.network.take].name)
if self.shown_scope != self.workspace.network.scope:
self.graph.reset_scope()
self.shown_scope = self.workspace.network.scope
self.actions.refresh()
self.spreadsheet.refresh()
self.inspector.refresh()
self.tool_bar.refresh()
self.place_tool_bar()
self.view.layout().invalidate()
self.graph.layout().invalidate()
self.status.set_text(self.workspace.notice if self.workspace.notice != "" else ("PREVIEW / D to return to outputs" if self.workspace.network.preview else "O: Out D: preview B: bypass Alt + mouse: camera Cmd/Ctrl-Z: undo"))
self.shown_revision = self.workspace.revision
pub func poll(self, elapsed: float) -> unit!:
self.view.poll_hold()
self.timeline.poll()
self.inspector.poll()
self.place_tool_bar()
if self.workspace.poll_compute():
self.graph.layout().invalidate()
if self.shown_revision != self.workspace.revision:
self.refresh()
if self.render_view.running():
self.render_view.layout().invalidate()
## The tool bar follows the viewport (resized, docked elsewhere).
func place_tool_bar(self) -> unit!:
let view_bounds = self.view.layout().bounds()
let body_bounds = self.body.layout().bounds()
self.tool_bar.place(Rect(view_bounds.x - body_bounds.x, view_bounds.y - body_bounds.y, view_bounds.width, view_bounds.height))
pub func report_error(self, message: str) -> unit!:
self.workspace.notice = message
self.refresh()
pub func close(self):
self.projects.close()
self.timeline.close()
self.view.on_shading = none
self.view.sketch.editor.on_value = none
self.view.sketch.editor.on_click = none
self.view.sketch.editor.on_modify = none
self.view.sketch.editor.on_finish = none
self.view.sketch.editor.on_text = none
self.view.sketch.editor.on_ask = none
self.sketch_value.disconnect()
self.tool_bar.close()
self.view.on_search = none
self.view.on_add = none
self.view.tools.chrome.on_reuse = none
self.graph.on_search = none
self.graph.on_inspect = none
for connection in self.connections:
connection.disconnect()
self.connections.clear()
self.inspector.close()
self.render_view.stop()
self.actions.close()