Damage events are now emitted directly after parsing PTY data, ensuring proper batching

Author: raphamorim

docs/docs/releases.md

@@ -9,6 +9,14 @@ language: 'en'
 
 - TBD.
 
+## 0.2.26
+
+- **Fix frame dropping in release builds**: Fixed an issue where release builds would drop frames due to damage event timing
+  - Damage events are now emitted directly after parsing PTY data, ensuring proper batching
+  - Removed redundant Wakeup event mechanism that was causing multiple renders per update
+  - Synchronized update timeouts now properly emit damage events
+  - Significantly improves rendering smoothness in optimized builds
+
 ## 0.2.25
 
 - Fix: Rio doesn't launch from context menu on Windows.

frontends/rioterm/src/application.rs

@@ -226,36 +226,6 @@ impl ApplicationHandler<EventPayload> for Application<'_> {
                     }
                 }
             }
-            RioEventType::Rio(RioEvent::Wakeup(route_id)) => {
-                if let Some(route) = self.router.routes.get_mut(&window_id) {
-                    let context_manager = route.window.screen.ctx_mut();
-                    let grid = context_manager.current_grid_mut();
-
-                    let mut request_pending_redraw = false;
-
-                    for (_key, grid_context) in grid.contexts().iter() {
-                        let ctx = grid_context.context();
-
-                        // In this case we know we have to render something that's pending.
-                        if ctx.renderable_content.pending_update.is_dirty() {
-                            request_pending_redraw = true;
-                        }
-
-                        if let Some(terminal) =
-                            grid_context.context().terminal.try_lock_unfair()
-                        {
-                            // Only emit damage event if there's actual damage
-                            if terminal.peek_damage_event().is_some() {
-                                terminal.emit_damage_event();
-                            }
-                        }
-                    }
-
-                    if request_pending_redraw {
-                        route.schedule_redraw(&mut self.scheduler, route_id);
-                    }
-                }
-            }
             RioEventType::Rio(RioEvent::TerminalDamaged { route_id, damage }) => {
                 if self.config.renderer.strategy.is_event_based() {
                     if let Some(route) = self.router.routes.get_mut(&window_id) {

frontends/rioterm/src/renderer/mod.rs

@@ -858,7 +858,7 @@ impl Renderer {
                     Some(snapshot) => snapshot,
                     None if force_full_damage => {
                         // Force full damage case - create a fresh snapshot
-                        let mut terminal = context.terminal.lock();
+                        let terminal = context.terminal.lock();
                         let snapshot = TerminalSnapshot {
                             colors: terminal.colors,
                             display_offset: terminal.display_offset(),

rio-backend/src/performer/mod.rs

@@ -206,6 +206,11 @@ where
             // Parse the incoming bytes.
             state.parser.advance(&mut **terminal, &buf[..unprocessed]);
 
+            // Emit damage event if there's any damage after parsing
+            if terminal.peek_damage_event().is_some() {
+                terminal.emit_damage_event();
+            }
+
             processed += unprocessed;
             unprocessed = 0;
 
@@ -217,8 +222,8 @@ where
 
         // Queue terminal update processing unless all processed bytes were synchronized.
         if state.parser.sync_bytes_count() < processed && processed > 0 {
-            self.event_proxy
-                .send_event(RioEvent::Wakeup(self.route_id), self.window_id);
+            // Damage events are now emitted directly after parsing
+            // No need to send Wakeup events
         }
 
         Ok(())
@@ -343,9 +348,14 @@ where
 
                 // Handle synchronized update timeout.
                 if events.is_empty() && self.receiver.peek().is_none() {
-                    state.parser.stop_sync(&mut *self.terminal.lock());
-                    self.event_proxy
-                        .send_event(RioEvent::Wakeup(self.route_id), self.window_id);
+                    let mut terminal = self.terminal.lock();
+                    state.parser.stop_sync(&mut *terminal);
+
+                    // Emit damage event if there's any damage after processing sync buffer
+                    if terminal.peek_damage_event().is_some() {
+                        terminal.emit_damage_event();
+                    }
+                    drop(terminal);
 
                     continue;
                 }