Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-image

Source of release 0.45.1

0.45.1 / src / canvas / paint_tests.lucb

#==============================================================================================
#
#   canvas/paint_tests - Strokes, the pencil, fills and gradients
#
#==============================================================================================

test "canvas strokes paint the selected layer and undo restores it":
    var device = gpu.Device.open() catch failure:
        assert(failure.code == gpu.unavailable)
        return
    defer device.destroy()
    var canvas = try Canvas(64, 64)
    defer canvas.close()
    let layer = try canvas.add_layer("Paint")
    var rejected = false
    canvas.begin_stroke(layer, 10.0, 10.0) catch failure:
        assert(failure.code == invalid)
        rejected = true
    assert(rejected)
    var target = try gpu.Texture.create(device, 64, 64, gpu.Format.rgba8_linear)
    defer target.destroy()
    let frame = try target.frame()
    defer frame.release()
    let root = try frame.value().target()
    defer root.release()
    try canvas.draw(root, gpu.Rect(width = 64.0, height = 64.0), 1.0, 0.0, 0.0)
    _ = try frame.value().present(gpu.Color(0.0, 0.0, 0.0, 1.0))
    try canvas.set_brush(10.0, 1.0, 1.0, 1.0, 0.0, 1.0, 0.0, false)
    try canvas.begin_stroke(layer, 8.0, 32.0)
    assert(canvas.painting())
    try canvas.extend_stroke(56.0, 32.0)
    try canvas.end_stroke()
    assert(canvas.can_undo() and not canvas.can_redo())
    let second = try target.frame()
    defer second.release()
    let again = try second.value().target()
    defer again.release()
    try canvas.draw(again, gpu.Rect(width = 64.0, height = 64.0), 1.0, 0.0, 0.0)
    _ = try second.value().present(gpu.Color(0.0, 0.0, 0.0, 1.0))
    var pixel: u8[4]
    try target.read(pixel, gpu.Region(32, 32, 1, 1))
    assert(pixel[1] == 255 and pixel[0] == 0)
    try target.read(pixel, gpu.Region(32, 5, 1, 1))
    assert(pixel[1] == 0)
    try canvas.undo()
    assert(not canvas.can_undo() and canvas.can_redo())
    let third = try target.frame()
    defer third.release()
    let once_more = try third.value().target()
    defer once_more.release()
    try canvas.draw(once_more, gpu.Rect(width = 64.0, height = 64.0), 1.0, 0.0, 0.0)
    _ = try third.value().present(gpu.Color(0.0, 0.0, 0.0, 1.0))
    try target.read(pixel, gpu.Region(32, 32, 1, 1))
    assert(pixel[1] == 0)
    try canvas.redo()
    assert(canvas.can_undo() and not canvas.can_redo())
    # Inverting the painted layer turns its green stroke magenta, undoably.
    try canvas.adjust_layer(layer, 2)
    let fourth = try target.frame()
    defer fourth.release()
    let last = try fourth.value().target()
    defer last.release()
    try canvas.draw(last, gpu.Rect(width = 64.0, height = 64.0), 1.0, 0.0, 0.0)
    _ = try fourth.value().present(gpu.Color(0.0, 0.0, 0.0, 1.0))
    try target.read(pixel, gpu.Region(32, 32, 1, 1))
    assert(pixel[0] == 255 and pixel[1] == 0 and pixel[2] == 255)
    try canvas.undo()
    assert(canvas.can_redo())
    # A mask painted black over the stroke's middle hides it there; undoing the
    # mask stroke shows it again.
    try canvas.set_mask(layer, true)
    assert(try canvas.layer_masked(0))
    canvas.edit_mask(true)
    try canvas.set_brush(12.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, false)
    try canvas.begin_stroke(layer, 32.0, 32.0)
    try canvas.end_stroke()
    canvas.edit_mask(false)
    let fifth = try target.frame()
    defer fifth.release()
    let masked = try fifth.value().target()
    defer masked.release()
    try canvas.draw(masked, gpu.Rect(width = 64.0, height = 64.0), 1.0, 0.0, 0.0)
    _ = try fifth.value().present(gpu.Color(0.0, 0.0, 0.0, 1.0))
    try target.read(pixel, gpu.Region(32, 32, 1, 1))
    assert(pixel[1] == 0)
    try target.read(pixel, gpu.Region(12, 32, 1, 1))
    assert(pixel[1] == 255)
    try canvas.undo()
    let sixth = try target.frame()
    defer sixth.release()
    let unmasked = try sixth.value().target()
    defer unmasked.release()
    try canvas.draw(unmasked, gpu.Rect(width = 64.0, height = 64.0), 1.0, 0.0, 0.0)
    _ = try sixth.value().present(gpu.Color(0.0, 0.0, 0.0, 1.0))
    try target.read(pixel, gpu.Region(32, 32, 1, 1))
    assert(pixel[1] == 255)
    try canvas.set_clipped(layer, true)
    assert(try canvas.layer_clipped(0))
    try canvas.set_clipped(layer, false)
    # A selection limits the fill: the left half turns red, the right stays.
    try canvas.select_rectangle(0, 0, 32, 64)
    assert(canvas.has_selection() and canvas.selection_width() == 32 and canvas.selected_at(5, 5) == 255 and canvas.selected_at(40, 5) == 0)
    try canvas.set_brush(10.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, false)
    try canvas.fill(layer, false)
    let seventh = try target.frame()
    defer seventh.release()
    let filled = try seventh.value().target()
    defer filled.release()
    try canvas.draw(filled, gpu.Rect(width = 64.0, height = 64.0), 1.0, 0.0, 0.0)
    _ = try seventh.value().present(gpu.Color(0.0, 0.0, 0.0, 1.0))
    try target.read(pixel, gpu.Region(5, 5, 1, 1))
    assert(pixel[0] == 255 and pixel[1] == 0)
    try target.read(pixel, gpu.Region(50, 5, 1, 1))
    assert(pixel[0] == 0)
    try canvas.deselect()
    assert(not canvas.has_selection())
    # Moving the layer right by 40 pushes the red fill out of the first column.
    try canvas.move_layer(layer, 40, 0)
    let eighth = try target.frame()
    defer eighth.release()
    let moved = try eighth.value().target()
    defer moved.release()
    try canvas.draw(moved, gpu.Rect(width = 64.0, height = 64.0), 1.0, 0.0, 0.0)
    _ = try eighth.value().present(gpu.Color(0.0, 0.0, 0.0, 1.0))
    try target.read(pixel, gpu.Region(5, 5, 1, 1))
    assert(pixel[0] == 0)
    try target.read(pixel, gpu.Region(45, 5, 1, 1))
    assert(pixel[0] == 255)
    try canvas.undo()
    try canvas.blur_layer(layer, 2.0)
    assert(canvas.can_undo())
    # Duplicate above, reorder, merge down: two layers become one with both.
    let twin = try canvas.duplicate_layer(layer, "Twin")
    assert(canvas.layer_count() == 2 and (try canvas.layer_id(1)) == twin and (try canvas.layer_name(1)) == "Twin")
    try canvas.reorder_layer(twin, -1)
    assert((try canvas.layer_id(0)) == twin)
    try canvas.reorder_layer(twin, 1)
    try canvas.merge_down(twin)
    assert(canvas.layer_count() == 1 and (try canvas.layer_id(0)) == layer and canvas.undo_name() == "Merge Down")
    # Merging is one step back: both layers again, then forward to one.
    try canvas.undo()
    assert(canvas.layer_count() == 2 and (try canvas.layer_id(1)) == twin and canvas.redo_name() == "Merge Down")
    try canvas.redo()
    assert(canvas.layer_count() == 1 and (try canvas.layer_id(0)) == layer)
    # The document round-trips through an .l2d package with its layers.
    try canvas.set_mask(layer, true)
    try canvas.save_package("build/canvas-test.l2d")
    let restored = try Canvas.open("build/canvas-test.l2d")
    defer restored.release()
    assert(restored.value().layer_count() == 1 and (try restored.value().layer_name(0)) == "Paint" and (try restored.value().layer_masked(0)))
    let ninth = try target.frame()
    defer ninth.release()
    let shown = try ninth.value().target()
    defer shown.release()
    try restored.value().draw(shown, gpu.Rect(width = 64.0, height = 64.0), 1.0, 0.0, 0.0)
    _ = try ninth.value().present(gpu.Color(0.0, 0.0, 0.0, 1.0))
    # The blurred, moved stroke over the red fill, as it was before saving,
    # mixed as sRGB-encoded values (about 102, 152, 0 in the file; the linear
    # target stores about 34, 80, 0).
    try target.read(pixel, gpu.Region(32, 32, 1, 1))
    assert(pixel[0] > 25 and pixel[0] < 45 and pixel[1] > 70 and pixel[1] < 90 and pixel[2] == 0)
    try target.read(pixel, gpu.Region(12, 32, 1, 1))
    assert(pixel[0] == 255 and pixel[1] == 0)
    try canvas.set_mask(layer, false)
    try canvas.select_ellipse(8, 8, 16, 16)
    try canvas.crop()
    assert(canvas.width() == 16 and canvas.height() == 16 and not canvas.has_selection())
    try canvas.resize_image(32, 8)
    assert(canvas.width() == 32 and canvas.height() == 8)

