Squashed commit of the following:

commit 2a98d1e40a513c82329640fa5ad1c5eb0c2471c3
Author: DoubleStyx <79298541+DoubleStyx@users.noreply.github.com>
Date:   Tue Jun 9 14:30:23 2026 -0500

    Refactor renderer frame and asset orchestration

Author: DoubleStyx

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

@@ -260,10 +260,7 @@ impl AppDriver {
 
     fn drain_submit_completion_work(&mut self) {
         if let Some(target) = self.target.as_mut() {
-            let gpu = target.gpu_mut();
-            self.runtime.maintain_nonblocking_gpu_jobs(gpu);
-            self.runtime.drain_reflection_probe_render_tasks(gpu);
-            self.runtime.drain_camera_render_tasks(gpu);
+            self.runtime.drain_submit_completion_work(target.gpu_mut());
         }
     }
 

crates/renderide/src/backend/asset_transfers.rs

@@ -425,6 +425,28 @@ impl AssetTransferQueue {
             .contains_key(&asset_id)
     }
 
+    /// Point render-buffer asset ids with retained uploads and no active background build.
+    pub(in crate::backend::asset_transfers) fn startable_point_render_buffer_upload_ids(
+        &self,
+    ) -> Vec<i32> {
+        self.pending_point_render_buffer_uploads
+            .keys()
+            .copied()
+            .filter(|asset_id| !self.active_point_render_buffer_builds.contains(asset_id))
+            .collect()
+    }
+
+    /// Trail render-buffer asset ids with retained uploads and no active background build.
+    pub(in crate::backend::asset_transfers) fn startable_trail_render_buffer_upload_ids(
+        &self,
+    ) -> Vec<i32> {
+        self.pending_trail_render_buffer_uploads
+            .keys()
+            .copied()
+            .filter(|asset_id| !self.active_trail_render_buffer_builds.contains(asset_id))
+            .collect()
+    }
+
     /// Invalidates in-flight point render-buffer work for `asset_id`.
     #[inline]
     pub(crate) fn cancel_point_render_buffer_generation(&mut self, asset_id: i32) -> bool {

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

@@ -8,7 +8,9 @@ use crate::materials::MaterialSystem;
 use crate::profiling::{AssetIntegrationProfileSample, plot_asset_integration};
 
 use super::super::AssetTransferQueue;
-use super::super::particle_task::drain_ready_particle_builds;
+use super::super::particle_task::{
+    drain_ready_particle_builds, enqueue_startable_particle_uploads,
+};
 use super::gpu_context::{AssetUploadGpuContext, GpuHandles, collect_gpu_handles};
 use super::queue::AssetTaskLane;
 use super::step::{StepResult, step_asset_task};
@@ -34,6 +36,10 @@ const DEADLINE_POLL_STRIDE: u32 = 4;
 struct LaneDrainOutcome {
     /// Whether the lane still had queued work when the drain ended.
     pending: bool,
+    /// Whether the lane ended with queued work that cannot make progress until background state changes.
+    blocked_on_background: bool,
+    /// Whether at least one task step completed useful work.
+    made_progress: bool,
     /// Queue steps processed by this drain.
     processed: u32,
 }
@@ -384,6 +390,16 @@ fn finalize_drain(
         render: outcomes.integration.render.processed,
         particle: outcomes.particle.processed,
     };
+    let made_progress = outcomes.integration.main.made_progress
+        || outcomes.integration.high_priority.made_progress
+        || outcomes.integration.normal_priority.made_progress
+        || outcomes.integration.render.made_progress
+        || outcomes.particle.made_progress;
+    let blocked_on_background = outcomes.integration.main.blocked_on_background
+        || outcomes.integration.high_priority.blocked_on_background
+        || outcomes.integration.normal_priority.blocked_on_background
+        || outcomes.integration.render.blocked_on_background
+        || outcomes.particle.blocked_on_background;
     summary.finish(
         asset,
         DrainFinishState {
@@ -395,6 +411,8 @@ fn finalize_drain(
                 particle: outcomes.particle.pending,
             },
             processed,
+            made_progress,
+            blocked_on_background,
             particle_elapsed: outcomes.particle_elapsed,
             elapsed: outcomes.integration_elapsed,
         },
@@ -495,6 +513,7 @@ fn drain_particle_asset_tasks(
 ) -> LaneDrainOutcome {
     profiling::scope!("asset::particle_drain");
     let particle_gpu = super::step::particle_task_gpu(gpu);
+    let startable_before = enqueue_startable_particle_uploads(asset);
     let ready_before = drain_ready_particle_builds(asset, particle_gpu.as_ref(), particle_deadline);
     let queued = drain_lane(
         asset,
@@ -506,15 +525,28 @@ fn drain_particle_asset_tasks(
         AssetTaskLane::Particle,
     );
     let ready_after = drain_ready_particle_builds(asset, particle_gpu.as_ref(), particle_deadline);
+    let startable_after = enqueue_startable_particle_uploads(asset);
     LaneDrainOutcome {
         pending: ready_before.pending
             || queued.pending
             || ready_after.pending
             || asset.has_ready_particle_build_results(),
+        blocked_on_background: queued.blocked_on_background
+            || (ready_before.pending && particle_gpu.is_none())
+            || (ready_after.pending && particle_gpu.is_none())
+            || startable_before.pending
+            || startable_after.pending,
+        made_progress: queued.made_progress
+            || ready_before.processed > 0
+            || ready_after.processed > 0
+            || startable_before.enqueued > 0
+            || startable_after.enqueued > 0,
         processed: ready_before
             .processed
+            .saturating_add(startable_before.enqueued)
             .saturating_add(queued.processed)
-            .saturating_add(ready_after.processed),
+            .saturating_add(ready_after.processed)
+            .saturating_add(startable_after.enqueued),
     }
 }
 
@@ -535,13 +567,16 @@ fn drain_lane(
     let mut yielded: usize = 0;
     let mut iter_count: u32 = 0;
     let mut processed: u32 = 0;
+    let mut made_progress = false;
     loop {
         // Coarse deadline check: every `DEADLINE_POLL_STRIDE` iterations rather than every
         // iteration, so cheap task steps (e.g. texture mip progression) do not pay the
         // `Instant::now` syscall on every pop.
         if iter_count.is_multiple_of(DEADLINE_POLL_STRIDE) && Instant::now() >= deadline {
             return LaneDrainOutcome {
                 pending: !asset.integrator.lane_is_empty(lane),
+                blocked_on_background: false,
+                made_progress,
                 processed,
             };
         }
@@ -550,6 +585,8 @@ fn drain_lane(
         let Some(mut task) = task_opt else {
             return LaneDrainOutcome {
                 pending: false,
+                blocked_on_background: false,
+                made_progress,
                 processed,
             };
         };
@@ -559,6 +596,7 @@ fn drain_lane(
             StepResult::Continue => {
                 asset.integrator.push_front_lane(task, lane);
                 yielded = 0;
+                made_progress = true;
             }
             StepResult::YieldBackground => {
                 asset.integrator.push_back_lane(task, lane);
@@ -567,12 +605,15 @@ fn drain_lane(
                 if yielded >= lane_len {
                     return LaneDrainOutcome {
                         pending: false,
+                        blocked_on_background: lane_len > 0,
+                        made_progress,
                         processed,
                     };
                 }
             }
             StepResult::Done => {
                 yielded = 0;
+                made_progress = true;
             }
         }
     }

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

@@ -49,6 +49,10 @@ pub struct AssetIntegrationDrainSummary {
     pub render_budget_exhausted: bool,
     /// Whether particle-lane work exceeded its separate post-main budget.
     pub particle_budget_exhausted: bool,
+    /// Whether at least one task made useful forward progress during the drain.
+    pub made_progress: bool,
+    /// Whether queued work remains but every runnable task is waiting on background/GPU state.
+    pub blocked_on_background: bool,
     /// Wall-clock time spent in non-particle integration lanes.
     pub elapsed: Duration,
     /// Wall-clock time spent in the particle lane.
@@ -88,6 +92,8 @@ impl AssetIntegrationDrainSummary {
         self.processed_normal_priority_tasks = finish.processed.normal_priority;
         self.processed_render_tasks = finish.processed.render;
         self.processed_particle_tasks = finish.processed.particle;
+        self.made_progress = finish.made_progress;
+        self.blocked_on_background = finish.blocked_on_background;
         self.elapsed = finish.elapsed;
         self.particle_elapsed = finish.particle_elapsed;
         self.peak_queued = asset.integrator.peak_queued();
@@ -136,6 +142,8 @@ pub(super) struct DrainFinishState {
     pub(super) gpu_ready: bool,
     pub(super) budgets: BudgetExhaustion,
     pub(super) processed: ProcessedLaneCounts,
+    pub(super) made_progress: bool,
+    pub(super) blocked_on_background: bool,
     pub(super) particle_elapsed: Duration,
     pub(super) elapsed: Duration,
 }

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

@@ -17,10 +17,14 @@ pub(super) fn poll_video_texture_events(
 ) {
     // Idle scenes never instantiate a video player; skip the `mem::take` swap and the inner
     // profiling scope entirely so the tracy timeline doesn't carry a zero-work zone every frame.
-    if asset.video.video_players.is_empty() {
+    if asset.video.video_players.is_empty() && asset.video.retiring_player_count() == 0 {
         return;
     }
     profiling::scope!("asset::video_texture_poll_events");
+    asset.video.poll_retiring_players();
+    if asset.video.video_players.is_empty() {
+        return;
+    }
     let mut video_textures = std::mem::take(&mut asset.video.video_players);
     {
         profiling::scope!("video::sample_clock_errors");