Luce packages
LuceLuce BaseLuciaOS

dymokomi/luced-3d

Source of release 0.11.6

0.11.6 / tests / editor / node_path_tests.luc

## Node paths (node_paths.luc, docs/NODE-PATHS.md): the one system every
## parameter naming another node uses. The module itself (normalizing,
## names, wildcards, writing and resolving paths, targets, choices,
## dependencies, references kept through edits, takes), Render's Camera
## following renames and grouping with undo and redo, in the takes too,
## the picker's Relative paths toggle, Import's Transform starting at Into
## this object, the worker cooking after a rename, and Modify › Rename….
from app import Luce3D
from workspace import Workspace
from network import Network
from node import Node
from luce_ui.ui import Event, Command
from luce_window.input import EventKind, Key
from object_import_tests import failure_of, settle
from stamps import stamp_graph
import node_paths
import node_catalog
import node_commands
import import_node
import take_commands

pub func node_path_tests() -> unit!:
    parsing()
    resolving()
    following()
    render_camera()
    camera_in_takes()
    chooser()
    default_transform()
    camera_on_worker()
    rename_command()
    print("PASS node paths: normalize, names, wildcards, absolute and relative, targets and choices, dependencies, references through edits and takes; Render's Camera follows renames and grouping with undo; the picker's relative toggle; Import starts Into this object; the worker; Modify › Rename (F2)")

## Normalizing, refused names and wildcards.
func parsing() -> unit!:
    assert(node_paths.normalize("  /Geo 2//./Box/../Cube 1/ ") == "/Geo 2/Cube 1")
    assert(node_paths.normalize("../Sphere 4/.") == "../Sphere 4" and node_paths.normalize("../../a/..") == "../..")
    assert(node_paths.normalize("Box/..") == "." and node_paths.normalize("") == "" and node_paths.normalize("/") == "/")
    assert(node_paths.normalize("/Geo*/C?be") == "/Geo*/C?be")
    assert(node_paths.is_absolute(" /Geo 2") and not node_paths.is_absolute("../Geo 2"))
    assert(node_paths.is_pattern("/Geo*") and node_paths.is_pattern("Ge?") and not node_paths.is_pattern("/Geo 2"))
    for name in ["Rock/Stone", "Rock*", "Ro?k", ".", "..", "  "]:
        assert(node_paths.name_problem(name) != "", name)
    assert(node_paths.name_problem("Geo 2") == "" and node_paths.name_problem("a.b") == "")
    assert(node_paths.matches("G*o ?", "Geo 4") and node_paths.matches("*", "") and node_paths.matches("a*b*c", "aXbYbc"))
    assert(not node_paths.matches("Geo ?", "Geo 12") and not node_paths.matches("a*c", "abd"))

## Root: Geo `source` (Cube inside), a Camera, a Light, Geo `reader` with an
## Import and a Group holding a Box; a Render.
func tree() -> (Network, Node, Node, Node, Node, Node, Node)!:
    let graph = Network(false)
    let source = graph.add("Geo", 0.0, 0.0)
    graph.scope = source.id
    let cube = graph.add("Box", 0.0, 0.0)
    graph.scope = -1
    let camera = graph.add("Camera", 200.0, 0.0)
    _ = graph.add("Light", 300.0, 0.0)
    let reader = graph.add("Geo", 400.0, 0.0)
    graph.scope = reader.id
    let importer = graph.add("Import", 0.0, 0.0)
    let group = graph.add("Group", 0.0, 100.0)
    graph.scope = group.id
    _ = graph.add("Box", 0.0, 0.0)
    graph.scope = -1
    let render = graph.add("Render", 0.0, 300.0)
    return (graph, source, cube, camera, reader, importer, render)

