use crate::core::id::ElementId;
use crate::style::Rect;
use std::collections::HashMap;
const MARGIN: f32 = 3.0;
pub(crate) struct DamageTracker {
prev_visual: HashMap<ElementId, Rect>,
}
impl Default for DamageTracker {
fn default() -> Self {
Self::new()
}
}
impl DamageTracker {
pub fn new() -> Self {
Self {
prev_visual: HashMap::new(),
}
}
pub fn compute(
&mut self,
dirty_ids: &[ElementId],
arena: &crate::core::element::ElementArena,
max_rects: usize,
viewport: Rect,
) -> Vec<Rect> {
let tables = arena.component_tables.clone();
let ct = tables.borrow();
let mut rects: Vec<Rect> = Vec::with_capacity(dirty_ids.len() * 2);
for id in dirty_ids {
match arena.get(*id) {
Some(el) => {
let visual = inflated_visual_rect(*id, el, &ct);
if let Some(prev) = self.prev_visual.insert(*id, visual) {
if prev != visual && prev.width > 0.0 && prev.height > 0.0 {
rects.push(prev);
}
}
if visual.width > 0.0 && visual.height > 0.0 {
rects.push(visual);
}
}
None => {
if let Some(prev) = self.prev_visual.remove(id) {
if prev.width > 0.0 && prev.height > 0.0 {
rects.push(prev);
}
}
}
}
}
rects = deduplicate_contained(rects);
greedy_merge(&mut rects, max_rects);
let mut out: Vec<Rect> = Vec::with_capacity(rects.len());
for r in rects {
let x0 = (r.x - MARGIN).max(viewport.x);
let y0 = (r.y - MARGIN).max(viewport.y);
let x1 = (r.x + r.width + MARGIN).min(viewport.x + viewport.width);
let y1 = (r.y + r.height + MARGIN).min(viewport.y + viewport.height);
if x1 > x0 && y1 > y0 {
out.push(Rect::new(x0, y0, x1 - x0, y1 - y0));
}
}
make_disjoint(&mut out);
out
}
#[allow(dead_code)]
pub fn clear(&mut self) {
self.prev_visual.clear();
}
}
fn inflated_visual_rect(
eid: ElementId,
el: &crate::core::element::Element,
ct: &crate::ecs::tables::ComponentTables,
) -> Rect {
let sb = el.screen_bounds;
let mut x = sb.x;
let mut y = sb.y;
let mut w = sb.width.max(1.0);
let mut h = sb.height.max(1.0);
if let Some(xf) = ct.xform.get(&eid) {
let off = xf.position_offset.get();
x += off.x;
y += off.y;
let sc = xf.size_scale.get();
w *= sc.x;
h *= sc.y;
}
let mut grow = 0.0f32;
if let Some(s) = ct.style.get(&eid) {
let resolved = crate::style::state_style::resolve_style(el.state.get(), s);
if let Some(sh) = resolved.shadow {
grow = grow.max(sh.blur + sh.offset_x.abs().max(sh.offset_y.abs()));
}
if resolved.outline_width > 0.0 {
grow = grow.max(resolved.outline_width + 1.0);
}
}
let mut r = Rect::new(x - grow, y - grow, w + 2.0 * grow, h + 2.0 * grow);
if let Some(xf) = ct.xform.get(&eid) {
if let Some(t) = xf.transform {
let tx = glam::Affine2::from_cols_array(&t);
let ox = xf.transform_origin_x * w;
let oy = xf.transform_origin_y * h;
let to_origin = glam::Affine2::from_translation(glam::Vec2::new(-(x + ox), -(y + oy)));
let from_origin = glam::Affine2::from_translation(glam::Vec2::new(x + ox, y + oy));
let m = from_origin * tx * to_origin;
let c = [
m.transform_point2(glam::Vec2::new(r.x, r.y)),
m.transform_point2(glam::Vec2::new(r.x + r.width, r.y)),
m.transform_point2(glam::Vec2::new(r.x + r.width, r.y + r.height)),
m.transform_point2(glam::Vec2::new(r.x, r.y + r.height)),
];
let min_x = c.iter().map(|p| p.x).fold(f32::MAX, f32::min);
let min_y = c.iter().map(|p| p.y).fold(f32::MAX, f32::min);
let max_x = c.iter().map(|p| p.x).fold(f32::MIN, f32::max);
let max_y = c.iter().map(|p| p.y).fold(f32::MIN, f32::max);
let t_rect = Rect::new(min_x, min_y, max_x - min_x, max_y - min_y);
r = r.union(&t_rect);
}
}
r
}
fn deduplicate_contained(mut rects: Vec<Rect>) -> Vec<Rect> {
let mut i = 0;
while i < rects.len() {
let r = rects[i];
let contained = rects
.iter()
.enumerate()
.any(|(j, &other)| j != i && other.contains_rect(&r));
if contained {
rects.swap_remove(i);
} else {
i += 1;
}
}
rects
}
fn greedy_merge(rects: &mut Vec<Rect>, max: usize) {
while rects.len() > max {
let mut best_area_increase = f32::MAX;
let mut best_pair = (0usize, 0usize);
let mut best_merged = Rect::ZERO;
for i in 0..rects.len() {
for j in (i + 1)..rects.len() {
let merged = rects[i].union(&rects[j]);
let increase = merged.area() - rects[i].area() - rects[j].area()
+ rects[i].intersection_area(&rects[j]);
if increase < best_area_increase {
best_area_increase = increase;
best_pair = (i, j);
best_merged = merged;
}
}
}
let (i, j) = best_pair;
rects.remove(j);
rects.remove(i);
rects.push(best_merged);
}
}
fn make_disjoint(rects: &mut Vec<Rect>) {
loop {
let mut merged_any = false;
'outer: for i in 0..rects.len() {
for j in (i + 1)..rects.len() {
if rects[i].intersects(&rects[j]) {
let u = rects[i].union(&rects[j]);
rects.remove(j);
rects[i] = u;
merged_any = true;
break 'outer;
}
}
}
if !merged_any {
break;
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_deduplicate_contained() {
let a = Rect::new(0.0, 0.0, 100.0, 100.0);
let b = Rect::new(10.0, 10.0, 20.0, 20.0); let c = Rect::new(200.0, 200.0, 50.0, 50.0);
let result = deduplicate_contained(vec![a, b, c]);
assert_eq!(result.len(), 2);
}
#[test]
fn test_greedy_merge_single() {
let mut rects = vec![Rect::new(0.0, 0.0, 100.0, 50.0)];
greedy_merge(&mut rects, 4);
assert_eq!(rects.len(), 1);
}
#[test]
fn test_greedy_merge_overlapping() {
let mut rects = vec![
Rect::new(0.0, 0.0, 100.0, 50.0),
Rect::new(80.0, 0.0, 100.0, 50.0),
Rect::new(200.0, 10.0, 50.0, 30.0),
Rect::new(210.0, 0.0, 60.0, 50.0),
Rect::new(400.0, 400.0, 100.0, 100.0),
];
greedy_merge(&mut rects, 3);
assert_eq!(rects.len(), 3);
}
#[test]
fn test_make_disjoint() {
let mut rects = vec![
Rect::new(0.0, 0.0, 100.0, 50.0),
Rect::new(80.0, 0.0, 100.0, 50.0), Rect::new(400.0, 400.0, 100.0, 100.0),
];
make_disjoint(&mut rects);
assert_eq!(rects.len(), 2);
for i in 0..rects.len() {
for j in (i + 1)..rects.len() {
assert!(!rects[i].intersects(&rects[j]), "rects must be disjoint");
}
}
}
}