Luce packages
LuceLuce BaseLuciaOS

dymokomi/luced-3d

Source of release 0.11.5

0.11.5 / 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