## The red byte at the centre of a 32×32 draw of `canvas`, for tests.
func shown_centre(canvas: Canvas*, target: gpu.Texture*, pixels: u8[]) -> u8!:
    let frame = try target.frame()
    defer frame.release()
    let root = try frame.value().target()
    defer root.release()
    try canvas.draw(root, gpu.Rect(width = 32.0, height = 32.0), 1.0, 0.0, 0.0)
    _ = try frame.value().present(gpu.Color(0.0, 0.0, 0.0, 1.0))
    try target.read(pixels)
    return pixels[(16 * 32 + 16) * 4]

test "painting one cell leaves every other cached tile alone, and redraws its own tile in place":
    var canvas = try Canvas(600, 300)
    defer canvas.close()
    let layer = try canvas.add_layer("Paint")
    canvas.bind_headless() catch failure:
        assert(failure.code == gpu.unavailable)
        return
    let document = canvas.document else trap("bound")
    var composer = canvas.composer else trap("bound")
    _ = try composer.tile(document, 0, 0, 0)
    _ = try composer.tile(document, 2, 0, 0)
    _ = try composer.tile(document, 0, 0, 1)
    let rendered = composer.renders
    try canvas.set_brush(20.0, 0.5, 1.0, 1.0, 0.0, 0.0, 1.0, false)
    try canvas.begin_stroke(layer, 50.0, 50.0)
    try canvas.extend_stroke(90.0, 60.0)
    try canvas.settle_stroke()
    let tiles = (document.find((u64)layer) else trap("layer")).tiles() else trap("tiles")
    let first = tiles.tile(0, 0) else trap("painted tile")
    let stamp = tiles.stamp(0, 0)
    # Moves between frames only queue dabs.
    try canvas.extend_stroke(120.0, 80.0)
    assert(tiles.stamp(0, 0) == stamp)
    try canvas.settle_stroke()
    # The same tile, drawn again, with a new stamp.
    let again = tiles.tile(0, 0) else trap("painted tile")
    assert(again == first and tiles.stamp(0, 0) != stamp)
    try canvas.end_stroke()
    # Cell (2, 0) is still cached; (0, 0) and the coarser tile over it are not.
    _ = try composer.tile(document, 2, 0, 0)
    assert(composer.renders == rendered)
    _ = try composer.tile(document, 0, 0, 0)
    _ = try composer.tile(document, 0, 0, 1)
    assert(composer.renders == rendered + 2)

