dymokomi/luce-browser-render
Source of release 0.6.1
0.6.1 / src / display_list / display_list_player_cpu_2.lucb
#==============================================================================================
#
# display_list_player_cpu_2 - the CPU display-list player (2): shadows, paths, effects
#
# DESCRIPTION:
# The second half of DisplayListPlayerCpu (see display_list_player_cpu.lucb), in the
# order of DisplayListPlayerSkia.cpp: box and text shadows, rounded rectangles, the
# SVG paint servers (gradients and patterns, `paint_style_to_skia_paint`), paths,
# ellipses, lines, backdrop filters, rectangles, rounded-rectangle clips, nested
# display lists, scrollbars, effects, transforms, clip paths and culling.
#
# A blurred shape (SkMaskFilter::MakeBlur) is drawn as Skia's raster backend draws
# it: the shape's anti-aliased coverage, blurred with the mask filter's sigma mapped by
# the transform (SkMatrix::mapRadius), then filled with the paint through the clip.
# The inner shadow's path difference (SkPathOps' kDifference) is the outer coverage
# times the inverse of the inner one.
#
# Copyright (c) 2024-2026, Aliaksandr Kalenik <kalenik.aliaksandr@gmail.com>
# Copyright (c) 2025, Jelle Raaijmakers <jelle@ladybird.org>
# Copyright (c) 2026 the luce-browser authors.
# SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================
# mark: Blurred shapes =========================================================================
## The anti-aliased device coverage of `path` in the current transform.
func cpu_canvas_path_coverage(canvas: CpuCanvas*, path: const raster.Path*, fill_rule: raster.FillRule, anti_alias: bool) -> raster.Mask:
var mask = raster.Mask.new_(cpu_canvas_target(canvas).width(), cpu_canvas_target(canvas).height()) else trap("CpuCanvas: empty size")
mask.fill_path(path, fill_rule, anti_alias, cpu_canvas_transform(canvas))
return mask
# mark: Shadows and rounded rectangles =========================================================
## Ported from Libraries/LibWeb/Painting/DisplayListPlayerSkia.h:36 Web::Painting::DisplayListPlayerSkia::paint_outer_box_shadow (override).
func display_list_player_cpu_paint_outer_box_shadow_impl(base: DisplayListPlayer*, command: PaintOuterBoxShadow):
var content_rrect = cpu_rrect_path_for(command.device_content_rect, &command.content_corner_radii) else return
defer content_rrect.release()
let canvas = display_list_player_cpu_canvas((DisplayListPlayerCpu*)base)
cpu_canvas_save(canvas)
cpu_canvas_clip_path(canvas, &content_rrect, raster.FillRule.winding, true, true)
let paint = cpu_color_paint(command.color, true)
# SkMaskFilter::MakeBlur(kNormal_SkBlurStyle, blur_radius / 2) makes no filter for sigma 0.
let sigma = (f32)(command.blur_radius // 2)
if let shadow_rect = cpu_rect(command.shadow_rect):
if sigma > 0.0:
cpu_canvas_fill_rrect_blurred(canvas, shadow_rect, cpu_radii(&command.shadow_corner_radii), &paint, sigma)
else:
var shadow_rounded_rect = cpu_rrect_path(shadow_rect, cpu_radii(&command.shadow_corner_radii))
cpu_canvas_fill_path(canvas, &shadow_rounded_rect, &paint, raster.FillRule.winding)
shadow_rounded_rect.release()
cpu_canvas_restore(canvas)
## Ported from Libraries/LibWeb/Painting/DisplayListPlayerSkia.h:37 Web::Painting::DisplayListPlayerSkia::paint_inner_box_shadow (override).
## Op(outer, inner, kDifference): two rectangles, the inner inside the outer, make the nested
## rectangles Op makes (filterRectsToNine); nested rounded rectangles make the two contours Op
## writes (cpu_inner_shadow_difference), drawn with the blur mask filter. Shapes that touch or
## cross would need SkPathOps' merge, which is not ported: their difference is the outer
## shape's coverage less the inner's.
func display_list_player_cpu_paint_inner_box_shadow_impl(base: DisplayListPlayer*, command: PaintInnerBoxShadow):
let outer_rect = cpu_rect(command.outer_shadow_rect) else return
let inner_rect = cpu_rect(command.inner_shadow_rect) else return
var clip_path = cpu_rrect_path_for(command.device_content_rect, &command.content_corner_radii) else return
defer clip_path.release()
let canvas = display_list_player_cpu_canvas((DisplayListPlayerCpu*)base)
if cpu_canvas_is_clip_empty(canvas):
return
let outer_radii = cpu_normalize_radii(outer_rect, cpu_radii(&command.content_corner_radii))
let inner_radii = cpu_normalize_radii(inner_rect, cpu_radii(&command.inner_shadow_corner_radii))
let path_paint = cpu_color_paint(command.color, true)
let ts = cpu_canvas_transform(canvas)
let sigma = cpu_xformed_sigma(ts, (f32)(command.blur_radius // 2))
cpu_canvas_save(canvas)
cpu_canvas_clip_path(canvas, &clip_path, raster.FillRule.winding, true, false)
defer cpu_canvas_restore(canvas)
let both_rects = cpu_rrect_kind(outer_rect, &outer_radii) == CpuRRectKind.rect and cpu_rrect_kind(inner_rect, &inner_radii) == CpuRRectKind.rect
let inside = inner_rect.left() >= outer_rect.left() and inner_rect.top() >= outer_rect.top() and inner_rect.right() <= outer_rect.right() and inner_rect.bottom() <= outer_rect.bottom()
let nested = both_rects and inside and (ts.is_identity() or ts.is_scale_translate())
if nested and command.blur_radius // 2 > 0:
let outer_device = outer_rect.transform(ts) else return
let inner_device = inner_rect.transform(ts) else return
match cpu_filter_nested_rects_to_nine([outer_device.left(), outer_device.top(), outer_device.right(), outer_device.bottom()],
[inner_device.left(), inner_device.top(), inner_device.right(), inner_device.bottom()], sigma):
.mask(value):
var expanded = value
cpu_canvas_blit_mask(canvas, &expanded, &path_paint)
cpu_a8_mask_release(&expanded)
return
_:
_ = 0
if let difference0 = cpu_inner_shadow_difference(outer_rect, outer_radii, inner_rect, inner_radii):
# SkPathOps' difference of nested rounded rectangles, drawn with the blur mask filter.
var difference = difference0
defer difference.release()
if command.blur_radius // 2 > 0:
var device_path = difference.clone()
defer device_path.release()
if device_path.transform(ts):
cpu_canvas_fill_dev_path_blurred(canvas, &device_path, raster.FillRule.even_odd, &path_paint, sigma)
else:
cpu_canvas_fill_path(canvas, &difference, &path_paint, raster.FillRule.even_odd)
return
# Rectangles that touch or cross, which SkPathOps merges (not ported): the outer coverage
# less the inner one.
var outer_path = cpu_rrect_path(outer_rect, outer_radii)
defer outer_path.release()
var inner_path = cpu_rrect_path(inner_rect, inner_radii)
defer inner_path.release()
var result = cpu_canvas_path_coverage(canvas, &outer_path, raster.FillRule.winding, true)
defer result.release()
var inner = cpu_canvas_path_coverage(canvas, &inner_path, raster.FillRule.winding, true)
defer inner.release()
let result_data = result.data_mut()
let inner_data = inner.data()
for i in 0..<result_data.length:
result_data[i] = raster.premultiply_u8(result_data[i], 255 - inner_data[i])
if command.blur_radius // 2 > 0:
let device_bounds = outer_path.bounds().transform(ts) else return
cpu_canvas_fill_coverage_blurred(canvas, &result, device_bounds, &path_paint, sigma)
else:
cpu_canvas_fill_coverage(canvas, &result, &path_paint)
## Ported from Libraries/LibWeb/Painting/DisplayListPlayerSkia.h:38 Web::Painting::DisplayListPlayerSkia::paint_text_shadow (override).
func display_list_player_cpu_paint_text_shadow_impl(base: DisplayListPlayer*, command: PaintTextShadow):
let canvas = display_list_player_cpu_canvas((DisplayListPlayerCpu*)base)
# SkImageFilters::Blur(blur_radius / 2, blur_radius / 2, nullptr), which answers no filter
# for a negative sigma.
let sigma = (f32)(command.blur_radius // 2)
var blur_filter: gfx.ImageFilter*? = none
if sigma >= 0.0:
blur_filter = new gfx.ImageFilter(node = .blur(sigma_x = sigma, sigma_y = sigma, input = none)) else trap("out of memory")
cpu_canvas_save_layer(canvas, CpuLayerEffects(filter = blur_filter))
let text_location = int_point_to_float_point(command.text_rect.m_location)
display_list_player_cpu_draw_glyph_run_impl(base, DrawGlyphRun(glyph_run = command.glyph_run, rect = command.text_rect,
translation = gfx.FloatPoint(m_x = command.draw_location.m_x + text_location.m_x, m_y = command.draw_location.m_y + text_location.m_y),
color = command.color, orientation = gfx.Orientation.horizontal))
cpu_canvas_restore(canvas)
## Ported from Libraries/LibWeb/Painting/DisplayListPlayerSkia.h:39 Web::Painting::DisplayListPlayerSkia::fill_rect_with_rounded_corners (override).
func display_list_player_cpu_fill_rect_with_rounded_corners_impl(base: DisplayListPlayer*, command: FillRectWithRoundedCorners):
let canvas = display_list_player_cpu_canvas((DisplayListPlayerCpu*)base)
let paint = cpu_color_paint(command.color, true)
var rounded_rect = cpu_rrect_path_for(command.rect, &command.corner_radii) else return
defer rounded_rect.release()
cpu_canvas_fill_path(canvas, &rounded_rect, &paint, raster.FillRule.winding)
# mark: SVG paint servers ======================================================================
## What a paint style paints with (the SkPaint `paint_style_to_skia_paint` answers).
enum CpuShader:
## A solid color: the default SkPaint is opaque black.
color(value: gfx.Color)
## A gradient shader.
gradient(value: CpuGradient)
## An image shader repeating `pixmap` (owned: release it), placed by `transform`.
pattern(pixmap: raster.Pixmap, transform: raster.Transform)
## `SkPaint {}`: opaque black.
func cpu_default_shader() -> CpuShader:
return .color(value = gfx.Color(m_value = 0xff000000))
## Frees what a shader owns.
func cpu_shader_release(shader: CpuShader*):
match *shader:
.pattern(pixmap, _):
var p = pixmap
p.release()
_:
_ = 0
## `to_skia_matrix`: a Gfx::AffineTransform (a, b, c, d, e, f) as a raster transform.
func cpu_transform_of_affine(transform: const gfx.AffineTransform*) -> raster.Transform:
return raster.Transform.from_row(gfx.affine_transform_a(transform), gfx.affine_transform_b(transform), gfx.affine_transform_c(transform),
gfx.affine_transform_d(transform), gfx.affine_transform_e(transform), gfx.affine_transform_f(transform))
## `to_skia_tile_mode`.
func cpu_tile_mode(spread_method: SvgGradientPaintStyleSpreadMethod) -> CpuTileMode:
match spread_method:
.pad_: return CpuTileMode.clamp
.reflect: return CpuTileMode.mirror
.repeat: return CpuTileMode.repeat
_: trap("VERIFY_NOT_REACHED")
## `gradient_paint_style_to_skia_paint`.
func cpu_gradient_paint_style_shader(paint_style: const SvgGradientPaintStyle*, bounding_rect: gfx.FloatRect) -> CpuShader:
let color_stops = svg_gradient_paint_style_color_stops(paint_style)
var stops: ak.Vector[CpuGradientStop]
ak.vector_ensure_capacity(&stops, color_stops.length)
for color_stop in color_stops:
ak.vector_append_t(&stops, CpuGradientStop(position = color_stop.position, color = cpu_color4(color_stop.color)))
# Skia makes no shader from no colors, leaving the default paint.
if color_stops.length == 0:
return cpu_default_shader()
var matrix = raster.Transform.from_translate(bounding_rect.m_location.m_x, bounding_rect.m_location.m_y)
if let gradient_transform = svg_gradient_paint_style_gradient_transform(paint_style):
matrix = matrix.pre_concat(cpu_transform_of_affine(&gradient_transform))
let tile_mode = cpu_tile_mode(svg_gradient_paint_style_spread_method(paint_style))
let geometry = cpu_svg_gradient_geometry(paint_style) else return cpu_default_shader()
# Flags 0: interpolate unpremultiplied sRGB. A linearRGB gradient adds
# SkColorFilters::LinearToSRGBGamma.
return .gradient(value = CpuGradient(geometry = geometry, stops = stops, tile_mode = tile_mode, interpolation = raster.GradientInterpolation(), local_matrix = matrix,
linear_to_srgb = svg_gradient_paint_style_color_space(paint_style) == gfx.InterpolationColorSpace.linear_rgb))
## The geometry of an SVG gradient: `SkGradientShader::MakeLinear` of a linear gradient's
## points, `MakeTwoPointConical` of a radial gradient's circles; none for any other.
func cpu_svg_gradient_geometry(paint_style: const SvgGradientPaintStyle*) -> CpuGradientGeometry?:
# The cast helpers take a mutable pointer; they only read the class id.
let style = (SvgGradientPaintStyle*)paint_style
if is_svg_linear_gradient_paint_style(style):
let linear_gradient_paint_style = (const SvgLinearGradientPaintStyle*)paint_style
let start = svg_linear_gradient_paint_style_start_point(linear_gradient_paint_style)
let end = svg_linear_gradient_paint_style_end_point(linear_gradient_paint_style)
return .linear(x0 = start.m_x, y0 = start.m_y, x1 = end.m_x, y1 = end.m_y)
if is_svg_radial_gradient_paint_style(style):
let radial_gradient_paint_style = (const SvgRadialGradientPaintStyle*)paint_style
let start_center = svg_radial_gradient_paint_style_start_center(radial_gradient_paint_style)
let end_center = svg_radial_gradient_paint_style_end_center(radial_gradient_paint_style)
let start_radius = svg_radial_gradient_paint_style_start_radius(radial_gradient_paint_style)
let end_radius = svg_radial_gradient_paint_style_end_radius(radial_gradient_paint_style)
return .two_point_conical(x0 = start_center.m_x, y0 = start_center.m_y, r0 = start_radius, x1 = end_center.m_x, y1 = end_center.m_y, r1 = end_radius)
return none
## Ported from Libraries/LibWeb/Painting/DisplayListPlayerSkia.h:59 Web::Painting::DisplayListPlayerSkia::paint_style_to_skia_paint.
func display_list_player_cpu_paint_style_to_shader(this: DisplayListPlayerCpu*, paint_style: SvgPaintServerPaintStyle*, bounding_rect: gfx.FloatRect) -> CpuShader:
if let gradient = as_if_svg_gradient_paint_style(paint_style):
return cpu_gradient_paint_style_shader(gradient, bounding_rect)
if let pattern = as_if_svg_pattern_paint_style(paint_style):
let tile_rect = svg_pattern_paint_style_tile_rect(pattern)
let tile_width = (i32)math32.ceil(tile_rect.m_size.m_width)
let tile_height = (i32)math32.ceil(tile_rect.m_size.m_height)
if tile_width <= 0 or tile_height <= 0:
return cpu_default_shader()
let tile_size = gfx.IntSize(m_width = tile_width, m_height = tile_height)
let tile_surface = gfx.painting_surface_create_with_size(tile_size, gfx.BitmapFormat.bgra8888, gfx.AlphaType.premultiplied)
display_list_player_cpu_attach_canvas(this, tile_surface, cpu_canvas_create((u32)tile_width, (u32)tile_height))
display_list_player_execute_display_list_into_surface(this.display_list_player(), svg_pattern_paint_style_tile_display_list(pattern), tile_surface)
# tile_surface->sk_surface().makeImageSnapshot()
let tile_canvas = display_list_player_cpu_detach_canvas(this, tile_surface) else trap("CpuPlayer: lost the tile canvas")
let image = cpu_canvas_pixmap(tile_canvas).clone()
cpu_canvas_release(tile_canvas)
var matrix = raster.Transform.from_translate(tile_rect.m_location.m_x, tile_rect.m_location.m_y)
matrix = matrix.pre_scale(tile_rect.m_size.m_width / (f32)tile_width, tile_rect.m_size.m_height / (f32)tile_height)
if let transform = svg_pattern_paint_style_pattern_transform(pattern):
matrix = matrix.pre_concat(cpu_transform_of_affine(&transform))
return .pattern(pixmap = image, transform = matrix)
return cpu_default_shader()
## The paint of `shader` at `opacity` (SkPaint::setAlphaf on a shader's paint); the caller
## releases it.
func cpu_shader_paint(shader: const CpuShader*, anti_alias: bool, opacity: f32) -> raster.Paint:
match *shader:
.color(color):
var paint = cpu_color_paint(color, anti_alias)
var c = cpu_color(color)
c.set_alpha(cpu_clamp_unit(opacity))
paint.set_color(c)
return paint
.gradient(gradient):
return cpu_gradient_paint(&gradient, anti_alias, opacity, false)
.pattern(pixmap, transform):
var paint = raster.Paint()
paint.anti_alias = anti_alias
paint.shader = raster.Pattern.new_(pixmap.as_ref(), raster.SpreadMode.repeat, raster.FilterQuality.bilinear, opacity, transform)
return paint
## Fills `path` with `shader` at `opacity`.
func cpu_canvas_fill_path_with_shader(canvas: CpuCanvas*, path: const raster.Path*, fill_rule: raster.FillRule, anti_alias: bool, shader: const CpuShader*, opacity: f32):
if cpu_canvas_is_clip_empty(canvas):
return
var paint = cpu_shader_paint(shader, anti_alias, opacity)
cpu_canvas_fill_path(canvas, path, &paint, fill_rule)
paint.release()
# mark: Paths ==================================================================================
## `to_skia_path_fill_type`.
func cpu_fill_rule(winding_rule: gfx.WindingRule) -> raster.FillRule:
match winding_rule:
.nonzero: return raster.FillRule.winding
.even_odd: return raster.FillRule.even_odd
_: trap("VERIFY_NOT_REACHED")
## `to_skia_cap`.
func cpu_line_cap(cap_style: gfx.PathCapStyle) -> raster.LineCap:
match cap_style:
.round: return raster.LineCap.round
.square: return raster.LineCap.square
.butt: return raster.LineCap.butt
_: trap("VERIFY_NOT_REACHED")
## `to_skia_join`.
func cpu_line_join(join_style: gfx.PathJoinStyle) -> raster.LineJoin:
match join_style:
.round: return raster.LineJoin.round
.bevel: return raster.LineJoin.bevel
.miter: return raster.LineJoin.miter
_: trap("VERIFY_NOT_REACHED")
## Ported from Libraries/LibWeb/Painting/DisplayListPlayerSkia.h:40 Web::Painting::DisplayListPlayerSkia::fill_path (override).
func display_list_player_cpu_fill_path_impl(base: DisplayListPlayer*, command: FillPath):
var cpu_path = to_raster_path(&command.path) else return
defer cpu_path.path.release()
cpu_path.fill_rule = cpu_fill_rule(command.winding_rule)
let anti_alias = command.should_anti_alias == ShouldAntiAlias.yes
let canvas = display_list_player_cpu_canvas((DisplayListPlayerCpu*)base)
match command.paint_style_or_color:
.svg_paint_server_paint_style(paint_style):
let style = paint_style else trap("VERIFY: a null paint style")
var shader = display_list_player_cpu_paint_style_to_shader((DisplayListPlayerCpu*)base, style, int_rect_to_float_rect(fill_path_bounding_rect(&command)))
defer cpu_shader_release(&shader)
cpu_canvas_fill_path_with_shader(canvas, &cpu_path.path, cpu_path.fill_rule, anti_alias, &shader, command.opacity)
.color(color):
let paint = cpu_color_paint(color, anti_alias)
cpu_canvas_fill_path(canvas, &cpu_path.path, &paint, cpu_path.fill_rule)
## The raster stroke of a StrokePath command (setStrokeWidth, setStrokeCap, setStrokeJoin,
## setStrokeMiter, and SkDashPathEffect::Make, which makes no effect from an invalid dash
## array); the caller releases its dash.
func cpu_stroke_of(command: const StrokePath*) -> raster.Stroke:
let dash = raster.StrokeDash.new_(ak.vector_span_const(&command.dash_array), command.dash_offset)
return raster.Stroke(width = command.thickness, miter_limit = command.miter_limit, line_cap = cpu_line_cap(command.cap_style),
line_join = cpu_line_join(command.join_style), dash = dash)
## Frees a stroke's dash.
func cpu_stroke_release(stroke: raster.Stroke*):
if let dash = stroke.dash:
var d = dash
d.release()
stroke.dash = none
## Ported from Libraries/LibWeb/Painting/DisplayListPlayerSkia.h:41 Web::Painting::DisplayListPlayerSkia::stroke_path (override).
func display_list_player_cpu_stroke_path_impl(base: DisplayListPlayer*, command: StrokePath):
var cpu_path = to_raster_path(&command.path) else return
defer cpu_path.path.release()
var stroke = cpu_stroke_of(&command)
defer cpu_stroke_release(&stroke)
let anti_alias = command.should_anti_alias == ShouldAntiAlias.yes
let canvas = display_list_player_cpu_canvas((DisplayListPlayerCpu*)base)
match command.paint_style_or_color:
.svg_paint_server_paint_style(paint_style):
let style = paint_style else trap("VERIFY: a null paint style")
var shader = display_list_player_cpu_paint_style_to_shader((DisplayListPlayerCpu*)base, style, int_rect_to_float_rect(stroke_path_bounding_rect(&command)))
defer cpu_shader_release(&shader)
var paint = cpu_shader_paint(&shader, anti_alias, command.opacity)
cpu_canvas_stroke_path(canvas, &cpu_path.path, &paint, &stroke)
paint.release()
.color(color):
let paint = cpu_color_paint(color, anti_alias)
cpu_canvas_stroke_path(canvas, &cpu_path.path, &paint, &stroke)
# mark: Ellipses and lines =====================================================================
## Ported from Libraries/LibWeb/Painting/DisplayListPlayerSkia.h:42 Web::Painting::DisplayListPlayerSkia::draw_ellipse (override).
func display_list_player_cpu_draw_ellipse_impl(base: DisplayListPlayer*, command: DrawEllipse):
let rect = cpu_rect(command.rect) else return
var oval = cpu_oval_path(rect) else return
defer oval.release()
let canvas = display_list_player_cpu_canvas((DisplayListPlayerCpu*)base)
let paint = cpu_color_paint(command.color, true)
let stroke = raster.Stroke(width = (f32)command.thickness)
cpu_canvas_stroke_path(canvas, &oval, &paint, &stroke)
## Ported from Libraries/LibWeb/Painting/DisplayListPlayerSkia.h:43 Web::Painting::DisplayListPlayerSkia::fill_ellipse (override).
func display_list_player_cpu_fill_ellipse_impl(base: DisplayListPlayer*, command: FillEllipse):
let rect = cpu_rect(command.rect) else return
var oval = cpu_oval_path(rect) else return
defer oval.release()
let canvas = display_list_player_cpu_canvas((DisplayListPlayerCpu*)base)
let paint = cpu_color_paint(command.color, true)
cpu_canvas_fill_path(canvas, &oval, &paint, raster.FillRule.winding)
## SkPoint::normalize: the unit vector of (x, y), or (0, 0) when it has no length.
func cpu_normalize(x: f32, y: f32) -> (f32, f32):
let length = math32.sqrt(x * x + y * y)
if not (length > 0.0) or not math32.is_finite(length):
return (0.0, 0.0)
return (x / length, y / length)
## Ported from Libraries/LibWeb/Painting/DisplayListPlayerSkia.h:44 Web::Painting::DisplayListPlayerSkia::draw_line (override).
func display_list_player_cpu_draw_line_impl(base: DisplayListPlayer*, command: DrawLine):
var from_x = (f32)command.from_.m_x
var from_y = (f32)command.from_.m_y
var to_x = (f32)command.to.m_x
var to_y = (f32)command.to.m_y
let canvas = display_list_player_cpu_canvas((DisplayListPlayerCpu*)base)
let paint = cpu_color_paint(command.color, true)
var stroke = raster.Stroke(width = (f32)command.thickness)
match command.style:
.dotted:
let length = gfx.int_point_distance_from(&command.to, command.from_)
let dot_count = math32.floor(length / ((f32)command.thickness * 2.0))
let interval = length / dot_count
let intervals: f32[2] = [0.0, interval]
stroke.dash = raster.StrokeDash.new_(intervals, 0.0)
stroke.line_cap = raster.LineCap.round
# NOTE: As Skia doesn't render a dot exactly at the end of a line, we need
# to extend it by less then an interval.
let (dx, dy) = cpu_normalize(to_x - from_x, to_y - from_y)
to_x += dx * (interval / 2.0)
to_y += dy * (interval / 2.0)
.dashed:
let length = gfx.int_point_distance_from(&command.to, command.from_) + (f32)command.thickness
let dash_count = math32.floor(length / (f32)command.thickness / 4.0) * 2.0 + 1.0
let interval = length / dash_count
let intervals: f32[2] = [interval, interval]
stroke.dash = raster.StrokeDash.new_(intervals, 0.0)
let (dx, dy) = cpu_normalize(to_x - from_x, to_y - from_y)
from_x -= dx * ((f32)command.thickness / 2.0)
from_y -= dy * ((f32)command.thickness / 2.0)
to_x += dx * ((f32)command.thickness / 2.0)
to_y += dy * ((f32)command.thickness / 2.0)
_:
_ = 0
defer cpu_stroke_release(&stroke)
# canvas.drawLine(from, to, paint)
var builder = raster.PathBuilder.new_()
builder.move_to(from_x, from_y)
builder.line_to(to_x, to_y)
var line = builder.finish() else return
defer line.release()
cpu_canvas_stroke_path(canvas, &line, &paint, &stroke)
# mark: Backdrop filters, rects, clips, nesting ================================================
## Ported from Libraries/LibWeb/Painting/DisplayListPlayerSkia.h:45 Web::Painting::DisplayListPlayerSkia::apply_backdrop_filter (override).
func display_list_player_cpu_apply_backdrop_filter_impl(base: DisplayListPlayer*, command: ApplyBackdropFilter):
let canvas = display_list_player_cpu_canvas((DisplayListPlayerCpu*)base)
let rect = cpu_rect(command.backdrop_region) else return
cpu_canvas_save(canvas)
cpu_canvas_clip_rect(canvas, rect, true)
defer cpu_canvas_restore(canvas)
if let backdrop_filter = command.backdrop_filter:
cpu_canvas_save_layer_with_backdrop(canvas, gfx.filter_impl(&backdrop_filter).filter)
cpu_canvas_restore(canvas)
## Ported from Libraries/LibWeb/Painting/DisplayListPlayerSkia.h:46 Web::Painting::DisplayListPlayerSkia::draw_rect (override).
func display_list_player_cpu_draw_rect_impl(base: DisplayListPlayer*, command: DrawRect):
let rect = cpu_rect(command.rect) else return
let canvas = display_list_player_cpu_canvas((DisplayListPlayerCpu*)base)
let paint = cpu_color_paint(command.color, true)
cpu_canvas_stroke_rect(canvas, rect, &paint, 1.0)
## Ported from Libraries/LibWeb/Painting/DisplayListPlayerSkia.h:49 Web::Painting::DisplayListPlayerSkia::add_rounded_rect_clip (override).
func display_list_player_cpu_add_rounded_rect_clip_impl(base: DisplayListPlayer*, command: AddRoundedRectClip):
var rounded_rect = cpu_rrect_path_for(command.border_rect, &command.corner_radii) else return
defer rounded_rect.release()
let canvas = display_list_player_cpu_canvas((DisplayListPlayerCpu*)base)
let difference = command.corner_clip == CornerClip.inside
cpu_canvas_clip_path(canvas, &rounded_rect, raster.FillRule.winding, true, difference)
## Ported from Libraries/LibWeb/Painting/DisplayListPlayerSkia.h:51 Web::Painting::DisplayListPlayerSkia::paint_nested_display_list (override).
func display_list_player_cpu_paint_nested_display_list_impl(base: DisplayListPlayer*, command: PaintNestedDisplayList):
let canvas = display_list_player_cpu_canvas((DisplayListPlayerCpu*)base)
cpu_canvas_translate(canvas, (f32)command.rect.m_location.m_x, (f32)command.rect.m_location.m_y)
var empty_scroll_state: ScrollStateSnapshot
let nested = command.display_list else trap("VERIFY: a null nested display list")
display_list_player_execute_impl(base, nested, &empty_scroll_state)
# mark: Scrollbars and effects =================================================================
## Ported from Libraries/LibWeb/Painting/DisplayListPlayerSkia.h:50 Web::Painting::DisplayListPlayerSkia::paint_scrollbar (override).
func display_list_player_cpu_paint_scrollbar_impl(base: DisplayListPlayer*, command: PaintScrollBar):
let gutter_rect = cpu_rect(command.gutter_rect) else return
let thumb_rect = cpu_rect(command.thumb_rect) else return
let radius = thumb_rect.width() / 2.0
var thumb_rrect = cpu_rrect_path(thumb_rect, cpu_uniform_radii(radius, radius))
defer thumb_rrect.release()
let canvas = display_list_player_cpu_canvas((DisplayListPlayerCpu*)base)
let gutter_fill_color = command.track_color
let gutter_fill_paint = cpu_color_paint(gutter_fill_color, false)
cpu_canvas_fill_rect(canvas, gutter_rect, &gutter_fill_paint)
var thumb_fill_color = command.thumb_color
if gfx.device_pixel_rect_is_empty(&command.gutter_rect) and thumb_fill_color == initial_values_scrollbar_color().thumb_color:
thumb_fill_color = gfx.color_with_alpha(&thumb_fill_color, 128)
let thumb_fill_paint = cpu_color_paint(thumb_fill_color, false)
cpu_canvas_fill_path(canvas, &thumb_rrect, &thumb_fill_paint, raster.FillRule.winding)
let stroke_color = gfx.color_lightened(&thumb_fill_color)
let stroke_paint = cpu_color_paint(stroke_color, true)
let stroke = raster.Stroke(width = 1.0)
cpu_canvas_stroke_path(canvas, &thumb_rrect, &stroke_paint, &stroke)
## `Gfx::to_skia_blender`: the raster blend mode of a compositing operator; plus-darker is
## composited by hand (CpuLayerEffects.plus_darker), so it answers source-over.
func cpu_blend_mode(compositing_and_blending_operator: gfx.CompositingAndBlendingOperator) -> raster.BlendMode:
match compositing_and_blending_operator:
.normal: return raster.BlendMode.source_over
.multiply: return raster.BlendMode.multiply
.screen: return raster.BlendMode.screen
.overlay: return raster.BlendMode.overlay
.darken: return raster.BlendMode.darken
.lighten: return raster.BlendMode.lighten
.color_dodge: return raster.BlendMode.color_dodge
.color_burn: return raster.BlendMode.color_burn
.hard_light: return raster.BlendMode.hard_light
.soft_light: return raster.BlendMode.soft_light
.difference: return raster.BlendMode.difference
.exclusion: return raster.BlendMode.exclusion
.hue: return raster.BlendMode.hue
.saturation: return raster.BlendMode.saturation
.color: return raster.BlendMode.color
.luminosity: return raster.BlendMode.luminosity
.clear: return raster.BlendMode.clear
.copy: return raster.BlendMode.source
.source_over: return raster.BlendMode.source_over
.destination_over: return raster.BlendMode.destination_over
.source_in: return raster.BlendMode.source_in
.destination_in: return raster.BlendMode.destination_in
.source_out: return raster.BlendMode.source_out
.destination_out: return raster.BlendMode.destination_out
.source_a_top: return raster.BlendMode.source_atop
.destination_a_top: return raster.BlendMode.destination_atop
.xor: return raster.BlendMode.xor
.lighter: return raster.BlendMode.plus
# https://drafts.fxtf.org/compositing/#porterduffcompositingoperators_plus_lighter:
# saturate(source + destination), which is kPlus.
.plus_lighter: return raster.BlendMode.plus
.plus_darker: return raster.BlendMode.source_over
_: trap("VERIFY_NOT_REACHED")
## Ported from Libraries/LibWeb/Painting/DisplayListPlayerSkia.h:52 Web::Painting::DisplayListPlayerSkia::apply_effects (override).
func display_list_player_cpu_apply_effects_impl(base: DisplayListPlayer*, command: ApplyEffects):
let canvas = display_list_player_cpu_canvas((DisplayListPlayerCpu*)base)
var effects = CpuLayerEffects()
if command.opacity < 1.0:
effects.opacity = command.opacity
if command.compositing_and_blending_operator != gfx.CompositingAndBlendingOperator.normal:
effects.blend_mode = cpu_blend_mode(command.compositing_and_blending_operator)
# https://drafts.fxtf.org/compositing/#porterduffcompositingoperators_plus_darker
# FIXME: This does not match the spec, however it looks like Safari, the only popular browser supporting this operator.
effects.plus_darker = command.compositing_and_blending_operator == gfx.CompositingAndBlendingOperator.plus_darker
if let filter = command.filter:
effects.filter = gfx.filter_impl(&filter).filter
if let mask_kind = command.mask_kind:
if mask_kind == gfx.MaskKind.luminance:
effects.luminance_to_alpha = true
cpu_canvas_save_layer(canvas, effects)
## Ported from Libraries/LibWeb/Painting/DisplayListPlayerSkia.h:53 Web::Painting::DisplayListPlayerSkia::apply_transform (override).
func display_list_player_cpu_apply_transform_impl(base: DisplayListPlayer*, origin: gfx.FloatPoint, matrix: gfx.FloatMatrix4X4):
var new_transform = gfx.translation_matrix(gfx.FloatVector3([origin.m_x, origin.m_y, 0.0]))
new_transform = gfx.float_matrix4_x4_mul(&new_transform, matrix)
new_transform = gfx.float_matrix4_x4_mul(&new_transform, gfx.translation_matrix(gfx.FloatVector3([-origin.m_x, -origin.m_y, 0.0])))
let skia_matrix = cpu_m44_of_matrix4x4(&new_transform)
cpu_canvas_concat44(display_list_player_cpu_canvas((DisplayListPlayerCpu*)base), &skia_matrix)
## Ported from Libraries/LibWeb/Painting/DisplayListPlayerSkia.h:55 Web::Painting::DisplayListPlayerSkia::add_clip_path (override).
func display_list_player_cpu_add_clip_path_impl(base: DisplayListPlayer*, path: gfx.Path):
let canvas = display_list_player_cpu_canvas((DisplayListPlayerCpu*)base)
var cpu_path = to_raster_path(&path) else return
defer cpu_path.path.release()
cpu_canvas_clip_path(canvas, &cpu_path.path, cpu_path.fill_rule, true, false)
## Ported from Libraries/LibWeb/Painting/DisplayListPlayerSkia.h:57 Web::Painting::DisplayListPlayerSkia::would_be_fully_clipped_by_painter (override).
func display_list_player_cpu_would_be_fully_clipped_by_painter_impl(base: DisplayListPlayer*, rect: gfx.DevicePixelRect) -> bool:
let canvas = display_list_player_cpu_canvas((DisplayListPlayerCpu*)base)
let r = cpu_rect(rect) else return true
return cpu_canvas_quick_reject(canvas, r)