Merge master into renderer cycle decoupling

Author: DoubleStyx

crates/renderide/src/app/driver.rs

@@ -50,6 +50,8 @@ pub(crate) struct AppDriver {
     pub(in crate::app::driver) frame_clock: FrameClock,
     /// Open Tracy span that attributes the winit wait gap to `app::about_to_wait`.
     pub(in crate::app::driver) about_to_wait_span: crate::profiling::DeferredCpuSpan,
+    /// Whether the last completed tick queued an HMD projection layer for compositor pacing.
+    pub(in crate::app::driver) hmd_compositor_paced_last_frame: bool,
     pub(in crate::app::driver) external_shutdown: Option<ExternalShutdownCoordinator>,
     pub(in crate::app::driver) main_heartbeat: Option<crate::diagnostics::Heartbeat>,
     /// RAII guard suppressing main-thread watchdog hang reports for the duration of the
@@ -88,6 +90,7 @@ impl AppDriver {
             cursor_output_tracking: CursorOutputTracking::default(),
             frame_clock: FrameClock::default(),
             about_to_wait_span: crate::profiling::DeferredCpuSpan::default(),
+            hmd_compositor_paced_last_frame: false,
             external_shutdown,
             main_heartbeat,
             shutdown_watchdog_pause: None,

crates/renderide/src/app/driver/events.rs

@@ -173,7 +173,7 @@ impl ApplicationHandler for AppDriver {
         let plan = plan_redraw(RedrawInputs {
             has_window: self.target.is_some(),
             exit_requested: self.exit_is_requested(),
-            vr_active: self.runtime.vr_active(),
+            hmd_compositor_paced: self.hmd_compositor_paced_last_frame,
             vsync,
             window_has_keyboard_focus: self.input.window_focused,
             foreground_fps_cap: frame_pacing_caps.foreground_fps_cap,

crates/renderide/src/app/driver/frame.rs

@@ -141,6 +141,7 @@ impl AppDriver {
         event_loop: &dyn ActiveEventLoop,
         frame_start: Instant,
     ) -> FrameTickOutcome {
+        self.hmd_compositor_paced_last_frame = false;
         self.frame_tick_prologue(frame_start);
         self.poll_ipc_and_window();
         if self.check_external_shutdown(event_loop) {
@@ -229,6 +230,7 @@ impl AppDriver {
         };
         self.runtime.note_frame_render_attempted();
         let hmd_projection_ended = render_outcome.hmd_projection_ended;
+        self.hmd_compositor_paced_last_frame = hmd_projection_ended;
         if self.handle_gpu_device_loss_request(event_loop) {
             if !hmd_projection_ended {
                 self.queue_empty_openxr_frame_if_needed(xr_tick);

crates/renderide/src/app/redraw_plan.rs

@@ -33,8 +33,8 @@ pub(crate) struct RedrawInputs {
     pub(crate) has_window: bool,
     /// Whether the app has already requested event-loop exit.
     pub(crate) exit_requested: bool,
-    /// Whether VR pacing owns frame cadence.
-    pub(crate) vr_active: bool,
+    /// Whether HMD compositor pacing owns frame cadence for the next redraw.
+    pub(crate) hmd_compositor_paced: bool,
     /// Swapchain VSync mode. `On` lets FIFO presentation own desktop cadence.
     pub(crate) vsync: VsyncMode,
     /// Whether winit reports that the renderer window currently has keyboard focus.
@@ -80,7 +80,7 @@ pub(crate) fn plan_redraw(inputs: RedrawInputs) -> RedrawPlan {
         };
     }
 
-    if inputs.vr_active || inputs.vsync == VsyncMode::On {
+    if inputs.hmd_compositor_paced || inputs.vsync == VsyncMode::On {
         return RedrawPlan {
             decision: RedrawDecision::RedrawNow,
             fps_cap: 0,
@@ -159,7 +159,7 @@ mod tests {
         let plan = plan_redraw(RedrawInputs {
             has_window: true,
             exit_requested: false,
-            vr_active: false,
+            hmd_compositor_paced: false,
             vsync: VsyncMode::Off,
             window_has_keyboard_focus: true,
             foreground_fps_cap: 60,
@@ -179,7 +179,7 @@ mod tests {
         let plan = plan_redraw(RedrawInputs {
             has_window: true,
             exit_requested: false,
-            vr_active: false,
+            hmd_compositor_paced: false,
             vsync: VsyncMode::Off,
             window_has_keyboard_focus: false,
             foreground_fps_cap: 60,
@@ -203,7 +203,7 @@ mod tests {
             let plan = plan_redraw(RedrawInputs {
                 has_window: true,
                 exit_requested: false,
-                vr_active: false,
+                hmd_compositor_paced: false,
                 vsync: VsyncMode::Off,
                 window_has_keyboard_focus: true,
                 foreground_fps_cap: 30,
@@ -218,13 +218,13 @@ mod tests {
     }
 
     #[test]
-    fn redraw_plan_redraws_immediately_when_uncapped_or_vr() {
+    fn redraw_plan_redraws_immediately_when_uncapped_or_hmd_paced() {
         let now = Instant::now();
         assert_eq!(
             plan_redraw(RedrawInputs {
                 has_window: true,
                 exit_requested: false,
-                vr_active: false,
+                hmd_compositor_paced: false,
                 vsync: VsyncMode::Off,
                 window_has_keyboard_focus: true,
                 foreground_fps_cap: 0,
@@ -235,21 +235,41 @@ mod tests {
             .decision,
             RedrawDecision::RedrawNow
         );
-        assert_eq!(
-            plan_redraw(RedrawInputs {
-                has_window: true,
-                exit_requested: false,
-                vr_active: true,
-                vsync: VsyncMode::Off,
-                window_has_keyboard_focus: true,
-                foreground_fps_cap: 60,
-                background_fps_cap: 15,
-                last_frame_start: Some(now),
-                now,
-            })
-            .decision,
-            RedrawDecision::RedrawNow
-        );
+        let hmd_paced = plan_redraw(RedrawInputs {
+            has_window: true,
+            exit_requested: false,
+            hmd_compositor_paced: true,
+            vsync: VsyncMode::Off,
+            window_has_keyboard_focus: true,
+            foreground_fps_cap: 60,
+            background_fps_cap: 15,
+            last_frame_start: Some(now),
+            now,
+        });
+        assert_eq!(hmd_paced.decision, RedrawDecision::RedrawNow);
+        assert_eq!(hmd_paced.fps_cap, 0);
+        assert_eq!(hmd_paced.wait_ms, 0.0);
+    }
+
+    #[test]
+    fn redraw_plan_caps_non_hmd_frames_even_after_xr_session_exists() {
+        let t0 = Instant::now();
+        let now = t0 + Duration::from_millis(1);
+        let plan = plan_redraw(RedrawInputs {
+            has_window: true,
+            exit_requested: false,
+            hmd_compositor_paced: false,
+            vsync: VsyncMode::Off,
+            window_has_keyboard_focus: true,
+            foreground_fps_cap: 60,
+            background_fps_cap: 15,
+            last_frame_start: Some(t0),
+            now,
+        });
+
+        assert_eq!(plan.fps_cap, 60);
+        assert!(matches!(plan.decision, RedrawDecision::WaitUntil(_)));
+        assert!(plan.wait_ms > 0.0);
     }
 
     #[test]
@@ -260,7 +280,7 @@ mod tests {
             let plan = plan_redraw(RedrawInputs {
                 has_window: true,
                 exit_requested: false,
-                vr_active: false,
+                hmd_compositor_paced: false,
                 vsync: VsyncMode::On,
                 window_has_keyboard_focus,
                 foreground_fps_cap: 60,
@@ -281,7 +301,7 @@ mod tests {
             plan_redraw(RedrawInputs {
                 has_window: false,
                 exit_requested: false,
-                vr_active: false,
+                hmd_compositor_paced: false,
                 vsync: VsyncMode::Off,
                 window_has_keyboard_focus: true,
                 foreground_fps_cap: 60,
@@ -296,7 +316,7 @@ mod tests {
             plan_redraw(RedrawInputs {
                 has_window: true,
                 exit_requested: true,
-                vr_active: true,
+                hmd_compositor_paced: true,
                 vsync: VsyncMode::Off,
                 window_has_keyboard_focus: true,
                 foreground_fps_cap: 60,

crates/renderide/src/backend/asset_transfers/integrator/drain.rs

@@ -193,6 +193,7 @@ fn submit_mesh_upload_flush(
         .submit(crate::gpu::driver_thread::SubmitBatch {
             submit_kind: crate::gpu::driver_thread::DriverSubmitKind::BackgroundGpuWork,
             command_buffers: vec![command_buffer],
+            retained_resources: crate::gpu::GpuRetainedResources::new(),
             surface_texture: None,
             on_submitted_work_done,
             frame_timing: None,

crates/renderide/src/backend/facade.rs

@@ -564,8 +564,13 @@ impl RenderBackend {
         let command_recording_mode = self.command_recording_mode();
         let wall_frame_time_ms = self.debug_frame_time_ms();
         let skin_weight_mode = self.skin_weight_mode();
-        let (transient_pool, history_registry, upload_arena, latest_upload_stats) =
-            self.graph_state.execution_resources_mut();
+        let (
+            transient_pool,
+            history_registry,
+            upload_arena,
+            latest_upload_stats,
+            pending_transient_releases,
+        ) = self.graph_state.execution_resources_mut();
         let (frame_resources, mesh_preprocess, mesh_deform_scratch, skin_cache) =
             self.frame_services.graph_access_slices();
         BackendGraphAccess {
@@ -581,6 +586,7 @@ impl RenderBackend {
             history_registry,
             upload_arena,
             latest_upload_stats,
+            pending_transient_releases,
             debug_hud: self.diagnostics.bundle_mut(),
             scene_color_format,
             gpu_limits,

crates/renderide/src/backend/facade/execute.rs

@@ -62,6 +62,7 @@ impl RenderBackend {
                 }
             }
         }
+        self.graph_state.release_completed_transient_submits(gpu);
         self.graph_state.history_registry_mut().advance_frame();
         debug_assert_eq!(
             requirements,

crates/renderide/src/backend/facade/graph_access.rs

@@ -21,6 +21,7 @@ use crate::passes::post_processing::settings_slots::{
 use crate::render_graph::TransientPool;
 use crate::render_graph::blackboard::Blackboard;
 use crate::render_graph::compiled::FrameView;
+use crate::render_graph::context::GraphResolvedResources;
 use crate::render_graph::execution_backend::{
     GraphExecutionBackend, GraphFrameParamsSplit, GraphViewBlackboardPreparer,
 };
@@ -30,6 +31,7 @@ use super::super::debug_hud_bundle::DebugHudBundle;
 use super::super::{
     FrameResourceManager, HistoryRegistry, WorldMeshDrawPlanSlot, WorldMeshOverlayDrawPlanSlot,
 };
+use super::graph_state::PendingTransientRelease;
 
 /// Live post-processing parameters seeded into per-view blackboards.
 #[derive(Clone, Copy, Debug, Default)]
@@ -74,6 +76,8 @@ pub(crate) struct BackendGraphAccess<'a> {
     pub(crate) upload_arena: &'a mut PersistentUploadArena,
     /// Latest frame-upload stats published for diagnostics.
     pub(crate) latest_upload_stats: &'a mut FrameUploadBatchStats,
+    /// Resolved transient resource sets waiting on driver submit before pool release.
+    pub(super) pending_transient_releases: &'a mut Vec<PendingTransientRelease>,
     /// Debug HUD state and encoder.
     pub(crate) debug_hud: &'a mut DebugHudBundle,
     /// Scene-color format snapshot selected before graph execution borrows backend fields.
@@ -137,6 +141,18 @@ impl<'a> BackendGraphAccess<'a> {
         self.transient_pool
     }
 
+    /// Schedules resolved transient resources for pool release once `token` has submitted.
+    pub(crate) fn schedule_transient_release_after_submit(
+        &mut self,
+        token: crate::gpu::driver_thread::SubmitToken,
+        resources: Vec<GraphResolvedResources>,
+    ) {
+        if !resources.is_empty() {
+            self.pending_transient_releases
+                .push(PendingTransientRelease { token, resources });
+        }
+    }
+
     /// Shared history registry for import resolution.
     pub(crate) fn history_registry(&self) -> &HistoryRegistry {
         self.history_registry
@@ -271,6 +287,14 @@ impl GraphExecutionBackend for BackendGraphAccess<'_> {
         BackendGraphAccess::transient_pool_mut(self)
     }
 
+    fn schedule_transient_release_after_submit(
+        &mut self,
+        token: crate::gpu::driver_thread::SubmitToken,
+        resources: Vec<GraphResolvedResources>,
+    ) {
+        BackendGraphAccess::schedule_transient_release_after_submit(self, token, resources);
+    }
+
     fn history_registry(&self) -> &HistoryRegistry {
         BackendGraphAccess::history_registry(self)
     }