Luce packages
LuceLuce BaseLuciaOS

dymokomi/luced-3d

Source of release 0.11.4

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