use super::super::*;
impl<H: UiHost> UiTree<H> {
#[stacksafe::stacksafe]
#[allow(clippy::too_many_arguments)]
pub(crate) fn paint_node(
&mut self,
app: &mut H,
services: &mut dyn UiServices,
node: NodeId,
bounds: Rect,
scene: &mut Scene,
scale_factor: f32,
paint_style: crate::tree::paint_style::PaintStyleState,
accumulated_transform: Transform2D,
) {
if self.debug_enabled {
self.debug_stats.paint_nodes = self.debug_stats.paint_nodes.saturating_add(1);
}
let prev_bounds_origin = self.nodes.get(node).map(|n| n.bounds.origin);
if let Some(n) = self.nodes.get_mut(node) {
n.bounds = bounds;
n.bounds_written_paint_pass = self.paint_pass;
}
let local_transform = self.node_render_transform(node);
let current_transform = match local_transform {
Some(t) => accumulated_transform.compose(t),
None => accumulated_transform,
};
let sf = scale_factor;
let (invalidated, hit_test_only_paint_invalidated, prev_cache) = match self.nodes.get(node)
{
Some(n) => (
n.invalidation.paint,
n.paint_invalidated_by_hit_test_only,
n.paint_cache,
),
None => return,
};
let view_cache = self
.nodes
.get(node)
.map(|n| n.view_cache)
.unwrap_or_default();
let span = if view_cache.enabled && tracing::enabled!(tracing::Level::TRACE) {
tracing::trace_span!(
"ui.cache_root.paint",
node = ?node,
view_cache_active = self.view_cache_active(),
contained_layout = view_cache.contained_layout,
invalidated = invalidated,
frame_id = app.frame_id().0,
)
} else {
tracing::Span::none()
};
let _span_guard = span.enter();
if self.window.is_some()
&& let Some(element) = self.nodes.get(node).and_then(|n| n.element)
{
let (_, record_elapsed) = fret_perf::measure(self.debug_enabled, || {
let visual = if current_transform == Transform2D::IDENTITY {
bounds
} else {
rect_aabb_transformed(bounds, current_transform)
};
self.scratch_visual_bounds_records.push((element, visual));
});
if let Some(record_elapsed) = record_elapsed {
self.debug_stats.paint_record_visual_bounds_time = self
.debug_stats
.paint_record_visual_bounds_time
.saturating_add(record_elapsed);
self.debug_stats.paint_record_visual_bounds_calls = self
.debug_stats
.paint_record_visual_bounds_calls
.saturating_add(1);
}
}
let (key, key_elapsed) = fret_perf::measure(self.debug_enabled, || {
let theme_revision = Theme::global(&*app).revision();
let children_render_transform = self.node_children_render_transform(node);
let child_transform = children_render_transform.unwrap_or(Transform2D::IDENTITY);
let inherited_text_style_fingerprint = self.window.and_then(|window| {
crate::declarative::frame::inherited_text_style_for_node(app, window, node)
.as_ref()
.map(crate::text_props::text_style_refinement_fingerprint)
});
PaintCacheKey::new(
bounds,
sf,
theme_revision,
paint_style,
inherited_text_style_fingerprint,
child_transform,
)
});
let relax_view_cache_gating = super::paint_cache_relax_view_cache_gating();
let allow_hit_test_only = super::paint_cache_allow_hit_test_only();
let cache_enabled = self.paint_cache_enabled()
&& self.node_render_transform(node).is_none()
&& (!self.view_cache_active()
|| relax_view_cache_gating
|| self.nodes.get(node).is_some_and(|n| n.view_cache.enabled));
if let Some(key_elapsed) = key_elapsed {
self.debug_stats.paint_cache_key_time = self
.debug_stats
.paint_cache_key_time
.saturating_add(key_elapsed);
}
let replay_allowed_by_hit_test_only_gate =
invalidated && allow_hit_test_only && hit_test_only_paint_invalidated;
let paint_cache_replay_allowed = !invalidated || replay_allowed_by_hit_test_only_gate;
if cache_enabled && paint_cache_replay_allowed {
if replay_allowed_by_hit_test_only_gate && self.debug_enabled {
self.debug_stats.paint_cache_hit_test_only_replay_allowed = self
.debug_stats
.paint_cache_hit_test_only_replay_allowed
.saturating_add(1);
}
struct PaintCacheReplayCtx {
range_start: usize,
range_end: usize,
delta: Point,
delta_visual: Point,
}
let (replay_ctx, hit_check_elapsed) = fret_perf::measure(self.debug_enabled, || {
let prev = prev_cache?;
if prev.generation != self.paint_cache.source_generation {
return None;
}
if prev.key != key {
return None;
}
if !prev_bounds_origin.is_some_and(|origin| {
(origin.x.0 - prev.origin.x.0).abs() <= 0.01
&& (origin.y.0 - prev.origin.y.0).abs() <= 0.01
}) {
return None;
}
let range_start = prev.start as usize;
let range_end = prev.end as usize;
if range_start > range_end || range_end > self.paint_cache.prev_ops.len() {
return None;
}
let delta = Point::new(
bounds.origin.x - prev.origin.x,
bounds.origin.y - prev.origin.y,
);
let delta_visual = if let Some(window) = self.window
&& let Some(element) = self.nodes.get(node).and_then(|n| n.element)
&& let Some(prev_visual) =
crate::elements::with_window_state(app, window, |st| {
st.last_visual_bounds(element)
.or_else(|| st.last_bounds(element))
}) {
let current_visual = if current_transform == Transform2D::IDENTITY {
bounds
} else {
rect_aabb_transformed(bounds, current_transform)
};
let size_dx = (current_visual.size.width.0 - prev_visual.size.width.0).abs();
let size_dy = (current_visual.size.height.0 - prev_visual.size.height.0).abs();
if size_dx <= 0.01 && size_dy <= 0.01 {
Point::new(
current_visual.origin.x - prev_visual.origin.x,
current_visual.origin.y - prev_visual.origin.y,
)
} else {
Point::new(Px(0.0), Px(0.0))
}
} else {
Point::new(Px(0.0), Px(0.0))
};
Some(PaintCacheReplayCtx {
range_start,
range_end,
delta,
delta_visual,
})
});
if let Some(hit_check_elapsed) = hit_check_elapsed {
self.debug_stats.paint_cache_hit_check_time = self
.debug_stats
.paint_cache_hit_check_time
.saturating_add(hit_check_elapsed);
}
if let Some(ctx) = replay_ctx {
let PaintCacheReplayCtx {
range_start,
range_end,
delta,
delta_visual,
} = ctx;
let start = scene.ops_len();
let trace_enabled = tracing::enabled!(tracing::Level::TRACE);
let (replayed_ops, replay_elapsed) = fret_perf::measure_span_with(
self.debug_enabled,
trace_enabled,
|| {
tracing::trace_span!(
"fret.ui.paint_cache.replay",
node = ?node,
ops = tracing::field::Empty,
scale_factor = sf,
)
},
|span| {
scene.replay_ops_translated(
&self.paint_cache.prev_ops[range_start..range_end],
delta,
);
let end = scene.ops_len();
let replayed_ops = end.saturating_sub(start);
span.record("ops", replayed_ops as u64);
replayed_ops
},
);
if let Some(replay_elapsed) = replay_elapsed {
self.debug_stats.paint_cache_replay_time = self
.debug_stats
.paint_cache_replay_time
.saturating_add(replay_elapsed);
}
self.debug_record_paint_cache_replay(node, replayed_ops as u32);
if let Some((prev, next)) = self.nodes.get_mut(node).map(|n| {
let prev = n.invalidation;
n.paint_cache = Some(PaintCacheEntry {
generation: self.paint_cache.target_generation,
key,
origin: bounds.origin,
start: start as u32,
end: (start + replayed_ops) as u32,
});
n.invalidation.paint = false;
n.paint_invalidated_by_hit_test_only = false;
(prev, n.invalidation)
}) {
self.update_invalidation_counters(prev, next);
}
if delta.x.0 != 0.0 || delta.y.0 != 0.0 {
let (translated_nodes, translate_elapsed) =
fret_perf::measure(self.debug_enabled, || {
let mut translated_nodes: u32 = 0;
let window = self.window;
let paint_pass = self.paint_pass;
let mut stack = self.take_scratch_node_stack();
stack.clear();
let mut i = 0usize;
loop {
let child = self
.nodes
.get(node)
.and_then(|n| n.children.get(i))
.copied();
let Some(child) = child else {
break;
};
stack.push(child);
i += 1;
}
while let Some(id) = stack.pop() {
let Some(n) = self.nodes.get_mut(id) else {
continue;
};
if n.bounds_written_paint_pass == paint_pass {
continue;
}
translated_nodes = translated_nodes.saturating_add(1);
n.bounds.origin = Point::new(
n.bounds.origin.x + delta.x,
n.bounds.origin.y + delta.y,
);
n.bounds_written_paint_pass = paint_pass;
if let Some(mut cache) = n.paint_cache {
cache.origin = Point::new(
cache.origin.x + delta.x,
cache.origin.y + delta.y,
);
n.paint_cache = Some(cache);
}
if let Some(window) = window
&& let Some(element) = n.element
{
crate::elements::record_bounds_for_element(
app, window, element, n.bounds,
);
}
for &child in &n.children {
stack.push(child);
}
}
self.restore_scratch_node_stack(stack);
translated_nodes
});
if let Some(translate_elapsed) = translate_elapsed {
self.debug_stats.paint_cache_bounds_translate_time = self
.debug_stats
.paint_cache_bounds_translate_time
.saturating_add(translate_elapsed);
self.debug_stats.paint_cache_bounds_translated_nodes = self
.debug_stats
.paint_cache_bounds_translated_nodes
.saturating_add(translated_nodes);
}
}
if delta_visual.x.0 != 0.0 || delta_visual.y.0 != 0.0 {
let window = self.window;
let mut stack: Vec<NodeId> = Vec::new();
let mut i = 0usize;
loop {
let child = self
.nodes
.get(node)
.and_then(|n| n.children.get(i))
.copied();
let Some(child) = child else {
break;
};
stack.push(child);
i += 1;
}
while let Some(id) = stack.pop() {
let Some(n) = self.nodes.get(id) else {
continue;
};
if let Some(window) = window
&& let Some(element) = n.element
&& let Some(prev_visual) =
crate::elements::with_window_state(app, window, |st| {
st.last_visual_bounds(element)
.or_else(|| st.last_bounds(element))
})
{
let visual = Rect::new(
Point::new(
prev_visual.origin.x + delta_visual.x,
prev_visual.origin.y + delta_visual.y,
),
prev_visual.size,
);
crate::elements::record_visual_bounds_for_element(
app, window, element, visual,
);
}
for &child in &n.children {
stack.push(child);
}
}
}
self.paint_cache.hits = self.paint_cache.hits.saturating_add(1);
self.paint_cache.replayed_ops = self
.paint_cache
.replayed_ops
.saturating_add(replayed_ops as u32);
return;
}
if replay_allowed_by_hit_test_only_gate
&& self.debug_enabled
&& prev_cache.is_some_and(|prev| {
prev.generation == self.paint_cache.source_generation && prev.key != key
})
{
self.debug_stats
.paint_cache_hit_test_only_replay_rejected_key_mismatch = self
.debug_stats
.paint_cache_hit_test_only_replay_rejected_key_mismatch
.saturating_add(1);
}
self.paint_cache.misses = self.paint_cache.misses.saturating_add(1);
}
if let Some((prev, next)) = self.nodes.get_mut(node).map(|n| {
let prev = n.invalidation;
n.invalidation.paint = false;
n.paint_invalidated_by_hit_test_only = false;
(prev, n.invalidation)
}) {
self.update_invalidation_counters(prev, next);
}
let mut observations = SmallCopyList::<(ModelId, Invalidation), 8>::default();
let mut observe_model = |model: ModelId, inv: Invalidation| {
observations.push((model, inv));
};
let mut global_observations = SmallCopyList::<(TypeId, Invalidation), 8>::default();
let mut observe_global = |id: TypeId, inv: Invalidation| {
global_observations.push((id, inv));
};
if self.debug_enabled {
self.debug_stats.paint_nodes_performed =
self.debug_stats.paint_nodes_performed.saturating_add(1);
}
let mut widget_type: &'static str = "<unknown>";
let (start, widget_elapsed) = fret_perf::measure(self.debug_enabled, || {
if self.debug_enabled {
self.debug_paint_stack.push(DebugPaintStackFrame {
child_inclusive_time: Duration::default(),
child_inclusive_scene_ops_delta: 0,
});
}
let start = scene.ops_len();
self.with_widget_mut(node, |widget, tree| {
if tree.debug_enabled {
widget_type = widget.debug_type_name();
}
let children_render_transform = widget
.children_render_transform(bounds)
.filter(|t| t.inverse().is_some());
let mut children_buf = SmallNodeList::<32>::default();
if let Some(children) = tree.nodes.get(node).map(|n| n.children.as_slice()) {
children_buf.set(children);
}
let window = tree.window;
let focus = tree.focus;
let mut cx = PaintCx {
app,
node,
window,
focus,
children: children_buf.as_slice(),
bounds,
scale_factor: sf,
paint_style,
accumulated_transform: current_transform,
children_render_transform,
services: &mut *services,
observe_model: &mut observe_model,
observe_global: &mut observe_global,
scene,
tree,
};
let transform = widget.render_transform(bounds);
let pushed_transform = if let Some(transform) = transform
&& transform.inverse().is_some()
{
cx.scene.push(SceneOp::PushTransform { transform });
true
} else {
false
};
cx.tree.debug_paint_widget_exclusive_resume();
widget.paint(&mut cx);
let _ = cx.tree.debug_paint_widget_exclusive_pause();
if pushed_transform {
cx.scene.push(SceneOp::PopTransform);
}
});
start
});
let end = scene.ops_len();
if let Some(inclusive_time) = widget_elapsed {
const MAX_PAINT_WIDGET_HOTSPOTS: usize = 16;
let inclusive_scene_ops_delta = end.saturating_sub(start).min(u32::MAX as usize) as u32;
let (child_inclusive_time, child_inclusive_scene_ops_delta) = self
.debug_paint_stack
.pop()
.map(|f| (f.child_inclusive_time, f.child_inclusive_scene_ops_delta))
.unwrap_or_default();
let exclusive_time = inclusive_time.saturating_sub(child_inclusive_time);
let exclusive_scene_ops_delta =
inclusive_scene_ops_delta.saturating_sub(child_inclusive_scene_ops_delta);
if let Some(parent) = self.debug_paint_stack.last_mut() {
parent.child_inclusive_time += inclusive_time;
parent.child_inclusive_scene_ops_delta = parent
.child_inclusive_scene_ops_delta
.saturating_add(inclusive_scene_ops_delta);
}
let should_record_hotspot =
if self.debug_paint_widget_hotspots.len() < MAX_PAINT_WIDGET_HOTSPOTS {
true
} else {
self.debug_paint_widget_hotspots
.last()
.is_some_and(|h| h.exclusive_time < exclusive_time)
};
if should_record_hotspot {
let element = self.nodes.get(node).and_then(|n| n.element);
let element_kind = self.window.and_then(|window| {
crate::declarative::frame::element_record_for_node(app, window, node)
.map(|record| record.instance.kind_name())
});
let element_path = if self.debug_enabled {
#[cfg(feature = "diagnostics")]
{
self.window.and_then(|window| {
element.and_then(|element| {
crate::elements::with_window_state(app, window, |st| {
st.debug_path_for_element(element)
})
})
})
}
#[cfg(not(feature = "diagnostics"))]
{
None
}
} else {
None
};
let record = UiDebugPaintWidgetHotspot {
node,
element,
element_kind,
element_path,
widget_type,
inclusive_time,
exclusive_time,
inclusive_scene_ops_delta,
exclusive_scene_ops_delta,
};
let idx = self
.debug_paint_widget_hotspots
.iter()
.position(|h| h.exclusive_time < record.exclusive_time)
.unwrap_or(self.debug_paint_widget_hotspots.len());
self.debug_paint_widget_hotspots.insert(idx, record);
if self.debug_paint_widget_hotspots.len() > MAX_PAINT_WIDGET_HOTSPOTS {
self.debug_paint_widget_hotspots
.truncate(MAX_PAINT_WIDGET_HOTSPOTS);
}
}
}
let (_, obs_elapsed) = fret_perf::measure(self.debug_enabled, || {
self.observed_in_paint.record(node, observations.as_slice());
self.observed_globals_in_paint
.record(node, global_observations.as_slice());
});
if let Some(obs_elapsed) = obs_elapsed {
self.debug_stats.paint_observation_record_time = self
.debug_stats
.paint_observation_record_time
.saturating_add(obs_elapsed);
}
if let Some(n) = self.nodes.get_mut(node) {
if cache_enabled {
n.paint_cache = Some(PaintCacheEntry {
generation: self.paint_cache.target_generation,
key,
origin: bounds.origin,
start: start as u32,
end: end as u32,
});
} else {
n.paint_cache = None;
}
}
}
}