dymokomi/luce-browser-render
Source of release 0.6.2
0.6.2 / src / display_list / display_list_player_cpu.lucb
#==============================================================================================
#
# display_list_player_cpu - the CPU display-list player (1): surfaces, images, clips, gradients
#
# DESCRIPTION:
# DisplayListPlayerCpu replaces Libraries/LibWeb/Painting/DisplayListPlayerSkia.cpp
# (lines 1-870) and DisplayListPlayerSkia.h (DESIGN.md ยง7.3): the same virtuals, in the
# same order and with the same drawing decisions, each Skia call replaced by the
# CpuCanvas (cpu_canvas.lucb) or raster call that does what it does. This fragment
# holds the player's surfaces, the seams to the modules that own paths, glyphs and
# filters, and the virtuals from `flush` through the gradients; the second fragment
# holds the rest.
#
# Surfaces: the player draws on a CpuCanvas per PaintingSurface. The canvas starts
# from the surface's pixels (PaintingSurface::read_into_bitmap) and is written back
# on `flush` (write_from_bitmap), where the Skia player's canvas draws into the
# surface directly. Surfaces the player makes itself (pattern tiles) start transparent.
#
# Seams: the player reaches into gfx.Path, a GlyphRun's cached text blob and gfx.Filter
# as the Skia player reaches into PathImplSkia, SkTextBlob and FilterImpl (SkiaUtils);
# the functions under "Seams" do it over regions r10's and r09's ports.
#
# 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: Seams ==================================================================================
## A path as the rasterizer takes it: its contours and its fill rule (an SkPath carries both).
pub struct CpuPath:
pub var path: raster.Path
pub var fill_rule: raster.FillRule
## `to_skia_path` (SkiaUtils.cpp; region r10's PathImplRaster): `path`'s contours as a raster
## path with the path's fill type (Path::set_fill_type), or none when it has no contour. The
## caller releases the path.
pub func to_raster_path(path: const gfx.Path*) -> CpuPath?:
let outline = gfx.path_to_raster_path(path) else return none
var fill_rule = raster.FillRule.winding
match gfx.sk_path_get_fill_type(gfx.path_sk_path_const(path)):
.winding: fill_rule = raster.FillRule.winding
.even_odd: fill_rule = raster.FillRule.even_odd
# (Gfx::WindingRule has no inverse fill types.)
_: trap("VERIFY_NOT_REACHED")
return CpuPath(path = outline, fill_rule = fill_rule)
## The outline of `glyph` in `font` (SkFont::getPath through region r09's font reader) as a
## raster path; none when the glyph has no outline. The caller releases the path.
func glyph_outline_path(font: const web_fonts.SkFont*, glyph: u32) -> raster.Path?:
var outline = web_fonts.sk_font_get_path(font, glyph)
var builder = raster.PathBuilder.new_()
let points = outline.points.view()
var point_index: usize = 0
for verb in outline.verbs.view():
match verb:
.move:
builder.move_to(points[point_index].x, points[point_index].y)
point_index += 1
.line:
builder.line_to(points[point_index].x, points[point_index].y)
point_index += 1
.quad:
builder.quad_to(points[point_index].x, points[point_index].y, points[point_index + 1].x, points[point_index + 1].y)
point_index += 2
.cubic:
builder.cubic_to(points[point_index].x, points[point_index].y, points[point_index + 1].x, points[point_index + 1].y,
points[point_index + 2].x, points[point_index + 2].y)
point_index += 3
.close: builder.close()
_: trap("VERIFY_NOT_REACHED")
outline.release()
let result = builder.finish()
builder.release()
return result
# mark: Construction and surfaces ==============================================================
## Ported from Libraries/LibWeb/Painting/DisplayListPlayerSkia.h:20 Web::Painting::DisplayListPlayerSkia::DisplayListPlayerSkia.
pub func display_list_player_cpu_construct(this: DisplayListPlayerCpu*):
this.display_list_player_base.vtable = (const DisplayListPlayerVTable*)&display_list_player_cpu_vtable
this.display_list_player_base.class_id = display_list_player_cpu_class.first_id
## `make<DisplayListPlayerCpu>()`: a new CPU player.
pub func display_list_player_cpu_create() -> DisplayListPlayerCpu*:
let this = new DisplayListPlayerCpu(display_list_player_base = DisplayListPlayer(vtable = (const DisplayListPlayerVTable*)&display_list_player_cpu_vtable, class_id = display_list_player_cpu_class.first_id)) else trap("out of memory")
display_list_player_cpu_construct(this)
return this
## The canvas record of `surface`, or none.
func display_list_player_cpu_find_canvas(this: DisplayListPlayerCpu*, surface: const gfx.PaintingSurface*) -> usize?:
for i in 0..<ak.vector_size(&this.m_canvases):
if ak.vector_at(&this.m_canvases, i).surface == surface:
return i
return none
## Draws on `canvas` whenever the player's surface is `surface` (a surface the player made).
func display_list_player_cpu_attach_canvas(this: DisplayListPlayerCpu*, surface: gfx.PaintingSurface*, canvas: CpuCanvas*):
ak.vector_append_t(&this.m_canvases, CpuSurfaceCanvas(surface = surface, canvas = canvas))
## Drops `surface`'s canvas record and answers its canvas (which the caller releases).
func display_list_player_cpu_detach_canvas(this: DisplayListPlayerCpu*, surface: const gfx.PaintingSurface*) -> CpuCanvas*?:
let index = display_list_player_cpu_find_canvas(this, surface) else return none
let record = ak.vector_take(&this.m_canvases, index)
return record.canvas
## `surface().canvas()`: the canvas of the player's current surface, made from the surface's
## pixels the first time the player draws on it.
func display_list_player_cpu_canvas(this: DisplayListPlayerCpu*) -> CpuCanvas*:
let surface = display_list_player_surface(this.display_list_player())
if let index = display_list_player_cpu_find_canvas(this, surface):
return ak.vector_at(&this.m_canvases, index).canvas
let size = gfx.painting_surface_size(surface)
let canvas = cpu_canvas_create((u32)size.m_width, (u32)size.m_height)
let bitmap = gfx.bitmap_create_alpha_type(gfx.BitmapFormat.bgra8888, gfx.AlphaType.premultiplied, size) else trap("MUST: Bitmap::create")
gfx.painting_surface_read_into_bitmap(surface, bitmap)
cpu_copy_bitmap_into_pixmap(bitmap, cpu_canvas_pixmap(canvas))
display_list_player_cpu_attach_canvas(this, surface, canvas)
return canvas
## Copies a Gfx::Bitmap's pixels into a premultiplied RGBA pixmap of at least its size,
## premultiplying unpremultiplied pixels and treating the x formats as opaque.
func cpu_copy_bitmap_into_pixmap(bitmap: const gfx.Bitmap*, pixmap: raster.Pixmap*):
let width = cpu_min_i32(gfx.bitmap_width(bitmap), (i32)pixmap.width())
let height = cpu_min_i32(gfx.bitmap_height(bitmap), (i32)pixmap.height())
let format_ = gfx.bitmap_format(bitmap)
let opaque = format_ == gfx.BitmapFormat.bg_rx8888 or format_ == gfx.BitmapFormat.rg_bx8888
let bgr = format_ == gfx.BitmapFormat.bgra8888 or format_ == gfx.BitmapFormat.bg_rx8888
let premultiplied = gfx.bitmap_alpha_type(bitmap) == gfx.AlphaType.premultiplied
let pixels = pixmap.pixels_mut()
let row_width = (usize)pixmap.width()
for y in 0..<height:
let row = gfx.bitmap_scanline_const(bitmap, y) else continue
for x in 0..<width:
# A 32-bit pixel: B, G, R, A bytes (BGRA) or R, G, B, A (RGBA) in memory.
let value = row[(usize)x]
let c0 = (u8)(value & 0xff)
let c1 = (u8)((value >> 8) & 0xff)
let c2 = (u8)((value >> 16) & 0xff)
let a: u8 = 255 if opaque else (u8)((value >> 24) & 0xff)
var r = c2 if bgr else c0
let g = c1
var b = c0 if bgr else c2
var gg = g
if not premultiplied or opaque:
r = raster.premultiply_u8(r, a)
gg = raster.premultiply_u8(g, a)
b = raster.premultiply_u8(b, a)
pixels[(usize)y * row_width + (usize)x] = raster.PremultipliedColorU8.from_rgba(r, gg, b, a) else raster.PremultipliedColorU8.transparent()
## Copies a premultiplied RGBA pixmap into a premultiplied BGRA8888 Gfx::Bitmap.
func cpu_copy_pixmap_into_bitmap(pixmap: const raster.Pixmap*, bitmap: gfx.Bitmap*):
let width = cpu_min_i32(gfx.bitmap_width(bitmap), (i32)pixmap.width())
let height = cpu_min_i32(gfx.bitmap_height(bitmap), (i32)pixmap.height())
let pixels = pixmap.pixels()
let row_width = (usize)pixmap.width()
for y in 0..<height:
let row = gfx.bitmap_scanline(bitmap, y) else continue
for x in 0..<width:
let p = pixels[(usize)y * row_width + (usize)x]
row[(usize)x] = ((u32)p.alpha() << 24) | ((u32)p.red() << 16) | ((u32)p.green() << 8) | (u32)p.blue()
## An immutable bitmap's pixels as a premultiplied RGBA pixmap (Skia's SkImage of it), or
## none when it has no CPU bitmap.
func cpu_pixmap_of_immutable_bitmap(image: const gfx.ImmutableBitmap*) -> raster.Pixmap?:
let bitmap = gfx.immutable_bitmap_bitmap(image) else return none
let width = gfx.bitmap_width(bitmap)
let height = gfx.bitmap_height(bitmap)
if width <= 0 or height <= 0:
return none
var pixmap = raster.Pixmap.new_((u32)width, (u32)height) else return none
cpu_copy_bitmap_into_pixmap(bitmap, &pixmap)
return pixmap
## An image shader (SkImage::makeShader) of `image` with `to_skia_sampling_options`'s sampling
## for `scaling_mode`: nearest, bilinear, or bilinear with linear mipmaps; its pixels converted
## by `xform` after sampling when its color space is not sRGB.
func cpu_image_shader(image: const raster.Pixmap*, spread_mode: raster.SpreadMode, scaling_mode: gfx.ScalingMode, transform: raster.Transform, xform: raster.ColorXform?) -> raster.Shader:
match scaling_mode:
.bilinear_mipmap: return raster.Pattern.new_mipmapped(image.as_ref(), spread_mode, 1.0, transform, xform)
.bilinear: return raster.Pattern.new_color_managed(image.as_ref(), spread_mode, raster.FilterQuality.bilinear, 1.0, transform, xform)
_: return raster.Pattern.new_color_managed(image.as_ref(), spread_mode, raster.FilterQuality.nearest, 1.0, transform, xform)
## SkCanvas::drawImageRect(image, src = the whole image, dst, sampling, paint with
## anti-aliasing): the image scaled onto `dst`, its pixels converted by `xform` when its color
## space is not sRGB.
func cpu_canvas_draw_image_rect(canvas: CpuCanvas*, image: const raster.Pixmap*, dst: raster.Rect, scaling_mode: gfx.ScalingMode, xform: raster.ColorXform? = none):
let sx = dst.width() / (f32)image.width()
let sy = dst.height() / (f32)image.height()
var paint = raster.Paint()
paint.anti_alias = true
paint.shader = cpu_image_shader(image, raster.SpreadMode.pad_, scaling_mode, raster.Transform.from_row(sx, 0.0, 0.0, sy, dst.left(), dst.top()), xform)
cpu_canvas_fill_rect(canvas, dst, &paint)
# mark: flush, glyph runs, rects, bitmaps ======================================================
## Ported from Libraries/LibWeb/Painting/DisplayListPlayerSkia.h:24 Web::Painting::DisplayListPlayerSkia::flush (override):
## writes the canvas back into the surface and flushes it.
func display_list_player_cpu_flush_impl(base: DisplayListPlayer*):
let this = (DisplayListPlayerCpu*)base
let surface = display_list_player_surface(base)
if let canvas = display_list_player_cpu_detach_canvas(this, surface):
let size = gfx.painting_surface_size(surface)
let bitmap = gfx.bitmap_create_alpha_type(gfx.BitmapFormat.bgra8888, gfx.AlphaType.premultiplied, size) else trap("MUST: Bitmap::create")
cpu_copy_pixmap_into_bitmap(cpu_canvas_pixmap(canvas), bitmap)
gfx.painting_surface_write_from_bitmap(surface, bitmap)
cpu_canvas_release(canvas)
gfx.painting_surface_flush(surface)
## Ported from Libraries/LibWeb/Painting/DisplayListPlayerSkia.h:25 Web::Painting::DisplayListPlayerSkia::draw_glyph_run (override).
func display_list_player_cpu_draw_glyph_run_impl(base: DisplayListPlayer*, command: DrawGlyphRun):
if web_fonts.glyph_run_cached_skia_text_blob(command.glyph_run) == none:
return
let canvas = display_list_player_cpu_canvas((DisplayListPlayerCpu*)base)
let translation = command.translation
match command.orientation:
.horizontal:
cpu_canvas_draw_text_blob(canvas, command.glyph_run, translation.m_x, translation.m_y, command.color)
.vertical:
cpu_canvas_save(canvas)
cpu_canvas_translate(canvas, (f32)command.rect.m_size.m_width, 0.0)
cpu_canvas_rotate(canvas, 90.0, (f32)command.rect.m_location.m_x, (f32)command.rect.m_location.m_y)
cpu_canvas_draw_text_blob(canvas, command.glyph_run, translation.m_x, translation.m_y, command.color)
cpu_canvas_restore(canvas)
_:
_ = 0
## Ported from Libraries/LibWeb/Painting/DisplayListPlayerSkia.h:26 Web::Painting::DisplayListPlayerSkia::fill_rect (override).
func display_list_player_cpu_fill_rect_impl(base: DisplayListPlayer*, command: FillRect):
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_fill_rect(canvas, rect, &paint)
## Ported from Libraries/LibWeb/Painting/DisplayListPlayerSkia.h:29 Web::Painting::DisplayListPlayerSkia::draw_external_content (override).
func display_list_player_cpu_draw_external_content_impl(base: DisplayListPlayer*, command: DrawExternalContent):
let bitmap = external_content_source_current_bitmap(command.source) else return
var image = cpu_pixmap_of_immutable_bitmap(bitmap) else return
defer image.release()
let dst_rect = cpu_rect(command.dst_rect) else return
let canvas = display_list_player_cpu_canvas((DisplayListPlayerCpu*)base)
cpu_canvas_draw_image_rect(canvas, &image, dst_rect, command.scaling_mode, gfx.immutable_bitmap_color_xform(bitmap))
## Ported from Libraries/LibWeb/Painting/DisplayListPlayerSkia.h:27 Web::Painting::DisplayListPlayerSkia::draw_scaled_immutable_bitmap (override).
func display_list_player_cpu_draw_scaled_immutable_bitmap_impl(base: DisplayListPlayer*, command: DrawScaledImmutableBitmap):
var image = cpu_pixmap_of_immutable_bitmap(command.bitmap) else return
defer image.release()
let dst_rect = cpu_rect(command.dst_rect) else return
let clip_rect = cpu_rect(command.clip_rect) else return
let canvas = display_list_player_cpu_canvas((DisplayListPlayerCpu*)base)
cpu_canvas_save(canvas)
cpu_canvas_clip_rect(canvas, clip_rect, true)
cpu_canvas_draw_image_rect(canvas, &image, dst_rect, command.scaling_mode, gfx.immutable_bitmap_color_xform(command.bitmap))
cpu_canvas_restore(canvas)
## Ported from Libraries/LibWeb/Painting/DisplayListPlayerSkia.h:28 Web::Painting::DisplayListPlayerSkia::draw_repeated_immutable_bitmap (override).
func display_list_player_cpu_draw_repeated_immutable_bitmap_impl(base: DisplayListPlayer*, command: DrawRepeatedImmutableBitmap):
var image = cpu_pixmap_of_immutable_bitmap(command.bitmap) else return
defer image.release()
let dst_rect = int_rect_to_float_rect(command.dst_rect)
let src_width = (f32)image.width()
let src_height = (f32)image.height()
# matrix.setScale(dst_w / src_w, dst_h / src_h); matrix.postTranslate(dst_x, dst_y)
let matrix = raster.Transform.from_row(dst_rect.m_size.m_width / src_width, 0.0, 0.0, dst_rect.m_size.m_height / src_height, dst_rect.m_location.m_x, dst_rect.m_location.m_y)
# canvas.drawPaint(paint) with a kRepeat or kDecal image shader per axis. The raster
# pattern repeats on both axes; a decal axis is kept to the image's own span by filling
# only that span on it.
let huge: f32 = 1073741824.0
let left = dst_rect.m_location.m_x if not command.repeat.x else -huge
let right = dst_rect.m_location.m_x + dst_rect.m_size.m_width if not command.repeat.x else huge
let top = dst_rect.m_location.m_y if not command.repeat.y else -huge
let bottom = dst_rect.m_location.m_y + dst_rect.m_size.m_height if not command.repeat.y else huge
let fill_rect = raster.Rect.from_ltrb(left, top, right, bottom) else return
var paint = raster.Paint()
paint.anti_alias = true
paint.shader = cpu_image_shader(&image, raster.SpreadMode.repeat, command.scaling_mode, matrix, gfx.immutable_bitmap_color_xform(command.bitmap))
let canvas = display_list_player_cpu_canvas((DisplayListPlayerCpu*)base)
cpu_canvas_fill_rect(canvas, fill_rect, &paint)
# mark: Clips and state ========================================================================
## Ported from Libraries/LibWeb/Painting/DisplayListPlayerSkia.h:30 Web::Painting::DisplayListPlayerSkia::add_clip_rect (override).
func display_list_player_cpu_add_clip_rect_impl(base: DisplayListPlayer*, command: AddClipRect):
let canvas = display_list_player_cpu_canvas((DisplayListPlayerCpu*)base)
let rect = cpu_rect(command.rect) else return
cpu_canvas_clip_rect(canvas, rect, true)
## Ported from Libraries/LibWeb/Painting/DisplayListPlayerSkia.h:31 Web::Painting::DisplayListPlayerSkia::save (override).
func display_list_player_cpu_save_impl(base: DisplayListPlayer*, arg0: Save):
cpu_canvas_save(display_list_player_cpu_canvas((DisplayListPlayerCpu*)base))
## Ported from Libraries/LibWeb/Painting/DisplayListPlayerSkia.h:32 Web::Painting::DisplayListPlayerSkia::save_layer (override).
func display_list_player_cpu_save_layer_impl(base: DisplayListPlayer*, arg0: SaveLayer):
cpu_canvas_save_layer(display_list_player_cpu_canvas((DisplayListPlayerCpu*)base), CpuLayerEffects())
## Ported from Libraries/LibWeb/Painting/DisplayListPlayerSkia.h:33 Web::Painting::DisplayListPlayerSkia::restore (override).
func display_list_player_cpu_restore_impl(base: DisplayListPlayer*, arg0: Restore):
cpu_canvas_restore(display_list_player_cpu_canvas((DisplayListPlayerCpu*)base))
## Ported from Libraries/LibWeb/Painting/DisplayListPlayerSkia.h:34 Web::Painting::DisplayListPlayerSkia::translate (override).
func display_list_player_cpu_translate_impl(base: DisplayListPlayer*, command: Translate):
cpu_canvas_translate(display_list_player_cpu_canvas((DisplayListPlayerCpu*)base), (f32)command.delta.m_x, (f32)command.delta.m_y)
# mark: Gradients ==============================================================================
## `to_skia_interpolation`: the interpolation space and hue method of a CSS color
## interpolation method; always premultiplied.
func cpu_interpolation(interpolation_method: ColorInterpolationMethod) -> raster.GradientInterpolation:
var interpolation = raster.GradientInterpolation(in_premul = true)
match interpolation_method:
.rectangular_color_space(color_space):
match color_space:
.srgb: interpolation.color_space = raster.GradientColorSpace.srgb
.srgb_linear: interpolation.color_space = raster.GradientColorSpace.srgb_linear
.lab: interpolation.color_space = raster.GradientColorSpace.lab
.oklab: interpolation.color_space = raster.GradientColorSpace.oklab
.display_p3: interpolation.color_space = raster.GradientColorSpace.display_p3
.a98_rgb: interpolation.color_space = raster.GradientColorSpace.a98_rgb
.prophoto_rgb: interpolation.color_space = raster.GradientColorSpace.prophoto_rgb
.rec2020: interpolation.color_space = raster.GradientColorSpace.rec2020
.display_p3_linear, .xyz_d50, .xyz_d65:
ak.dbgln("FIXME: Unsupported gradient color space")
interpolation.color_space = raster.GradientColorSpace.oklab
.xyz:
# NB: Xyz should have been canonicalized to XyzD65 at parse time
trap("VERIFY_NOT_REACHED")
_:
trap("VERIFY_NOT_REACHED")
.polar_color_interpolation_method(color_space):
match color_space.color_space:
.hsl: interpolation.color_space = raster.GradientColorSpace.hsl
.hwb: interpolation.color_space = raster.GradientColorSpace.hwb
.lch: interpolation.color_space = raster.GradientColorSpace.lch
.oklch: interpolation.color_space = raster.GradientColorSpace.oklch
_: trap("VERIFY_NOT_REACHED")
match color_space.hue_interpolation_method:
.shorter: interpolation.hue_method = raster.GradientHueMethod.shorter
.longer: interpolation.hue_method = raster.GradientHueMethod.longer
.increasing: interpolation.hue_method = raster.GradientHueMethod.increasing
.decreasing: interpolation.hue_method = raster.GradientHueMethod.decreasing
_: trap("VERIFY_NOT_REACHED")
return interpolation
## The color and position lists of a CSS gradient: the stops, skipping a stop equal to the
## one before it, with each position mapped by `(position - first_position) / scale`.
func cpu_gradient_stops(color_stop_list: const ak.Vector[gfx.ColorStop]*, first_position: f32, scale: f32) -> ak.Vector[CpuGradientStop]:
var stops: ak.Vector[CpuGradientStop]
let list = ak.vector_span_const(color_stop_list)
for stop_index in 0..<list.length:
let stop = list[stop_index]
if stop_index > 0 and stop == list[stop_index - 1]:
continue
ak.vector_append_t(&stops, CpuGradientStop(position = (stop.position - first_position) / scale, color = cpu_color4(stop.color)))
return stops
## The paint a gradient command fills its rectangle with (SkPaint with the gradient shader,
## anti-aliased or not, dithered), and that rectangle: what the paint_*_gradient virtuals draw,
## shared with the GPU player. The caller releases the paint.
pub struct CpuGradientFill:
pub var paint: raster.Paint
pub var rect: raster.Rect
## Fills `fill`'s rectangle with its paint, and releases the paint.
func cpu_canvas_fill_gradient(canvas: CpuCanvas*, fill: CpuGradientFill*):
defer fill.paint.release()
if cpu_canvas_is_clip_empty(canvas):
return
var path = cpu_rect_path(fill.rect)
defer path.release()
cpu_canvas_fill_path(canvas, &path, &fill.paint, raster.FillRule.winding)
## Ported from Libraries/LibWeb/Painting/DisplayListPlayerSkia.h:35 Web::Painting::DisplayListPlayerSkia::paint_linear_gradient (override).
func display_list_player_cpu_paint_linear_gradient_impl(base: DisplayListPlayer*, command: PaintLinearGradient):
var fill = cpu_linear_gradient_fill(&command) else return
cpu_canvas_fill_gradient(display_list_player_cpu_canvas((DisplayListPlayerCpu*)base), &fill)
## paint_linear_gradient's paint and rectangle.
pub func cpu_linear_gradient_fill(command: const PaintLinearGradient*) -> CpuGradientFill?:
let linear_gradient_data = command.linear_gradient_data
let color_stop_list = &linear_gradient_data.color_stops.list
let repeat_length = linear_gradient_data.color_stops.repeat_length
assert(not ak.vector_is_empty(color_stop_list))
let first_position: f32 = ak.vector_first_const(color_stop_list).position if repeat_length != none else 0.0
let stops = cpu_gradient_stops(color_stop_list, first_position, repeat_length else 1.0)
let rect = int_rect_to_float_rect(command.gradient_rect)
let length = gfx.calculate_gradient_length(rect.m_size, linear_gradient_data.gradient_angle)
# Starting and ending points before rotation (0deg / "to top")
let rect_center = gfx.FloatPoint(m_x = rect.m_location.m_x + rect.m_size.m_width / 2.0, m_y = rect.m_location.m_y + rect.m_size.m_height / 2.0)
let start = gfx.FloatPoint(m_x = rect_center.m_x, m_y = rect_center.m_y + (0.5 - first_position) * length)
let end = gfx.FloatPoint(m_x = start.m_x, m_y = start.m_y + (repeat_length else 1.0) * -length)
# matrix.setRotate(gradient_angle, rect_center)
let matrix = cpu_rotate_matrix(linear_gradient_data.gradient_angle, rect_center.m_x, rect_center.m_y)
let gradient = CpuGradient(geometry = .linear(x0 = start.m_x, y0 = start.m_y, x1 = end.m_x, y1 = end.m_y), stops = stops,
tile_mode = CpuTileMode.repeat, interpolation = cpu_interpolation(linear_gradient_data.interpolation_method),
local_matrix = matrix, linear_to_srgb = false)
let draw_rect = cpu_float_rect(rect) else return none
# paint.setDither(true)
return CpuGradientFill(paint = cpu_gradient_paint(&gradient, false, 1.0, true), rect = draw_rect)
## Ported from Libraries/LibWeb/Painting/DisplayListPlayerSkia.h:47 Web::Painting::DisplayListPlayerSkia::paint_radial_gradient (override).
func display_list_player_cpu_paint_radial_gradient_impl(base: DisplayListPlayer*, command: PaintRadialGradient):
var fill = cpu_radial_gradient_fill(&command) else return
cpu_canvas_fill_gradient(display_list_player_cpu_canvas((DisplayListPlayerCpu*)base), &fill)
## paint_radial_gradient's paint and rectangle.
pub func cpu_radial_gradient_fill(command: const PaintRadialGradient*) -> CpuGradientFill?:
let radial_gradient_data = command.radial_gradient_data
let color_stop_list = &radial_gradient_data.color_stops.list
assert(not ak.vector_is_empty(color_stop_list))
let stops = cpu_gradient_stops(color_stop_list, 0.0, 1.0)
let rect = command.rect
let center = gfx.FloatPoint(m_x = (f32)(command.center.m_x + rect.m_location.m_x), m_y = (f32)(command.center.m_y + rect.m_location.m_y))
let size = int_size_to_float_size(command.size)
# Skia does not support specifying of horizontal and vertical radius's separately,
# so instead we apply scale matrix
let aspect_ratio = size.m_width / size.m_height
let sx: f32 = 1.0 if math32.is_infinite(aspect_ratio) else aspect_ratio
# matrix.setScale(sx, 1.0f, center.x(), center.y())
let matrix = raster.Transform.from_row(sx, 0.0, 0.0, 1.0, center.m_x - sx * center.m_x, 0.0)
let tile_mode = CpuTileMode.repeat if radial_gradient_data.color_stops.repeating else CpuTileMode.clamp
let gradient = CpuGradient(geometry = .radial(cx = center.m_x, cy = center.m_y, radius = size.m_height), stops = stops,
tile_mode = tile_mode, interpolation = cpu_interpolation(radial_gradient_data.interpolation_method),
local_matrix = matrix, linear_to_srgb = false)
let draw_rect = cpu_rect(rect) else return none
return CpuGradientFill(paint = cpu_gradient_paint(&gradient, true, 1.0, true), rect = draw_rect)
## Ported from Libraries/LibWeb/Painting/DisplayListPlayerSkia.h:48 Web::Painting::DisplayListPlayerSkia::paint_conic_gradient (override).
func display_list_player_cpu_paint_conic_gradient_impl(base: DisplayListPlayer*, command: PaintConicGradient):
var fill = cpu_conic_gradient_fill(&command) else return
cpu_canvas_fill_gradient(display_list_player_cpu_canvas((DisplayListPlayerCpu*)base), &fill)
## paint_conic_gradient's paint and rectangle.
pub func cpu_conic_gradient_fill(command: const PaintConicGradient*) -> CpuGradientFill?:
let conic_gradient_data = command.conic_gradient_data
let color_stop_list = &conic_gradient_data.color_stops.list
assert(not ak.vector_is_empty(color_stop_list))
let stops = cpu_gradient_stops(color_stop_list, 0.0, 1.0)
let rect = command.rect
let center = gfx.FloatPoint(m_x = (f32)(command.position.m_x + rect.m_location.m_x), m_y = (f32)(command.position.m_y + rect.m_location.m_y))
# matrix.setRotate(-90 + start_angle, center)
let matrix = cpu_rotate_matrix(-90.0 + conic_gradient_data.start_angle, center.m_x, center.m_y)
let gradient = CpuGradient(geometry = .sweep(cx = center.m_x, cy = center.m_y), stops = stops,
tile_mode = CpuTileMode.repeat, interpolation = cpu_interpolation(conic_gradient_data.interpolation_method),
local_matrix = matrix, linear_to_srgb = false)
let draw_rect = cpu_rect(rect) else return none
return CpuGradientFill(paint = cpu_gradient_paint(&gradient, true, 1.0, true), rect = draw_rect)