Luce packages
LuceLuce BaseLuciaOS

dymokomi/luced-3d

Source of release 0.11.5

0.11.5 / tests / editor / model_tests.luc

from network import Network
from edit_operations import EditStep
from workspace import Workspace
from luce_3d.graphics import Vector3
from geometry_tests import near
import modeling_commands
import node_commands
import selection_commands
import component_moves

pub func model_tests() -> unit!:
    let empty = Network()
    empty.require(1).enabled = false
    empty.invalidate(1)
    assert(empty.evaluate(1).point_count() == 0)
    let graph = Network()
    let left = graph.add("Transform", 300.0, 30.0)
    let right = graph.add("Transform", 300.0, 180.0)
    let merge = graph.add("Merge", 600.0, 80.0)
    graph.connect(1, left.id, 0)
    graph.connect(1, right.id, 0)
    graph.connect(left.id, merge.id, 0)
    graph.connect(right.id, merge.id, 1)
    right.values[1] = 4.0
    let result = graph.evaluate(merge.id)
    assert(result.point_count() == 16)
    near(result.bounds().maximum.x, 5.0)
    assert(graph.require(1).evaluations == 1)
    left.values[2] = 3.0
    graph.invalidate(left.id)
    _ = graph.evaluate(merge.id)
    assert(left.evaluations == 2 and right.evaluations == 1 and merge.evaluations == 2)
    var rejected = false
    graph.connect(merge.id, left.id, 0) catch failure:
        rejected = true
    assert(rejected and left.inputs[0] == 1)
    rejected = false
    graph.connect(left.id, left.id, 0) catch failure:
        rejected = true
    assert(rejected)
    let edit = graph.add("Edit Mesh", 500.0, 50.0)
    graph.connect(left.id, edit.id, 0)
    let input = graph.evaluate(left.id)
    edit.edits.append(EditStep("PolyExtrude", "2", 3, [1.0], input.topology_hash()))
    assert(graph.evaluate(edit.id).face_count() == 10)
    edit.enabled = false
    graph.invalidate(edit.id)
    assert(graph.evaluate(edit.id).face_count() == 6)
    edit.enabled = true
    graph.connect(merge.id, edit.id, 0)
    rejected = false
    _ = graph.evaluate(edit.id) catch failure:
        rejected = true
    assert(rejected and edit.failure != "")
    graph.remove(right.id)
    assert(merge.inputs[1] == -1)
    rejected = false
    _ = graph.evaluate(merge.id) catch failure:
        rejected = true
    assert(rejected)

    let w = Workspace()
    node_commands.add_node(w, "Transform", 300.0, 20.0)
    let transform_id = w.network.selected
    w.begin("Scrub translate")
    node_commands.set_parameter(w, 1, 1.0)
    node_commands.set_parameter(w, 1, 2.0)
    node_commands.set_parameter(w, 1, 3.0)
    w.commit()
    assert(w.history.changes.length == 2)
    w.undo()
    near(w.network.require(transform_id).values[1], 0.0)
    w.redo()
    near(w.network.require(transform_id).values[1], 3.0)
    node_commands.add_node(w, "Edit Mesh", 550.0, 20.0)
    let edit_id = w.network.selected
    assert(w.editing())
    selection_commands.choose_component(w, 2, false)
    modeling_commands.extrude(w)
    assert((w.geometry else trap("mesh")).face_count() == 10)
    assert(w.network.require(edit_id).edits.length == 1)
    modeling_commands.set_last_step(w, 0, 1.25, -100.0, 100.0)
    near((w.geometry else trap("mesh")).bounds().maximum.y, 3.25)
    w.undo()
    near((w.geometry else trap("mesh")).bounds().maximum.y, 2.5)
    w.undo()
    assert((w.geometry else trap("mesh")).face_count() == 6 and w.selected_ids() == [2])
    w.redo()
    assert((w.geometry else trap("mesh")).face_count() == 10)
    w.begin("Move gizmo")
    component_moves.preview_move(w, Vector3(0.0, 0.2, 0.0))
    component_moves.preview_move(w, Vector3(0.0, 0.7, 0.0))
    w.commit()
    assert(w.network.require(edit_id).edits.length == 2)
    near((w.geometry else trap("mesh")).bounds().maximum.y, 3.2)
    w.undo()
    near((w.geometry else trap("mesh")).bounds().maximum.y, 2.5)
    w.begin("Cancelled gizmo")
    component_moves.preview_move(w, Vector3(0.0, 3.0, 0.0))
    w.cancel()
    near((w.geometry else trap("mesh")).bounds().maximum.y, 2.5)
    node_commands.toggle_enabled(w)
    assert((w.geometry else trap("mesh")).face_count() == 6)
    w.undo()
    assert((w.geometry else trap("mesh")).face_count() == 10)
    node_commands.select_node(w, 1)
    assert(w.network.display == edit_id and not w.editing())
    node_commands.display_selected(w)
    assert(w.network.display == 1)
    w.undo()
    assert(w.network.display == edit_id)
    let before = w.history.changes.length
    node_commands.connect(w, edit_id, transform_id, 0)
    assert(w.notice != "" and w.history.changes.length == before)
    # Undo followed by a fresh command clears the redo branch.
    w.undo()
    node_commands.rename(w, "Renamed cube")
    assert(not w.history.can_redo())
    print("PASS branching DAG, cycles, cache invalidation, bypass, topology guards and undo transactions")