## Writing and resolving paths, targets, choices, dependencies.
func resolving() -> unit!:
    let (graph, source, cube, camera, reader, importer, render) = tree()
    let nodes = graph.nodes
    assert(node_paths.absolute(nodes, cube) == f"/{source.name}/{cube.name}")
    assert(node_paths.relative(nodes, importer, cube) == f"../../{source.name}/{cube.name}")
    assert(node_paths.relative(nodes, importer, reader) == ".." and node_paths.relative(nodes, importer, importer) == ".")
    assert(node_paths.relative(nodes, render, camera) == f"../{camera.name}")
    assert(node_paths.written(nodes, render, camera, false) == f"/{camera.name}")
    # Either form reaches the same node; `.` the holder, nothing above the root.
    for path in [f"/{source.name}/{cube.name}", f"../../{source.name}/./{cube.name}", f"../..//{source.name}/{cube.name}/"]:
        let found = node_paths.resolve(nodes, importer, path) else trap(path)
        assert(found.id == cube.id, path)
    assert(node_paths.resolve(nodes, importer, ".") != none and node_paths.resolve(nodes, importer, "../../../..") == none)
    assert(node_paths.resolve(nodes, importer, cube.name) == none and node_paths.resolve(nodes, importer, "/Geo*") == none)
    # A wildcard matches only what the row names: the Import's Object never
    # its own Geo, cameras or lights.
    let object = node_paths.row("Import", import_node.object_slot) else trap("object row")
    assert(object.patterns and object.targets == "geometry")
    let matched = node_paths.resolve_all(nodes, importer, "/*", object.targets)
    assert(matched.length == 1 and matched[0].id == source.id)
    let cameras = node_paths.resolve_all(nodes, render, "/*", "camera")
    assert(cameras.length == 1 and cameras[0].id == camera.id)
    # Every node path row is declared in node_catalog, and is a "node" row
    # among the pane's fields.
    assert(node_paths.holds_paths("Import") and node_paths.holds_paths("Render") and not node_paths.holds_paths("Camera"))
    let camera_row = node_paths.row("Render", 0) else trap("camera row")
    assert(camera_row.targets == "camera" and camera_row.recorded and node_paths.recorded_slot("Render") == 0 and node_paths.recorded_slot("Import") < 0)
    var declared = 0
    for kind in ["Import", "Render"]:
        for row in node_catalog.fields(kind):
            if row.kind == "node":
                declared += 1
                assert(node_paths.row(kind, row.slot) != none, row.name)
    assert(declared == 3)
    # Choices: by target, the holder left out; written either way.
    let geometry = node_paths.choice_paths(nodes, importer, object, false)
    assert(f"/{source.name}" in geometry and f"/{source.name}/{cube.name}" in geometry and f"/{reader.name}" in geometry)
    for path in geometry:
        assert(not path.contains("Camera") and not path.contains("Light") and not path.contains("Import") and not path.contains("Render"), path)
    assert(node_paths.choice_paths(nodes, render, camera_row, false) == [f"/{camera.name}"])
    assert(node_paths.choice_paths(nodes, render, camera_row, true) == [f"../{camera.name}"])
    # Dependencies and resolutions: what the rows reach, by id.
    importer.texts[import_node.object_slot] = f"/{source.name}"
    importer.texts[import_node.transform_object_slot] = "../../" + camera.name
    let reached = node_paths.dependencies(nodes, importer)
    assert(reached.length == 2 and reached[0].id == source.id and reached[1].id == camera.id)
    let before = node_paths.resolution(nodes, importer)
    importer.texts[import_node.object_slot] = f"../../{source.name}"
    assert(node_paths.resolution(nodes, importer) == before)
    importer.texts[import_node.object_slot] = "/nowhere"
    assert(node_paths.resolution(nodes, importer) != before)
    # `require`: a Render's Camera must name a Camera.
    render.texts[0] = f"/{source.name}"
    var refused = ""
    _ = node_paths.require(nodes, render, 0, "camera") catch failure:
        refused = failure.message
        recover camera
    assert(refused == f"No camera at /{source.name}")

## References taken before an edit, retargeted after: absolute stays
## absolute, relative relative, patterns and "." as typed; takes too.
func following() -> unit!:
    let (graph, source, cube, camera, _, importer, render) = tree()
    importer.texts[import_node.object_slot] = f"../../{source.name}/{cube.name}"
    importer.texts[import_node.transform_object_slot] = "."
    render.texts[0] = f"/{camera.name}"
    graph.takes[0].cameras = []
    graph.takes.append(graph.takes[0].copy())
    graph.takes[1].ids = [render.id]
    graph.takes[1].cameras = [f"../{camera.name}"]
    let taken = node_paths.references(graph.nodes, graph.takes, 0)
    assert(taken.length == 3)
    source.name = "Rock"
    camera.name = "Hero"
    let changed = node_paths.retarget(graph.nodes, graph.takes, taken)
    assert(changed.length == 2 and importer.id in changed and render.id in changed)
    assert(importer.texts[0] == f"../../Rock/{cube.name}" and importer.texts[1] == "." and render.texts[0] == "/Hero")
    assert(graph.takes[1].cameras == ["../Hero"])
    # Nothing moved: nothing rewritten.
    assert(node_paths.retarget(graph.nodes, graph.takes, node_paths.references(graph.nodes, graph.takes, 0)).length == 0)

