dymokomi/luced-3d
Source of release 0.11.6
0.11.6 / tests / bench / bench.luc
## Headless editor benchmark (tests/bench/run.py): the real Workspace, worker
## and publisher, drawing into an offscreen texture as the viewport does. It
## times importing and cooking a mesh, its first display, selecting 1k faces,
## and a Move round trip (request, cook, hand-off, adopt, redraw).
from workspace import Workspace
from network import Network
from luce_geocore.geocore import GeometryFile
from luce_3d.graphics import Vector3, Renderer, EditOverlay, Color
from offscreen import OffscreenView
from geometry_sheet import GeometrySheet
import theme
import time
from luce_std import math
import node_commands
import selection_commands
import component_moves
func since(start: int) -> float:
return float(time.now() - start) / 1000000.0
func report(name: str, value: float) -> unit:
print(f"{name}\t{value}")
func settle(workspace: Workspace) -> unit!:
let session = workspace.compute else trap("compute")
let deadline = time.now() + 600000000000
while session.busy and time.now() < deadline:
_ = workspace.poll_compute()
assert(not session.busy)
## One viewport frame as SceneViewport draws it: the shaded scene with Edit
## mode's wires from the GPU arrays, then the selection overlay.
func frame(view: OffscreenView, w: Workspace, renderer: Renderer, overlay: EditOverlay) -> float!:
let start = time.now()
let target = view.begin()
let editing = w.editing()
renderer.set_edges(1.0 if editing else 0.0, theme.grey(90.0))
renderer.set_wire_overlay(1.0 if editing else 0.0)
let accent = theme.accent()
if editing and w.component_mode == 3 and w.selection != none:
renderer.set_selected_faces(w.geometry else trap("geometry"), w.selection else trap("selection"), Color(accent.red, accent.green, accent.blue), 0.45)
else:
renderer.clear_face_selection()
renderer.render(w.scene, w.view.camera, target, true)
if editing:
if let mesh = w.geometry:
overlay.show(mesh, w.overlay_mode(), w.selection, -1)
overlay.draw(w.view.camera, target, theme.grey(90.0), theme.accent(), theme.text(), wires = false)
view.end()
return since(start)
## `label`: File (and for STEP, Tessellate) into an Edit node, then the timings.
func run_case(label: str, path: str, tessellate: bool, view: OffscreenView) -> unit!:
let w = Workspace()
w.enable_compute()
settle(w)
node_commands.delete_selected(w)
let renderer = Renderer(true)
let overlay = EditOverlay()
overlay.set_fill(false)
var start = time.now()
let whole = start
node_commands.add_node(w, "File", 0.0, 0.0)
node_commands.set_text(w, 0, path)
settle(w)
report(f"{label}: File (import and display cook)", since(start))
w.frame_cube()
report(f"{label}: File first display", frame(view, w, renderer, overlay))
if tessellate:
start = time.now()
node_commands.add_node(w, "Tessellate", 0.0, 100.0)
settle(w)
report(f"{label}: Tessellate", since(start))
report(f"{label}: Tessellate first display", frame(view, w, renderer, overlay))
start = time.now()
node_commands.add_node(w, "Edit Mesh", 0.0, 200.0)
settle(w)
report(f"{label}: Edit node cook", since(start))
report(f"{label}: import and cook to an Edit node", since(whole))
let mesh = w.geometry else trap("no mesh to edit")
print(f"# {label}: {mesh.point_count()} points, {mesh.face_count()} faces, {(mesh.edge_count())} edges")
report(f"{label}: first display", frame(view, w, renderer, overlay))
w.view.orbit(4.0, 0.0)
report(f"{label}: camera-only redraw", frame(view, w, renderer, overlay))
selection_commands.set_mode(w, 3)
let faces = mesh.face_count()
start = time.now()
for at in 0..<1000:
selection_commands.choose_component(w, (at * 691) % faces, true)
report(f"{label}: select 1k faces (1000 clicks)", since(start))
report(f"{label}: redraw with the selection", frame(view, w, renderer, overlay))
start = time.now()
component_moves.move_selection(w, Vector3(0.0, 0.01, 0.0))
settle(w)
let cooked = since(start)
let drawn = frame(view, w, renderer, overlay)
report(f"{label}: Move 1k faces, request to adopted result", cooked)
report(f"{label}: Move 1k faces, redraw", drawn)
report(f"{label}: Move 1k faces round trip", cooked + drawn)
# A local edit: 1,000 faces in a row of the face order (a patch), the
# common case, whose uploads cover only that neighbourhood.
selection_commands.set_mode(w, 3)
let first = faces // 2
selection_commands.choose_component(w, first, false)
for at in 1..<1000:
selection_commands.choose_component(w, first + at, true)
_ = frame(view, w, renderer, overlay)
start = time.now()
component_moves.move_selection(w, Vector3(0.0, 0.01, 0.0))
settle(w)
let local_cooked = since(start)
let local_drawn = frame(view, w, renderer, overlay)
report(f"{label}: Move 1k adjacent faces round trip", local_cooked + local_drawn)
start = time.now()
selection_commands.invert_selection(w)
report(f"{label}: invert a 1k-face selection", since(start))
report(f"{label}: redraw with the inverted selection", frame(view, w, renderer, overlay))
print(f"# {label}: {w.selected_count()} faces selected")
start = time.now()
w.frame_cube()
report(f"{label}: frame the inverted selection", since(start))
let sheet = GeometrySheet(w)
sheet.set_domain(2)
sheet.selected_only = true
start = time.now()
_ = sheet.row_count()
report(f"{label}: spreadsheet rows, selected only", since(start))
(w.compute else trap("compute")).close()
## `label`'s cooked result (File, and Tessellate for STEP) saved to a .prism
## file by the codec and loaded back: what a Cache node writes and reads.
func codec_case(label: str, path: str, tessellate: bool) -> unit!:
let graph = Network(false)
let file = graph.add("File", 0.0, 0.0)
file.texts[0] = path
var last = file
if tessellate:
let tessellated = graph.add("Tessellate", 0.0, 60.0)
graph.connect(file.id, tessellated.id, 0)
last = tessellated
let data = graph.evaluate_data(last.id)
var start = time.now()
let size = GeometryFile.save(data.geometry, "codec.prism", 1)
report(f"{label}: save to .prism", since(start))
start = time.now()
let loaded = GeometryFile.load("codec.prism")
report(f"{label}: load from .prism", since(start))
print(f"# {label}: .prism of {size} bytes, {loaded.description()}")
# Its signed distance at 1/256 of its size, and that surface meshed.
let box = data.geometry.bounds()
let extent = box.maximum.subtract(box.minimum)
let solid = graph.add("Mesh to SDF", 0.0, 120.0)
graph.connect(last.id, solid.id, 0)
solid.values[0] = math.max(extent.x, math.max(extent.y, extent.z)) / 256.0
start = time.now()
let volume = graph.evaluate_data(solid.id)
report(f"{label}: Mesh to SDF, 256 voxels across", since(start))
let surface = graph.add("Convert to Mesh", 0.0, 180.0)
graph.connect(solid.id, surface.id, 0)
start = time.now()
let meshed = graph.evaluate(surface.id)
report(f"{label}: its surface as a mesh", since(start))
print(f"# {label}: {volume.description()}, surface of {meshed.face_count()} faces")
## A 64-segment unit sphere's signed distance at voxel 0.01: a closed mesh
## with fewer triangles than band voxels, rasterized.
func sphere_case() -> unit!:
let graph = Network(false)
let sphere = graph.add("Sphere", 0.0, 0.0)
sphere.values[1] = 64.0
let solid = graph.add("Mesh to SDF", 0.0, 60.0)
graph.connect(sphere.id, solid.id, 0)
solid.values[0] = 0.01
_ = graph.evaluate_data(sphere.id)
let start = time.now()
let volume = graph.evaluate_data(solid.id)
report("sphere 64: Mesh to SDF, voxel 0.01", since(start))
print(f"# sphere 64: {volume.description()}")
## A CV drag on `path`'s CAD in an Edit CAD node: each frame of the drag
## (request, quick preview, hand-off, redraw), then the release's full cook.
func cad_drag_case(label: str, path: str, view: OffscreenView) -> unit!:
let w = Workspace()
w.enable_compute()
settle(w)
node_commands.delete_selected(w)
let renderer = Renderer(true)
let overlay = EditOverlay()
overlay.set_fill(false)
node_commands.add_node(w, "File", 0.0, 0.0)
node_commands.set_text(w, 0, path)
settle(w)
node_commands.add_node(w, "Edit CAD", 0.0, 100.0)
settle(w)
_ = frame(view, w, renderer, overlay)
selection_commands.set_mode(w, 1)
settle(w)
for cv in 100..<111:
selection_commands.choose_component(w, cv, cv > 100)
print(f"# {label}: {w.selected_count()} CVs selected of {(w.geometry else trap("cloud")).point_count()}")
w.begin("Move gizmo")
var worst = 0.0
var total = 0.0
for step in 1..<6:
let start = time.now()
component_moves.preview_move(w, Vector3(0.0, float(step) * 0.5, 0.0))
settle(w)
let spent = since(start) + frame(view, w, renderer, overlay)
worst = math.max(worst, spent)
total += spent
report(f"{label}: CV drag frame, mean of 5", total / 5.0)
report(f"{label}: CV drag frame, worst", worst)
let start = time.now()
w.commit()
settle(w)
report(f"{label}: CV drag release, full tessellation", since(start) + frame(view, w, renderer, overlay))
(w.compute else trap("compute")).close()
pub func main(arguments: list[str]) -> int!:
let view = OffscreenView()
if arguments.length > 2 and arguments[2] == "drag":
cad_drag_case("camera.step", arguments[1], view)
view.close()
return 0
run_case("grid 700k", arguments[0], false, view)
codec_case("grid 700k", arguments[0], false)
sphere_case()
if arguments.length > 1 and arguments[1] != "":
run_case("camera.step", arguments[1], true, view)
codec_case("camera.step", arguments[1], true)
cad_drag_case("camera.step", arguments[1], view)
view.close()
return 0