## The composited picture's red at (`x`, `y`) in the first cell, as the view draws it.
func composite_red(canvas: Canvas*, x: usize, y: usize) -> f32!:
    let document = canvas.document else trap("bound")
    let composer = canvas.composer else trap("bound")
    let texture = try composer.tile(document, 0, 0, 0)
    let bytes = try new u8[(usize)tile_size * (usize)tile_size * 8] --- in memory.heap
    defer free(bytes) in memory.heap
    try texture.read(bytes)
    let at = (y * (usize)tile_size + x) * 8
    return from_half((u16)bytes[at] | ((u16)bytes[at + 1] << 8))

test "a gradient previews while its ends move, on pixels or on a mask, and keeps as one step":
    var canvas = try Canvas(64, 16)
    defer canvas.close()
    let layer = try canvas.add_layer("Paint")
    canvas.bind_headless() catch failure:
        assert(failure.code == gpu.unavailable)
        return
    let document = canvas.document else trap("bound")
    let pixels = try new f32[(usize)64 * 16 * 4] --- in memory.heap
    defer free(pixels) in memory.heap
    let steps = canvas.step_serial()
    # Black to white along x, then the ends swapped: the left edge turns white.
    try canvas.begin_preview(layer)
    try canvas.preview_gradient(0.0, 8.0, 64.0, 8.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0)
    try canvas.preview_gradient(64.0, 8.0, 0.0, 8.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0)
    # Shown through the compositor while the ends move; the layer keeps its pixels until kept.
    assert((try composite_red(&canvas, 1, 8)) > 0.9 and (try composite_red(&canvas, 62, 8)) < 0.1)
    let unchanged = (document.find((u64)layer) else trap("layer")).tiles() else trap("tiles")
    assert(unchanged.tile(0, 0) == none)
    try canvas.end_preview(true)
    let tiles = (document.find((u64)layer) else trap("layer")).tiles() else trap("tiles")
    try tiles.read(pixels)
    assert(pixels[(8 * 64 + 1) * 4] > 0.9 and pixels[(8 * 64 + 62) * 4] < 0.1)
    assert(canvas.step_serial() == steps + 1 and canvas.undo_name() == "Gradient")
    try canvas.undo()
    let restored = (document.find((u64)layer) else trap("layer")).tiles() else trap("tiles")
    assert(restored.tile(0, 0) == none)
    # On a mask: previewed there, and dropped the mask is white again.
    try canvas.set_mask(layer, true)
    try canvas.begin_preview(layer, true)
    try canvas.preview_gradient(0.0, 8.0, 64.0, 8.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0)
    try canvas.end_preview(false)
    let kept = (document.find((u64)layer) else trap("layer")).mask_tiles() else trap("mask")
    if kept.tile(0, 0) != none:
        try kept.read(pixels)
        assert(pixels[(8 * 64 + 1) * 4] > 0.9)