## A Render node's Camera row through renames and grouping, undo and redo;
## the render reaches the camera through it.
func render_camera() -> unit!:
    let w = Workspace()
    node_commands.leave_group(w)
    node_commands.add_node(w, "Camera", 300.0, 0.0)
    let camera = w.network.selected
    node_commands.add_node(w, "Light", 400.0, 0.0)
    node_commands.add_node(w, "Render", 300.0, 200.0)
    let render = w.network.selected
    let name = w.network.require(camera).name
    node_commands.set_text(w, 0, f"../{name}/")
    assert(text(w, render, 0) == f"../{name}")
    assert(failure_of(w.network, render) == "" and w.network.render_camera(w.network.require(render)) == f"camera{camera}")
    stamp_graph(w.network)
    let stamp = w.network.require(render).stamp
    node_commands.reveal_node(w, camera)
    node_commands.rename(w, "Hero")
    assert(text(w, render, 0) == "../Hero" and failure_of(w.network, render) == "")
    # A rename the path followed changes no stamp.
    stamp_graph(w.network)
    assert(w.network.require(render).stamp == stamp)
    w.undo()
    assert(w.network.require(camera).name == name and text(w, render, 0) == f"../{name}")
    w.redo()
    assert(text(w, render, 0) == "../Hero")
    # The camera grouped: the relative path climbs into the Group.
    node_commands.group_selected(w)
    let group = w.network.require(camera).parent
    assert(group >= 0)
    assert(text(w, render, 0) == "../" + w.network.require(group).name + "/Hero")
    assert(w.network.render_camera(w.network.require(render)) == f"camera{camera}")
    w.undo()
    assert(w.network.require(camera).parent == -1 and text(w, render, 0) == "../Hero")
    # The Render grouped, an absolute path stays.
    node_commands.reveal_node(w, render)
    node_commands.set_text(w, 0, "/Hero")
    node_commands.group_selected(w)
    assert(w.network.require(render).parent >= 0 and text(w, render, 0) == "/Hero")
    w.undo()
    w.undo()
    assert(text(w, render, 0) == "../Hero")
    # A path to something that is not a camera, or to nothing.
    node_commands.set_text(w, 0, "/nowhere")
    assert(failure_of(w.network, render).contains("No camera at /nowhere"))

## A take records the Render camera: an inactive take's path follows a
## rename too, and switching to it renders through the renamed camera.
func camera_in_takes() -> unit!:
    let w = Workspace()
    node_commands.leave_group(w)
    node_commands.add_node(w, "Camera", 300.0, 0.0)
    let first = w.network.selected
    node_commands.add_node(w, "Camera", 400.0, 0.0)
    let second = w.network.selected
    node_commands.add_node(w, "Render", 300.0, 200.0)
    let render = w.network.selected
    take_commands.add_take(w)
    take_commands.set_camera(w, second)
    assert(text(w, render, 0) == "/" + w.network.require(second).name)
    take_commands.switch_take(w, 0)
    take_commands.set_camera(w, first)
    # In Main, rename the camera the other take looks through: one undo
    # step takes both back.
    node_commands.reveal_node(w, second)
    node_commands.rename(w, "Close")
    assert("/Close" in w.network.takes[1].cameras)
    w.undo()
    assert(w.network.require(second).name != "Close" and not ("/Close" in w.network.takes[1].cameras))
    w.redo()
    assert("/Close" in w.network.takes[1].cameras)
    take_commands.switch_take(w, 1)
    assert(text(w, render, 0) == "/Close" and w.network.render_camera(w.network.require(render)) == f"camera{second}")
    take_commands.switch_take(w, 0)
    assert(text(w, render, 0) == "/" + w.network.require(first).name)

## The picker lists what the row may name, written absolute or, with its
## toggle, relative; choosing sets the row.
func chooser() -> unit!:
    let editor = Luce3D()
    let w = editor.workspace
    editor.app.layout(1200.0, 800.0)
    let geo = w.network.scope
    let cube = w.network.children(geo)[0]
    node_commands.leave_group(w)
    node_commands.add_node(w, "Geo", 300.0, 0.0)
    node_commands.enter_group(w, w.network.selected)
    node_commands.add_node(w, "Import", 0.0, 0.0)
    let importer = w.network.selected
    let picker = editor.panels.node_path_picker
    picker.open(100.0, 100.0, import_node.object_slot)
    let absolute = "/" + w.network.require(geo).name + "/" + cube.name
    assert(labels(picker.commands).contains(absolute) and not picker.relative)
    assert(picker.commands[0].text() == "Relative paths" and not picker.commands[0].is_checked())
    # The toggle: the same nodes, relative to the Import.
    picker.commands[0].trigger()
    let relative = "../../" + w.network.require(geo).name + "/" + cube.name
    assert(picker.relative and picker.commands[0].is_checked() and labels(picker.commands).contains(relative) and not labels(picker.commands).contains(absolute))
    choose(picker.commands, relative)
    assert(text(w, importer, import_node.object_slot) == relative and failure_of(w.network, importer) == "")
    # Opened again: what the row names is checked; back to absolute.
    picker.open(100.0, 100.0, import_node.object_slot)
    for command in picker.commands:
        if command.text() == relative:
            assert(command.is_checked())
    picker.commands[0].trigger()
    choose(picker.commands, absolute)
    assert(text(w, importer, import_node.object_slot) == absolute)
    # The Transform Object row, and a Render's Camera row: only cameras.
    picker.open(100.0, 100.0, import_node.transform_object_slot)
    assert(labels(picker.commands).contains("/" + w.network.require(geo).name))
    node_commands.leave_group(w)
    node_commands.add_node(w, "Camera", 600.0, 0.0)
    let camera = w.network.require(w.network.selected)
    node_commands.add_node(w, "Render", 600.0, 200.0)
    let render = w.network.selected
    picker.open(100.0, 100.0, 0)
    assert(labels(picker.commands) == ["Relative paths", "", "/" + camera.name])
    picker.commands[0].trigger()
    choose(picker.commands, "../" + camera.name)
    assert(text(w, render, 0) == "../" + camera.name)
    # A row that is not a node path opens nothing.
    picker.open(100.0, 100.0, 1)
    assert(labels(picker.commands) == ["Relative paths", "", "../" + camera.name])
    editor.close()

