docs: compare cold grid and translated pan rendering alternatives

harness/experiments/grid-cache-20260925/cold_grid_probe.rs

@@ -0,0 +1,142 @@
+//! Experimental cold-grid candidates; no window or input automation.
+use iced::advanced::{
+    graphics::geometry::Renderer as _,
+    renderer::{Headless, Renderer as _},
+};
+use iced::{
+    Color, Point, Rectangle, Renderer, Size, Vector,
+    widget::canvas::{Frame, Geometry, Path},
+};
+use std::{hint::black_box, time::Instant};
+const BG: Color = Color::from_rgb8(246, 248, 251);
+const DOT: Color = Color::from_rgb(0.86, 0.89, 0.91);
+
+#[derive(Debug, Clone, Copy)]
+enum Candidate {
+    Original,
+    Template,
+    Column,
+    Square,
+}
+fn draw(r: &Renderer, size: Size, zoom: f32, pan: Vector, candidate: Candidate) -> Geometry {
+    let mut f = Frame::new(r, size);
+    f.fill_rectangle(Point::ORIGIN, size, BG);
+    let step = (24. * zoom).max(14.);
+    let ox = pan.x.rem_euclid(step);
+    let oy = pan.y.rem_euclid(step);
+    let circle = Path::circle(Point::ORIGIN, 0.65);
+    for x in 0..(size.width / step) as i32 + 1 {
+        if matches!(candidate, Candidate::Column) {
+            let p = Path::new(|p| {
+                for y in 0..(size.height / step) as i32 + 1 {
+                    p.circle(Point::new(ox + x as f32 * step, oy + y as f32 * step), 0.65);
+                    p.close();
+                }
+            });
+            f.fill(&p, DOT);
+            continue;
+        }
+        for y in 0..(size.height / step) as i32 + 1 {
+            let center = Point::new(ox + x as f32 * step, oy + y as f32 * step);
+            match candidate {
+                Candidate::Original => f.fill(&Path::circle(center, 0.65), DOT),
+                Candidate::Template => f.with_save(|f| {
+                    f.translate(Vector::new(center.x, center.y));
+                    f.fill(&circle, DOT);
+                }),
+                Candidate::Square => f.fill_rectangle(
+                    center - Vector::new(0.575, 0.575),
+                    Size::new(1.15, 1.15),
+                    DOT,
+                ),
+                Candidate::Column => unreachable!(),
+            }
+        }
+    }
+    f.into_geometry()
+}
+fn pixels(r: &mut Renderer, size: Size, g: Geometry) -> Vec<u8> {
+    r.reset(Rectangle::with_size(size));
+    r.draw_geometry(g);
+    Headless::screenshot(r, Size::new(size.width as u32, size.height as u32), 1., BG)
+}
+fn main() {
+    let n = std::env::args()
+        .nth(1)
+        .map(|s| s.parse::<usize>().unwrap())
+        .unwrap_or(20)
+        .max(1);
+    let rt = tokio::runtime::Builder::new_current_thread()
+        .enable_all()
+        .build()
+        .unwrap();
+    let mut r = rt
+        .block_on(<Renderer as Headless>::new(
+            iced::Font::DEFAULT,
+            16.into(),
+            None,
+        ))
+        .unwrap();
+    println!(
+        "renderer={} n={n}; construction only, unoptimized linked dependencies; NOT native FPS",
+        r.name()
+    );
+    for (size, zoom) in [
+        (Size::new(1900., 660.), 1.),
+        (Size::new(1900., 660.), 0.5),
+        (Size::new(1440., 900.), 1.),
+        (Size::new(1440., 900.), 0.5),
+    ] {
+        println!("size={}x{} zoom={zoom}", size.width, size.height);
+        for candidate in [
+            Candidate::Original,
+            Candidate::Template,
+            Candidate::Column,
+            Candidate::Square,
+        ] {
+            for pan in [
+                Vector::new(-13.25, 9.75),
+                Vector::new(0., 0.),
+                Vector::new(6.125, -8.5),
+            ] {
+                let base = draw(&r, size, zoom, pan, Candidate::Original);
+                let base = pixels(&mut r, size, base);
+                let test = draw(&r, size, zoom, pan, candidate);
+                let test = pixels(&mut r, size, test);
+                let changed = base
+                    .chunks_exact(4)
+                    .zip(test.chunks_exact(4))
+                    .filter(|(a, b)| a != b)
+                    .count();
+                let max = base
+                    .iter()
+                    .zip(&test)
+                    .map(|(a, b)| a.abs_diff(*b))
+                    .max()
+                    .unwrap_or(0);
+                println!(
+                    "{candidate:?} pan={},{} changed_pixels={changed} max_channel_delta={max}",
+                    pan.x, pan.y
+                );
+            }
+            let mut ms = Vec::new();
+            for i in 0..n + 3 {
+                let pan = Vector::new(-13.25 + i as f32 * 0.25, 9.75);
+                let now = Instant::now();
+                let g = black_box(draw(&r, size, zoom, pan, candidate));
+                let elapsed = now.elapsed().as_secs_f64() * 1000.;
+                drop(g);
+                if i >= 3 {
+                    ms.push(elapsed);
+                }
+            }
+            ms.sort_by(f64::total_cmp);
+            println!(
+                "{candidate:?} changing_pan n={n} p50_ms={:.4} p95_ms={:.4} max_ms={:.4}",
+                ms[((n - 1) as f64 * 0.5).ceil() as usize],
+                ms[((n - 1) as f64 * 0.95).ceil() as usize],
+                ms[n - 1]
+            );
+        }
+    }
+}