Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-image

Source of release 0.45.1

0.45.1 / src / canvas / graph_tests.lucb

#==============================================================================================
#
#   canvas/graph_tests - Node graphs on a vector layer: files, steps and the cells an edit draws
#
#==============================================================================================

## Layer `id`'s pixels read back into `pixels`.
func graph_pixels(canvas: Canvas*, id: i64, pixels: f32[]) -> !:
    let document = canvas.document else trap("bound")
    try ((document.find((u64)id) else trap("layer")).tiles() else trap("tiles")).read(pixels)

func graph_alpha(pixels: const f32[], width: usize, x: usize, y: usize) -> f32:
    return pixels[(y * width + x) * 4 + 3]

## The node of `kind` in the layer at `index`'s graph, by id.
func node_of(canvas: Canvas*, index: i64, kind: i64) -> i64!:
    for node in 0..<(try canvas.graph_node_count(index)):
        if (try canvas.graph_node_value(index, node, 1)) == (f64)kind:
            return (i64)(try canvas.graph_node_value(index, node, 0))
    trap("no such node")

test "a new vector layer draws its default graph; edits are steps, undone and saved":
    var canvas = try Canvas(800, 600)
    defer canvas.close()
    _ = try canvas.add_layer("Background")
    canvas.bind_headless() catch failure:
        assert(failure.code == gpu.unavailable)
        return
    let layer = try canvas.add_vector_layer("Vector 1")
    assert((try canvas.layer_shaped(1)) and canvas.undo_name() == "New Vector Layer")
    assert((try canvas.graph_node_count(1)) == 4 and (try canvas.graph_link_count(1)) == 3 and (try canvas.generated_count(1)) == 12)
    let pixels = try new f32[800 * 600 * 4] --- in memory.heap
    defer free(pixels) in memory.heap
    try graph_pixels(&canvas, layer, pixels)
    # The top star of the ring sits above the middle; the middle itself is clear.
    let radius = 600.0 * 0.32
    assert(graph_alpha(pixels, 800, 400, (usize)(300.0 - radius)) > 0.99 and graph_alpha(pixels, 800, 400, 300) < 0.01)
    # More stars round the ring: a step of its own, undone.
    let circle = try node_of(&canvas, 1, node_circle)
    try canvas.set_graph_value(layer, circle, 0, 20.0)
    assert(canvas.undo_name() == "Node Setting" and (try canvas.generated_count(1)) == 20)
    try canvas.set_graph_value(layer, circle, 0, 24.0)
    assert((try canvas.generated_count(1)) == 24)
    try canvas.undo()
    assert((try canvas.generated_count(1)) == 12 and (try canvas.graph_node_value(1, 1, 4)) == 12.0)
    try canvas.redo()
    assert((try canvas.generated_count(1)) == 24)
    # A square wired in instead of the star; the old wire's gone, both nodes kept.
    let square = try canvas.add_graph_node(layer, node_rectangle, 0.0, 0.0)
    let clone = try node_of(&canvas, 1, node_clone)
    try canvas.link_graph(layer, square, clone, 0)
    assert((try canvas.graph_link_count(1)) == 3 and canvas.undo_name() == "Connect")
    try canvas.unlink_graph(layer, clone, 0)
    assert((try canvas.generated_count(1)) == 0 and (try canvas.graph_link_count(1)) == 2)
    try graph_pixels(&canvas, layer, pixels)
    assert(graph_alpha(pixels, 800, 400, (usize)(300.0 - radius)) < 0.01)
    try canvas.undo()
    assert((try canvas.generated_count(1)) == 24)
    try canvas.delete_graph_node(layer, square)
    assert((try canvas.graph_node_count(1)) == 4 and (try canvas.graph_link_count(1)) == 2 and (try canvas.generated_count(1)) == 0)
    try canvas.undo()
    # A node moved in the editor draws nothing new, but is a step.
    try canvas.move_graph_node(layer, square, 300.0, 500.0)
    assert(canvas.undo_name() == "Move Node" and (try canvas.graph_node_value(1, 4, 2)) == 300.0)
    # Saved and opened: the same graph, which puts out the same shapes.
    let path = "build/canvas-graph.l2d"
    try canvas.save_package(path)
    let reopened = try Canvas.open(path)
    defer reopened.release()
    let opened = reopened.value()
    assert((try opened.graph_node_count(1)) == 5 and (try opened.graph_link_count(1)) == 3)
    for node in 0..<(i64)5:
        for field in 0..<(i64)28:
            assert((try opened.graph_node_value(1, node, field)) == (try canvas.graph_node_value(1, node, field)))
    for link in 0..<(i64)3:
        for field in 0..<(i64)3:
            assert((try opened.graph_link_value(1, link, field)) == (try canvas.graph_link_value(1, link, field)))
    assert((try opened.generated_count(1)) == 24)
    # Undone back to before the layer, it is gone.
    while canvas.can_undo():
        try canvas.undo()
    assert(canvas.layer_count() == 1)

