fix edit overlay getting stuck on mirrors

wlx-overlay-s/src/overlays/edit/mod.rs

@@ -101,6 +101,8 @@ impl EditWrapperManager {
         owc.backend = Box::new(EditModeBackendWrapper {
             inner: ManuallyDrop::new(inner),
             panel: ManuallyDrop::new(panel),
+            last_render: Instant::now(),
+            can_render_inner: false,
         });
         owc.editing = true;
 
@@ -139,6 +141,9 @@ impl EditWrapperManager {
 pub struct EditModeBackendWrapper {
     panel: ManuallyDrop<EditModeWrapPanel>,
     inner: ManuallyDrop<Box<dyn OverlayBackend>>,
+
+    last_render: Instant,
+    can_render_inner: bool,
 }
 
 impl OverlayBackend for EditModeBackendWrapper {
@@ -160,9 +165,9 @@ impl OverlayBackend for EditModeBackendWrapper {
             app.tasks.transfer_from(&mut local_tasks);
         }
 
-        let i = self.inner.should_render(app)?;
+        let inner = self.inner.should_render(app)?;
 
-        if !matches!(i, ShouldRender::Unable)
+        if !matches!(inner, ShouldRender::Unable)
             && let Some(ref frame_meta) = self.inner.frame_meta()
         {
             let (width_px, height_px) = (frame_meta.extent[0], frame_meta.extent[1]);
@@ -176,18 +181,25 @@ impl OverlayBackend for EditModeBackendWrapper {
                 self.panel.gui_scale = (gui_scale * 4.0).round() / 4.0;
                 self.panel.update_layout()?;
             }
+
+            self.can_render_inner = true;
         } else {
+            self.can_render_inner = false;
+            if self.last_render.elapsed() < Duration::from_millis(100) {
                 return Ok(ShouldRender::Unable);
             }
+        }
 
-        let p = self.panel.should_render(app)?;
+        let panel = self.panel.should_render(app)?;
 
         #[allow(clippy::match_same_arms)]
-        Ok(match (i, p) {
+        Ok(match (inner, panel) {
             (ShouldRender::Should, ShouldRender::Should) => ShouldRender::Should,
             (ShouldRender::Should, ShouldRender::Can) => ShouldRender::Should,
             (ShouldRender::Can, ShouldRender::Should) => ShouldRender::Should,
             (ShouldRender::Can, ShouldRender::Can) => ShouldRender::Can,
+            // only if last render was more than 100ms ago.
+            (ShouldRender::Unable, ShouldRender::Should) => ShouldRender::Should,
             _ => ShouldRender::Unable,
         })
     }
@@ -196,7 +208,9 @@ impl OverlayBackend for EditModeBackendWrapper {
         app: &mut crate::state::AppState,
         rdr: &mut RenderResources,
     ) -> anyhow::Result<()> {
+        if self.can_render_inner {
             self.inner.render(app, rdr)?;
+        }
 
         self.panel.render(app, rdr)?;
         // `GuiPanel` is not stereo-aware, so just render the same pass twice

wlx-overlay-s/src/overlays/screen/backend.rs

@@ -51,6 +51,7 @@ pub struct ScreenBackend {
     pub(super) logical_size: Vec2,
     pub(super) mouse_transform_original: Transform,
     mouse_transform_override: MouseTransform,
+    just_resumed: bool,
 }
 
 impl ScreenBackend {
@@ -76,6 +77,7 @@ impl ScreenBackend {
             logical_size: Vec2::ZERO,
             mouse_transform_original: Transform::Undefined,
             mouse_transform_override: MouseTransform::Default,
+            just_resumed: false,
         }
     }
 
@@ -203,17 +205,22 @@ impl OverlayBackend for ScreenBackend {
 
             self.meta = Some(meta);
             self.cur_frame = Some(frame);
-        }
 
-        if self.cur_frame.is_some() {
             Ok(ShouldRender::Should)
+        } else if self.cur_frame.is_some() {
+            if self.just_resumed {
+                self.just_resumed = false;
+                Ok(ShouldRender::Should)
+            } else {
+                Ok(ShouldRender::Can)
+            }
         } else {
             Ok(ShouldRender::Unable)
         }
     }
     fn render(&mut self, app: &mut AppState, rdr: &mut RenderResources) -> anyhow::Result<()> {
         // want panic; must be some if should_render was not Unable
-        let capture = self.cur_frame.take().unwrap();
+        let capture = self.cur_frame.as_ref().unwrap();
 
         // want panic; must be Some if cur_frame is also Some
         self.pipeline.as_mut().unwrap().render(&capture, app, rdr)?;
@@ -225,6 +232,7 @@ impl OverlayBackend for ScreenBackend {
         Ok(())
     }
     fn resume(&mut self, _app: &mut AppState) -> anyhow::Result<()> {
+        self.just_resumed = true;
         self.capture.resume();
         Ok(())
     }