dmaax/ladybird
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
ladybird/Libraries/LibWeb/Painting/AccumulatedVisualContext.cpp

256 lines
10 KiB
C++
Raw Normal View History

LibWeb: Introduce AccumulatedVisualContext Introduce AccumulatedVisualContext, a tree structure that tracks the cumulative visual state (scroll offsets, clip regions, transforms, perspective) for each paintable box. Motivation: Before this change, visual state was fragmented across multiple mechanisms: - ClipFrame: Tracked clip rectangles, each storing its own enclosing_scroll_frame_id to handle scroll offset adjustments - scroll_frame_id: Passed separately to each display list command - PushStackingContext: Stored transform matrices directly in the command - Every display list command implemented translate_by() (45 methods total) to allow scroll offset adjustment during playback This fragmentation led to: - Complex, error-prone coordinate transformation logic scattered throughout the codebase - Commands being mutated during playback to apply scroll offsets - Duplicate logic between painting and hit testing for coordinate transformations Solution: AccumulatedVisualContext builds a tree where each node represents a single visual operation: - ScrollData: A scroll frame with its ID - ClipData: A clip rectangle with optional border radii - TransformData: A 4x4 transform matrix with its origin - PerspectiveData: A perspective projection matrix Each PaintableBox stores a reference to its accumulated context node. The tree structure naturally captures the parent-child relationships, so traversing from any node to the root gives the complete chain of visual transformations. Benefits this enables (in subsequent commits): - Display list commands become immutable - no more translate_by() - Single RefPtr<AccumulatedVisualContext> replaces separate scroll_frame_id and ClipFrame on commands - LCA-based tree traversal during playback for efficient save/restore - transform_point_for_hit_test() provides coordinate transformation for hit testing using the same structure
2026-01-13 16:30:32 -03:00
/*
* Copyright (c) 2026, Aliaksandr Kalenik <kalenik.aliaksandr@gmail.com>
LibWeb: Use local coordinates for overflow clip hit testing
2026-01-21 08:12:31 -03:00
* Copyright (c) 2026, Jelle Raaijmakers <jelle@ladybird.org>
LibWeb: Introduce AccumulatedVisualContext Introduce AccumulatedVisualContext, a tree structure that tracks the cumulative visual state (scroll offsets, clip regions, transforms, perspective) for each paintable box. Motivation: Before this change, visual state was fragmented across multiple mechanisms: - ClipFrame: Tracked clip rectangles, each storing its own enclosing_scroll_frame_id to handle scroll offset adjustments - scroll_frame_id: Passed separately to each display list command - PushStackingContext: Stored transform matrices directly in the command - Every display list command implemented translate_by() (45 methods total) to allow scroll offset adjustment during playback This fragmentation led to: - Complex, error-prone coordinate transformation logic scattered throughout the codebase - Commands being mutated during playback to apply scroll offsets - Duplicate logic between painting and hit testing for coordinate transformations Solution: AccumulatedVisualContext builds a tree where each node represents a single visual operation: - ScrollData: A scroll frame with its ID - ClipData: A clip rectangle with optional border radii - TransformData: A 4x4 transform matrix with its origin - PerspectiveData: A perspective projection matrix Each PaintableBox stores a reference to its accumulated context node. The tree structure naturally captures the parent-child relationships, so traversing from any node to the root gives the complete chain of visual transformations. Benefits this enables (in subsequent commits): - Display list commands become immutable - no more translate_by() - Single RefPtr<AccumulatedVisualContext> replaces separate scroll_frame_id and ClipFrame on commands - LCA-based tree traversal during playback for efficient save/restore - transform_point_for_hit_test() provides coordinate transformation for hit testing using the same structure
2026-01-13 16:30:32 -03:00
*
* SPDX-License-Identifier: BSD-2-Clause
*/
LibWeb: Add AccumulatedVisualContext debugging infrastructure
2026-01-13 16:40:48 -03:00
#include <AK/StringBuilder.h>
LibWeb: Introduce AccumulatedVisualContext Introduce AccumulatedVisualContext, a tree structure that tracks the cumulative visual state (scroll offsets, clip regions, transforms, perspective) for each paintable box. Motivation: Before this change, visual state was fragmented across multiple mechanisms: - ClipFrame: Tracked clip rectangles, each storing its own enclosing_scroll_frame_id to handle scroll offset adjustments - scroll_frame_id: Passed separately to each display list command - PushStackingContext: Stored transform matrices directly in the command - Every display list command implemented translate_by() (45 methods total) to allow scroll offset adjustment during playback This fragmentation led to: - Complex, error-prone coordinate transformation logic scattered throughout the codebase - Commands being mutated during playback to apply scroll offsets - Duplicate logic between painting and hit testing for coordinate transformations Solution: AccumulatedVisualContext builds a tree where each node represents a single visual operation: - ScrollData: A scroll frame with its ID - ClipData: A clip rectangle with optional border radii - TransformData: A 4x4 transform matrix with its origin - PerspectiveData: A perspective projection matrix Each PaintableBox stores a reference to its accumulated context node. The tree structure naturally captures the parent-child relationships, so traversing from any node to the root gives the complete chain of visual transformations. Benefits this enables (in subsequent commits): - Display list commands become immutable - no more translate_by() - Single RefPtr<AccumulatedVisualContext> replaces separate scroll_frame_id and ClipFrame on commands - LCA-based tree traversal during playback for efficient save/restore - transform_point_for_hit_test() provides coordinate transformation for hit testing using the same structure
2026-01-13 16:30:32 -03:00
#include <LibGfx/Matrix4x4.h>
#include <LibWeb/Painting/AccumulatedVisualContext.h>
LibWeb: Remove CSS pixel offsets from ScrollState This was arguably put in a worse place by #8162; we mostly need the device pixel offsets from the scroll state so keep track of those and convert back to CSS pixels when necessary (i.e. scrollbar data).
2026-02-26 11:38:47 -03:00
#include <LibWeb/Painting/ScrollState.h>
LibWeb: Introduce AccumulatedVisualContext Introduce AccumulatedVisualContext, a tree structure that tracks the cumulative visual state (scroll offsets, clip regions, transforms, perspective) for each paintable box. Motivation: Before this change, visual state was fragmented across multiple mechanisms: - ClipFrame: Tracked clip rectangles, each storing its own enclosing_scroll_frame_id to handle scroll offset adjustments - scroll_frame_id: Passed separately to each display list command - PushStackingContext: Stored transform matrices directly in the command - Every display list command implemented translate_by() (45 methods total) to allow scroll offset adjustment during playback This fragmentation led to: - Complex, error-prone coordinate transformation logic scattered throughout the codebase - Commands being mutated during playback to apply scroll offsets - Duplicate logic between painting and hit testing for coordinate transformations Solution: AccumulatedVisualContext builds a tree where each node represents a single visual operation: - ScrollData: A scroll frame with its ID - ClipData: A clip rectangle with optional border radii - TransformData: A 4x4 transform matrix with its origin - PerspectiveData: A perspective projection matrix Each PaintableBox stores a reference to its accumulated context node. The tree structure naturally captures the parent-child relationships, so traversing from any node to the root gives the complete chain of visual transformations. Benefits this enables (in subsequent commits): - Display list commands become immutable - no more translate_by() - Single RefPtr<AccumulatedVisualContext> replaces separate scroll_frame_id and ClipFrame on commands - LCA-based tree traversal during playback for efficient save/restore - transform_point_for_hit_test() provides coordinate transformation for hit testing using the same structure
2026-01-13 16:30:32 -03:00
namespace Web::Painting {
LibWeb: Store visual context nodes in arena-based tree Replace per-node heap-allocated AtomicRefCounted AccumulatedVisualContext objects with a single contiguous Vector inside AccumulatedVisualContextTree. All nodes for a frame are now stored in one allocation, using type-safe VisualContextIndex instead of RefPtr pointers. This reduces allocation churn, improves cache locality, and opens the door for future snapshotting of visual context state — similar to how scroll offsets are snapshotted today.
2026-03-10 20:21:46 -03:00
bool ClipData::contains(DevicePixelPoint point) const
LibWeb: Introduce AccumulatedVisualContext Introduce AccumulatedVisualContext, a tree structure that tracks the cumulative visual state (scroll offsets, clip regions, transforms, perspective) for each paintable box. Motivation: Before this change, visual state was fragmented across multiple mechanisms: - ClipFrame: Tracked clip rectangles, each storing its own enclosing_scroll_frame_id to handle scroll offset adjustments - scroll_frame_id: Passed separately to each display list command - PushStackingContext: Stored transform matrices directly in the command - Every display list command implemented translate_by() (45 methods total) to allow scroll offset adjustment during playback This fragmentation led to: - Complex, error-prone coordinate transformation logic scattered throughout the codebase - Commands being mutated during playback to apply scroll offsets - Duplicate logic between painting and hit testing for coordinate transformations Solution: AccumulatedVisualContext builds a tree where each node represents a single visual operation: - ScrollData: A scroll frame with its ID - ClipData: A clip rectangle with optional border radii - TransformData: A 4x4 transform matrix with its origin - PerspectiveData: A perspective projection matrix Each PaintableBox stores a reference to its accumulated context node. The tree structure naturally captures the parent-child relationships, so traversing from any node to the root gives the complete chain of visual transformations. Benefits this enables (in subsequent commits): - Display list commands become immutable - no more translate_by() - Single RefPtr<AccumulatedVisualContext> replaces separate scroll_frame_id and ClipFrame on commands - LCA-based tree traversal during playback for efficient save/restore - transform_point_for_hit_test() provides coordinate transformation for hit testing using the same structure
2026-01-13 16:30:32 -03:00
{
LibWeb: Store visual context nodes in arena-based tree Replace per-node heap-allocated AtomicRefCounted AccumulatedVisualContext objects with a single contiguous Vector inside AccumulatedVisualContextTree. All nodes for a frame are now stored in one allocation, using type-safe VisualContextIndex instead of RefPtr pointers. This reduces allocation churn, improves cache locality, and opens the door for future snapshotting of visual context state — similar to how scroll offsets are snapshotted today.
2026-03-10 20:21:46 -03:00
return corner_radii.contains(point.to_type<int>(), rect.to_type<int>());
LibWeb: Introduce AccumulatedVisualContext Introduce AccumulatedVisualContext, a tree structure that tracks the cumulative visual state (scroll offsets, clip regions, transforms, perspective) for each paintable box. Motivation: Before this change, visual state was fragmented across multiple mechanisms: - ClipFrame: Tracked clip rectangles, each storing its own enclosing_scroll_frame_id to handle scroll offset adjustments - scroll_frame_id: Passed separately to each display list command - PushStackingContext: Stored transform matrices directly in the command - Every display list command implemented translate_by() (45 methods total) to allow scroll offset adjustment during playback This fragmentation led to: - Complex, error-prone coordinate transformation logic scattered throughout the codebase - Commands being mutated during playback to apply scroll offsets - Duplicate logic between painting and hit testing for coordinate transformations Solution: AccumulatedVisualContext builds a tree where each node represents a single visual operation: - ScrollData: A scroll frame with its ID - ClipData: A clip rectangle with optional border radii - TransformData: A 4x4 transform matrix with its origin - PerspectiveData: A perspective projection matrix Each PaintableBox stores a reference to its accumulated context node. The tree structure naturally captures the parent-child relationships, so traversing from any node to the root gives the complete chain of visual transformations. Benefits this enables (in subsequent commits): - Display list commands become immutable - no more translate_by() - Single RefPtr<AccumulatedVisualContext> replaces separate scroll_frame_id and ClipFrame on commands - LCA-based tree traversal during playback for efficient save/restore - transform_point_for_hit_test() provides coordinate transformation for hit testing using the same structure
2026-01-13 16:30:32 -03:00
}
LibWeb: Store visual context nodes in arena-based tree Replace per-node heap-allocated AtomicRefCounted AccumulatedVisualContext objects with a single contiguous Vector inside AccumulatedVisualContextTree. All nodes for a frame are now stored in one allocation, using type-safe VisualContextIndex instead of RefPtr pointers. This reduces allocation churn, improves cache locality, and opens the door for future snapshotting of visual context state — similar to how scroll offsets are snapshotted today.
2026-03-10 20:21:46 -03:00
NonnullRefPtr<AccumulatedVisualContextTree> AccumulatedVisualContextTree::create()
LibWeb: Account for border-radius in hit testing This change adds border-radius awareness to hit testing in two places: 1. ClipData::contains() now uses BorderRadiiData::contains() to properly check if a point is inside a rounded clip rect. This handles overflow clips from ancestor elements that have border-radius. 2. PaintableBox::hit_test() now directly checks the element's own border-radius before reporting a hit.
2026-01-19 03:19:23 -03:00
{
LibWeb: Store visual context nodes in arena-based tree Replace per-node heap-allocated AtomicRefCounted AccumulatedVisualContext objects with a single contiguous Vector inside AccumulatedVisualContextTree. All nodes for a frame are now stored in one allocation, using type-safe VisualContextIndex instead of RefPtr pointers. This reduces allocation churn, improves cache locality, and opens the door for future snapshotting of visual context state — similar to how scroll offsets are snapshotted today.
2026-03-10 20:21:46 -03:00
auto visual_context_tree = adopt_ref(*new AccumulatedVisualContextTree());
// Sentinel at index 0 (null context). Data type doesn't matter; it's never accessed.
LibWeb: Store scroll frames by value in contiguous storage Replace per-frame heap-allocated RefCounted ScrollFrame objects with a single contiguous Vector<ScrollFrame> inside ScrollState. All frames for a viewport are now stored in one allocation, using type-safe ScrollFrameIndex instead of RefPtr pointers. This reduces allocation churn, improves cache locality, and moves parent-chain traversal (cumulative offset, nearest scrolling ancestor) into ScrollState — similar to how visual context nodes were recently consolidated into AccumulatedVisualContextTree.
2026-03-11 19:07:02 -03:00
visual_context_tree->m_nodes.append({ ScrollData { {}, false }, {}, 0, false });
LibWeb: Store visual context nodes in arena-based tree Replace per-node heap-allocated AtomicRefCounted AccumulatedVisualContext objects with a single contiguous Vector inside AccumulatedVisualContextTree. All nodes for a frame are now stored in one allocation, using type-safe VisualContextIndex instead of RefPtr pointers. This reduces allocation churn, improves cache locality, and opens the door for future snapshotting of visual context state — similar to how scroll offsets are snapshotted today.
2026-03-10 20:21:46 -03:00
return visual_context_tree;
}
VisualContextIndex AccumulatedVisualContextTree::append(VisualContextData data, VisualContextIndex parent_index)
{
size_t depth = parent_index.value() ? m_nodes[parent_index.value()].depth + 1 : 1;
bool empty_clip = false;
if (parent_index.value() && m_nodes[parent_index.value()].has_empty_effective_clip) {
empty_clip = true;
} else if (data.has<ClipData>()) {
empty_clip = data.get<ClipData>().rect.is_empty();
} else if (data.has<ClipPathData>()) {
empty_clip = data.get<ClipPathData>().path.bounding_box().is_empty();
}
auto index = VisualContextIndex(m_nodes.size());
m_nodes.append({ move(data), parent_index, depth, empty_clip });
return index;
}
VisualContextIndex AccumulatedVisualContextTree::find_common_ancestor(VisualContextIndex a, VisualContextIndex b) const
{
if (!a.value() || !b.value())
return {};
size_t a_index = a.value();
size_t b_index = b.value();
while (m_nodes[a_index].depth > m_nodes[b_index].depth)
a_index = m_nodes[a_index].parent_index.value();
while (m_nodes[b_index].depth > m_nodes[a_index].depth)
b_index = m_nodes[b_index].parent_index.value();
while (a_index != b_index) {
a_index = m_nodes[a_index].parent_index.value();
b_index = m_nodes[b_index].parent_index.value();
}
LibWeb: Don't tear down an active effect saveLayer during culling check Before applying an effect context (filter, opacity, blend-mode), the display list player runs a culling check by tentatively switching to the effect's parent first. When the effect was already on the stack (i.e. the current context was a descendant of the target) that walk restored the saveLayer prematurely. The filter was then applied to a partial batch of commands, and subsequent commands opened a fresh saveLayer for a second, independent application, producing visibly wrong compositing. Fold the culling check into switch_to_context: while walking down to apply contexts, check the bounding rect right before each EffectsData node and abort if the command is fully clipped. Walks that only go up never traverse an EffectsData node, so an already-applied effect is never torn down. This regressed in cd0705334be55faedcedaec78fdb541d85bdd059.
2026-04-28 10:27:55 -03:00
return a_index;
LibWeb: Store visual context nodes in arena-based tree Replace per-node heap-allocated AtomicRefCounted AccumulatedVisualContext objects with a single contiguous Vector inside AccumulatedVisualContextTree. All nodes for a frame are now stored in one allocation, using type-safe VisualContextIndex instead of RefPtr pointers. This reduces allocation churn, improves cache locality, and opens the door for future snapshotting of visual context state — similar to how scroll offsets are snapshotted today.
2026-03-10 20:21:46 -03:00
}
Vector<size_t, 8> AccumulatedVisualContextTree::build_ancestor_chain(VisualContextIndex index) const
{
auto const& node = m_nodes[index.value()];
Vector<size_t, 8> chain;
chain.ensure_capacity(node.depth);
for (size_t i = index.value(); i; i = m_nodes[i].parent_index.value())
chain.append(i);
return chain;
LibWeb: Account for border-radius in hit testing This change adds border-radius awareness to hit testing in two places: 1. ClipData::contains() now uses BorderRadiiData::contains() to properly check if a point is inside a rounded clip rect. This handles overflow clips from ancestor elements that have border-radius. 2. PaintableBox::hit_test() now directly checks the element's own border-radius before reporting a hit.
2026-01-19 03:19:23 -03:00
}
LibWeb: Store visual context nodes in arena-based tree Replace per-node heap-allocated AtomicRefCounted AccumulatedVisualContext objects with a single contiguous Vector inside AccumulatedVisualContextTree. All nodes for a frame are now stored in one allocation, using type-safe VisualContextIndex instead of RefPtr pointers. This reduces allocation churn, improves cache locality, and opens the door for future snapshotting of visual context state — similar to how scroll offsets are snapshotted today.
2026-03-10 20:21:46 -03:00
Optional<Gfx::FloatPoint> AccumulatedVisualContextTree::transform_point_for_hit_test(VisualContextIndex index, Gfx::FloatPoint screen_point, ScrollStateSnapshot const& scroll_state) const
LibWeb: Introduce AccumulatedVisualContext Introduce AccumulatedVisualContext, a tree structure that tracks the cumulative visual state (scroll offsets, clip regions, transforms, perspective) for each paintable box. Motivation: Before this change, visual state was fragmented across multiple mechanisms: - ClipFrame: Tracked clip rectangles, each storing its own enclosing_scroll_frame_id to handle scroll offset adjustments - scroll_frame_id: Passed separately to each display list command - PushStackingContext: Stored transform matrices directly in the command - Every display list command implemented translate_by() (45 methods total) to allow scroll offset adjustment during playback This fragmentation led to: - Complex, error-prone coordinate transformation logic scattered throughout the codebase - Commands being mutated during playback to apply scroll offsets - Duplicate logic between painting and hit testing for coordinate transformations Solution: AccumulatedVisualContext builds a tree where each node represents a single visual operation: - ScrollData: A scroll frame with its ID - ClipData: A clip rectangle with optional border radii - TransformData: A 4x4 transform matrix with its origin - PerspectiveData: A perspective projection matrix Each PaintableBox stores a reference to its accumulated context node. The tree structure naturally captures the parent-child relationships, so traversing from any node to the root gives the complete chain of visual transformations. Benefits this enables (in subsequent commits): - Display list commands become immutable - no more translate_by() - Single RefPtr<AccumulatedVisualContext> replaces separate scroll_frame_id and ClipFrame on commands - LCA-based tree traversal during playback for efficient save/restore - transform_point_for_hit_test() provides coordinate transformation for hit testing using the same structure
2026-01-13 16:30:32 -03:00
{
LibWeb: Store visual context nodes in arena-based tree Replace per-node heap-allocated AtomicRefCounted AccumulatedVisualContext objects with a single contiguous Vector inside AccumulatedVisualContextTree. All nodes for a frame are now stored in one allocation, using type-safe VisualContextIndex instead of RefPtr pointers. This reduces allocation churn, improves cache locality, and opens the door for future snapshotting of visual context state — similar to how scroll offsets are snapshotted today.
2026-03-10 20:21:46 -03:00
if (!index.value())
return screen_point;
auto chain = build_ancestor_chain(index);
LibWeb: Introduce AccumulatedVisualContext Introduce AccumulatedVisualContext, a tree structure that tracks the cumulative visual state (scroll offsets, clip regions, transforms, perspective) for each paintable box. Motivation: Before this change, visual state was fragmented across multiple mechanisms: - ClipFrame: Tracked clip rectangles, each storing its own enclosing_scroll_frame_id to handle scroll offset adjustments - scroll_frame_id: Passed separately to each display list command - PushStackingContext: Stored transform matrices directly in the command - Every display list command implemented translate_by() (45 methods total) to allow scroll offset adjustment during playback This fragmentation led to: - Complex, error-prone coordinate transformation logic scattered throughout the codebase - Commands being mutated during playback to apply scroll offsets - Duplicate logic between painting and hit testing for coordinate transformations Solution: AccumulatedVisualContext builds a tree where each node represents a single visual operation: - ScrollData: A scroll frame with its ID - ClipData: A clip rectangle with optional border radii - TransformData: A 4x4 transform matrix with its origin - PerspectiveData: A perspective projection matrix Each PaintableBox stores a reference to its accumulated context node. The tree structure naturally captures the parent-child relationships, so traversing from any node to the root gives the complete chain of visual transformations. Benefits this enables (in subsequent commits): - Display list commands become immutable - no more translate_by() - Single RefPtr<AccumulatedVisualContext> replaces separate scroll_frame_id and ClipFrame on commands - LCA-based tree traversal during playback for efficient save/restore - transform_point_for_hit_test() provides coordinate transformation for hit testing using the same structure
2026-01-13 16:30:32 -03:00
auto point = screen_point;
for (size_t i = chain.size(); i > 0; --i) {
LibWeb: Store visual context nodes in arena-based tree Replace per-node heap-allocated AtomicRefCounted AccumulatedVisualContext objects with a single contiguous Vector inside AccumulatedVisualContextTree. All nodes for a frame are now stored in one allocation, using type-safe VisualContextIndex instead of RefPtr pointers. This reduces allocation churn, improves cache locality, and opens the door for future snapshotting of visual context state — similar to how scroll offsets are snapshotted today.
2026-03-10 20:21:46 -03:00
auto const& node = m_nodes[chain[i - 1]];
LibWeb: Introduce AccumulatedVisualContext Introduce AccumulatedVisualContext, a tree structure that tracks the cumulative visual state (scroll offsets, clip regions, transforms, perspective) for each paintable box. Motivation: Before this change, visual state was fragmented across multiple mechanisms: - ClipFrame: Tracked clip rectangles, each storing its own enclosing_scroll_frame_id to handle scroll offset adjustments - scroll_frame_id: Passed separately to each display list command - PushStackingContext: Stored transform matrices directly in the command - Every display list command implemented translate_by() (45 methods total) to allow scroll offset adjustment during playback This fragmentation led to: - Complex, error-prone coordinate transformation logic scattered throughout the codebase - Commands being mutated during playback to apply scroll offsets - Duplicate logic between painting and hit testing for coordinate transformations Solution: AccumulatedVisualContext builds a tree where each node represents a single visual operation: - ScrollData: A scroll frame with its ID - ClipData: A clip rectangle with optional border radii - TransformData: A 4x4 transform matrix with its origin - PerspectiveData: A perspective projection matrix Each PaintableBox stores a reference to its accumulated context node. The tree structure naturally captures the parent-child relationships, so traversing from any node to the root gives the complete chain of visual transformations. Benefits this enables (in subsequent commits): - Display list commands become immutable - no more translate_by() - Single RefPtr<AccumulatedVisualContext> replaces separate scroll_frame_id and ClipFrame on commands - LCA-based tree traversal during playback for efficient save/restore - transform_point_for_hit_test() provides coordinate transformation for hit testing using the same structure
2026-01-13 16:30:32 -03:00
LibWeb: Store visual context nodes in arena-based tree Replace per-node heap-allocated AtomicRefCounted AccumulatedVisualContext objects with a single contiguous Vector inside AccumulatedVisualContextTree. All nodes for a frame are now stored in one allocation, using type-safe VisualContextIndex instead of RefPtr pointers. This reduces allocation churn, improves cache locality, and opens the door for future snapshotting of visual context state — similar to how scroll offsets are snapshotted today.
2026-03-10 20:21:46 -03:00
auto result = node.data.visit(
LibWeb: Use device-pixel coordinates in display list and AVC Stop converting between CSS and device pixels as part of rendering - the display list should be as simple as possible, so convert to DevicePixels once when constructing the display list.
2026-02-25 13:09:59 -03:00
[&](PerspectiveData const& perspective) -> Optional<Gfx::FloatPoint> {
LibWeb: Introduce AccumulatedVisualContext Introduce AccumulatedVisualContext, a tree structure that tracks the cumulative visual state (scroll offsets, clip regions, transforms, perspective) for each paintable box. Motivation: Before this change, visual state was fragmented across multiple mechanisms: - ClipFrame: Tracked clip rectangles, each storing its own enclosing_scroll_frame_id to handle scroll offset adjustments - scroll_frame_id: Passed separately to each display list command - PushStackingContext: Stored transform matrices directly in the command - Every display list command implemented translate_by() (45 methods total) to allow scroll offset adjustment during playback This fragmentation led to: - Complex, error-prone coordinate transformation logic scattered throughout the codebase - Commands being mutated during playback to apply scroll offsets - Duplicate logic between painting and hit testing for coordinate transformations Solution: AccumulatedVisualContext builds a tree where each node represents a single visual operation: - ScrollData: A scroll frame with its ID - ClipData: A clip rectangle with optional border radii - TransformData: A 4x4 transform matrix with its origin - PerspectiveData: A perspective projection matrix Each PaintableBox stores a reference to its accumulated context node. The tree structure naturally captures the parent-child relationships, so traversing from any node to the root gives the complete chain of visual transformations. Benefits this enables (in subsequent commits): - Display list commands become immutable - no more translate_by() - Single RefPtr<AccumulatedVisualContext> replaces separate scroll_frame_id and ClipFrame on commands - LCA-based tree traversal during playback for efficient save/restore - transform_point_for_hit_test() provides coordinate transformation for hit testing using the same structure
2026-01-13 16:30:32 -03:00
auto affine = Gfx::extract_2d_affine_transform(perspective.matrix);
auto inverse = affine.inverse();
if (!inverse.has_value())
return {};
LibWeb: Use device-pixel coordinates in display list and AVC Stop converting between CSS and device pixels as part of rendering - the display list should be as simple as possible, so convert to DevicePixels once when constructing the display list.
2026-02-25 13:09:59 -03:00
point = inverse->map(point);
LibWeb: Introduce AccumulatedVisualContext Introduce AccumulatedVisualContext, a tree structure that tracks the cumulative visual state (scroll offsets, clip regions, transforms, perspective) for each paintable box. Motivation: Before this change, visual state was fragmented across multiple mechanisms: - ClipFrame: Tracked clip rectangles, each storing its own enclosing_scroll_frame_id to handle scroll offset adjustments - scroll_frame_id: Passed separately to each display list command - PushStackingContext: Stored transform matrices directly in the command - Every display list command implemented translate_by() (45 methods total) to allow scroll offset adjustment during playback This fragmentation led to: - Complex, error-prone coordinate transformation logic scattered throughout the codebase - Commands being mutated during playback to apply scroll offsets - Duplicate logic between painting and hit testing for coordinate transformations Solution: AccumulatedVisualContext builds a tree where each node represents a single visual operation: - ScrollData: A scroll frame with its ID - ClipData: A clip rectangle with optional border radii - TransformData: A 4x4 transform matrix with its origin - PerspectiveData: A perspective projection matrix Each PaintableBox stores a reference to its accumulated context node. The tree structure naturally captures the parent-child relationships, so traversing from any node to the root gives the complete chain of visual transformations. Benefits this enables (in subsequent commits): - Display list commands become immutable - no more translate_by() - Single RefPtr<AccumulatedVisualContext> replaces separate scroll_frame_id and ClipFrame on commands - LCA-based tree traversal during playback for efficient save/restore - transform_point_for_hit_test() provides coordinate transformation for hit testing using the same structure
2026-01-13 16:30:32 -03:00
return point;
},
LibWeb: Use device-pixel coordinates in display list and AVC Stop converting between CSS and device pixels as part of rendering - the display list should be as simple as possible, so convert to DevicePixels once when constructing the display list.
2026-02-25 13:09:59 -03:00
[&](ScrollData const& scroll) -> Optional<Gfx::FloatPoint> {
LibWeb: Store scroll frames by value in contiguous storage Replace per-frame heap-allocated RefCounted ScrollFrame objects with a single contiguous Vector<ScrollFrame> inside ScrollState. All frames for a viewport are now stored in one allocation, using type-safe ScrollFrameIndex instead of RefPtr pointers. This reduces allocation churn, improves cache locality, and moves parent-chain traversal (cumulative offset, nearest scrolling ancestor) into ScrollState — similar to how visual context nodes were recently consolidated into AccumulatedVisualContextTree.
2026-03-11 19:07:02 -03:00
point.translate_by(-scroll_state.device_offset_for_index(scroll.scroll_frame_index));
LibWeb: Introduce AccumulatedVisualContext Introduce AccumulatedVisualContext, a tree structure that tracks the cumulative visual state (scroll offsets, clip regions, transforms, perspective) for each paintable box. Motivation: Before this change, visual state was fragmented across multiple mechanisms: - ClipFrame: Tracked clip rectangles, each storing its own enclosing_scroll_frame_id to handle scroll offset adjustments - scroll_frame_id: Passed separately to each display list command - PushStackingContext: Stored transform matrices directly in the command - Every display list command implemented translate_by() (45 methods total) to allow scroll offset adjustment during playback This fragmentation led to: - Complex, error-prone coordinate transformation logic scattered throughout the codebase - Commands being mutated during playback to apply scroll offsets - Duplicate logic between painting and hit testing for coordinate transformations Solution: AccumulatedVisualContext builds a tree where each node represents a single visual operation: - ScrollData: A scroll frame with its ID - ClipData: A clip rectangle with optional border radii - TransformData: A 4x4 transform matrix with its origin - PerspectiveData: A perspective projection matrix Each PaintableBox stores a reference to its accumulated context node. The tree structure naturally captures the parent-child relationships, so traversing from any node to the root gives the complete chain of visual transformations. Benefits this enables (in subsequent commits): - Display list commands become immutable - no more translate_by() - Single RefPtr<AccumulatedVisualContext> replaces separate scroll_frame_id and ClipFrame on commands - LCA-based tree traversal during playback for efficient save/restore - transform_point_for_hit_test() provides coordinate transformation for hit testing using the same structure
2026-01-13 16:30:32 -03:00
return point;
},
LibWeb: Use device-pixel coordinates in display list and AVC Stop converting between CSS and device pixels as part of rendering - the display list should be as simple as possible, so convert to DevicePixels once when constructing the display list.
2026-02-25 13:09:59 -03:00
[&](TransformData const& transform) -> Optional<Gfx::FloatPoint> {
LibWeb: Introduce AccumulatedVisualContext Introduce AccumulatedVisualContext, a tree structure that tracks the cumulative visual state (scroll offsets, clip regions, transforms, perspective) for each paintable box. Motivation: Before this change, visual state was fragmented across multiple mechanisms: - ClipFrame: Tracked clip rectangles, each storing its own enclosing_scroll_frame_id to handle scroll offset adjustments - scroll_frame_id: Passed separately to each display list command - PushStackingContext: Stored transform matrices directly in the command - Every display list command implemented translate_by() (45 methods total) to allow scroll offset adjustment during playback This fragmentation led to: - Complex, error-prone coordinate transformation logic scattered throughout the codebase - Commands being mutated during playback to apply scroll offsets - Duplicate logic between painting and hit testing for coordinate transformations Solution: AccumulatedVisualContext builds a tree where each node represents a single visual operation: - ScrollData: A scroll frame with its ID - ClipData: A clip rectangle with optional border radii - TransformData: A 4x4 transform matrix with its origin - PerspectiveData: A perspective projection matrix Each PaintableBox stores a reference to its accumulated context node. The tree structure naturally captures the parent-child relationships, so traversing from any node to the root gives the complete chain of visual transformations. Benefits this enables (in subsequent commits): - Display list commands become immutable - no more translate_by() - Single RefPtr<AccumulatedVisualContext> replaces separate scroll_frame_id and ClipFrame on commands - LCA-based tree traversal during playback for efficient save/restore - transform_point_for_hit_test() provides coordinate transformation for hit testing using the same structure
2026-01-13 16:30:32 -03:00
auto affine = Gfx::extract_2d_affine_transform(transform.matrix);
auto inverse = affine.inverse();
if (!inverse.has_value())
return {};
auto offset_point = point - transform.origin;
LibWeb: Use device-pixel coordinates in display list and AVC Stop converting between CSS and device pixels as part of rendering - the display list should be as simple as possible, so convert to DevicePixels once when constructing the display list.
2026-02-25 13:09:59 -03:00
auto transformed = inverse->map(offset_point);
LibWeb: Introduce AccumulatedVisualContext Introduce AccumulatedVisualContext, a tree structure that tracks the cumulative visual state (scroll offsets, clip regions, transforms, perspective) for each paintable box. Motivation: Before this change, visual state was fragmented across multiple mechanisms: - ClipFrame: Tracked clip rectangles, each storing its own enclosing_scroll_frame_id to handle scroll offset adjustments - scroll_frame_id: Passed separately to each display list command - PushStackingContext: Stored transform matrices directly in the command - Every display list command implemented translate_by() (45 methods total) to allow scroll offset adjustment during playback This fragmentation led to: - Complex, error-prone coordinate transformation logic scattered throughout the codebase - Commands being mutated during playback to apply scroll offsets - Duplicate logic between painting and hit testing for coordinate transformations Solution: AccumulatedVisualContext builds a tree where each node represents a single visual operation: - ScrollData: A scroll frame with its ID - ClipData: A clip rectangle with optional border radii - TransformData: A 4x4 transform matrix with its origin - PerspectiveData: A perspective projection matrix Each PaintableBox stores a reference to its accumulated context node. The tree structure naturally captures the parent-child relationships, so traversing from any node to the root gives the complete chain of visual transformations. Benefits this enables (in subsequent commits): - Display list commands become immutable - no more translate_by() - Single RefPtr<AccumulatedVisualContext> replaces separate scroll_frame_id and ClipFrame on commands - LCA-based tree traversal during playback for efficient save/restore - transform_point_for_hit_test() provides coordinate transformation for hit testing using the same structure
2026-01-13 16:30:32 -03:00
point = transformed + transform.origin;
return point;
},
LibWeb: Use device-pixel coordinates in display list and AVC Stop converting between CSS and device pixels as part of rendering - the display list should be as simple as possible, so convert to DevicePixels once when constructing the display list.
2026-02-25 13:09:59 -03:00
[&](ClipData const& clip) -> Optional<Gfx::FloatPoint> {
// 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 (!clip.contains(point.to_type<int>().to_type<DevicePixels>()))
LibWeb: Introduce AccumulatedVisualContext Introduce AccumulatedVisualContext, a tree structure that tracks the cumulative visual state (scroll offsets, clip regions, transforms, perspective) for each paintable box. Motivation: Before this change, visual state was fragmented across multiple mechanisms: - ClipFrame: Tracked clip rectangles, each storing its own enclosing_scroll_frame_id to handle scroll offset adjustments - scroll_frame_id: Passed separately to each display list command - PushStackingContext: Stored transform matrices directly in the command - Every display list command implemented translate_by() (45 methods total) to allow scroll offset adjustment during playback This fragmentation led to: - Complex, error-prone coordinate transformation logic scattered throughout the codebase - Commands being mutated during playback to apply scroll offsets - Duplicate logic between painting and hit testing for coordinate transformations Solution: AccumulatedVisualContext builds a tree where each node represents a single visual operation: - ScrollData: A scroll frame with its ID - ClipData: A clip rectangle with optional border radii - TransformData: A 4x4 transform matrix with its origin - PerspectiveData: A perspective projection matrix Each PaintableBox stores a reference to its accumulated context node. The tree structure naturally captures the parent-child relationships, so traversing from any node to the root gives the complete chain of visual transformations. Benefits this enables (in subsequent commits): - Display list commands become immutable - no more translate_by() - Single RefPtr<AccumulatedVisualContext> replaces separate scroll_frame_id and ClipFrame on commands - LCA-based tree traversal during playback for efficient save/restore - transform_point_for_hit_test() provides coordinate transformation for hit testing using the same structure
2026-01-13 16:30:32 -03:00
return {};
return point;
LibWeb: Integrate clip-path into AccumulatedVisualContext Previously, clip-path was applied only during painting in StackingContext::paint(), which meant hit testing did not respect clip-path boundaries. Clicks outside the visible clipped region but inside the element's bounding box would incorrectly register as hits. By moving clip-path into AccumulatedVisualContext, it becomes part of the same system that handles transforms, clips, and scroll offsets for both painting and hit testing, ensuring consistent behavior.
2026-01-15 23:56:34 -03:00
},
LibWeb: Use device-pixel coordinates in display list and AVC Stop converting between CSS and device pixels as part of rendering - the display list should be as simple as possible, so convert to DevicePixels once when constructing the display list.
2026-02-25 13:09:59 -03:00
[&](ClipPathData const& clip_path) -> Optional<Gfx::FloatPoint> {
// 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 (!clip_path.bounding_rect.contains(point.to_type<int>().to_type<DevicePixels>()))
LibWeb: Integrate clip-path into AccumulatedVisualContext Previously, clip-path was applied only during painting in StackingContext::paint(), which meant hit testing did not respect clip-path boundaries. Clicks outside the visible clipped region but inside the element's bounding box would incorrectly register as hits. By moving clip-path into AccumulatedVisualContext, it becomes part of the same system that handles transforms, clips, and scroll offsets for both painting and hit testing, ensuring consistent behavior.
2026-01-15 23:56:34 -03:00
return {};
LibWeb: Use device-pixel coordinates in display list and AVC Stop converting between CSS and device pixels as part of rendering - the display list should be as simple as possible, so convert to DevicePixels once when constructing the display list.
2026-02-25 13:09:59 -03:00
if (!clip_path.path.contains(point, clip_path.fill_rule))
LibWeb: Integrate clip-path into AccumulatedVisualContext Previously, clip-path was applied only during painting in StackingContext::paint(), which meant hit testing did not respect clip-path boundaries. Clicks outside the visible clipped region but inside the element's bounding box would incorrectly register as hits. By moving clip-path into AccumulatedVisualContext, it becomes part of the same system that handles transforms, clips, and scroll offsets for both painting and hit testing, ensuring consistent behavior.
2026-01-15 23:56:34 -03:00
return {};
return point;
LibWeb: Move effects application into AccumulatedVisualContext Effects (opacity, blend mode, filters) must be applied in the parent's coordinate space, before the element's transform. Previously this was handled by manually switching to the parent's visual context when applying effects at paint time. By adding EffectsData to AccumulatedVisualContext and positioning it before TransformData in the chain, effects are now naturally applied in the correct order during display list replay, eliminating the special case in StackingContext::paint(). For SVG filters that can generate content from empty elements (feFlood, feImage, feTurbulence), a transparent FillRect command is emitted to trigger the filter through the same AVC pipeline.
2026-01-21 07:08:32 -03:00
},
LibWeb: Use device-pixel coordinates in display list and AVC Stop converting between CSS and device pixels as part of rendering - the display list should be as simple as possible, so convert to DevicePixels once when constructing the display list.
2026-02-25 13:09:59 -03:00
[&](EffectsData const&) -> Optional<Gfx::FloatPoint> {
LibWeb: Move effects application into AccumulatedVisualContext Effects (opacity, blend mode, filters) must be applied in the parent's coordinate space, before the element's transform. Previously this was handled by manually switching to the parent's visual context when applying effects at paint time. By adding EffectsData to AccumulatedVisualContext and positioning it before TransformData in the chain, effects are now naturally applied in the correct order during display list replay, eliminating the special case in StackingContext::paint(). For SVG filters that can generate content from empty elements (feFlood, feImage, feTurbulence), a transparent FillRect command is emitted to trigger the filter through the same AVC pipeline.
2026-01-21 07:08:32 -03:00
// Effects don't affect coordinate transforms
return point;
LibWeb: Introduce AccumulatedVisualContext Introduce AccumulatedVisualContext, a tree structure that tracks the cumulative visual state (scroll offsets, clip regions, transforms, perspective) for each paintable box. Motivation: Before this change, visual state was fragmented across multiple mechanisms: - ClipFrame: Tracked clip rectangles, each storing its own enclosing_scroll_frame_id to handle scroll offset adjustments - scroll_frame_id: Passed separately to each display list command - PushStackingContext: Stored transform matrices directly in the command - Every display list command implemented translate_by() (45 methods total) to allow scroll offset adjustment during playback This fragmentation led to: - Complex, error-prone coordinate transformation logic scattered throughout the codebase - Commands being mutated during playback to apply scroll offsets - Duplicate logic between painting and hit testing for coordinate transformations Solution: AccumulatedVisualContext builds a tree where each node represents a single visual operation: - ScrollData: A scroll frame with its ID - ClipData: A clip rectangle with optional border radii - TransformData: A 4x4 transform matrix with its origin - PerspectiveData: A perspective projection matrix Each PaintableBox stores a reference to its accumulated context node. The tree structure naturally captures the parent-child relationships, so traversing from any node to the root gives the complete chain of visual transformations. Benefits this enables (in subsequent commits): - Display list commands become immutable - no more translate_by() - Single RefPtr<AccumulatedVisualContext> replaces separate scroll_frame_id and ClipFrame on commands - LCA-based tree traversal during playback for efficient save/restore - transform_point_for_hit_test() provides coordinate transformation for hit testing using the same structure
2026-01-13 16:30:32 -03:00
});
if (!result.has_value())
return {};
}
return point;
}
LibWeb: Store visual context nodes in arena-based tree Replace per-node heap-allocated AtomicRefCounted AccumulatedVisualContext objects with a single contiguous Vector inside AccumulatedVisualContextTree. All nodes for a frame are now stored in one allocation, using type-safe VisualContextIndex instead of RefPtr pointers. This reduces allocation churn, improves cache locality, and opens the door for future snapshotting of visual context state — similar to how scroll offsets are snapshotted today.
2026-03-10 20:21:46 -03:00
Gfx::FloatPoint AccumulatedVisualContextTree::inverse_transform_point(VisualContextIndex index, Gfx::FloatPoint screen_point) const
LibWeb: Fix mouse event offset computation with nested CSS transforms compute_mouse_event_offset() only inverted the target element's own CSS transform, ignoring ancestor transforms. This caused incorrect offsetX/ offsetY values when elements were nested inside transformed parents. Use AccumulatedVisualContext::inverse_transform_point() to invert the full ancestor transform chain instead.
2026-01-31 11:34:23 -03:00
{
LibWeb: Store visual context nodes in arena-based tree Replace per-node heap-allocated AtomicRefCounted AccumulatedVisualContext objects with a single contiguous Vector inside AccumulatedVisualContextTree. All nodes for a frame are now stored in one allocation, using type-safe VisualContextIndex instead of RefPtr pointers. This reduces allocation churn, improves cache locality, and opens the door for future snapshotting of visual context state — similar to how scroll offsets are snapshotted today.
2026-03-10 20:21:46 -03:00
if (!index.value())
return screen_point;
auto chain = build_ancestor_chain(index);
LibWeb: Fix mouse event offset computation with nested CSS transforms compute_mouse_event_offset() only inverted the target element's own CSS transform, ignoring ancestor transforms. This caused incorrect offsetX/ offsetY values when elements were nested inside transformed parents. Use AccumulatedVisualContext::inverse_transform_point() to invert the full ancestor transform chain instead.
2026-01-31 11:34:23 -03:00
auto point = screen_point;
for (size_t i = chain.size(); i > 0; --i) {
LibWeb: Store visual context nodes in arena-based tree Replace per-node heap-allocated AtomicRefCounted AccumulatedVisualContext objects with a single contiguous Vector inside AccumulatedVisualContextTree. All nodes for a frame are now stored in one allocation, using type-safe VisualContextIndex instead of RefPtr pointers. This reduces allocation churn, improves cache locality, and opens the door for future snapshotting of visual context state — similar to how scroll offsets are snapshotted today.
2026-03-10 20:21:46 -03:00
auto const& node = m_nodes[chain[i - 1]];
LibWeb: Fix mouse event offset computation with nested CSS transforms compute_mouse_event_offset() only inverted the target element's own CSS transform, ignoring ancestor transforms. This caused incorrect offsetX/ offsetY values when elements were nested inside transformed parents. Use AccumulatedVisualContext::inverse_transform_point() to invert the full ancestor transform chain instead.
2026-01-31 11:34:23 -03:00
LibWeb: Store visual context nodes in arena-based tree Replace per-node heap-allocated AtomicRefCounted AccumulatedVisualContext objects with a single contiguous Vector inside AccumulatedVisualContextTree. All nodes for a frame are now stored in one allocation, using type-safe VisualContextIndex instead of RefPtr pointers. This reduces allocation churn, improves cache locality, and opens the door for future snapshotting of visual context state — similar to how scroll offsets are snapshotted today.
2026-03-10 20:21:46 -03:00
node.data.visit(
LibWeb: Fix mouse event offset computation with nested CSS transforms compute_mouse_event_offset() only inverted the target element's own CSS transform, ignoring ancestor transforms. This caused incorrect offsetX/ offsetY values when elements were nested inside transformed parents. Use AccumulatedVisualContext::inverse_transform_point() to invert the full ancestor transform chain instead.
2026-01-31 11:34:23 -03:00
[&](PerspectiveData const& perspective) {
auto affine = Gfx::extract_2d_affine_transform(perspective.matrix);
auto inverse = affine.inverse();
if (inverse.has_value())
LibWeb: Use device-pixel coordinates in display list and AVC Stop converting between CSS and device pixels as part of rendering - the display list should be as simple as possible, so convert to DevicePixels once when constructing the display list.
2026-02-25 13:09:59 -03:00
point = inverse->map(point);
LibWeb: Fix mouse event offset computation with nested CSS transforms compute_mouse_event_offset() only inverted the target element's own CSS transform, ignoring ancestor transforms. This caused incorrect offsetX/ offsetY values when elements were nested inside transformed parents. Use AccumulatedVisualContext::inverse_transform_point() to invert the full ancestor transform chain instead.
2026-01-31 11:34:23 -03:00
},
[&](TransformData const& transform) {
auto affine = Gfx::extract_2d_affine_transform(transform.matrix);
auto inverse = affine.inverse();
if (inverse.has_value()) {
auto offset_point = point - transform.origin;
LibWeb: Use device-pixel coordinates in display list and AVC Stop converting between CSS and device pixels as part of rendering - the display list should be as simple as possible, so convert to DevicePixels once when constructing the display list.
2026-02-25 13:09:59 -03:00
auto transformed = inverse->map(offset_point);
LibWeb: Fix mouse event offset computation with nested CSS transforms compute_mouse_event_offset() only inverted the target element's own CSS transform, ignoring ancestor transforms. This caused incorrect offsetX/ offsetY values when elements were nested inside transformed parents. Use AccumulatedVisualContext::inverse_transform_point() to invert the full ancestor transform chain instead.
2026-01-31 11:34:23 -03:00
point = transformed + transform.origin;
}
},
[&](auto const&) {});
}
return point;
}
LibWeb: Store visual context nodes in arena-based tree Replace per-node heap-allocated AtomicRefCounted AccumulatedVisualContext objects with a single contiguous Vector inside AccumulatedVisualContextTree. All nodes for a frame are now stored in one allocation, using type-safe VisualContextIndex instead of RefPtr pointers. This reduces allocation churn, improves cache locality, and opens the door for future snapshotting of visual context state — similar to how scroll offsets are snapshotted today.
2026-03-10 20:21:46 -03:00
Gfx::FloatRect AccumulatedVisualContextTree::transform_rect_to_viewport(VisualContextIndex index, Gfx::FloatRect const& source_rect, ScrollStateSnapshot const& scroll_state) const
LibWeb: Use AccumulatedVisualContext in Element::get_client_rects() The previous implementation had a bug: it composed all ancestor transforms but applied them around only the innermost element's transform origin. The correct behavior is to apply each transform around its own origin. AccumulatedVisualContext already tracks all visual transformations (transforms, scroll offsets, perspective) correctly for hit testing. This change adds a new transform_rect_to_viewport() method that performs the forward transformation (element coordinates to viewport coordinates), which is the inverse direction of transform_point_for_hit_test(). This fixes getBoundingClientRect() returning incorrect coordinates for elements inside transformed ancestors with non-default transform-origins.
2026-01-19 02:23:05 -03:00
{
LibWeb: Store visual context nodes in arena-based tree Replace per-node heap-allocated AtomicRefCounted AccumulatedVisualContext objects with a single contiguous Vector inside AccumulatedVisualContextTree. All nodes for a frame are now stored in one allocation, using type-safe VisualContextIndex instead of RefPtr pointers. This reduces allocation churn, improves cache locality, and opens the door for future snapshotting of visual context state — similar to how scroll offsets are snapshotted today.
2026-03-10 20:21:46 -03:00
if (!index.value())
return source_rect;
LibWeb: Use device-pixel coordinates in display list and AVC Stop converting between CSS and device pixels as part of rendering - the display list should be as simple as possible, so convert to DevicePixels once when constructing the display list.
2026-02-25 13:09:59 -03:00
auto rect = source_rect;
LibWeb: Store visual context nodes in arena-based tree Replace per-node heap-allocated AtomicRefCounted AccumulatedVisualContext objects with a single contiguous Vector inside AccumulatedVisualContextTree. All nodes for a frame are now stored in one allocation, using type-safe VisualContextIndex instead of RefPtr pointers. This reduces allocation churn, improves cache locality, and opens the door for future snapshotting of visual context state — similar to how scroll offsets are snapshotted today.
2026-03-10 20:21:46 -03:00
for (size_t i = index.value(); i; i = m_nodes[i].parent_index.value()) {
auto const& node = m_nodes[i];
node.data.visit(
LibWeb: Use AccumulatedVisualContext in Element::get_client_rects() The previous implementation had a bug: it composed all ancestor transforms but applied them around only the innermost element's transform origin. The correct behavior is to apply each transform around its own origin. AccumulatedVisualContext already tracks all visual transformations (transforms, scroll offsets, perspective) correctly for hit testing. This change adds a new transform_rect_to_viewport() method that performs the forward transformation (element coordinates to viewport coordinates), which is the inverse direction of transform_point_for_hit_test(). This fixes getBoundingClientRect() returning incorrect coordinates for elements inside transformed ancestors with non-default transform-origins.
2026-01-19 02:23:05 -03:00
[&](TransformData const& transform) {
auto affine = Gfx::extract_2d_affine_transform(transform.matrix);
LibWeb: Use device-pixel coordinates in display list and AVC Stop converting between CSS and device pixels as part of rendering - the display list should be as simple as possible, so convert to DevicePixels once when constructing the display list.
2026-02-25 13:09:59 -03:00
rect.translate_by(-transform.origin);
LibWeb: Use AccumulatedVisualContext in Element::get_client_rects() The previous implementation had a bug: it composed all ancestor transforms but applied them around only the innermost element's transform origin. The correct behavior is to apply each transform around its own origin. AccumulatedVisualContext already tracks all visual transformations (transforms, scroll offsets, perspective) correctly for hit testing. This change adds a new transform_rect_to_viewport() method that performs the forward transformation (element coordinates to viewport coordinates), which is the inverse direction of transform_point_for_hit_test(). This fixes getBoundingClientRect() returning incorrect coordinates for elements inside transformed ancestors with non-default transform-origins.
2026-01-19 02:23:05 -03:00
rect = affine.map(rect);
LibWeb: Use device-pixel coordinates in display list and AVC Stop converting between CSS and device pixels as part of rendering - the display list should be as simple as possible, so convert to DevicePixels once when constructing the display list.
2026-02-25 13:09:59 -03:00
rect.translate_by(transform.origin);
LibWeb: Use AccumulatedVisualContext in Element::get_client_rects() The previous implementation had a bug: it composed all ancestor transforms but applied them around only the innermost element's transform origin. The correct behavior is to apply each transform around its own origin. AccumulatedVisualContext already tracks all visual transformations (transforms, scroll offsets, perspective) correctly for hit testing. This change adds a new transform_rect_to_viewport() method that performs the forward transformation (element coordinates to viewport coordinates), which is the inverse direction of transform_point_for_hit_test(). This fixes getBoundingClientRect() returning incorrect coordinates for elements inside transformed ancestors with non-default transform-origins.
2026-01-19 02:23:05 -03:00
},
[&](PerspectiveData const& perspective) {
auto affine = Gfx::extract_2d_affine_transform(perspective.matrix);
rect = affine.map(rect);
},
[&](ScrollData const& scroll) {
LibWeb: Store scroll frames by value in contiguous storage Replace per-frame heap-allocated RefCounted ScrollFrame objects with a single contiguous Vector<ScrollFrame> inside ScrollState. All frames for a viewport are now stored in one allocation, using type-safe ScrollFrameIndex instead of RefPtr pointers. This reduces allocation churn, improves cache locality, and moves parent-chain traversal (cumulative offset, nearest scrolling ancestor) into ScrollState — similar to how visual context nodes were recently consolidated into AccumulatedVisualContextTree.
2026-03-11 19:07:02 -03:00
rect.translate_by(scroll_state.device_offset_for_index(scroll.scroll_frame_index));
LibWeb: Use AccumulatedVisualContext in Element::get_client_rects() The previous implementation had a bug: it composed all ancestor transforms but applied them around only the innermost element's transform origin. The correct behavior is to apply each transform around its own origin. AccumulatedVisualContext already tracks all visual transformations (transforms, scroll offsets, perspective) correctly for hit testing. This change adds a new transform_rect_to_viewport() method that performs the forward transformation (element coordinates to viewport coordinates), which is the inverse direction of transform_point_for_hit_test(). This fixes getBoundingClientRect() returning incorrect coordinates for elements inside transformed ancestors with non-default transform-origins.
2026-01-19 02:23:05 -03:00
},
[&](ClipData const&) { /* clips don't affect rect coordinates */ },
LibWeb: Move effects application into AccumulatedVisualContext Effects (opacity, blend mode, filters) must be applied in the parent's coordinate space, before the element's transform. Previously this was handled by manually switching to the parent's visual context when applying effects at paint time. By adding EffectsData to AccumulatedVisualContext and positioning it before TransformData in the chain, effects are now naturally applied in the correct order during display list replay, eliminating the special case in StackingContext::paint(). For SVG filters that can generate content from empty elements (feFlood, feImage, feTurbulence), a transparent FillRect command is emitted to trigger the filter through the same AVC pipeline.
2026-01-21 07:08:32 -03:00
[&](ClipPathData const&) { /* clip paths don't affect rect coordinates */ },
[&](EffectsData const&) { /* effects don't affect rect coordinates */ });
LibWeb: Use AccumulatedVisualContext in Element::get_client_rects() The previous implementation had a bug: it composed all ancestor transforms but applied them around only the innermost element's transform origin. The correct behavior is to apply each transform around its own origin. AccumulatedVisualContext already tracks all visual transformations (transforms, scroll offsets, perspective) correctly for hit testing. This change adds a new transform_rect_to_viewport() method that performs the forward transformation (element coordinates to viewport coordinates), which is the inverse direction of transform_point_for_hit_test(). This fixes getBoundingClientRect() returning incorrect coordinates for elements inside transformed ancestors with non-default transform-origins.
2026-01-19 02:23:05 -03:00
}
LibWeb: Use device-pixel coordinates in display list and AVC Stop converting between CSS and device pixels as part of rendering - the display list should be as simple as possible, so convert to DevicePixels once when constructing the display list.
2026-02-25 13:09:59 -03:00
return rect;
LibWeb: Use AccumulatedVisualContext in Element::get_client_rects() The previous implementation had a bug: it composed all ancestor transforms but applied them around only the innermost element's transform origin. The correct behavior is to apply each transform around its own origin. AccumulatedVisualContext already tracks all visual transformations (transforms, scroll offsets, perspective) correctly for hit testing. This change adds a new transform_rect_to_viewport() method that performs the forward transformation (element coordinates to viewport coordinates), which is the inverse direction of transform_point_for_hit_test(). This fixes getBoundingClientRect() returning incorrect coordinates for elements inside transformed ancestors with non-default transform-origins.
2026-01-19 02:23:05 -03:00
}
LibWeb: Store visual context nodes in arena-based tree Replace per-node heap-allocated AtomicRefCounted AccumulatedVisualContext objects with a single contiguous Vector inside AccumulatedVisualContextTree. All nodes for a frame are now stored in one allocation, using type-safe VisualContextIndex instead of RefPtr pointers. This reduces allocation churn, improves cache locality, and opens the door for future snapshotting of visual context state — similar to how scroll offsets are snapshotted today.
2026-03-10 20:21:46 -03:00
void AccumulatedVisualContextTree::dump(VisualContextIndex index, StringBuilder& builder) const
LibWeb: Add AccumulatedVisualContext debugging infrastructure
2026-01-13 16:40:48 -03:00
{
LibWeb: Store visual context nodes in arena-based tree Replace per-node heap-allocated AtomicRefCounted AccumulatedVisualContext objects with a single contiguous Vector inside AccumulatedVisualContextTree. All nodes for a frame are now stored in one allocation, using type-safe VisualContextIndex instead of RefPtr pointers. This reduces allocation churn, improves cache locality, and opens the door for future snapshotting of visual context state — similar to how scroll offsets are snapshotted today.
2026-03-10 20:21:46 -03:00
if (!index.value())
return;
auto const& node = m_nodes[index.value()];
node.data.visit(
LibWeb: Add AccumulatedVisualContext debugging infrastructure
2026-01-13 16:40:48 -03:00
[&](PerspectiveData const&) {
builder.append("perspective"sv);
},
[&](ScrollData const& scroll) {
LibWeb: Store scroll frames by value in contiguous storage Replace per-frame heap-allocated RefCounted ScrollFrame objects with a single contiguous Vector<ScrollFrame> inside ScrollState. All frames for a viewport are now stored in one allocation, using type-safe ScrollFrameIndex instead of RefPtr pointers. This reduces allocation churn, improves cache locality, and moves parent-chain traversal (cumulative offset, nearest scrolling ancestor) into ScrollState — similar to how visual context nodes were recently consolidated into AccumulatedVisualContextTree.
2026-03-11 19:07:02 -03:00
builder.appendff("scroll_frame_id={}", scroll.scroll_frame_index);
LibWeb: Add AccumulatedVisualContext debugging infrastructure
2026-01-13 16:40:48 -03:00
if (scroll.is_sticky)
builder.append(" (sticky)"sv);
},
[&](TransformData const& transform) {
auto const& matrix = transform.matrix.elements();
auto const& origin = transform.origin;
LibWeb: Use device-pixel coordinates in display list and AVC Stop converting between CSS and device pixels as part of rendering - the display list should be as simple as possible, so convert to DevicePixels once when constructing the display list.
2026-02-25 13:09:59 -03:00
builder.appendff("transform=[{},{},{},{},{},{}] origin=({},{})", matrix[0][0], matrix[0][1], matrix[1][0], matrix[1][1], matrix[0][3], matrix[1][3], origin.x(), origin.y());
LibWeb: Add AccumulatedVisualContext debugging infrastructure
2026-01-13 16:40:48 -03:00
},
[&](ClipData const& clip) {
auto const& rect = clip.rect;
LibWeb: Use device-pixel coordinates in display list and AVC Stop converting between CSS and device pixels as part of rendering - the display list should be as simple as possible, so convert to DevicePixels once when constructing the display list.
2026-02-25 13:09:59 -03:00
builder.appendff("clip=[{},{} {}x{}]", rect.x(), rect.y(), rect.width(), rect.height());
LibWeb: Add AccumulatedVisualContext debugging infrastructure
2026-01-13 16:40:48 -03:00
if (clip.corner_radii.has_any_radius()) {
auto const& corner_radii = clip.corner_radii;
builder.appendff(" radii=({},{},{},{})", corner_radii.top_left.horizontal_radius, corner_radii.top_right.horizontal_radius, corner_radii.bottom_right.horizontal_radius, corner_radii.bottom_left.horizontal_radius);
}
LibWeb: Integrate clip-path into AccumulatedVisualContext Previously, clip-path was applied only during painting in StackingContext::paint(), which meant hit testing did not respect clip-path boundaries. Clicks outside the visible clipped region but inside the element's bounding box would incorrectly register as hits. By moving clip-path into AccumulatedVisualContext, it becomes part of the same system that handles transforms, clips, and scroll offsets for both painting and hit testing, ensuring consistent behavior.
2026-01-15 23:56:34 -03:00
},
[&](ClipPathData const& clip_path) {
auto const& rect = clip_path.bounding_rect;
LibWeb: Use device-pixel coordinates in display list and AVC Stop converting between CSS and device pixels as part of rendering - the display list should be as simple as possible, so convert to DevicePixels once when constructing the display list.
2026-02-25 13:09:59 -03:00
builder.appendff("clip_path=[bounds: {},{} {}x{}, path: {}]", rect.x(), rect.y(), rect.width(), rect.height(), clip_path.path.to_svg_string());
LibWeb: Move effects application into AccumulatedVisualContext Effects (opacity, blend mode, filters) must be applied in the parent's coordinate space, before the element's transform. Previously this was handled by manually switching to the parent's visual context when applying effects at paint time. By adding EffectsData to AccumulatedVisualContext and positioning it before TransformData in the chain, effects are now naturally applied in the correct order during display list replay, eliminating the special case in StackingContext::paint(). For SVG filters that can generate content from empty elements (feFlood, feImage, feTurbulence), a transparent FillRect command is emitted to trigger the filter through the same AVC pipeline.
2026-01-21 07:08:32 -03:00
},
[&](EffectsData const& effects) {
builder.append("effects=["sv);
bool has_content = false;
if (effects.opacity < 1.0f) {
builder.appendff("opacity={}", effects.opacity);
has_content = true;
}
if (effects.blend_mode != Gfx::CompositingAndBlendingOperator::Normal) {
if (has_content)
builder.append(' ');
builder.appendff("blend_mode={}", static_cast<int>(effects.blend_mode));
has_content = true;
}
LibWeb: Use device-pixel coordinates in display list and AVC Stop converting between CSS and device pixels as part of rendering - the display list should be as simple as possible, so convert to DevicePixels once when constructing the display list.
2026-02-25 13:09:59 -03:00
if (effects.gfx_filter.has_value()) {
LibWeb: Move effects application into AccumulatedVisualContext Effects (opacity, blend mode, filters) must be applied in the parent's coordinate space, before the element's transform. Previously this was handled by manually switching to the parent's visual context when applying effects at paint time. By adding EffectsData to AccumulatedVisualContext and positioning it before TransformData in the chain, effects are now naturally applied in the correct order during display list replay, eliminating the special case in StackingContext::paint(). For SVG filters that can generate content from empty elements (feFlood, feImage, feTurbulence), a transparent FillRect command is emitted to trigger the filter through the same AVC pipeline.
2026-01-21 07:08:32 -03:00
if (has_content)
builder.append(' ');
LibWeb: Use device-pixel coordinates in display list and AVC Stop converting between CSS and device pixels as part of rendering - the display list should be as simple as possible, so convert to DevicePixels once when constructing the display list.
2026-02-25 13:09:59 -03:00
builder.append("filter"sv);
LibWeb: Move effects application into AccumulatedVisualContext Effects (opacity, blend mode, filters) must be applied in the parent's coordinate space, before the element's transform. Previously this was handled by manually switching to the parent's visual context when applying effects at paint time. By adding EffectsData to AccumulatedVisualContext and positioning it before TransformData in the chain, effects are now naturally applied in the correct order during display list replay, eliminating the special case in StackingContext::paint(). For SVG filters that can generate content from empty elements (feFlood, feImage, feTurbulence), a transparent FillRect command is emitted to trigger the filter through the same AVC pipeline.
2026-01-21 07:08:32 -03:00
has_content = true;
}
builder.append("]"sv);
LibWeb: Add AccumulatedVisualContext debugging infrastructure
2026-01-13 16:40:48 -03:00
});
}
LibWeb: Introduce AccumulatedVisualContext Introduce AccumulatedVisualContext, a tree structure that tracks the cumulative visual state (scroll offsets, clip regions, transforms, perspective) for each paintable box. Motivation: Before this change, visual state was fragmented across multiple mechanisms: - ClipFrame: Tracked clip rectangles, each storing its own enclosing_scroll_frame_id to handle scroll offset adjustments - scroll_frame_id: Passed separately to each display list command - PushStackingContext: Stored transform matrices directly in the command - Every display list command implemented translate_by() (45 methods total) to allow scroll offset adjustment during playback This fragmentation led to: - Complex, error-prone coordinate transformation logic scattered throughout the codebase - Commands being mutated during playback to apply scroll offsets - Duplicate logic between painting and hit testing for coordinate transformations Solution: AccumulatedVisualContext builds a tree where each node represents a single visual operation: - ScrollData: A scroll frame with its ID - ClipData: A clip rectangle with optional border radii - TransformData: A 4x4 transform matrix with its origin - PerspectiveData: A perspective projection matrix Each PaintableBox stores a reference to its accumulated context node. The tree structure naturally captures the parent-child relationships, so traversing from any node to the root gives the complete chain of visual transformations. Benefits this enables (in subsequent commits): - Display list commands become immutable - no more translate_by() - Single RefPtr<AccumulatedVisualContext> replaces separate scroll_frame_id and ClipFrame on commands - LCA-based tree traversal during playback for efficient save/restore - transform_point_for_hit_test() provides coordinate transformation for hit testing using the same structure
2026-01-13 16:30:32 -03:00
}
Reference in a new issue Copy permalink