Luce packages
LuceLuce BaseLuciaOS

dymokomi/luced-3d

Source of release 0.11.4

0.11.4 / tests / editor / edit_move_tests.luc

## Moves on tessellated CAD keep the supplied display triangles. Re-triangulating
## cut-cell n-gons failed, so every Move on a tessellated STEP file failed.
from luce_geocore.geocore import Mesh
from geometry_tests import verb
from luce_3d.graphics import Vector3
from edit_operations import move_step
from app import Luce3D
from workspace import Workspace
from luce_std import math
import time
import node_commands
import selection_commands
import component_moves

## One 300-degree band polygon: ear clipping in its average plane fails, as it
## does for curved CAD cells, so only its explicit strip triangles work.
func band() -> Mesh!:
    let points: list[Vector3] = []
    for ring in 0..<2:
        for at in 0..<8:
            let angle = float(at) * (300.0 / 7.0) * math.pi / 180.0
            points.append(Vector3(math.cos(angle), math.sin(angle), float(ring)))
    let corners = [0, 1, 2, 3, 4, 5, 6, 7, 15, 14, 13, 12, 11, 10, 9, 8]
    let display: list[int] = []
    for strip in 0..<7:
        for corner in [strip, strip + 1, 14 - strip, strip, 14 - strip, 15 - strip]:
            display.append(corner)
    return Mesh(points, [16], corners, display)

func same_indices(a: Mesh, b: Mesh) -> unit!:
    assert(a.index_count() == b.index_count())
    for at in 0..<a.index_count():
        assert(a.index(at) == b.index(at))

pub func edit_move_tests() -> unit!:
    let mesh = band()
    let moved = move_step("3 11", 1, Vector3(0.0, 0.0, 0.05), mesh.topology_hash()).evaluate(mesh).mesh()
    same_indices(moved, mesh)
    # Points are stored as f32.
    assert(math.abs(moved.point(3).z - 0.05) < 0.0000001 and (moved.edge_count()) == (mesh.edge_count()))
    same_indices(move_step("0 5", 1, Vector3(), mesh.topology_hash()).evaluate(mesh).mesh(), mesh)
    # Extrusion keeps the cap's triangles and triangulates only the new walls.
    let extruded = verb("PolyExtrude", mesh, "0", 3, [0.1])
    for at in 0..<mesh.index_count():
        assert(extruded.index(at) == mesh.index(at))
    # The real Edit node path on a tessellated STEP file: the move succeeds.
    let editor = Luce3D()
    let w = editor.workspace
    node_commands.delete_selected(w)
    node_commands.add_node(w, "File", 0.0, 0.0)
    node_commands.set_text(w, 0, "tests/fixtures/cylinder.step")
    node_commands.add_node(w, "Tessellate", 0.0, 100.0)
    node_commands.add_node(w, "Edit Mesh", 0.0, 200.0)
    assert(w.editing())
    let before = w.geometry else trap("tessellated geometry")
    selection_commands.set_mode(w, 3)
    selection_commands.choose_component(w, 0, false)
    component_moves.move_selection(w, Vector3(0.0, 0.1, 0.0))
    assert(w.notice == "")
    let after = w.geometry else trap("moved geometry")
    same_indices(after, before)
    let corner = before.face_point(0, 0)
    assert(math.abs(after.point(corner).y - before.point(corner).y - 0.1) < 0.000001)
    editor.close()
    worker_edit()
    print("PASS position-only edits keep CAD display triangles through Move, the Edit node and extrusion; File(OBJ) -> Edit on the worker")

func settle(workspace: Workspace) -> unit!:
    let session = workspace.compute else trap("compute")
    let deadline = time.now() + 20000000000
    while session.busy and time.now() < deadline:
        _ = workspace.poll_compute()
    assert(not session.busy)

## File(OBJ) -> Edit through the worker, as the editor runs it. Reaching the
## Edit node by a network click (select_node) after previewing its input
## displays it, so its tools appear; a face moves; F frames the selection.
func worker_edit() -> unit!:
    let w = Workspace()
    w.enable_compute()
    settle(w)
    node_commands.delete_selected(w)
    node_commands.add_node(w, "File", 0.0, 0.0)
    node_commands.set_text(w, 0, "tests/fixtures/grid500k.obj")
    let file = w.network.selected
    node_commands.add_node(w, "Edit Mesh", 0.0, 100.0)
    let edit = w.network.selected
    settle(w)
    assert(w.editing())
    node_commands.select_node(w, file)
    node_commands.display_selected(w)
    settle(w)
    assert(w.network.display == file and not w.editing())
    node_commands.select_node(w, edit)
    settle(w)
    assert(w.network.display == edit and w.editing())
    let before = w.geometry else trap("edit geometry")
    selection_commands.set_mode(w, 3)
    selection_commands.choose_component(w, 0, false)
    assert(w.selected_ids() == [0])
    let corner = before.face_point(0, 0)
    component_moves.move_selection(w, Vector3(0.0, 0.25, 0.0))
    settle(w)
    assert(w.notice == "" and w.editing())
    let after = w.geometry else trap("moved geometry")
    assert(math.abs(after.point(corner).y - before.point(corner).y - 0.25) < 0.000001)
    selection_commands.choose_component(w, 0, false)
    w.frame_cube()
    assert(w.view.distance < 20.0 and math.abs(w.view.target.y - 0.25) < 0.001)
    # A drag previews on the worker; the tools and overlay stay up between
    # previews, and the release commits one undo entry.
    w.begin("Move gizmo")
    component_moves.preview_move(w, Vector3(0.0, 0.1, 0.0))
    assert(w.editing())
    component_moves.preview_move(w, Vector3(0.0, 0.2, 0.0))
    assert(w.editing())
    settle(w)
    w.commit()
    settle(w)
    let dragged = w.geometry else trap("dragged geometry")
    assert(w.editing() and math.abs(dragged.point(corner).y - before.point(corner).y - 0.45) < 0.000001)