test "a Path node takes a hand-made element and follows it when it changes":
    var canvas = try Canvas(400, 300)
    defer canvas.close()
    let layer = try canvas.add_layer("Vector")
    canvas.bind_headless() catch failure:
        assert(failure.code == gpu.unavailable)
        return
    try canvas.set_shape(layer, 0, 10.0, 10.0, 20.0, 20.0, 5, 0.0, true, 1.0, 0.0, 0.0, false, 0.0, 0.0, 0.0, 1.0)
    let output = try canvas.add_graph_node(layer, node_output, 0.0, 0.0)
    let path = try canvas.add_graph_node(layer, node_path, 0.0, 0.0)
    try canvas.set_graph_value(layer, path, (i64)slot_x, 200.0)
    try canvas.link_graph(layer, path, output, 0)
    assert((try canvas.generated_count(0)) == 1)
    let pixels = try new f32[400 * 300 * 4] --- in memory.heap
    defer free(pixels) in memory.heap
    try graph_pixels(&canvas, layer, pixels)
    assert(graph_alpha(pixels, 400, 20, 20) > 0.99 and graph_alpha(pixels, 400, 220, 20) > 0.99)
    # The element moved alone: its copy follows it.
    try canvas.set_active_element(layer, 0)
    try canvas.move_layer(layer, 0, 100)
    try graph_pixels(&canvas, layer, pixels)
    assert(graph_alpha(pixels, 400, 220, 20) < 0.01 and graph_alpha(pixels, 400, 220, 120) > 0.99)

test "a graph edit draws again only the cells its changed shapes cover, at 15000 by 24000":
    # Thousands of shapes' drawing is more than the test's fixed buffer holds.
    with memory.heap:
        try many_stars()

func many_stars() -> !:
    var canvas = try Canvas(15000, 24000)
    defer canvas.close()
    _ = try canvas.add_layer("Background")
    canvas.bind_headless() catch failure:
        assert(failure.code == gpu.unavailable)
        return
    let started = time.now()
    let layer = try canvas.add_vector_layer("Stars")
    # Thousands of stars: a 60 by 80 grid over the canvas, and the default ring.
    let star = try node_of(&canvas, 1, node_star)
    try canvas.set_graph_value(layer, star, (i64)slot_width, 90.0)
    try canvas.set_graph_value(layer, star, (i64)slot_height, 90.0)
    let grid = try canvas.add_graph_node(layer, node_grid, 0.0, 0.0)
    try canvas.set_graph_value(layer, grid, 0, 60.0)
    try canvas.set_graph_value(layer, grid, 1, 80.0)
    try canvas.set_graph_value(layer, grid, 2, 240.0)
    try canvas.set_graph_value(layer, grid, 3, 290.0)
    try canvas.set_graph_value(layer, grid, 4, 7500.0)
    try canvas.set_graph_value(layer, grid, 5, 12000.0)
    let field = try canvas.add_graph_node(layer, node_clone, 0.0, 0.0)
    try canvas.link_graph(layer, star, field, 0)
    try canvas.link_graph(layer, grid, field, 1)
    let both = try canvas.add_graph_node(layer, node_merge, 0.0, 0.0)
    let ring = try node_of(&canvas, 1, node_clone)
    let output = try node_of(&canvas, 1, node_output)
    try canvas.link_graph(layer, field, both, 0)
    try canvas.link_graph(layer, ring, both, 1)
    let built = time.now()
    try canvas.link_graph(layer, both, output, 0)
    let drawn_at = time.now()
    assert((try canvas.generated_count(1)) == 4812)
    let document = canvas.document else trap("bound")
    let tiles = (document.find((u64)layer) else trap("layer")).tiles() else trap("tiles")
    let columns = tiles.columns()
    let rows = tiles.rows()
    let before = try new u64[(usize)columns * (usize)rows] --- in memory.heap
    defer free(before) in memory.heap
    for row in 0..<rows:
        for column in 0..<columns:
            before[(usize)row * (usize)columns + (usize)column] = tiles.stamp(column, row)
    # The ring's radius changed: its twelve stars move, the grid's 4800 stay.
    var expected = try CellMask.create(15000, 24000)
    defer expected.close()
    for at in 4800..<(usize)4812:
        try expected.mark_spec(canvas.records[1].generated.specs[at])
    let circle = try node_of(&canvas, 1, node_circle)
    let edit = time.now()
    try canvas.set_graph_value(layer, circle, 1, 5000.0)
    let edited = time.now()
    assert(canvas.records[1].graph_evaluated == 3)
    for at in 4800..<(usize)4812:
        try expected.mark_spec(canvas.records[1].generated.specs[at])
    let after = (document.find((u64)layer) else trap("layer")).tiles() else trap("tiles")
    var changed: usize = 0
    for row in 0..<rows:
        for column in 0..<columns:
            if after.stamp(column, row) != before[(usize)row * (usize)columns + (usize)column]:
                changed += 1
                assert(expected.marked(column, row))
    assert(changed > 0 and changed <= expected.count())
    print(f"graph timing: layer {(built - started) // 1000000} ms, 4812 stars drawn {(drawn_at - built) // 1000000} ms, ring edit {(edited - edit) // 1000000} ms over {changed} cells")