Decouple path tracing preparation from SSGI

Author: proggeramlug

docs/compiled-render-graph.md

@@ -25,9 +25,10 @@ counts, allowed usage, load policy, and alias class.
 - generates a stable plan ID from the complete execution contract.
 
 The live topology is declared in `renderer/graph/frame_plan.rs`. Optional
-SSAO, SSR, SSGI (including acceleration/card/SDF/radiance-cache preparation),
-bloom, scene-snapshot, and capture work is selected before compilation by
-`FramePlanKey`. Uniform-only changes do not affect the key.
+SSAO, SSR, SSGI, PT, bloom, scene-snapshot, and capture work is selected before
+compilation by `FramePlanKey`. SSGI and PT independently select their shared
+acceleration/card-capture prefix; SDF, clipmap, radiance-cache, and card-light
+preparation remain SSGI-only. Uniform-only changes do not affect the key.
 `ExecutableGraph` binds only frame-local recording closures to cached pass
 positions; it does not rebuild or schedule a declaration graph per frame.
 

docs/pt/pt-roadmap.md

@@ -34,8 +34,11 @@ fixed exposure) so images are comparable number-to-number.
 
 Mode is a runtime setting (`bloom_set_path_tracing`), toggleable per frame.
 When PT is active, SSGI/SSR/GTAO are skipped (their output would be
-overwritten; skipping banks their cost). Shadow cascades still render — mode 2
-reuses them nowhere, but the card-light pass (Tier 1 hit shading) does.
+overwritten; skipping banks their cost). PT independently keeps only the
+shared TLAS/geometry rebuild and raw-albedo card capture it consumes. SSGI-only
+SDF, clipmap, radiance-cache, and card-light passes remain absent when SSGI is
+off. Shadow cascades still render because realtime PT can use them for its
+noise-free hybrid sun path.
 
 ## Tiers
 

docs/temporal-history.md

@@ -331,7 +331,4 @@ silently passing.
 
 Complete the PT-specific moving-object, lighting-change, and reset sequence
 coverage on required hardware runners, including the goldens owned by #127 and
-the timing/memory qualification owned by #128. PT's shared TLAS/card
-preparation is currently scheduled through the SSGI infrastructure feature;
-decouple that ownership before claiming an independent PT-on/SSGI-off mode
-matrix.
+the timing/memory qualification owned by #128.

native/shared/src/renderer/frame_graph_runtime.rs

@@ -123,7 +123,11 @@ impl Renderer {
             quality_tier,
             feature_mask,
             capability,
-            path_tracing: graph::PathTracingMode::from_u32(self.pt_mode),
+            path_tracing: graph::PathTracingMode::from_u32(if self.pt_active() {
+                self.pt_mode
+            } else {
+                0
+            }),
             post_pass_count: self.post_passes.len().min(u16::MAX as usize) as u16,
             render_target_output,
         }

native/shared/src/renderer/graph/frame_plan.rs

@@ -406,16 +406,18 @@ pub fn build_renderer_frame_plan(
         },
     );
 
+    let ssgi_preparation = key.feature_mask & super::FRAME_FEATURE_SSGI != 0;
+    let pt_preparation = key.path_tracing != super::PathTracingMode::Off;
     let mut previous_gi = None;
