dymokomi/luce-browser-render
Source of release 0.6.1
0.6.1 / src / display_list / tests_cpu_canvas.lucb
#==============================================================================================
#
# tests_cpu_canvas - the CPU canvas: states, clips, layers, culling and shapes
#
# DESCRIPTION:
# Tests of the CpuCanvas mechanics the player relies on, with expectations that
# follow from SkCanvas's documented behaviour: save/restore bookkeeping, integer and
# anti-aliased clips, clip differences, quickReject's one-pixel outset, layer
# compositing (opacity, the luminance color filter, plus-darker) and SkRRect's radius
# normalization. The mask blur is checked against Skia in tests_cpu_shadow_skia.lucb.
#
#==============================================================================================
## The premultiplied pixel at (x, y) of the canvas, as 0xAARRGGBB.
func test_canvas_pixel(canvas: CpuCanvas*, x: u32, y: u32) -> u32:
let p = cpu_canvas_pixmap(canvas).pixel(x, y) else trap("pixel outside the canvas")
return ((u32)p.alpha() << 24) | ((u32)p.red() << 16) | ((u32)p.green() << 8) | (u32)p.blue()
## Traps unless the pixel at (x, y) is `expected`.
func expect_pixel(canvas: CpuCanvas*, x: u32, y: u32, expected: u32):
let actual = test_canvas_pixel(canvas, x, y)
if actual != expected:
print(f"pixel ({x}, {y}): expected {expected:x}, got {actual:x}")
trap("pixel mismatch")
## A raster rectangle.
func test_raster_rect(x: f32, y: f32, width: f32, height: f32) -> raster.Rect:
return raster.Rect.from_xywh(x, y, width, height) else trap("bad rectangle")
## Fills the whole canvas with `color` through the current clip.
func test_fill_everything(canvas: CpuCanvas*, color: gfx.Color):
let paint = cpu_color_paint(color, true)
cpu_canvas_fill_rect(canvas, test_raster_rect(-100.0, -100.0, 1000.0, 1000.0), &paint)
# mark: States and clips =======================================================================
test "cpu canvas: save, restore and the save count":
let canvas = cpu_canvas_create(8, 8)
defer cpu_canvas_release(canvas)
assert(cpu_canvas_save_count(canvas) == 1)
cpu_canvas_save(canvas)
cpu_canvas_translate(canvas, 2.0, 3.0)
cpu_canvas_save_layer(canvas, CpuLayerEffects())
assert(cpu_canvas_save_count(canvas) == 3)
assert(cpu_canvas_transform(canvas).tx == 2.0 and cpu_canvas_transform(canvas).ty == 3.0)
cpu_canvas_restore(canvas)
cpu_canvas_restore(canvas)
assert(cpu_canvas_save_count(canvas) == 1)
assert(cpu_canvas_transform(canvas).is_identity())
# A restore with nothing saved is ignored, as SkCanvas does.
cpu_canvas_restore(canvas)
assert(cpu_canvas_save_count(canvas) == 1)
test "cpu canvas: an integer clip narrows the bounds, restore widens them":
let canvas = cpu_canvas_create(8, 8)
defer cpu_canvas_release(canvas)
assert(cpu_canvas_draw_mask(canvas) == none)
cpu_canvas_save(canvas)
cpu_canvas_translate(canvas, 1.0, 1.0)
cpu_canvas_clip_rect(canvas, test_raster_rect(1.0, 2.0, 3.0, 2.0), true)
let state = cpu_canvas_state(canvas)
assert(state.clip_left == 2 and state.clip_top == 3 and state.clip_right == 5 and state.clip_bottom == 5)
assert(not state.has_clip_mask)
test_fill_everything(canvas, test_color(255, 0, 0, 255))
cpu_canvas_restore(canvas)
assert(cpu_canvas_draw_mask(canvas) == none)
expect_pixel(canvas, 2, 3, 0xffff0000)
expect_pixel(canvas, 4, 4, 0xffff0000)
expect_pixel(canvas, 1, 3, 0)
expect_pixel(canvas, 5, 4, 0)
expect_pixel(canvas, 3, 5, 0)
test "cpu canvas: an anti-aliased fractional clip":
let canvas = cpu_canvas_create(8, 8)
defer cpu_canvas_release(canvas)
cpu_canvas_clip_rect(canvas, test_raster_rect(1.5, 1.0, 3.0, 4.0), true)
let state = cpu_canvas_state(canvas)
assert(state.has_clip_mask)
assert(state.clip_left == 1 and state.clip_right == 5)
test_fill_everything(canvas, test_color(0, 0, 255, 255))
expect_pixel(canvas, 1, 2, 0x80000080)
expect_pixel(canvas, 2, 2, 0xff0000ff)
expect_pixel(canvas, 4, 2, 0x80000080)
expect_pixel(canvas, 5, 2, 0)
expect_pixel(canvas, 2, 0, 0)
test "cpu canvas: an empty clip draws nothing and rejects everything":
let canvas = cpu_canvas_create(8, 8)
defer cpu_canvas_release(canvas)
cpu_canvas_save(canvas)
cpu_canvas_clip_rect(canvas, test_raster_rect(1.0, 1.0, 2.0, 2.0), true)
cpu_canvas_clip_rect(canvas, test_raster_rect(5.0, 5.0, 2.0, 2.0), true)
assert(cpu_canvas_is_clip_empty(canvas))
assert(cpu_canvas_quick_reject(canvas, test_raster_rect(0.0, 0.0, 8.0, 8.0)))
test_fill_everything(canvas, test_color(255, 0, 0, 255))
cpu_canvas_restore(canvas)
expect_pixel(canvas, 1, 1, 0)
expect_pixel(canvas, 5, 5, 0)
assert(not cpu_canvas_quick_reject(canvas, test_raster_rect(0.0, 0.0, 8.0, 8.0)))
test "cpu canvas: a difference clip keeps the outside":
let canvas = cpu_canvas_create(8, 8)
defer cpu_canvas_release(canvas)
var path = cpu_rect_path(test_raster_rect(2.0, 2.0, 4.0, 4.0))
defer path.release()
cpu_canvas_clip_path(canvas, &path, raster.FillRule.winding, true, true)
test_fill_everything(canvas, test_color(0, 255, 0, 255))
expect_pixel(canvas, 1, 1, 0xff00ff00)
expect_pixel(canvas, 3, 3, 0)
expect_pixel(canvas, 6, 6, 0xff00ff00)
test "cpu canvas: quick reject outsets the clip by one pixel":
let canvas = cpu_canvas_create(16, 16)
defer cpu_canvas_release(canvas)
cpu_canvas_clip_rect(canvas, test_raster_rect(4.0, 4.0, 4.0, 4.0), true)
# The quick-reject bounds are [3, 9) x [3, 9).
assert(not cpu_canvas_quick_reject(canvas, test_raster_rect(8.5, 4.0, 2.0, 2.0)))
assert(cpu_canvas_quick_reject(canvas, test_raster_rect(9.0, 4.0, 2.0, 2.0)))
assert(cpu_canvas_quick_reject(canvas, test_raster_rect(0.0, 0.0, 3.0, 3.0)))
assert(not cpu_canvas_quick_reject(canvas, test_raster_rect(0.0, 0.0, 3.5, 3.5)))
# In the current transform.
cpu_canvas_translate(canvas, 10.0, 0.0)
assert(cpu_canvas_quick_reject(canvas, test_raster_rect(4.0, 4.0, 2.0, 2.0)))
assert(not cpu_canvas_quick_reject(canvas, test_raster_rect(-4.0, 4.0, 2.0, 2.0)))
# mark: Layers =================================================================================
test "cpu canvas: a layer's opacity and the clip it is composited through":
let canvas = cpu_canvas_create(8, 8)
defer cpu_canvas_release(canvas)
cpu_canvas_save(canvas)
cpu_canvas_clip_rect(canvas, test_raster_rect(0.0, 0.0, 4.0, 8.0), true)
cpu_canvas_save_layer(canvas, CpuLayerEffects(opacity = 0.5))
# Clips inside the layer only affect drawing into it.
test_fill_everything(canvas, test_color(255, 255, 255, 255))
cpu_canvas_restore(canvas)
cpu_canvas_restore(canvas)
expect_pixel(canvas, 1, 1, 0x80808080)
expect_pixel(canvas, 5, 1, 0)
test "cpu canvas: the luminance color filter":
var pixmap = raster.Pixmap.new_(3, 1) else trap("pixmap")
defer pixmap.release()
let pixels = pixmap.pixels_mut()
pixels[0] = raster.PremultipliedColorU8.from_rgba(255, 255, 255, 255) else trap("color")
pixels[1] = raster.PremultipliedColorU8.from_rgba(255, 0, 0, 255) else trap("color")
pixels[2] = raster.PremultipliedColorU8.from_rgba(0, 64, 0, 128) else trap("color")
cpu_luminance_to_alpha(&pixmap)
let out = pixmap.pixels()
assert(out[0].alpha() == 255 and out[0].red() == 0)
# 0.2126 * 255 = 54.2
assert(out[1].alpha() == 54)
# The unpremultiplied green is 0.5, its luma 0.3576, times alpha 0.502: 46.
assert(out[2].alpha() == 46)
test "cpu canvas: plus-darker":
var target = raster.Pixmap.new_(1, 1) else trap("pixmap")
defer target.release()
var source = raster.Pixmap.new_(1, 1) else trap("pixmap")
defer source.release()
target.pixels_mut()[0] = raster.PremultipliedColorU8.from_rgba(200, 100, 0, 255) else trap("color")
source.pixels_mut()[0] = raster.PremultipliedColorU8.from_rgba(51, 102, 153, 204) else trap("color")
cpu_composite_plus_darker(&target, 0, 0, &source, 1.0, none)
# saturate(saturate(da + sa) - saturate(da - d) - saturate(sa - s)) per channel.
let p = target.pixels()[0]
assert(p.alpha() == 255)
assert(p.red() == 47)
assert(p.green() == 0)
assert(p.blue() == 0)
# mark: Rounded rectangles =====================================================================
test "cpu shapes: rounded-rect radii are scaled to fit, as SkRRect does":
let rect = test_raster_rect(0.0, 0.0, 10.0, 20.0)
let fitting = cpu_normalize_radii(rect, cpu_uniform_radii(3.0, 4.0))
assert(fitting.x == [3.0, 3.0, 3.0, 3.0] and fitting.y == [4.0, 4.0, 4.0, 4.0])
# 8 + 8 > 10 across: every radius is scaled by 10 / 16.
let scaled = cpu_normalize_radii(rect, cpu_uniform_radii(8.0, 8.0))
assert(scaled.x == [5.0, 5.0, 5.0, 5.0] and scaled.y == [5.0, 5.0, 5.0, 5.0])
# A corner with one zero radius is square.
let corners = cpu_normalize_radii(rect, CpuRadii(x = [2.0, 0.0, 3.0, 1.0], y = [2.0, 5.0, 0.0, 1.0]))
assert(corners.x == [2.0, 0.0, 0.0, 1.0] and corners.y == [2.0, 0.0, 0.0, 1.0])
test "gfx conversions: to_type and to_rounded":
let point = float_point_to_int_point(gfx.FloatPoint(m_x = -1.7, m_y = 2.9))
assert(point.m_x == -1 and point.m_y == 2)
let rect = float_rect_to_rounded_int_rect(gfx.FloatRect(m_location = gfx.FloatPoint(m_x = 1.5, m_y = 2.5), m_size = gfx.FloatSize(m_width = 3.4, m_height = -0.6)))
# AK::round_to rounds half to even (rintf).
assert(rect == test_rect(2, 2, 3, -1))
let floats = int_rect_to_float_rect(test_rect(-3, 4, 5, 6))
assert(floats.m_location.m_x == -3.0 and floats.m_size.m_height == 6.0)