test "the pencil paints whole pixels, with no soft edge":
    var canvas = try Canvas(64, 32)
    defer canvas.close()
    let layer = try canvas.add_layer("Lines")
    canvas.bind_headless() catch failure:
        assert(failure.code == gpu.unavailable)
        return
    try canvas.set_brush(7.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, false)
    canvas.set_brush_aliased(true)
    try canvas.begin_stroke(layer, 5.3, 10.6)
    try canvas.extend_stroke(50.7, 21.2)
    try canvas.end_stroke()
    let document = canvas.document else trap("bound")
    let pixels = try new f32[64 * 32 * 4] --- in memory.heap
    defer free(pixels) in memory.heap
    try ((document.find((u64)layer) else trap("layer")).tiles() else trap("tiles")).read(pixels)
    var painted = 0
    for at in 0..<(usize)(64 * 32):
        let alpha = pixels[at * 4 + 3]
        assert(alpha < 0.001 or alpha > 0.999)
        if alpha > 0.999:
            painted += 1
    assert(painted > 200)

test "an opaque fill shares one tile over every wholly selected cell, and makes only its edge cells":
    var device = gpu.Device.open() catch failure:
        assert(failure.code == gpu.unavailable)
        return
    defer device.destroy()
    var canvas = try Canvas(1024, 1024)
    defer canvas.close()
    let layer = try canvas.add_layer("Paint")
    var target = try gpu.Texture.create(device, 64, 64, gpu.Format.rgba8_linear)
    defer target.destroy()
    _ = try shown_at(&canvas, &target, 0, 0)
    # 4 by 4 cells; the rectangle holds cells (1..2, 1..2) whole, and edges of the ring round them.
    try canvas.select_rectangle(200, 200, 624, 624)
    let before = tiles_alive()
    try canvas.set_brush(10.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, false)
    try canvas.fill(layer, false)
    let tiles = layer_tiles(&canvas, layer)
    let middle = tiles.stamp(1, 1)
    assert(middle != 0 and tiles.stamp(2, 1) == middle and tiles.stamp(1, 2) == middle and tiles.stamp(2, 2) == middle)
    assert(tiles.stamp(0, 0) != middle and tiles.stamp(0, 0) != tiles.stamp(3, 3))
    # One shared middle tile and twelve edge tiles for the layer; the
    # selection's own GPU tiles came before, when it was drawn or first used.
    assert(tiles_alive() - before <= 13 + 13)
    # The whole layer with nothing selected: one tile for all sixteen cells.
    try canvas.deselect()
    try canvas.fill(layer, false)
    let whole = layer_tiles(&canvas, layer)
    for row in 0..<(u32)4:
        for column in 0..<(u32)4:
            assert(whole.stamp(column, row) == whole.stamp(0, 0))
    let shown = try shown_at(&canvas, &target, 10, 10)
    assert(shown[0] > 200 and shown[1] < 30)

