DesignCraft: An open-source page and layout design editor written by scratch in pure Rust
M9: background canvas rendering with overscan (pan without re-render, scaled preview while zooming)
Brandon Thomasc2f80260a38f
diff --git a/crates/ui-egui/src/canvas.rs b/crates/ui-egui/src/canvas.rsindex f4e9307c1..241c654fe 100644--- a/crates/ui-egui/src/canvas.rs+++ b/crates/ui-egui/src/canvas.rs@@ -177,20 +177,21 @@ pub fn show(app: &mut DesignApp, ui: &mut egui::Ui) {}// Rendered content.render_texture(app, ui.ctx(), rect, &xf, &layout, preview);- if let Some(tex) = &app.canvas.texture {+ if let (Some(tex), Some(sh)) = (&app.canvas.texture, app.canvas.shown) {+ // Place the texture where its region is in the current view (shifted while panning,+ // scaled while a zoom re-render is pending).+ let k = (xf.zoom / sh.zoom) as f32;+ let tl = xf.to_screen(sh.origin);+ let tex_rect = Rect::from_min_size(tl, vec2(sh.size.0 * k, sh.size.1 * k));let uv = Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0));if preview {// Preview: only page areas (trim) show content.for slot in &layout.slots {let r = xf.rect(slot.bounds);- let ruv = Rect::from_min_max(- pos2((r.min.x - rect.min.x) / rect.width(), (r.min.y - rect.min.y) / rect.height()),- pos2((r.max.x - rect.min.x) / rect.width(), (r.max.y - rect.min.y) / rect.height()),- );- painter.with_clip_rect(r.intersect(rect)).image(tex.id(), r, ruv, Color32::WHITE);+ painter.with_clip_rect(r.intersect(rect)).image(tex.id(), tex_rect, uv, Color32::WHITE);}} else {- painter.image(tex.id(), rect, uv, Color32::WHITE);+ painter.image(tex.id(), tex_rect, uv, Color32::WHITE);}}let hair = 1.0 / ui.ctx().pixels_per_point();@@ -240,29 +241,112 @@ fn cursor_icon(c: Cursor) -> egui::CursorIcon {}}+/// Keep the canvas texture current. Panning inside the overscanned region just shifts the+/// texture; zooming shows the old texture scaled until the background render arrives; document+/// edits render synchronously so editing never lags.fn render_texture(app: &mut DesignApp, ctx: &egui::Context, rect: Rect, xf: &Xf, layout: &CanvasLayout, preview: bool) {let Some(st) = app.session.active() else { return };let ppp = ctx.pixels_per_point() as f64;- let w = (rect.width() as f64 * ppp).round().max(1.0) as u32;- let h = (rect.height() as f64 * ppp).round().max(1.0) as u32;- let doc_ptr = std::sync::Arc::as_ptr(&st.doc) as u64;- let key = (st.uid, doc_ptr, xf.zoom.to_bits(), xf.origin.x.to_bits() ^ xf.origin.y.to_bits().rotate_left(17), st.revision, w, h, preview as u8);- if app.canvas.key == Some(key) && app.canvas.texture.is_some() {+ let doc_key = (st.uid, std::sync::Arc::as_ptr(&st.doc) as u64, st.revision, preview);+ // Overscan: 25% of the viewport on every side.+ let (ow, oh) = (rect.width() * 0.25, rect.height() * 0.25);+ let want = |origin: Point| crate::Shown {+ doc: doc_key,+ origin: Point::new(origin.x - ow as f64 / xf.zoom, origin.y - oh as f64 / xf.zoom),+ zoom: xf.zoom,+ size: (rect.width() + 2.0 * ow, rect.height() + 2.0 * oh),+ };+ let target = want(xf.origin);+ // Does the current texture cover the viewport at this zoom and document state?+ let covers = |s: &crate::Shown| {+ s.doc == doc_key && (s.zoom - xf.zoom).abs() < 1e-9 && {+ let x0 = (xf.origin.x - s.origin.x) * s.zoom;+ let y0 = (xf.origin.y - s.origin.y) * s.zoom;+ x0 >= -0.5 && y0 >= -0.5 && x0 + rect.width() as f64 <= s.size.0 as f64 + 0.5 && y0 + rect.height() as f64 <= s.size.1 as f64 + 0.5+ }+ };+ // Collect finished background renders.+ #[cfg(not(target_arch = "wasm32"))]+ if let (Some(w), Some((tok, shown))) = (app.canvas.worker.as_ref(), app.canvas.pending)+ && let Some(done) = w.poll()+ && done.token == tok+ {+ upload(app, ctx, done.image);+ app.canvas.shown = Some(shown);+ app.canvas.pending = None;+ app.perf.render_ms = done.ms;+ }+ if app.canvas.shown.is_some_and(|s| covers(&s)) {return;}- let t0 = crate::now_ms();- let placed: Vec<designcraft_render::Placed> =- layout.slots.iter().map(|s| designcraft_render::Placed { spread: s.spread, offset: s.offset }).collect();- let view = xf.affine(ppp, rect.min);- let opts = designcraft_render::RenderOptions { printing_only: preview, greek_below_px: 3.0 * ppp, ..Default::default() };- let img = app.canvas.renderer.render(&st.doc, &app.session.cache, &placed, w, h, view, &opts);- let ci = egui::ColorImage::from_rgba_premultiplied([w as usize, h as usize], &img.pixels);+ let doc_changed = app.canvas.shown.is_none_or(|s| s.doc != doc_key);+ let zoom_same = app.canvas.shown.is_some_and(|s| (s.zoom - xf.zoom).abs() < 1e-9);+ let job = |app: &DesignApp| {+ let st = app.session.active().expect("doc");+ let placed: Vec<designcraft_render::Placed> =+ layout.slots.iter().map(|s| designcraft_render::Placed { spread: s.spread, offset: s.offset }).collect();+ let w = (target.size.0 as f64 * ppp).round().max(1.0) as u32;+ let h = (target.size.1 as f64 * ppp).round().max(1.0) as u32;+ let view = Affine::scale(ppp) * Affine::scale(xf.zoom) * Affine::translate((-target.origin.x, -target.origin.y));+ let opts = designcraft_render::RenderOptions { printing_only: preview, greek_below_px: 3.0 * ppp, ..Default::default() };+ (st.doc.clone(), placed, w, h, view, opts)+ };+ // Synchronous path: document edits (keep editing crisp), first frame, or no worker.+ #[cfg(not(target_arch = "wasm32"))]+ if !app.canvas.worker_started {+ app.canvas.worker_started = true;+ app.canvas.worker = render_worker_spawn(ctx);+ }+ #[cfg(not(target_arch = "wasm32"))]+ let has_worker = app.canvas.worker.is_some();+ #[cfg(target_arch = "wasm32")]+ let has_worker = false;+ if !has_worker || app.canvas.shown.is_none() || (doc_changed && zoom_same) {+ let t0 = crate::now_ms();+ let (doc, placed, w, h, view, opts) = job(app);+ let img = app.canvas.renderer.render(&doc, &app.session.cache, &placed, w, h, view, &opts);+ upload(app, ctx, img);+ app.canvas.shown = Some(target);+ app.canvas.pending = None;+ app.perf.render_ms = crate::now_ms() - t0;+ return;+ }+ #[cfg(not(target_arch = "wasm32"))]+ {+ // Already rendering this view?+ if app.canvas.pending.is_some_and(|(_, p)| {+ p.doc == doc_key && (p.zoom - xf.zoom).abs() < 1e-9 && {+ let x0 = (xf.origin.x - p.origin.x) * p.zoom;+ let y0 = (xf.origin.y - p.origin.y) * p.zoom;+ x0 >= 0.0 && y0 >= 0.0 && x0 + rect.width() as f64 <= p.size.0 as f64 && y0 + rect.height() as f64 <= p.size.1 as f64+ }+ }) {+ return;+ }+ let (doc, placed, w, h, view, opts) = job(app);+ app.canvas.token += 1;+ let token = app.canvas.token;+ if let Some(wk) = app.canvas.worker.as_ref() {+ wk.submit(crate::render_worker::Job { token, doc, cache: app.session.cache.clone(), placed, w, h, view, opts });+ }+ app.canvas.pending = Some((token, target));+ }+}++#[cfg(not(target_arch = "wasm32"))]+fn render_worker_spawn(ctx: &egui::Context) -> Option<crate::render_worker::Worker> {+ if std::env::var_os("DESIGNCRAFT_SYNC_RENDER").is_some() {+ return None;+ }+ crate::render_worker::Worker::spawn(ctx.clone())+}++fn upload(app: &mut DesignApp, ctx: &egui::Context, img: designcraft_render::Rendered) {+ let ci = egui::ColorImage::from_rgba_premultiplied([img.width as usize, img.height as usize], &img.pixels);match &mut app.canvas.texture {Some(tex) => tex.set(ci, egui::TextureOptions::LINEAR),None => app.canvas.texture = Some(ctx.load_texture("canvas", ci, egui::TextureOptions::LINEAR)),}- app.canvas.key = Some(key);- app.perf.render_ms = crate::now_ms() - t0;}fn dashed(painter: &egui::Painter, a: Pos2, b: Pos2, stroke: Stroke, dash: f32, gap: f32) {diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rsindex 5240fc0dd..e148ae231 100644--- a/crates/ui-egui/src/lib.rs+++ b/crates/ui-egui/src/lib.rs@@ -13,6 +13,7 @@ pub mod dock;pub mod icons;pub mod menus;pub mod panels;+pub mod render_worker;pub mod story_editor;pub mod theme;pub mod toolbar;@@ -141,10 +142,27 @@ impl Default for View {}}+/// What the canvas texture currently shows.+#[derive(Clone, Copy, Debug, PartialEq)]+pub struct Shown {+ /// (doc uid, doc pointer, revision, preview).+ pub doc: (u64, u64, u64, bool),+ /// Canvas point at the texture's top-left, zoom, and texture size in screen points.+ pub origin: Point,+ pub zoom: f64,+ pub size: (f32, f32),+}+pub struct CanvasCache {pub renderer: designcraft_render::Renderer,pub texture: Option<egui::TextureHandle>,- pub key: Option<(u64, u64, u64, u64, u64, u32, u32, u8)>,+ pub shown: Option<Shown>,+ /// The request in flight on the worker.+ pub pending: Option<(u64, Shown)>,+ pub token: u64,+ #[cfg(not(target_arch = "wasm32"))]+ pub worker: Option<render_worker::Worker>,+ pub worker_started: bool,pub last_ms: f64,}@@ -190,7 +208,17 @@ impl DesignApp {ui: UiState::default(),services,views: HashMap::new(),- canvas: CanvasCache { renderer, texture: None, key: None, last_ms: 0.0 },+ canvas: CanvasCache {+ renderer,+ texture: None,+ shown: None,+ pending: None,+ token: 0,+ #[cfg(not(target_arch = "wasm32"))]+ worker: None,+ worker_started: false,+ last_ms: 0.0,+ },canvas_rect: None,perf: Perf::default(),synthetic: vec![],diff --git a/crates/ui-egui/src/render_worker.rs b/crates/ui-egui/src/render_worker.rsnew file mode 100644index 000000000..36c8016d6--- /dev/null+++ b/crates/ui-egui/src/render_worker.rs@@ -0,0 +1,73 @@+//! Background canvas rendering (native): a thread that owns its own `Renderer` and renders+//! requested regions while the UI keeps drawing the previous texture (shifted/scaled).+//! On wasm the canvas renders synchronously.++use std::sync::Arc;++use designcraft_compose::Cache;+use designcraft_doc::Document;+use designcraft_geom::Affine;+use designcraft_render::{Placed, RenderOptions, Rendered};++pub struct Job {+ pub token: u64,+ pub doc: Arc<Document>,+ pub cache: Arc<Cache>,+ pub placed: Vec<Placed>,+ pub w: u32,+ pub h: u32,+ pub view: Affine,+ pub opts: RenderOptions,+}++pub struct Done {+ pub token: u64,+ pub image: Rendered,+ pub ms: f64,+}++#[cfg(not(target_arch = "wasm32"))]+pub struct Worker {+ tx: std::sync::mpsc::Sender<Job>,+ rx: std::sync::mpsc::Receiver<Done>,+}++#[cfg(not(target_arch = "wasm32"))]+impl Worker {+ pub fn spawn(ctx: egui::Context) -> Option<Self> {+ let (tx, jobs) = std::sync::mpsc::channel::<Job>();+ let (done_tx, rx) = std::sync::mpsc::channel::<Done>();+ std::thread::Builder::new()+ .name("designcraft-render".into())+ .spawn(move || {+ let mut r = designcraft_render::Renderer::new();+ while let Ok(mut job) = jobs.recv() {+ // Only the newest job matters.+ while let Ok(newer) = jobs.try_recv() {+ job = newer;+ }+ let t0 = crate::now_ms();+ let image = r.render(&job.doc, &job.cache, &job.placed, job.w, job.h, job.view, &job.opts);+ if done_tx.send(Done { token: job.token, image, ms: crate::now_ms() - t0 }).is_err() {+ break;+ }+ ctx.request_repaint();+ }+ })+ .ok()?;+ Some(Worker { tx, rx })+ }+ pub fn submit(&self, job: Job) {+ let _ = self.tx.send(job);+ }+ pub fn poll(&self) -> Option<Done> {+ let mut last = None;+ while let Ok(d) = self.rx.try_recv() {+ last = Some(d);+ }+ last+ }+}++#[cfg(target_arch = "wasm32")]+pub struct Worker;