Luce packages
LuceLuce BaseLuciaOS

dymokomi/luced-3d

Source of release 0.11.6

0.11.6 / tests / editor / gizmo_tests.luc

## Actual handle hit tests and drag gestures, including pivot compensation.
from workspace import Workspace
from node_gizmos import NodeGizmos
from luce_3d.graphics import Vector3
from luce_ui.ui import Event, Painter
from luce_gpu.gpu import Frame
from luce_window import window
from luce_window.input import EventKind, Key
from geometry_tests import near
import view_projection as gm
from luce_std import math
import node_commands
import selection_commands
import modeling_commands
import time
from snapping import grid_step

func drag(gizmo: NodeGizmos, at: list[float], dx: float, dy: float, snap: bool = false) -> unit!:
    assert(gizmo.event(Event(kind = EventKind.pointer_down, inside = true, x = at[0], y = at[1], button = 0), 1000.0, 600.0))
    assert(gizmo.dragging)
    _ = gizmo.event(Event(kind = EventKind.pointer_moved, inside = true, x = at[0] + dx, y = at[1] + dy, shift = snap), 1000.0, 600.0)
    _ = gizmo.event(Event(kind = EventKind.pointer_up, inside = true, x = at[0] + dx, y = at[1] + dy, button = 0), 1000.0, 600.0)
    assert(not gizmo.dragging)

pub func gizmo_tests() -> unit!:
    let w = Workspace()
    let gizmo = NodeGizmos(w)
    # The Cube's own handles are the Manipulator's (T).
    modeling_commands.choose_tool(w, "Manipulator")
    let corner = gm.project(w, Vector3(1.0, 2.0, 1.0), 1000.0, 600.0)
    assert(gizmo.hit(corner[0], corner[1], 1000.0, 600.0) == 17)
    let history = w.history.cursor
    drag(gizmo, corner, 22.0, -17.0, true)
    let resized = (w.geometry else trap("resized Cube")).bounds()
    near(resized.minimum.x, -1.0)
    near(resized.minimum.y, 0.0)
    near(resized.minimum.z, -1.0)
    assert(w.history.cursor == history + 1)
    w.undo()
    near((w.geometry else trap("Cube undo")).bounds().maximum.y, 2.0)
    node_commands.add_node(w, "Transform", 0.0, 100.0)
    modeling_commands.choose_tool(w, "Move")
    let length = w.view.distance * 0.14
    let end = gm.project(w, gizmo.origin().add(gm.axis(1).multiply_scalar(length)), 1000.0, 600.0)
    drag(gizmo, end, 0.0, -32.0, true)
    # The move lands on the snapping grid.
    let moved = (w.selected() else trap("Transform")).values[2]
    let step = grid_step(w.view.distance)
    assert(moved > 0.0)
    near(moved / step, math.round(moved / step))
    w.undo()
    # The rest moves freely.
    w.snaps.flags[1] = false
    let plane = gm.project(w, Vector3(length * 0.31, length * 0.31, 0.0), 1000.0, 600.0)
    assert(gizmo.hit(plane[0], plane[1], 1000.0, 600.0) == 5)
    drag(gizmo, plane, 25.0, -19.0)
    near((w.selected() else trap("XY plane")).values[3], 0.0)
    w.undo()
    modeling_commands.choose_tool(w, "Rotate")
    let ring = gm.project(w, Vector3(length * 0.707106781, length * 0.707106781, 0.0), 1000.0, 600.0)
    drag(gizmo, ring, 50.0, -70.0, true)
    let rotated = (w.selected() else trap("rotation")).values[6]
    assert(rotated != 0.0)
    near(rotated / 15.0, math.round(rotated / 15.0))
    w.undo()
    modeling_commands.choose_tool(w, "Scale")
    let scale = gm.project(w, Vector3(length, 0.0, 0.0), 1000.0, 600.0)
    drag(gizmo, scale, 35.0, 0.0, true)
    assert((w.selected() else trap("scale")).values[7] > 1.0)
    node_commands.set_parameter(w, 5, 30.0)
    let before = w.geometry else trap("before pivot")
    gizmo.pivot = true
    let origin = gm.project(w, gizmo.origin(), 1000.0, 600.0)
    drag(gizmo, origin, 27.0, -13.0)
    let after = w.geometry else trap("after pivot")
    for index in 0..<before.point_count():
        near(before.point(index).subtract(after.point(index)).length(), 0.0)
    let size = gizmo.size
    _ = gizmo.event(Event(kind = EventKind.key_down, key = Key.equal), 1000.0, 600.0)
    assert(gizmo.size > size)
    _ = gizmo.event(Event(kind = EventKind.key_down, key = Key.minus), 1000.0, 600.0)
    near(gizmo.size, size)
    # A close-up of a small, offset imported part leaves its Transform pivot
    # very far offscreen. Labels must not create out-of-range GPU regions.
    w.view.target = Vector3(0.952, 0.24, -0.872)
    w.view.distance = 0.02
    w.view.yaw = 0.7
    w.view.pitch = 0.5
    w.view.update_camera()
    let remote = gm.project(w, gizmo.origin(), 2200.0, 1400.0)
    assert(remote[2] > 0.0 and (math.abs(remote[0]) > 16384.0 or math.abs(remote[1]) > 16384.0))
    for mode in ["Move", "Rotate", "Scale", "Pivot"]:
        gizmo.pivot = mode == "Pivot"
        if mode != "Pivot":
            modeling_commands.choose_tool(w, mode)
        let frame = Frame(window.Size(2200.0, 1400.0, 4400.0, 2800.0, 2.0))
        let painter = Painter(frame.target())
        gizmo.draw(painter, 2200.0, 1400.0)
        painter.close()
        frame.close()
    components()
    scene_objects()
    print("PASS Cube corner resizing, plane constraints, snapped move/rotate/scale, compensated pivot, sizing and undo, component rotate and scale")

