dymokomi/luce-image
Source of release 0.45.1
0.45.1 / src / canvas / package_tests.lucb
#==============================================================================================
#
# canvas/package_tests - The .l2d file: exact tiles, shared tiles, safe saves, budgets
#
#==============================================================================================
## Whether cell (`column`, `row`) holds the same half floats in both stores.
func same_cell(a: const Tiles*, b: const Tiles*, column: u32, row: u32) -> bool!:
let first = try new f32[(usize)tile_size * (usize)tile_size * 4] --- in memory.heap
defer free(first) in memory.heap
let second = try new f32[(usize)tile_size * (usize)tile_size * 4] --- in memory.heap
defer free(second) in memory.heap
try a.read_cell(column, row, first)
try b.read_cell(column, row, second)
let rows = (usize)a.region(column, row).height
let columns = (usize)a.region(column, row).width
for y in 0..<rows:
for x in 0..<columns:
for channel in 0..<(usize)4:
let at = (y * (usize)tile_size + x) * 4 + channel
if first[at] != second[at]:
return false
return true
## Whether every canvas cell of two stores holds the same half floats and
## the same cells are painted.
func same_tiles(a: const Tiles*, b: const Tiles*) -> bool!:
for row in 0..<a.rows():
for column in 0..<a.columns():
if a.painted(column, row) != b.painted(column, row):
return false
if a.painted(column, row) and not (try same_cell(a, b, column, row)):
return false
return true
test "an .l2d keeps every layer's exact half floats, its mask, groups, adjustments and pixels past the canvas":
var device = gpu.Device.open() catch failure:
assert(failure.code == gpu.unavailable)
return
defer device.destroy()
# Partial cells at the right and bottom edges.
var canvas = try Canvas(700, 500)
defer canvas.close()
let paint = 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(paint, 0.0, 0.0, 700.0, 500.0, 0.1, 0.7, 0.3, 1.0, 0.9, 0.2, 0.6, 0.4)
# A second layer moved partly past the canvas.
let moved = try canvas.add_layer("Moved")
try canvas.fill_gradient(moved, 0.0, 0.0, 700.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 1.0)
try canvas.move_layer(moved, 450, 120)
# A mask painted half black, a group and an adjustment layer.
try canvas.set_mask(paint, true)
canvas.edit_mask(true)
try canvas.select_rectangle(0, 0, 350, 500)
try canvas.set_brush(40.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, false)
try canvas.fill(paint, false)
try canvas.deselect()
canvas.edit_mask(false)
_ = try canvas.add_group("Group")
_ = try canvas.add_adjustment_layer("Levels", 1)
_ = try shown_at(&canvas, &target, 0, 0)
try canvas.save_package("build/package-exact.l2d")
let opened = try Canvas.open("build/package-exact.l2d")
defer opened.release()
var restored = opened.value()
_ = try shown_at(restored, &target, 0, 0)
assert(restored.layer_count() == 4 and (try restored.layer_name(2)) == "Group")
let before = canvas.document else trap("bound")
let after = restored.document else trap("bound")
for id in [paint, moved]:
let was = (before.find((u64)id) else trap("layer")).tiles() else trap("pixels")
let now = (after.find((u64)id) else trap("layer")).tiles() else trap("pixels")
assert(try same_tiles(was, now))
# The moved layer still reaches past the canvas, to the same box.
assert(try canvas.measure_content(moved))
let box = canvas.content
assert(try restored.measure_content(moved))
assert(restored.content.left == box.left and restored.content.right == box.right and restored.content.right > 700)
# The mask, exactly.
let mask_was = (before.find((u64)paint) else trap("layer")).mask_tiles() else trap("mask")
let mask_now = (after.find((u64)paint) else trap("layer")).mask_tiles() else trap("mask")
assert(try same_tiles(mask_was, mask_now))
test "a tile shared by many cells is stored once and comes back shared":
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("Fill")
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.set_brush(40.0, 1.0, 1.0, 1.0, 0.2, 0.4, 0.6, false)
try canvas.fill(layer, false)
try canvas.save_package("build/package-shared.l2d")
var text: u8[]
var source = try read_package("build/package-shared.l2d", &text)
defer source.destroy()
defer free(text) in memory.heap
assert(source.cells.length == 16 and source.blobs.length == 1)
let opened = try Canvas.open("build/package-shared.l2d")
defer opened.release()
_ = try shown_at(opened.value(), &target, 0, 0)
let tiles = ((opened.value().document else trap("bound")).find((u64)layer) else trap("layer")).tiles() else trap("pixels")
assert(tiles.stamp(0, 0) != 0 and tiles.stamp(0, 0) == tiles.stamp(3, 3))
test "a save that cannot finish leaves the document already on disk as it was":
var device = gpu.Device.open() catch failure:
assert(failure.code == gpu.unavailable)
return
defer device.destroy()
var canvas = try Canvas(300, 200)
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, 300.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0)
files.remove_tree((c_api.str)"build/package-keep.l2d.saving") catch failure:
_ = failure
try canvas.save_package("build/package-keep.l2d")
let kept = try files.read((c_api.str)"build/package-keep.l2d")
defer kept.release()
# Something in the way of the file being written: the save fails.
try files.create_directory((c_api.str)"build/package-keep.l2d.saving")
try canvas.fill_gradient(layer, 0.0, 0.0, 300.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0)
var failed = false
canvas.save_package("build/package-keep.l2d") catch failure:
_ = failure
failed = true
assert(failed)
let after = try files.read((c_api.str)"build/package-keep.l2d")
defer after.release()
assert(after.value.length == kept.value.length and (str)after.value == (str)kept.value)
try files.remove_tree((c_api.str)"build/package-keep.l2d.saving")
test "a document past its memory budget saves and opens within it, pixels unchanged":
var device = gpu.Device.open() catch failure:
assert(failure.code == gpu.unavailable)
return
defer device.destroy()
var canvas = try Canvas(1500, 1100)
defer canvas.close()
defer residency_budgets(0, 0)
var target = try gpu.Texture.create(device, 256, 192, gpu.Format.rgba8_linear)
defer target.destroy()
var reference: u8[196608]
var seen: u8[196608]
try frame_pixels(&canvas, &target, 1.0, -600.0, -500.0, reference)
# Four tiles of GPU and eight of RAM against four layers of thirty tiles each.
try canvas.set_memory_budgets(4 * 524288, 8 * 524288)
for index in 0..<(usize)4:
let layer = try canvas.add_layer("Layer")
let f = (f64)index / 4.0
try canvas.fill_gradient(layer, f * 100.0, 0.0, 1500.0 - f * 100.0, 1100.0, 0.1 + f * 0.6, 0.8 - f * 0.5, 0.4, 1.0 if index == 0 else 0.35,
0.8 - f * 0.2, 0.3 + f * 0.5, 0.7, 1.0 if index == 0 else 0.25)
try frame_pixels(&canvas, &target, 1.0, -600.0, -500.0, seen)
try canvas.settle_memory()
try frame_pixels(&canvas, &target, 0.25, 0.0, 0.0, reference)
try canvas.save_package("build/package-budget.l2d")
assert(canvas.memory_ram_bytes() <= 8 * 524288)
let written = canvas.memory_disk_bytes()
let opened = try Canvas.open("build/package-budget.l2d")
defer opened.release()
try frame_pixels(opened.value(), &target, 0.25, 0.0, 0.0, seen)
assert(seen == reference)
# The opened tiles are backed by the file: past the budget they leave without
# being written to the scratch file, and the GPU keeps within the budget (and
# a batch of slack) once the load settles.
try opened.value().settle_memory()
assert(opened.value().memory_disk_bytes() <= written)
assert(opened.value().memory_gpu_bytes() <= 4 * 524288 + 32 * 524288)
# Panning over tiles that left comes back exact, read from the file.
try frame_pixels(opened.value(), &target, 1.0, -600.0, -500.0, seen)
try frame_pixels(&canvas, &target, 1.0, -600.0, -500.0, reference)
assert(seen == reference)
test "the selected layer is saved with the document and comes back":
var device = gpu.Device.open() catch failure:
assert(failure.code == gpu.unavailable)
return
defer device.destroy()
var canvas = try Canvas(300, 200)
defer canvas.close()
_ = try canvas.add_layer("Background")
_ = try canvas.add_layer("Top")
var target = try gpu.Texture.create(device, 64, 64, gpu.Format.rgba8_linear)
defer target.destroy()
_ = try shown_at(&canvas, &target, 0, 0)
assert(canvas.selected_layer() == -1)
canvas.set_selected_layer(1)
try canvas.save_package("build/package-selected.l2d")
let opened = try Canvas.open("build/package-selected.l2d")
defer opened.release()
assert(opened.value().selected_layer() == 1)
test "a document saved over the file it came from keeps every pixel, and undo still reaches before the save":
var device = gpu.Device.open() catch failure:
assert(failure.code == gpu.unavailable)
return
defer device.destroy()
defer residency_budgets(0, 0)
var target = try gpu.Texture.create(device, 256, 192, gpu.Format.rgba8_linear)
defer target.destroy()
var first: u8[196608]
var second: u8[196608]
var seen: u8[196608]
# A document on disk, then opened from it: its tiles are backed by that file.
var canvas = try Canvas(1200, 900)
defer canvas.close()
let layer = try canvas.add_layer("Paint")
_ = try shown_at(&canvas, &target, 0, 0)
try canvas.fill_gradient(layer, 0.0, 0.0, 1200.0, 900.0, 0.2, 0.6, 0.3, 1.0, 0.9, 0.1, 0.7, 1.0)
try canvas.save_package("build/package-over.l2d")
let opened = try Canvas.open("build/package-over.l2d")
defer opened.release()
let document = opened.value()
try document.set_memory_budgets(4 * 524288, 4 * 524288)
try frame_pixels(document, &target, 0.25, 0.0, 0.0, first)
# An edit, then the document saved over its own file.
try document.select_rectangle(100, 100, 600, 500)
try document.set_brush(40.0, 1.0, 1.0, 1.0, 0.1, 0.2, 0.9, false)
try document.fill(try document.layer_id(0), false)
try document.deselect()
try frame_pixels(document, &target, 0.25, 0.0, 0.0, second)
try document.save_package("build/package-over.l2d")
try document.settle_memory()
# What the document shows now, read back through the new file.
try frame_pixels(document, &target, 0.25, 0.0, 0.0, seen)
assert(seen == second)
let again = try Canvas.open("build/package-over.l2d")
defer again.release()
try frame_pixels(again.value(), &target, 0.25, 0.0, 0.0, seen)
assert(seen == second)
# Undo (deselect, fill, select) reaches the pixels from before, which only
# history held: they left the old file before it was replaced.
try document.undo()
try document.undo()
try document.undo()
try frame_pixels(document, &target, 0.25, 0.0, 0.0, seen)
assert(seen == first)