## A new Import carries its source into this object (Houdini's Object Merge
## starts at None; the owner chose Into this object).
func default_transform() -> unit!:
    let graph = Network(false)
    let importer = graph.add("Import", 0.0, 0.0)
    assert(importer.values[import_node.transform_slot] == import_node.into_this_object)
    let w = Workspace()
    node_commands.add_node(w, "Import", 0.0, 0.0)
    assert(w.network.require(w.network.selected).values[import_node.transform_slot] == import_node.into_this_object)

## The worker renders through a camera that was renamed and grouped.
func camera_on_worker() -> unit!:
    let w = Workspace()
    node_commands.leave_group(w)
    node_commands.add_node(w, "Camera", 300.0, 0.0)
    let camera = w.network.selected
    node_commands.add_node(w, "Light", 400.0, 0.0)
    node_commands.add_node(w, "Render", 300.0, 200.0)
    let render = w.network.selected
    node_commands.set_text(w, 0, "/" + w.network.require(camera).name)
    # The worker cooks the selected node.
    w.enable_compute()
    settle(w)
    assert(w.network.require(render).failure == "", w.network.require(render).failure)
    node_commands.reveal_node(w, camera)
    node_commands.rename(w, "Hero")
    node_commands.group_selected(w)
    node_commands.reveal_node(w, render)
    settle(w)
    assert(text(w, render, 0) == "/" + w.network.require(w.network.require(camera).parent).name + "/Hero")
    assert(w.network.require(render).failure == "", w.network.require(render).failure)
    # A path to nothing fails there too.
    node_commands.set_text(w, 0, "/Hero")
    settle(w)
    assert(w.network.require(render).failure.contains("No camera at /Hero"), w.network.require(render).failure)
    (w.compute else trap("worker")).close()

## Modify › Rename… (F2) asks for the selected node's name and renames it
## in one undo step, paths following.
func rename_command() -> unit!:
    let editor = Luce3D()
    let w = editor.workspace
    editor.app.layout(1200.0, 800.0)
    let a = editor.panels.actions
    let shortcut = a.rename.shortcut()
    assert(shortcut.key == Key.f2 and not shortcut.primary and not shortcut.shift)
    var listed = false
    for command in editor.panels.menus.modify_entries:
        listed = listed or command.id() == "rename_node"
    assert(listed)
    # F2 is no other command's.
    for command in a.all:
        if command.id() != "rename_node":
            assert(command.shortcut().key != Key.f2, command.text())
    let cube = w.network.nodes[0].id
    node_commands.select_node(w, cube)
    editor.panels.refresh()
    assert(a.rename.is_enabled())
    a.rename.trigger()
    assert(editor.panels.rename_prompt.is_open() and editor.panels.rename_prompt.value() == w.network.require(cube).name)
    for c in [66, 111, 120]:
        editor.app.dispatch(Event(kind = EventKind.text_input, codepoint = c))
    editor.app.dispatch(Event(kind = EventKind.key_down, key = Key.enter))
    assert(not editor.panels.rename_prompt.is_open() and w.network.require(cube).name == "Box")
    assert(w.history.undo_label() == "Undo Rename node")
    w.undo()
    assert(w.network.require(cube).name != "Box")
    # Nothing selected: nothing to rename.
    w.network.selected = -1
    w.network.picked = []
    w.revision += 1
    editor.panels.refresh()
    assert(not a.rename.is_enabled())
    editor.close()

func text(w: Workspace, id: int, slot: int) -> str!:
    return w.network.require(id).texts[slot]

func labels(commands: list[Command]) -> list[str]:
    let result: list[str] = []
    for command in commands:
        result.append(command.text())
    return result

func choose(commands: list[Command], label: str) -> unit!:
    for command in commands:
        if command.text() == label:
            command.trigger()
            return
    trap(f"no entry {label}")