## A fill's tile fault: out of GPU memory once five tiles are made.
func fail_sixth_tile(made: usize) -> !:
    if made == 5:
        error(limit, "out of GPU memory (simulated)")

test "a fill that fails part way leaves the layer as it was, with nothing in the history":
    var device = gpu.Device.open() catch failure:
        assert(failure.code == gpu.unavailable)
        return
    defer device.destroy()
    var canvas = try Canvas(1024, 1024)
    defer canvas.close()
    let layer = try canvas.add_layer("Paint")
    var target = try gpu.Texture.create(device, 64, 64, gpu.Format.rgba8_linear)
    defer target.destroy()
    _ = try shown_at(&canvas, &target, 0, 0)
    try canvas.fill_gradient(layer, 0.0, 0.0, 1024.0, 1024.0, 0.0, 0.0, 1.0, 1.0, 0.0, 1.0, 0.0, 1.0)
    let tiles = layer_tiles(&canvas, layer)
    var stamps: u64[16]
    for index in 0..<(u32)16:
        stamps[(usize)index] = tiles.stamp(index % 4, index // 4)
    try canvas.select_rectangle(100, 100, 700, 700)
    let steps = canvas.undo_steps()
    try canvas.set_brush(10.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, false)
    canvas.fill_fault = fail_sixth_tile
    var failed = false
    canvas.fill(layer, false) catch failure:
        failed = true
        assert(failure.code == limit)
    assert(failed)
    canvas.fill_fault = none
    let kept = layer_tiles(&canvas, layer)
    for index in 0..<(u32)16:
        assert(kept.stamp(index % 4, index // 4) == stamps[(usize)index])
    assert(canvas.undo_steps() == steps)
    # And the next fill works.
    try canvas.fill(layer, false)
    assert(canvas.undo_steps() == steps + 1)