Merge branch 'fix-realtime-reflection-probe-sh2'

Author: DoubleStyx

crates/renderide/src/reflection_probes/source_resolution.rs

@@ -86,7 +86,10 @@ pub(super) fn resolve_task_source(
         ));
     }
 
-    if state.r#type == ReflectionProbeType::OnChanges {
+    if matches!(
+        state.r#type,
+        ReflectionProbeType::OnChanges | ReflectionProbeType::Realtime
+    ) {
         return resolve_runtime_capture_source(render_space_id, probe, captures);
     }
     None
@@ -145,6 +148,7 @@ fn cubemap_residency_from_pool(
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::backend::AssetTransferQueue;
     use crate::shared::{ReflectionProbeClear, ReflectionProbeState};
 
     #[test]
@@ -209,4 +213,50 @@ mod tests {
         assert!(matches!(skybox_source, Sh2ResolvedSource::Postpone));
         assert!(matches!(color_source, Sh2ResolvedSource::Postpone));
     }
+
+    #[test]
+    fn realtime_task_without_capture_postpones_runtime_cubemap_source() {
+        let mut scene = SceneCoordinator::new();
+        let space_id = RenderSpaceId(7);
+        scene.test_seed_space_identity_worlds(space_id, Vec::new(), Vec::new());
+        scene.test_push_reflection_probes(
+            space_id,
+            [ReflectionProbeEntry {
+                renderable_index: 0,
+                transform_id: 12,
+                state: ReflectionProbeState {
+                    renderable_index: 0,
+                    clear_flags: ReflectionProbeClear::Skybox,
+                    r#type: ReflectionProbeType::Realtime,
+                    ..Default::default()
+                },
+            }],
+        );
+        let assets = AssetTransferQueue::new();
+        let captures = RuntimeReflectionProbeCaptureStore::default();
+
+        let (key, source) = resolve_task_source(
+            &scene,
+            &assets,
+            &captures,
+            space_id.0,
+            TaskHeader {
+                renderable_index: 42,
+                reflection_probe_renderable_index: 0,
+            },
+        )
+        .expect("realtime probes should resolve to a postponed runtime cubemap source");
+
+        assert_eq!(
+            key,
+            Sh2SourceKey::RuntimeCubemap {
+                render_space_id: space_id.0,
+                renderable_index: 0,
+                generation: 0,
+                size: 0,
+                sample_size: DEFAULT_SAMPLE_SIZE,
+            }
+        );
+        assert!(matches!(source, Sh2ResolvedSource::Postpone));
+    }
 }

crates/renderide/src/scene/coordinator/tests.rs

@@ -9,7 +9,9 @@
 
 use crate::scene::overrides::RenderTransformOverrideEntry;
 use crate::scene::render_space::{LayerAssignmentEntry, RenderSpaceState};
-use crate::scene::{CameraRenderableEntry, SkinnedMeshRenderer, StaticMeshRenderer};
+use crate::scene::{
+    CameraRenderableEntry, ReflectionProbeEntry, SkinnedMeshRenderer, StaticMeshRenderer,
+};
 use crate::shared::{LayerType, RenderTransform, RenderingContext};
 
 use super::super::ids::RenderSpaceId;
@@ -140,6 +142,16 @@ impl SceneCoordinator {
         space.cameras.extend(cameras);
     }
 
+    /// Appends reflection-probe renderables to a seeded render space (unit tests only).
+    pub(crate) fn test_push_reflection_probes(
+        &mut self,
+        id: RenderSpaceId,
+        probes: impl IntoIterator<Item = ReflectionProbeEntry>,
+    ) {
+        let space = self.spaces.get_mut(&id).expect("seeded space");
+        space.reflection_probes.extend(probes);
+    }
+
     /// Inserts a render space with skinned mesh renderers (unit tests only).
     pub(crate) fn test_insert_skinned_mesh_renderers(
         &mut self,

crates/renderide/src/scene/reflection_probe.rs

@@ -229,11 +229,8 @@ pub(crate) fn drain_reflection_probe_render_changes(
                     unique_id: task.unique_id,
                 });
         } else if entry.state.r#type == ReflectionProbeType::Realtime {
-            logger::debug!(
-                "reflection probe changed render not completed: render_space={} renderable_index={} is realtime",
-                space.id.0,
-                task.renderable_index
-            );
+            out.completed
+                .push(changed_probe_completion(space.id.0, task.unique_id, false));
         }
     }
     out
@@ -432,6 +429,38 @@ mod tests {
         assert!(results.scene_captures.is_empty());
     }
 
+    #[test]
+    fn changed_realtime_probe_returns_immediate_completion() {
+        let mut space = RenderSpaceState {
+            id: crate::scene::RenderSpaceId(12),
+            ..RenderSpaceState::default()
+        };
+        space.reflection_probes.push(ReflectionProbeEntry {
+            renderable_index: 0,
+            transform_id: 1,
+            state: ReflectionProbeState {
+                renderable_index: 0,
+                r#type: ReflectionProbeType::Realtime,
+                ..ReflectionProbeState::default()
+            },
+        });
+        space
+            .pending_reflection_probe_render_changes
+            .push(ReflectionProbeChangeRenderTask {
+                renderable_index: 0,
+                unique_id: 101,
+            });
+
+        let results = drain_reflection_probe_render_changes(&mut space);
+
+        assert_eq!(results.completed.len(), 1);
+        assert_eq!(results.completed[0].render_space_id, 12);
+        assert_eq!(results.completed[0].render_probe_unique_id, 101);
+        assert_eq!(results.completed[0].require_reset, 0);
+        assert!(results.scene_captures.is_empty());
+        assert!(space.pending_reflection_probe_render_changes.is_empty());
+    }
+
     #[test]
     fn changed_missing_probe_returns_reset_completion() {
         let mut space = RenderSpaceState {