wtemple/ruin
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Lots of claude-driven performance work.

Browse Source
This commit is contained in:
Will Temple
2026-03-23 00:24:55 -04:00
parent 497af9151d
commit e90f09bf3e
14 changed files with 1820 additions and 394 deletions
Download Patch File Download Diff File Expand all files Collapse all files

315
lib/ui/src/layout.rs
View File

@@ -1,8 +1,10 @@
use std::collections::HashMap;
use std::time::Instant;
use crate::ImageFit;
use crate::scene::{
PreparedImage, PreparedText, Rect, RoundedRect, SceneSnapshot, ShadowRect, UiSize,
DisplayItem, Point, PreparedImage, PreparedText, Rect, RoundedRect, SceneSnapshot, ShadowRect,
UiSize,
};
use crate::text::TextSystem;
use crate::tree::{CursorIcon, Edges, Element, ElementId, FlexDirection, ImageNode, Style};
@@ -122,6 +124,38 @@ impl InteractionTree {
}
}
impl LayoutNode {
/// Return a copy of this node (and all descendants) with all positions shifted by `offset`.
pub fn translated(self, offset: Point) -> Self {
fn translate_rect(r: Rect, o: Point) -> Rect {
Rect::new(r.origin.x + o.x, r.origin.y + o.y, r.size.width, r.size.height)
}
let rect = translate_rect(self.rect, offset);
let clip_rect = self.clip_rect.map(|r| translate_rect(r, offset));
let scroll_metrics = self.scroll_metrics.map(|m| ScrollMetrics {
viewport_rect: translate_rect(m.viewport_rect, offset),
scrollbar_track: m.scrollbar_track.map(|r| translate_rect(r, offset)),
scrollbar_thumb: m.scrollbar_thumb.map(|r| translate_rect(r, offset)),
..m
});
let prepared_text = self.prepared_text.map(|t| t.translated(offset));
let prepared_image = self.prepared_image.map(|img| PreparedImage {
rect: translate_rect(img.rect, offset),
..img
});
let children = self.children.into_iter().map(|c| c.translated(offset)).collect();
LayoutNode {
rect,
clip_rect,
scroll_metrics,
prepared_text,
prepared_image,
children,
..self
}
}
}
pub fn layout_snapshot(version: u64, logical_size: UiSize, root: &Element) -> LayoutSnapshot {
let mut text_system = TextSystem::new();
layout_snapshot_with_text_system(version, logical_size, root, &mut text_system)
@@ -132,6 +166,17 @@ pub fn layout_snapshot_with_text_system(
logical_size: UiSize,
root: &Element,
text_system: &mut TextSystem,
) -> LayoutSnapshot {
let mut layout_cache = LayoutCache::new();
layout_snapshot_with_cache(version, logical_size, root, text_system, &mut layout_cache)
}
pub fn layout_snapshot_with_cache(
version: u64,
logical_size: UiSize,
root: &Element,
text_system: &mut TextSystem,
layout_cache: &mut LayoutCache,
) -> LayoutSnapshot {
let layout_started = Instant::now();
let perf_enabled = tracing::enabled!(target: "ruin_ui::layout_perf", tracing::Level::DEBUG);
@@ -150,6 +195,8 @@ pub fn layout_snapshot_with_text_system(
&mut scene,
text_system,
&mut perf_stats,
layout_cache,
None,
);
let text_stats = text_system.take_frame_stats();
if perf_stats.enabled {
@@ -170,6 +217,10 @@ pub fn layout_snapshot_with_text_system(
intrinsic_ms = perf_stats.intrinsic_ms,
text_prepare_calls = perf_stats.text_prepare_calls,
text_prepare_ms = perf_stats.text_prepare_ms,
viewport_culled = perf_stats.viewport_culled,
layout_cache_hits = perf_stats.layout_cache_hits,
layout_cache_misses = perf_stats.layout_cache_misses,
intrinsic_cache_hits = perf_stats.intrinsic_cache_hits,
text_requests = text_stats.requests,
text_cache_hits = text_stats.cache_hits,
text_cache_misses = text_stats.cache_misses,
@@ -197,8 +248,54 @@ fn layout_element(
scene: &mut SceneSnapshot,
text_system: &mut TextSystem,
perf_stats: &mut LayoutPerfStats,
layout_cache: &mut LayoutCache,
// Scissor rect from the nearest enclosing scroll box (window coords).
// Elements that don't overlap this rect are skipped entirely.
clip_rect: Option<Rect>,
) -> LayoutNode {
perf_stats.nodes += 1;
// Viewport culling: skip fully off-screen elements inside a scroll box.
if let Some(clip) = clip_rect {
if !rects_overlap(rect, clip) {
perf_stats.viewport_culled += 1;
return LayoutNode {
path,
element_id: element.id,
rect,
corner_radius: 0.0,
clip_rect: None,
pointer_events: element.style.pointer_events,
focusable: element.style.focusable,
cursor: element.style.cursor.unwrap_or(CursorIcon::Default),
scroll_metrics: None,
prepared_image: None,
prepared_text: None,
children: Vec::new(),
};
}
}
// Incremental layout cache check.
// Round to nearest pixel to eliminate floating-point representation
// artifacts from arithmetic paths (e.g. total - padding - gap) that
// produce logically identical sizes with different bit patterns.
let subtree_hash = element.subtree_hash();
let cache_key = LayoutCacheKey {
subtree_hash,
avail_width_bits: rect.size.width.round() as u32,
avail_height_bits: rect.size.height.round() as u32,
};
if let Some(cached) = layout_cache.results.get(&cache_key) {
let offset = rect.origin;
for item in &cached.scene_items {
scene.items.push(item.translated(offset));
}
perf_stats.layout_cache_hits += 1;
return cached.interaction_node.clone().translated(offset);
}
perf_stats.layout_cache_misses += 1;
let scene_start = scene.items.len();
let cursor = element.style.cursor.unwrap_or_else(|| {
if element.text_node().is_some() {
CursorIcon::Text
@@ -222,6 +319,7 @@ fn layout_element(
};
if rect.size.width <= 0.0 || rect.size.height <= 0.0 {
cache_layout(layout_cache, cache_key, &interaction, &[], rect.origin);
return interaction;
}
@@ -270,6 +368,7 @@ fn layout_element(
if pushed_clip {
scene.pop_clip();
}
cache_layout(layout_cache, cache_key, &interaction, &scene.items[scene_start..], rect.origin);
return interaction;
}
@@ -283,6 +382,7 @@ fn layout_element(
if pushed_clip {
scene.pop_clip();
}
cache_layout(layout_cache, cache_key, &interaction, &scene.items[scene_start..], rect.origin);
return interaction;
}
@@ -311,6 +411,7 @@ fn layout_element(
),
text_system,
perf_stats,
layout_cache,
);
let provisional_content_height = content_size.height.max(viewport_rect.size.height);
let requested_offset_y = scroll_box.offset_y.max(0.0);
@@ -333,6 +434,8 @@ fn layout_element(
scene,
text_system,
perf_stats,
layout_cache,
Some(viewport_rect),
);
scene.pop_clip();
}
@@ -367,6 +470,8 @@ fn layout_element(
scene,
text_system,
perf_stats,
layout_cache,
Some(viewport_rect),
);
scene.pop_clip();
} else {
@@ -403,6 +508,7 @@ fn layout_element(
if pushed_clip {
scene.pop_clip();
}
cache_layout(layout_cache, cache_key, &interaction, &scene.items[scene_start..], rect.origin);
return interaction;
}
@@ -412,6 +518,7 @@ fn layout_element(
if pushed_clip {
scene.pop_clip();
}
cache_layout(layout_cache, cache_key, &interaction, &scene.items[scene_start..], rect.origin);
return interaction;
}
@@ -420,6 +527,7 @@ fn layout_element(
if pushed_clip {
scene.pop_clip();
}
cache_layout(layout_cache, cache_key, &interaction, &scene.items[scene_start..], rect.origin);
return interaction;
}
interaction.children = layout_container_children(
@@ -429,15 +537,33 @@ fn layout_element(
scene,
text_system,
perf_stats,
layout_cache,
clip_rect,
);
if pushed_clip {
scene.pop_clip();
}
cache_layout(layout_cache, cache_key, &interaction, &scene.items[scene_start..], rect.origin);
interaction
}
/// Store a layout result in the cache in origin-relative (local) coordinates.
fn cache_layout(
cache: &mut LayoutCache,
key: LayoutCacheKey,
interaction: &LayoutNode,
scene_items: &[DisplayItem],
origin: Point,
) {
let neg = Point::new(-origin.x, -origin.y);
cache.results.insert(key, CachedLayout {
interaction_node: interaction.clone().translated(neg),
scene_items: scene_items.iter().map(|i| i.translated(neg)).collect(),
});
}
fn hit_path_node(node: &LayoutNode, point: crate::scene::Point) -> Option<Vec<HitTarget>> {
if !point_hits_node_shape(node, point) {
return None;
@@ -616,6 +742,8 @@ fn layout_container_children(
scene: &mut SceneSnapshot,
text_system: &mut TextSystem,
perf_stats: &mut LayoutPerfStats,
layout_cache: &mut LayoutCache,
clip_rect: Option<Rect>,
) -> Vec<LayoutNode> {
if element.children.is_empty() || content.size.width <= 0.0 || content.size.height <= 0.0 {
return Vec::new();
@@ -655,6 +783,7 @@ fn layout_container_children(
available_main,
text_system,
perf_stats,
layout_cache,
);
if let Some(intrinsic_started) = intrinsic_started {
perf_stats.intrinsic_ms += intrinsic_started.elapsed().as_secs_f64() * 1_000.0;
@@ -701,6 +830,8 @@ fn layout_container_children(
scene,
text_system,
perf_stats,
layout_cache,
clip_rect,
));
cursor += child_main.max(0.0) + element.style.gap;
}
@@ -714,6 +845,7 @@ fn intrinsic_main_size(
available_main: f32,
text_system: &mut TextSystem,
perf_stats: &mut LayoutPerfStats,
layout_cache: &mut LayoutCache,
) -> f32 {
if let Some(text) = child.text_node() {
let constraints = match direction {
@@ -736,7 +868,7 @@ fn intrinsic_main_size(
FlexDirection::Column => UiSize::new(cross_size.max(0.0), available_main.max(0.0)),
};
main_axis_size(
intrinsic_size(child, available_size, text_system, perf_stats),
intrinsic_size(child, available_size, text_system, perf_stats, layout_cache),
direction,
)
}
@@ -746,6 +878,7 @@ fn intrinsic_container_content_size(
content_size: UiSize,
text_system: &mut TextSystem,
perf_stats: &mut LayoutPerfStats,
layout_cache: &mut LayoutCache,
) -> UiSize {
if element.children.is_empty() {
return UiSize::new(0.0, 0.0);
@@ -766,6 +899,7 @@ fn intrinsic_container_content_size(
),
text_system,
perf_stats,
layout_cache,
);
width = width.max(child.style.width.unwrap_or(child_size.width));
if !skip_main {
@@ -795,6 +929,7 @@ fn intrinsic_container_content_size(
),
text_system,
perf_stats,
layout_cache,
);
let child_main = child.style.width.unwrap_or(child_size.width);
fixed_main += child_main;
@@ -818,6 +953,7 @@ fn intrinsic_container_content_size(
),
text_system,
perf_stats,
layout_cache,
);
if !skip_main {
width += child_main;
@@ -834,9 +970,35 @@ fn intrinsic_size(
available_size: UiSize,
text_system: &mut TextSystem,
perf_stats: &mut LayoutPerfStats,
layout_cache: &mut LayoutCache,
) -> UiSize {
perf_stats.intrinsic_size_calls += 1;
// Intrinsic size cache check.
// Round to nearest pixel — same rationale as the layout cache key.
let cache_key = (
element.subtree_hash(),
available_size.width.round() as u32,
available_size.height.round() as u32,
);
if let Some(&cached) = layout_cache.intrinsic_cache.get(&cache_key) {
perf_stats.intrinsic_cache_hits += 1;
return cached;
}
let insets = content_insets(&element.style);
let result = intrinsic_size_inner(element, available_size, insets, text_system, perf_stats, layout_cache);
layout_cache.intrinsic_cache.insert(cache_key, result);
result
}
fn intrinsic_size_inner(
element: &Element,
available_size: UiSize,
insets: Edges,
text_system: &mut TextSystem,
perf_stats: &mut LayoutPerfStats,
layout_cache: &mut LayoutCache,
) -> UiSize {
if let Some(text) = element.text_node() {
let measured = text_system.measure_spans(
&text.spans,
@@ -886,7 +1048,7 @@ fn intrinsic_size(
}
let intrinsic_content =
intrinsic_container_content_size(element, content_size, text_system, perf_stats);
intrinsic_container_content_size(element, content_size, text_system, perf_stats, layout_cache);
UiSize::new(
explicit_width
@@ -895,6 +1057,43 @@ fn intrinsic_size(
)
}
/// Cache for incremental layout. Holds both full-subtree layout results and
/// intrinsic-size results keyed by subtree hash + available size.
///
/// Cleared by calling [`LayoutCache::clear`] or dropped between runs if desired.
/// In practice, the cache is held across frames so unchanged subtrees pay no layout cost.
#[derive(Default)]
pub struct LayoutCache {
results: HashMap<LayoutCacheKey, CachedLayout>,
/// Intrinsic-size cache: keyed by (subtree_hash, avail_w.to_bits(), avail_h.to_bits()).
pub intrinsic_cache: HashMap<(u64, u32, u32), UiSize>,
}
impl LayoutCache {
pub fn new() -> Self {
Self::default()
}
pub fn clear(&mut self) {
self.results.clear();
self.intrinsic_cache.clear();
}
}
#[derive(Eq, Hash, PartialEq)]
struct LayoutCacheKey {
subtree_hash: u64,
avail_width_bits: u32,
avail_height_bits: u32,
}
struct CachedLayout {
/// Layout node in origin-relative (local) coordinates.
interaction_node: LayoutNode,
/// Scene items in origin-relative (local) coordinates.
scene_items: Vec<DisplayItem>,
}
#[derive(Debug, Default)]
struct LayoutPerfStats {
enabled: bool,
@@ -909,6 +1108,10 @@ struct LayoutPerfStats {
intrinsic_ms: f64,
text_prepare_calls: usize,
text_prepare_ms: f64,
viewport_culled: usize,
layout_cache_hits: usize,
layout_cache_misses: usize,
intrinsic_cache_hits: usize,
}
impl LayoutPerfStats {
@@ -926,10 +1129,23 @@ impl LayoutPerfStats {
intrinsic_ms: 0.0,
text_prepare_calls: 0,
text_prepare_ms: 0.0,
viewport_culled: 0,
layout_cache_hits: 0,
layout_cache_misses: 0,
intrinsic_cache_hits: 0,
}
}
}
/// Returns true if two rects have any overlap (including touching edges).
#[inline]
fn rects_overlap(a: Rect, b: Rect) -> bool {
a.origin.x < b.origin.x + b.size.width
&& a.origin.x + a.size.width > b.origin.x
&& a.origin.y < b.origin.y + b.size.height
&& a.origin.y + a.size.height > b.origin.y
}
fn prepare_image(image: &ImageNode, rect: Rect, element_id: Option<ElementId>) -> PreparedImage {
let source_size = image.resource.size();
let source_aspect = if source_size.height > 0.0 {
@@ -1321,10 +1537,11 @@ fn child_rect(
#[cfg(test)]
mod tests {
use super::{layout_scene, layout_snapshot};
use super::{LayoutCache, layout_scene, layout_snapshot, layout_snapshot_with_cache};
use crate::scene::{Color, DisplayItem, Point, Quad, Rect, UiSize};
use crate::text::{TextStyle, TextWrap};
use crate::tree::{Edges, Element, ElementId};
use crate::tree::{Edges, Element, ElementId, FlexDirection};
use crate::text::TextSystem;
#[test]
fn row_layout_apportions_fixed_and_flex_children() {
@@ -1916,4 +2133,92 @@ mod tests {
.is_none()
);
}
// --- incremental layout cache tests ---
fn text_style() -> TextStyle {
TextStyle::new(14.0, Color::rgb(0xFF, 0xFF, 0xFF))
}
fn make_tree(n: usize) -> Element {
let mut root = Element::new().direction(FlexDirection::Column);
for i in 0..n {
root = root.child(Element::text(format!("item {i}"), text_style()));
}
root
}
#[test]
fn stable_layout_produces_equal_snapshots() {
let mut text_system = TextSystem::new();
let mut layout_cache = LayoutCache::new();
let root = make_tree(10);
let size = UiSize::new(400.0, 600.0);
let snap1 = layout_snapshot_with_cache(1, size, &root, &mut text_system, &mut layout_cache);
let snap2 = layout_snapshot_with_cache(2, size, &root, &mut text_system, &mut layout_cache);
assert_eq!(snap1.scene.items, snap2.scene.items, "scene items should be identical");
assert_eq!(
snap1.interaction_tree.root,
snap2.interaction_tree.root,
"interaction trees should be identical"
);
}
#[test]
fn cache_effectiveness_single_change() {
let mut text_system = TextSystem::new();
let mut layout_cache = LayoutCache::new();
// Build a 200-node tree; warm up the cache.
let root = make_tree(200);
let size = UiSize::new(400.0, 4000.0);
layout_snapshot_with_cache(1, size, &root, &mut text_system, &mut layout_cache);
// Change one node and re-layout.
let mut root2 = root;
root2.children[100] = Element::text("CHANGED", text_style());
let _ = layout_snapshot_with_cache(2, size, &root2, &mut text_system, &mut layout_cache);
let hits = layout_cache.results.len();
// At least 199 of 200 children should be cached (one changed).
// The root (container) also misses since its hash changed.
// Total cache entries: 200 children (199 hit on second pass + 1 new) + root.
// We verify that we have substantially more hits than misses on the second pass
// by checking that the cache has entries for at least 199 children.
assert!(hits >= 199, "expected >= 199 cache entries, got {hits}");
}
#[test]
fn scroll_culling_skips_off_screen_children() {
use crate::tree::ScrollbarStyle;
let mut text_system = TextSystem::new();
let mut layout_cache = LayoutCache::new();
// Scroll box showing roughly 5 items (each 40px tall), 100 total.
let item_height = 40.0;
let viewport_height = 200.0;
let n = 100;
let mut scroll_box = Element::scroll_box(0.0).width(400.0).height(viewport_height);
for i in 0..n {
scroll_box = scroll_box.child(
Element::new()
.height(item_height)
.child(Element::text(format!("item {i}"), text_style()))
);
}
let root = Element::new().child(scroll_box);
let size = UiSize::new(400.0, viewport_height);
// Hack: we need LayoutPerfStats to check viewport_culled.
// Instead, test indirectly: scene items for off-screen text should be absent.
let snap = layout_snapshot_with_cache(1, size, &root, &mut text_system, &mut layout_cache);
// Only text items within the 200px viewport should appear in the scene.
let text_items = snap.scene.items.iter().filter(|item| {
matches!(item, DisplayItem::Text(_))
}).count();
// At most 6 text items should be visible (5 fit + 1 partial).
assert!(text_items <= 6, "expected <= 6 text items in scene, got {text_items} (culling not working)");
assert!(text_items >= 4, "expected >= 4 text items visible, got {text_items}");
}
}