## The gizmo on a selected face of an Edit Mesh: Rotate turns its points
## about its center (which stays), Scale spreads them from it; each drag
## one undo step.
func components() -> unit!:
    let w = Workspace()
    let gizmo = NodeGizmos(w)
    w.snaps.flags[1] = false
    node_commands.add_node(w, "Edit Mesh", 0.0, 100.0)
    assert(w.editing())
    selection_commands.set_mode(w, 3)
    selection_commands.choose_component(w, 2, false)
    let center = w.selection_center()
    let length = w.view.distance * 0.14
    let before = w.geometry else trap("cube")
    let history = w.history.cursor
    modeling_commands.choose_tool(w, "Rotate")
    let ring = gm.project(w, center.add(Vector3(length * 0.707106781, length * 0.707106781, 0.0)), 1000.0, 600.0)
    drag(gizmo, ring, 50.0, -70.0)
    let turned = w.geometry else trap("turned")
    var moved = 0
    for index in 0..<before.point_count():
        if before.point(index).subtract(turned.point(index)).length() > 1e-4:
            moved += 1
    assert(moved == 4 and w.history.cursor == history + 1)
    near(w.selection_center().subtract(center).length(), 0.0)
    w.undo()
    modeling_commands.choose_tool(w, "Scale")
    let handle = gm.project(w, center.add(Vector3(length, 0.0, 0.0)), 1000.0, 600.0)
    drag(gizmo, handle, 35.0, 0.0)
    let grown = w.geometry else trap("grown")
    let corner = grown.face_point(2, 0)
    assert(math.abs(grown.point(corner).x - center.x) > math.abs(before.point(corner).x - center.x))

## Camera/Light own translation and rotation, but have no scale or pivot slots.
func scene_objects() -> unit!:
    for kind in ["Light", "Camera"]:
        let w = Workspace()
        node_commands.leave_group(w)
        node_commands.add_node(w, kind, 200.0, 0.0)
        let original_gizmo = NodeGizmos(w)
        modeling_commands.choose_tool(w, "Move")
        w.frame_cube()
        let framed = gm.project(w, original_gizmo.origin(), 1000.0, 600.0)
        assert(framed[0] > 20.0 and framed[0] < 980.0 and framed[1] > 20.0 and framed[1] < 580.0)
        for slot in [1, 2, 3]: node_commands.set_parameter(w, slot, 0.0)
        let gizmo = NodeGizmos(w)
        # A pivot setting left over from Geo must not reinterpret light intensity.
        gizmo.pivot = true
        w.snaps.flags[1] = false
        for background in [false, true]:
            if background: w.enable_compute()
            modeling_commands.choose_tool(w, "Move")
            assert(gizmo.available() and gizmo.mode() == "Move")
            let before = (w.selected() else trap(kind)).values.copy()
            near(gizmo.origin().subtract(Vector3(before[1], before[2], before[3])).length(), 0.0)
            let origin = gm.project(w, gizmo.origin(), 1000.0, 600.0)
            let cursor = w.history.cursor
            drag(gizmo, origin, 37.0, -23.0)
            let after = (w.selected() else trap(kind)).values.copy()
            assert(after[1] != before[1] or after[2] != before[2] or after[3] != before[3])
            for slot in 0..<after.length:
                if slot < 1 or slot > 3: near(after[slot], before[slot])
            assert(w.history.cursor == cursor + 1)
            if let worker = w.compute:
                let deadline = time.now() + 20000000000
                while worker.busy and time.now() < deadline: _ = w.poll_compute()
                assert(not worker.busy and w.notice == "", w.notice)
            var seen = false
            for data in w.batches.scenes:
                let scene = data.scene()
                for at in 0..<scene.count():
                    if scene.is_camera(at) == (kind == "Camera"):
                        near(scene.object(at).matrix.translation.subtract(Vector3(after[1], after[2], after[3])).length(), 0.0)
                        seen = true
            assert(seen)
            w.undo()
            assert((w.selected() else trap(kind)).values == before)
            w.redo()
            assert((w.selected() else trap(kind)).values == after)
            modeling_commands.choose_tool(w, "Rotate")
            assert(gizmo.available() and gizmo.mode() == "Rotate")
            let length = w.view.distance * 0.14
            let ring = gm.project(w, gizmo.origin().add(Vector3(length * 0.707106781, length * 0.707106781, 0.0)), 1000.0, 600.0)
            drag(gizmo, ring, 50.0, -70.0)
            let turned = (w.selected() else trap(kind)).values
            assert(turned[4] != after[4] or turned[5] != after[5] or turned[6] != after[6])
            for slot in 7..<turned.length: near(turned[slot], after[slot])
            modeling_commands.choose_tool(w, "Scale")
            assert(not gizmo.available())
        if let worker = w.compute: worker.close()
    print("PASS root Light/Camera Move and Rotate gestures, preserved settings, stale pivot flag, undo/redo and worker transforms")