Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-render

Source of release 0.6.2

0.6.2 / 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)