From ca38c458cb15963a0907d2ee6017d9649c77458b Mon Sep 17 00:00:00 2001 From: Simon Hull <5488089+simonhull@users.noreply.github.com> Date: Tue, 3 Nov 2026 22:42:07 -0600 Subject: [PATCH] Forget a set's sent display kinds only when its textures are recreated The renderer keeps a set's textures when a mesh, layout or project change leaves its size and display shift alone. Clearing the record of sent kinds on those changes let a kind the new channels don't need, such as Emissive, keep its old content on screen. The renderer now reports which sets it recreated, and only those start over with the kinds their channels need. --- crates/ui-egui/src/gpu.rs | 92 ++++++++++++++++++++++++++++++++++++--- 1 file changed, 86 insertions(+), 6 deletions(-) diff --git a/crates/ui-egui/src/gpu.rs b/crates/ui-egui/src/gpu.rs index 9b361ac1..0251a1f8 100644 --- a/crates/ui-egui/src/gpu.rs +++ b/crates/ui-egui/src/gpu.rs @@ -43,6 +43,9 @@ pub struct GpuState { pub renderer: Renderer, /// Raised when texture-set textures were recreated: the UI must upload every tile again. pub reset: Arc, + /// The texture sets whose textures were recreated (all neutral again), for [`GpuLink`]'s + /// record of the display kinds each set holds. + pub recreated: Arc>>, pub reports: Arc>, /// Wakes the UI when the GPU side has something to report. pub ctx: egui::Context, @@ -63,6 +66,8 @@ const MAX_GPU_ERRORS: usize = 8; /// UI-side bookkeeping of what the GPU already has. pub struct GpuLink { pub reset: Arc, + /// [`GpuState::recreated`]. + recreated: Arc>>, pub reports: Arc>, /// Raised when a view callback was dropped before the GPU applied its scene sync (the /// frame was never painted, e.g. a WebGPU surface not ready yet): send everything again. @@ -76,7 +81,9 @@ pub struct GpuLink { /// What each set's aux texture holds: (mesh map or mask key, revision). aux: BTreeMap, /// The display kinds sent to the GPU per set: kinds the set has no channels for are not - /// converted, unless an earlier upload gave them content that must be overwritten. + /// converted, unless an earlier upload gave them content that must be overwritten. Only the + /// renderer recreating a set's textures ([`GpuState::recreated`]) clears its entry: a set + /// that keeps its size keeps its textures through mesh, layout and project changes. sent: HashMap>, pub adapter: String, /// Most tiles waiting to be composited since compositing last caught up (progress). @@ -99,6 +106,7 @@ const UPLOAD_MS_PER_TILE: f64 = 0.006; pub fn init(rs: &egui_wgpu::RenderState, ctx: &egui::Context) -> GpuLink { let reset = Arc::new(AtomicBool::new(false)); + let recreated = Arc::new(Mutex::new(BTreeSet::new())); let reports = Arc::new(Mutex::new(GpuReports::default())); // wgpu's default handler panics on any error no scope caught (an out-of-memory texture, a // driver hiccup): report it instead, so the user keeps the session. @@ -114,10 +122,17 @@ pub fn init(rs: &egui_wgpu::RenderState, ctx: &egui::Context) -> GpuLink { wake.request_repaint(); })); let renderer = Renderer::new(&rs.device, &rs.queue, rs.target_format); - rs.renderer.write().callback_resources.insert(GpuState { renderer, reset: reset.clone(), reports: reports.clone(), ctx: ctx.clone() }); + rs.renderer.write().callback_resources.insert(GpuState { + renderer, + reset: reset.clone(), + recreated: recreated.clone(), + reports: reports.clone(), + ctx: ctx.clone(), + }); let info = rs.adapter.get_info(); GpuLink { reset, + recreated, reports, lost: Arc::new(AtomicBool::new(false)), mesh_id: 0, @@ -158,20 +173,17 @@ impl GpuLink { self.sets.clear(); self.env = Default::default(); self.reset.store(true, Ordering::Release); - self.sent.clear(); } if self.mesh_id != s.mesh_id { out.mesh = Some((s.mesh.clone(), s.mesh_id)); self.mesh_id = s.mesh_id; self.aux.clear(); - self.sent.clear(); } let sets: Vec = s.doc.project.texture_sets.iter().map(|t| (t.size(), t.material)).collect(); if sets != self.sets || shift != self.shift || out.mesh.is_some() { out.sets = Some((sets.clone(), s.mesh.materials.len().max(1), shift)); self.sets = sets; self.shift = shift; - self.sent.clear(); } let d = &s.doc.project.display; let image = d.environment_resource().and_then(|n| s.images.get(n)); @@ -185,7 +197,9 @@ impl GpuLink { c.upload.extend(texturecraft_engine::compose::all_tiles(c.size.0, c.size.1)); } self.aux.clear(); - self.sent.clear(); + } + for ts in std::mem::take(&mut *self.recreated.lock().unwrap_or_else(PoisonError::into_inner)) { + self.sent.remove(&ts); } for ts in 0..s.caches.len() { let tiles = s.take_uploads(ts); @@ -305,6 +319,7 @@ impl CallbackTrait for ViewCallback { gpu.renderer.set_display_shift(*shift); let reset = gpu.renderer.set_texture_sets(device, queue, sets, *mats); if !reset.is_empty() { + gpu.recreated.lock().unwrap_or_else(PoisonError::into_inner).extend(reset); gpu.reset.store(true, Ordering::Release); } } @@ -349,3 +364,68 @@ impl CallbackTrait for ViewCallback { gpu.renderer.blit_prepared(pass, self.frame.view_id); } } + +#[cfg(test)] +mod tests { + use super::*; + use serde_json::json; + use texturecraft_engine::execute; + use texturecraft_engine::geom::primitives; + + fn link() -> GpuLink { + GpuLink { + reset: Arc::default(), + recreated: Arc::default(), + reports: Arc::default(), + lost: Arc::default(), + mesh_id: 0, + sets: Vec::new(), + shift: 0, + env: Default::default(), + aux: BTreeMap::new(), + sent: HashMap::new(), + adapter: String::new(), + composite_total: 0, + } + } + + fn session(emissive: bool) -> Session { + let mut s = Session::new_project("t", primitives::sphere(1.0, 16, 8), "builtin:sphere", None, 128).unwrap(); + if emissive { + execute(&mut s, "textureSet.channel.add", &json!({"channel": "emissive"})).unwrap(); + execute(&mut s, "layer.add.fill", &json!({})).unwrap(); + execute(&mut s, "layer.fill.set", &json!({"channel": "emissive", "color": [1.0, 0.5, 0.0]})).unwrap(); + } + s + } + + fn kinds(out: &SceneSync) -> BTreeSet { + out.tiles.iter().filter(|t| t.0 == 0).map(|t| t.1).collect() + } + + #[test] + fn a_kind_sent_before_a_project_change_is_overwritten_while_its_textures_survive() { + let mut gpu = link(); + let out = gpu.sync(&mut session(true), None, 0, 0.0); + assert!(kinds(&out).contains(&DisplayKind::Emissive)); + // A same-size project without emissive: a new mesh and the same set layout, so the + // renderer keeps the set's textures, emissive content included. It must be overwritten. + let out = gpu.sync(&mut session(false), None, 0, 0.0); + assert!(out.mesh.is_some() && out.sets.is_some()); + assert!(kinds(&out).contains(&DisplayKind::Emissive), "the stale emissive texture is overwritten"); + } + + #[test] + fn a_recreated_set_converts_only_the_kinds_it_has_channels_for() { + let mut gpu = link(); + gpu.sync(&mut session(true), None, 0, 0.0); + let mut plain = session(false); + gpu.sync(&mut plain, None, 0, 0.0); + // The renderer recreated set 0 (all neutral) and asked for every tile again. + gpu.recreated.lock().unwrap().insert(0); + gpu.reset.store(true, Ordering::Release); + let out = gpu.sync(&mut plain, None, 0, 0.0); + assert!(!out.tiles.is_empty()); + assert!(!kinds(&out).contains(&DisplayKind::Emissive), "nothing to overwrite in a neutral texture"); + } +}