-    if key.feature_mask & super::FRAME_FEATURE_SSGI != 0 {
-        for name in [
-            "accel_rebuild",
-            "card_capture",
-            "sdf_bake",
-            "scene_sdf_clipmap",
-            "wsrc_bake",
-            "card_light",
-        ] {
+    for (name, enabled) in [
+        ("accel_rebuild", ssgi_preparation || pt_preparation),
+        ("card_capture", ssgi_preparation || pt_preparation),
+        ("sdf_bake", ssgi_preparation),
+        ("scene_sdf_clipmap", ssgi_preparation),
+        ("wsrc_bake", ssgi_preparation),
+        ("card_light", ssgi_preparation),
+    ] {
+        if enabled {
             let pass = graph.add_pass(name);
             if let Some(previous) = previous_gi {
                 graph.after(pass, previous);
@@ -746,6 +748,65 @@ mod tests {
         assert!(plan.pass("capture_readback").is_none());
     }
 
+    #[test]
+    fn path_tracing_owns_shared_ray_scene_preparation_without_ssgi_bakes() {
+        let mut pt_key = key(0);
+        pt_key.path_tracing = PathTracingMode::Realtime;
+        pt_key.capability = CapabilityTier::HardwareRayQuery;
+        let plan = build_renderer_frame_plan(pt_key, wgpu::TextureFormat::Bgra8UnormSrgb)
+            .compile(CompileOptions::CONSERVATIVE_ALIASING)
+            .unwrap();
+        for present in ["accel_rebuild", "card_capture", "pt"] {
+            assert!(plan.pass(present).is_some(), "{present} must serve PT");
+        }
+        for absent in [
+            "sdf_bake",
+            "scene_sdf_clipmap",
+            "wsrc_bake",
+            "card_light",
+            "ssgi",
+        ] {
+            assert!(
+                plan.pass(absent).is_none(),
+                "{absent} must remain SSGI-only"
+            );
+        }
+        let names = plan
+            .passes
+            .iter()
+            .map(|pass| pass.name.as_str())
+            .collect::<Vec<_>>();
+        assert!(
+            names
+                .iter()
+                .position(|name| *name == "card_capture")
+                .unwrap()
+                < names.iter().position(|name| *name == "pt").unwrap()
+        );
+
+        let mut combined_key = key(FRAME_FEATURE_SSGI);
+        combined_key.path_tracing = PathTracingMode::Realtime;
+        combined_key.capability = CapabilityTier::HardwareRayQuery;
+        let combined = build_renderer_frame_plan(combined_key, wgpu::TextureFormat::Bgra8UnormSrgb)
+            .compile(CompileOptions::CONSERVATIVE_ALIASING)
+            .unwrap();
+        for present in [
+            "accel_rebuild",
+            "card_capture",
+            "sdf_bake",
+            "scene_sdf_clipmap",
+            "wsrc_bake",
+            "card_light",
+            "pt",
+            "ssgi",
+        ] {
+            assert!(
+                combined.pass(present).is_some(),
+                "{present} must serve the combined SSGI+PT topology"
+            );
+        }
+    }
+
     #[test]
     fn capture_is_a_terminal_copy_pass_over_named_logical_resources() {
         let plan = build_renderer_frame_plan(

native/shared/src/renderer/quality_capture.rs

@@ -727,6 +727,16 @@ impl Renderer {
         } else {
             "false"
         });
+        out.push_str(",\"ray_scene_preparation\":");
+        json_string(
+            &mut out,
+            match (self.ssgi_enabled, self.pt_active()) {
+                (true, true) => "ssgi+pt",
+                (true, false) => "ssgi",
+                (false, true) => "pt",
+                (false, false) => "disabled",
+            },
+        );
         out.push_str(",\"temporal_history\":{");
         out.push_str("\"ssr_valid\":");
         out.push_str(if self.ssr_history_valid {

native/shared/src/renderer/shaders/mod.rs

@@ -30,9 +30,9 @@ pub(super) use ssgi::{
     SSR_TEMPORAL_SHADER_WGSL,
 };
 mod pt;
-pub(super) use pt::{pt_fault_constants, pt_kernel_variant, PT_ATROUS_WGSL, PT_SKIN_WGSL};
 #[cfg(test)]
 pub(super) use pt::PT_KERNEL_WGSL;
+pub(super) use pt::{pt_fault_constants, pt_kernel_variant, PT_ATROUS_WGSL, PT_SKIN_WGSL};
 
 /// Naga's Metal lowering completes a query in `rayQueryInitialize`; its
 /// non-modern `rayQueryProceed` only reads a `ready` flag that never clears.

native/shared/tests/golden_render/ssgi_quality.rs

@@ -102,6 +102,7 @@ fn ssgi_capture_exposes_probe_history_without_normal_frame_resources() {
     );
 
     let paths = eng.renderer.quality_runtime_paths_json();
+    assert!(paths.contains("\"ray_scene_preparation\":\"ssgi\""));
     assert!(paths.contains("\"ssgi_diagnostic_persistent_bytes\":0"));
     assert!(paths.contains("\"ssgi_diagnostic_capture_passes\":1"));
     assert!(paths.contains("\"ssgi_diagnostic_resources_live\":false"));

native/shared/tests/golden_render/temporal_history.rs

@@ -356,6 +356,10 @@ fn path_tracing_mode_transitions_reset_incompatible_history() {
     eng.renderer.set_path_tracing(2);
     let _ = render(&mut eng, 1, draw_pt_static_frame);
     assert!(eng.renderer.path_tracing_sample_count() > 0);
+    assert!(eng
+        .renderer
+        .quality_runtime_paths_json()
+        .contains("\"ray_scene_preparation\":\"ssgi+pt\""));
 
     eng.renderer.set_path_tracing(1);
     assert_eq!(eng.renderer.path_tracing_sample_count(), 0);
@@ -384,9 +388,7 @@ fn realtime_path_tracing_capture_exposes_svgf_history_without_normal_frame_resou
     r.set_taa_enabled(false);
     r.set_ssao_enabled(false);
     r.set_ssr_enabled(false);
-    // The current frame graph builds PT's shared TLAS/card inputs under the
-    // SSGI infrastructure node; PT still owns the rendered GI result.
-    r.set_ssgi_enabled(true);
+    r.set_ssgi_enabled(false);
     r.set_bloom_enabled(false);
     r.set_auto_exposure(false);
     r.set_path_tracing(2);
@@ -405,6 +407,7 @@ fn realtime_path_tracing_capture_exposes_svgf_history_without_normal_frame_resou
         "realtime PT reached only {samples_before_capture} history frames before capture"
     );
     let normal_paths = eng.renderer.quality_runtime_paths_json();
+    assert!(normal_paths.contains("\"ray_scene_preparation\":\"pt\""));
     assert!(normal_paths.contains("\"pt_diagnostic_persistent_bytes\":0"));
     assert!(normal_paths.contains("\"pt_diagnostic_resources_live\":false"));
 

tools/quality/README.md

@@ -153,7 +153,10 @@ The native renderer reports the adapter name, vendor/device IDs, device type,
 driver fields when exposed by wgpu, backend, capability tier, semantic feature
 set, actual SSGI trace backend, and path-tracing availability. Empty driver
 strings are valid on Metal because the backend does not expose them; they are
-recorded rather than invented.
+recorded rather than invented. Runtime evidence also reports
+`ray_scene_preparation` as `disabled`, `ssgi`, `pt`, or `ssgi+pt`; this makes
+the shared acceleration/card prefix observable without conflating it with
+SSGI-only baking.
 
 The one debug-capture API snapshots existing render-graph products: