Luce packages
LuceLuce BaseLuciaOS

dymokomi/luced-3d

Source of release 0.11.1

0.11.1 / src / panels.luc

from luce_ui.ui import VStack, HStack, Text, TextField, Font, Button, Spacer, DStack, Panel, DockPosition, Size, ScrollView, Menu
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
import node_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
    let path: Text
    pub let search: NodeMenu
    pub let shading: ShadingMenu
    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

    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.search = NodeMenu(self.actions.add)
        self.shading = ShadingMenu(workspace)
        self.view.on_shading = self.open_shading
        let types = kinds()
        for index in 0..<types.length:
            let kind = types[index]
            self.connections.append(self.actions.add[index].on_trigger(func () -> unit!:
                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], 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), 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)
        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 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, parameters, outliner, 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, footer, self.search, self.shading, self.projects.confirm], spacing = 0.0)
        self.body.layout().set_flex()
        self.refresh()

    pub func open_search(self) -> unit!:
        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)

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

    pub func refresh(self) -> unit!:
        self.projects.refresh()
        self.path.set_text(self.workspace.network.path())
        self.outliner.refresh()
        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.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()
        if self.workspace.poll_compute():
            self.graph.layout().invalidate()
        if self.shown_revision != self.workspace.revision:
            self.refresh()

    pub func report_error(self, message: str) -> unit!:
        self.workspace.notice = message
        self.refresh()

    pub func close(self):
        self.projects.close()
        self.view.on_shading = 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.actions.close()