dymokomi/luce-browser-render
Source of release 0.6.1
0.6.1 / src / display_list / accumulated_visual_context.lucb
#==============================================================================================
#
# accumulated_visual_context - the tree of scroll, clip, transform and effect contexts
#
# DESCRIPTION:
# Port of Libraries/LibWeb/Painting/AccumulatedVisualContext.h (lines 1-109) and
# AccumulatedVisualContext.cpp (lines 1-255). Every display-list command is recorded
# against a node of this tree; the player walks from the node it has applied to the
# node of the next command, restoring and applying contexts on the way (DisplayList.cpp).
# VisualContextIndex is a u64 (AK_TYPEDEF_DISTINCT_ORDERED_ID(size_t)); index 0 is the
# null context, a sentinel node that is never read.
#
# Copyright (c) 2026, Aliaksandr Kalenik <kalenik.aliaksandr@gmail.com>
# Copyright (c) 2026, Jelle Raaijmakers <jelle@ladybird.org>
# SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================
# mark: ClipData, EffectsData ==================================================================
## Ported from Libraries/LibWeb/Painting/AccumulatedVisualContext.h:39 Web::Painting::ClipData::ClipData.
pub func clip_data_construct(this: ClipData*, r: gfx.DevicePixelRect, radii: CornerRadii):
this.rect = r
this.corner_radii = radii
## Ported from Libraries/LibWeb/Painting/AccumulatedVisualContext.cpp:15 Web::Painting::ClipData::contains.
pub func clip_data_contains(this: const ClipData*, point: gfx.IntPoint) -> bool:
# DevicePixelPoint and DevicePixelRect are IntPoint and IntRect in the port, so both
# to_type<int>() conversions are the identity.
return corner_radii_contains(&this.corner_radii, point, this.rect)
## Ported from Libraries/LibWeb/Painting/AccumulatedVisualContext.h:68 Web::Painting::EffectsData::needs_layer.
pub func effects_data_needs_layer(this: const EffectsData*) -> bool:
return this.opacity < 1.0 or this.blend_mode != gfx.CompositingAndBlendingOperator.normal or this.gfx_filter != none
# mark: AccumulatedVisualContextTree ===========================================================
## Ported from Libraries/LibWeb/Painting/AccumulatedVisualContext.cpp:20 Web::Painting::AccumulatedVisualContextTree::create.
pub func accumulated_visual_context_tree_create() -> AccumulatedVisualContextTree*:
let visual_context_tree = new AccumulatedVisualContextTree else trap("out of memory")
# Sentinel at index 0 (null context). Data type doesn't matter; it's never accessed.
ak.vector_append_t(&visual_context_tree.m_nodes, AccumulatedVisualContextNode(
data = .scroll_data(value = ScrollData(scroll_frame_index = 0, is_sticky = false)),
parent_index = 0, depth = 0, has_empty_effective_clip = false))
return visual_context_tree
## Ported from Libraries/LibWeb/Painting/AccumulatedVisualContext.cpp:28 Web::Painting::AccumulatedVisualContextTree::append.
pub func accumulated_visual_context_tree_append(this: AccumulatedVisualContextTree*, data: VisualContextData, parent_index: u64) -> u64:
let depth: usize = accumulated_visual_context_tree_node_at(this, parent_index).depth + 1 if parent_index != 0 else 1
var empty_clip = false
if parent_index != 0 and accumulated_visual_context_tree_node_at(this, parent_index).has_empty_effective_clip:
empty_clip = true
else:
match data:
.clip_data(clip):
empty_clip = gfx.device_pixel_rect_is_empty(&clip.rect)
.clip_path_data(clip_path):
let bounding_box = gfx.path_bounding_box(&clip_path.path)
empty_clip = gfx.float_rect_is_empty(&bounding_box)
_:
empty_clip = false
let index = (u64)ak.vector_size(&this.m_nodes)
ak.vector_append_t(&this.m_nodes, AccumulatedVisualContextNode(data = data, parent_index = parent_index, depth = depth, has_empty_effective_clip = empty_clip))
return index
## Ported from Libraries/LibWeb/Painting/AccumulatedVisualContext.h:91 Web::Painting::AccumulatedVisualContextTree::node_at.
pub func accumulated_visual_context_tree_node_at(this: const AccumulatedVisualContextTree*, index: u64) -> const AccumulatedVisualContextNode*:
return ak.vector_at_const(&this.m_nodes, (usize)index)
## Ported from Libraries/LibWeb/Painting/AccumulatedVisualContext.cpp:46 Web::Painting::AccumulatedVisualContextTree::find_common_ancestor.
pub func accumulated_visual_context_tree_find_common_ancestor(this: const AccumulatedVisualContextTree*, a: u64, b: u64) -> u64:
if a == 0 or b == 0:
return 0
var a_index = a
var b_index = b
while accumulated_visual_context_tree_node_at(this, a_index).depth > accumulated_visual_context_tree_node_at(this, b_index).depth:
a_index = accumulated_visual_context_tree_node_at(this, a_index).parent_index
while accumulated_visual_context_tree_node_at(this, b_index).depth > accumulated_visual_context_tree_node_at(this, a_index).depth:
b_index = accumulated_visual_context_tree_node_at(this, b_index).parent_index
while a_index != b_index:
a_index = accumulated_visual_context_tree_node_at(this, a_index).parent_index
b_index = accumulated_visual_context_tree_node_at(this, b_index).parent_index
return a_index
## Ported from Libraries/LibWeb/Painting/AccumulatedVisualContext.cpp:63 Web::Painting::AccumulatedVisualContextTree::build_ancestor_chain.
## The chain runs from `index` up to (not including) the null context.
func accumulated_visual_context_tree_build_ancestor_chain(this: const AccumulatedVisualContextTree*, index: u64) -> ak.Vector[u64]:
let node = accumulated_visual_context_tree_node_at(this, index)
var chain: ak.Vector[u64]
ak.vector_ensure_capacity(&chain, node.depth)
var i = index
while i != 0:
ak.vector_append_t(&chain, i)
i = accumulated_visual_context_tree_node_at(this, i).parent_index
return chain
## The inverse of a 2D affine transform applied to `point` about `origin`: C++'s
## `inverse->map(point - origin) + origin`.
func map_about_origin(inverse: const gfx.AffineTransform*, point: gfx.FloatPoint, origin: gfx.FloatPoint) -> gfx.FloatPoint:
let offset_point = gfx.float_point_sub(&point, origin)
let transformed = gfx.affine_transform_map_f32_float_point(inverse, offset_point)
return gfx.float_point_add(&transformed, origin)
## Ported from Libraries/LibWeb/Painting/AccumulatedVisualContext.cpp:73 Web::Painting::AccumulatedVisualContextTree::transform_point_for_hit_test.
pub func accumulated_visual_context_tree_transform_point_for_hit_test(this: const AccumulatedVisualContextTree*, index: u64, screen_point: gfx.FloatPoint, scroll_state: const ScrollStateSnapshot*) -> gfx.FloatPoint?:
if index == 0:
return screen_point
var chain = accumulated_visual_context_tree_build_ancestor_chain(this, index)
var point = screen_point
var i = ak.vector_size(&chain)
while i > 0:
let node = accumulated_visual_context_tree_node_at(this, *ak.vector_at(&chain, i - 1))
# The C++ visits the node's data with a lambda per alternative, each answering the
# point or nothing; nothing ends the walk.
match node.data:
.perspective_data(perspective):
let affine = gfx.extract_2d_affine_transform(&perspective.matrix)
let inverse = gfx.affine_transform_inverse(&affine) else return none
point = gfx.affine_transform_map_f32_float_point(&inverse, point)
.scroll_data(scroll):
let offset = scroll_state_snapshot_device_offset_for_index(scroll_state, scroll.scroll_frame_index)
gfx.float_point_translate_by_float_point(&point, gfx.float_point_neg(&offset))
.transform_data(transform):
let affine = gfx.extract_2d_affine_transform(&transform.matrix)
let inverse = gfx.affine_transform_inverse(&affine) else return none
point = map_about_origin(&inverse, point, transform.origin)
.clip_data(clip):
# NOTE: The clip rect is in absolute device-pixel coordinates. After inverse-transforming, `point`
# is also in device-pixel coordinates, so we compare them directly.
if not clip_data_contains(&clip, float_point_to_int_point(point)):
return none
.clip_path_data(clip_path):
# NOTE: The clip path is in absolute device-pixel coordinates. After inverse-transforming, `point`
# is also in device-pixel coordinates, so we compare them directly.
if not gfx.device_pixel_rect_contains_int_point(&clip_path.bounding_rect, float_point_to_int_point(point)):
return none
if not gfx.path_contains(&clip_path.path, point, clip_path.fill_rule):
return none
.effects_data(_):
# Effects don't affect coordinate transforms
_ = 0
i -= 1
return point
## Ported from Libraries/LibWeb/Painting/AccumulatedVisualContext.cpp:136 Web::Painting::AccumulatedVisualContextTree::inverse_transform_point.
pub func accumulated_visual_context_tree_inverse_transform_point(this: const AccumulatedVisualContextTree*, index: u64, screen_point: gfx.FloatPoint) -> gfx.FloatPoint:
if index == 0:
return screen_point
var chain = accumulated_visual_context_tree_build_ancestor_chain(this, index)
var point = screen_point
var i = ak.vector_size(&chain)
while i > 0:
let node = accumulated_visual_context_tree_node_at(this, *ak.vector_at(&chain, i - 1))
match node.data:
.perspective_data(perspective):
let affine = gfx.extract_2d_affine_transform(&perspective.matrix)
if let inverse = gfx.affine_transform_inverse(&affine):
point = gfx.affine_transform_map_f32_float_point(&inverse, point)
.transform_data(transform):
let affine = gfx.extract_2d_affine_transform(&transform.matrix)
if let inverse = gfx.affine_transform_inverse(&affine):
point = map_about_origin(&inverse, point, transform.origin)
_:
_ = 0
i -= 1
return point
## Ported from Libraries/LibWeb/Painting/AccumulatedVisualContext.cpp:169 Web::Painting::AccumulatedVisualContextTree::transform_rect_to_viewport.
pub func accumulated_visual_context_tree_transform_rect_to_viewport(this: const AccumulatedVisualContextTree*, index: u64, source_rect: gfx.FloatRect, scroll_state: const ScrollStateSnapshot*) -> gfx.FloatRect:
if index == 0:
return source_rect
var rect = source_rect
var i = index
while i != 0:
let node = accumulated_visual_context_tree_node_at(this, i)
match node.data:
.transform_data(transform):
let affine = gfx.extract_2d_affine_transform(&transform.matrix)
gfx.float_rect_translate_by_float_point(&rect, gfx.float_point_neg(&transform.origin))
rect = gfx.affine_transform_map_f32_float_rect(&affine, rect)
gfx.float_rect_translate_by_float_point(&rect, transform.origin)
.perspective_data(perspective):
let affine = gfx.extract_2d_affine_transform(&perspective.matrix)
rect = gfx.affine_transform_map_f32_float_rect(&affine, rect)
.scroll_data(scroll):
gfx.float_rect_translate_by_float_point(&rect, scroll_state_snapshot_device_offset_for_index(scroll_state, scroll.scroll_frame_index))
.clip_data(_):
# clips don't affect rect coordinates
_ = 0
.clip_path_data(_):
# clip paths don't affect rect coordinates
_ = 0
.effects_data(_):
# effects don't affect rect coordinates
_ = 0
i = node.parent_index
return rect
## Ported from Libraries/LibWeb/Painting/AccumulatedVisualContext.cpp:199 Web::Painting::AccumulatedVisualContextTree::dump.
pub func accumulated_visual_context_tree_dump(this: const AccumulatedVisualContextTree*, index: u64, builder: ak.StringBuilder*):
if index == 0:
return
let node = accumulated_visual_context_tree_node_at(this, index)
match node.data:
.perspective_data(_):
ak.string_builder_append(builder, "perspective")
.scroll_data(scroll):
ak.string_builder_append(builder, "scroll_frame_id=")
ak.format_u64(builder, scroll.scroll_frame_index)
if scroll.is_sticky:
ak.string_builder_append(builder, " (sticky)")
.transform_data(transform):
let matrix = transform.matrix.m_elements
let origin = transform.origin
# "transform=[{},{},{},{},{},{}] origin=({},{})"
ak.string_builder_append(builder, "transform=[")
ak.format_f32(builder, matrix[0][0])
ak.string_builder_append(builder, ",")
ak.format_f32(builder, matrix[0][1])
ak.string_builder_append(builder, ",")
ak.format_f32(builder, matrix[1][0])
ak.string_builder_append(builder, ",")
ak.format_f32(builder, matrix[1][1])
ak.string_builder_append(builder, ",")
ak.format_f32(builder, matrix[0][3])
ak.string_builder_append(builder, ",")
ak.format_f32(builder, matrix[1][3])
ak.string_builder_append(builder, "] origin=(")
ak.format_f32(builder, gfx.float_point_x(&origin))
ak.string_builder_append(builder, ",")
ak.format_f32(builder, gfx.float_point_y(&origin))
ak.string_builder_append(builder, ")")
.clip_data(clip):
let rect = clip.rect
# "clip=[{},{} {}x{}]"
ak.string_builder_append(builder, "clip=[")
append_rect_bounds(builder, &rect)
ak.string_builder_append(builder, "]")
if corner_radii_has_any_radius(&clip.corner_radii):
let corner_radii = clip.corner_radii
# " radii=({},{},{},{})"
ak.string_builder_append(builder, " radii=(")
ak.format_i64(builder, corner_radii.top_left.horizontal_radius)
ak.string_builder_append(builder, ",")
ak.format_i64(builder, corner_radii.top_right.horizontal_radius)
ak.string_builder_append(builder, ",")
ak.format_i64(builder, corner_radii.bottom_right.horizontal_radius)
ak.string_builder_append(builder, ",")
ak.format_i64(builder, corner_radii.bottom_left.horizontal_radius)
ak.string_builder_append(builder, ")")
.clip_path_data(clip_path):
let rect = clip_path.bounding_rect
# "clip_path=[bounds: {},{} {}x{}, path: {}]"
ak.string_builder_append(builder, "clip_path=[bounds: ")
append_rect_bounds(builder, &rect)
ak.string_builder_append(builder, ", path: ")
let svg = gfx.path_to_svg_string(&clip_path.path)
ak.string_builder_append_string_view(builder, ak.string_bytes_as_string_view(&svg))
ak.string_builder_append(builder, "]")
.effects_data(effects):
ak.string_builder_append(builder, "effects=[")
var has_content = false
if effects.opacity < 1.0:
ak.string_builder_append(builder, "opacity=")
ak.format_f32(builder, effects.opacity)
has_content = true
if effects.blend_mode != gfx.CompositingAndBlendingOperator.normal:
if has_content:
ak.string_builder_append_u8(builder, ' ')
ak.string_builder_append(builder, "blend_mode=")
ak.format_i64(builder, (i32)effects.blend_mode)
has_content = true
if effects.gfx_filter != none:
if has_content:
ak.string_builder_append_u8(builder, ' ')
ak.string_builder_append(builder, "filter")
has_content = true
ak.string_builder_append(builder, "]")
## `appendff("{},{} {}x{}", rect.x(), rect.y(), rect.width(), rect.height())`.
func append_rect_bounds(builder: ak.StringBuilder*, rect: const gfx.DevicePixelRect*):
ak.format_i64(builder, gfx.device_pixel_rect_x(rect))
ak.string_builder_append(builder, ",")
ak.format_i64(builder, gfx.device_pixel_rect_y(rect))
ak.string_builder_append(builder, " ")
ak.format_i64(builder, gfx.device_pixel_rect_width(rect))
ak.string_builder_append(builder, "x")
ak.format_i64(builder, gfx.device_pixel_rect_height(rect))
## Ported from Libraries/LibWeb/Painting/AccumulatedVisualContext.h:99 Web::Painting::AccumulatedVisualContextTree::has_empty_effective_clip.
pub func accumulated_visual_context_tree_has_empty_effective_clip(this: const AccumulatedVisualContextTree*, i: u64) -> bool:
return accumulated_visual_context_tree_node_at(this, i).has_empty_effective_clip