Luce packages
LuceLuce BaseLuciaOS

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)