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)