dymokomi/luced-3d
Source of release 0.11.3
0.11.3 / 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))