Move use ray tracing into a function

Author: Vecvec

naga/src/back/spv/writer.rs

@@ -3598,40 +3598,11 @@ impl Writer {
             .iter()
             .flat_map(|entry| entry.function.arguments.iter())
             .any(|arg| has_view_index_check(ir_module, arg.binding.as_ref(), arg.ty));
-        let mut has_ray_query = ir_module.special_types.ray_intersection.is_some();
         let has_vertex_return = ir_module.special_types.ray_vertex_return.is_some();
-        // implies we need a longer search.
-        let mut has_ray_tracing = ir_module.special_types.ray_desc.is_some();
-        let mut has_ray_tracing_pipeline = false;
-
-        for (_, &crate::Type { ref inner, .. }) in ir_module.types.iter() {
-            // spirv does not know whether these have vertex return - that is done by us
-            match *inner {
-                crate::TypeInner::AccelerationStructure { .. } => {
-                    has_ray_tracing = true;
-                }
-                crate::TypeInner::RayQuery { .. } => has_ray_query = true,
-                _ => {}
-            }
-        }
-
-        for (index, ep) in ir_module.entry_points.iter().enumerate() {
-            if ep_index.is_some() && ep_index != Some(index) {
-                continue;
-            }
-
-            if matches!(
-                ep.stage,
-                crate::ShaderStage::RayGeneration
-                    | crate::ShaderStage::AnyHit
-                    | crate::ShaderStage::ClosestHit
-                    | crate::ShaderStage::Miss
-            ) {
-                has_ray_tracing_pipeline = true;
-            } else {
-                has_ray_query |= has_ray_tracing;
-            }
-        }
+        
+        let rt_uses = ir_module.uses_ray_tracing(ep_index);
+        let has_ray_query = rt_uses.queries;
+        let has_ray_tracing_pipeline = rt_uses.pipelines;
 
         self.has_ray_tracing_pipeline = has_ray_tracing_pipeline;
 

naga/src/proc/mod.rs

@@ -948,6 +948,56 @@ impl crate::Module {
         }
         false
     }
+
+    pub fn uses_ray_tracing(&self, ep_index: Option<usize>) -> RayTracingUses {
+        let mut uses = RayTracingUses::default();
+        // Whether this uses ray tracing (unknown whether the usage is pipelines or ray queries).
+        let mut uses_ray_tracing = self.special_types.ray_desc.is_some();
+
+        uses.queries |= self.special_types.ray_intersection.is_some();
+
+
+        for (_, &crate::Type { ref inner, .. }) in self.types.iter() {
+            // Backends do not know whether these have vertex return - that is done by us
+            match *inner {
+                crate::TypeInner::AccelerationStructure { .. } => {
+                    uses_ray_tracing = true;
+                }
+                crate::TypeInner::RayQuery { .. } => uses.queries = true,
+                _ => {}
+            }
+        }
+
+        for (index, ep) in self.entry_points.iter().enumerate() {
+            if ep_index.is_some() && ep_index != Some(index) {
+                continue;
+            }
+
+            // if we have a ray tracing pipeline shader we are definitly using 
+            // pipelines, otherwise, if we have a ray tracing type, we might
+            // be using it in the shader (which would require ray queries),
+            // so we should use queries.
+            if matches!(
+                ep.stage,
+                crate::ShaderStage::RayGeneration
+                    | crate::ShaderStage::AnyHit
+                    | crate::ShaderStage::ClosestHit
+                    | crate::ShaderStage::Miss
+            ) {
+                uses.pipelines = true;
+            } else {
+                uses.queries |= uses_ray_tracing;
+            }
+        }
+
+        uses
+    }
+}
+
+#[derive(Default, Copy, Clone)]
+pub struct RayTracingUses {
+    pub pipelines: bool,
+    pub queries: bool,
 }
 
 impl crate::MeshOutputTopology {