Luce packages
LuceLuce BaseLuciaOS

dymokomi/luced-3d

Source of release 0.11.2

0.11.2 / src / panels.luc

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