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"); + } +}