Add tests (plus some spots that had incorrect errors)

Vecvec · Vecvec · commit bee83af58605 · 2025-11-27T10:04:26.000+13:00
diff --git a/naga/src/valid/interface.rs b/naga/src/valid/interface.rs
@@ -972,7 +972,7 @@ impl super::Validator {
                     .contains(Capabilities::RAY_TRACING_PIPELINE)
                 {
                     return Err(GlobalVariableError::UnsupportedCapability(
-                        Capabilities::PUSH_CONSTANT,
+                        Capabilities::RAY_TRACING_PIPELINE,
                     ));
                 }
                 (TypeFlags::DATA | TypeFlags::SIZED, false)
@@ -1082,14 +1082,28 @@ impl super::Validator {
         module: &crate::Module,
         mod_info: &ModuleInfo,
     ) -> Result<FunctionInfo, WithSpan<EntryPointError>> {
-        if matches!(
-            ep.stage,
+        match ep.stage {
             crate::ShaderStage::Task | crate::ShaderStage::Mesh
-        ) && !self.capabilities.contains(Capabilities::MESH_SHADER)
-        {
-            return Err(
-                EntryPointError::UnsupportedCapability(Capabilities::MESH_SHADER).with_span(),
-            );
+                if !self.capabilities.contains(Capabilities::MESH_SHADER) =>
+            {
+                return Err(
+                    EntryPointError::UnsupportedCapability(Capabilities::MESH_SHADER).with_span(),
+                );
+            }
+            crate::ShaderStage::RayGeneration
+            | crate::ShaderStage::AnyHit
+            | crate::ShaderStage::ClosestHit
+            | crate::ShaderStage::Miss
+                if !self
+                    .capabilities
+                    .contains(Capabilities::RAY_TRACING_PIPELINE) =>
+            {
+                return Err(EntryPointError::UnsupportedCapability(
+                    Capabilities::RAY_TRACING_PIPELINE,
+                )
+                .with_span());
+            }
+            _ => {}
         }
         if ep.early_depth_test.is_some() {
             let required = Capabilities::EARLY_DEPTH_TEST;
diff --git a/naga/src/valid/mod.rs b/naga/src/valid/mod.rs
@@ -212,6 +212,7 @@ impl Capabilities {
             Self::CLIP_DISTANCE => Some(Ext::ClipDistances),
             Self::RAY_QUERY => Some(Ext::WgpuRayQuery),
             Self::RAY_HIT_VERTEX_POSITION => Some(Ext::WgpuRayQueryVertexReturn),
+            Self::RAY_TRACING_PIPELINE => Some(Ext::WgpuRayTracingPipeline),
             _ => None,
         }
     }
diff --git a/naga/src/valid/type.rs b/naga/src/valid/type.rs
@@ -766,7 +766,10 @@ impl super::Validator {
                 Alignment::ONE,
             ),
             Ti::AccelerationStructure { vertex_return } => {
-                self.require_type_capability(Capabilities::RAY_QUERY)?;
+                self.require_type_capability(Capabilities::RAY_QUERY)
+                    .or_else(|_| {
+                        self.require_type_capability(Capabilities::RAY_TRACING_PIPELINE)
+                    })?;
                 if vertex_return {
                     self.require_type_capability(Capabilities::RAY_HIT_VERTEX_POSITION)?;
                 }
diff --git a/naga/tests/naga/wgsl_errors.rs b/naga/tests/naga/wgsl_errors.rs
@@ -4379,3 +4379,166 @@ fn ray_query_vertex_return_enable_extension() {
         })
     );
 }
+
+/// Checks that every ray tracing pipeline binding in naga is invalid in other stages.
+#[test]
+fn check_ray_tracing_pipeline_bindings() {
+    for (builtin, ty) in [
+        ("ray_invocation_id", "vec3<u32>"),
+        ("num_ray_invocations", "vec3<u32>"),
+        ("instance_custom_data", "u32"),
+        ("geometry_index", "u32"),
+        ("world_ray_origin", "vec3<f32>"),
+        ("world_ray_direction", "vec3<f32>"),
+        ("object_ray_origin", "vec3<f32>"),
+        ("object_ray_direction", "vec3<f32>"),
+        ("ray_t_min", "f32"),
+        ("ray_t_current_max", "f32"),
+        ("object_to_world", "mat4x3<f32>"),
+        ("world_to_object", "mat4x3<f32>"),
+        ("hit_kind", "u32"),
+    ] {
+        check_one_validation!(
+            &format!(
+                "@compute
+        @workgroup_size(1)
+        fn main(@builtin({builtin}) v: {ty}) {{}}
+        "
+            ),
+            Err(naga::valid::ValidationError::EntryPoint {
+                source: naga::valid::EntryPointError::Argument(
+                    0,
+                    naga::valid::VaryingError::InvalidBuiltInStage(_),
+                ),
+                ..
+            },)
+        );
+        check_one_validation!(
+            &format!(
+                "@vertex
+        fn main(@builtin({builtin}) v: {ty}) {{}}
+        "
+            ),
+            Err(naga::valid::ValidationError::EntryPoint {
+                source: naga::valid::EntryPointError::Argument(
+                    0,
+                    naga::valid::VaryingError::InvalidBuiltInStage(_),
+                ),
+                ..
+            },)
+        );
+        check_one_validation!(
+            &format!(
+                "@fragment
+        fn main(@builtin({builtin}) v: {ty}) {{}}
+        "
+            ),
+            Err(naga::valid::ValidationError::EntryPoint {
+                source: naga::valid::EntryPointError::Argument(
+                    0,
+                    naga::valid::VaryingError::InvalidBuiltInStage(_),
+                ),
+                ..
+            },)
+        );
+    }
+}
+
+/// Checks ray generation stage is invalid without enable extension (other stages require `@incoming_payload` which forces a ray payload which is checked in [`check_ray_tracing_pipeline_payload`])
+#[test]
+fn check_ray_tracing_pipeline_ray_generation() {
+    check_extension_validation!(
+            Capabilities::RAY_TRACING_PIPELINE,
+            "@ray_generation
+                fn main() {{}}",
+            "error: the `wgpu_ray_tracing_pipeline` enable extension is not enabled
+  ┌─ wgsl:1:2
+  │
+1 │ @ray_generation
+  │  ^^^^^^^^^^^^^^ the `wgpu_ray_tracing_pipeline` \"Enable Extension\" is needed for this functionality, but it is not currently enabled.
+  │
+  = note: You can enable this extension by adding `enable wgpu_ray_tracing_pipeline;` at the top of the shader, before any other items.
+
+",
+            Err(naga::valid::ValidationError::EntryPoint {
+                source: naga::valid::EntryPointError::UnsupportedCapability(naga::valid::Capabilities::RAY_TRACING_PIPELINE),
+                ..
+            },)
+        );
+}
+
+#[test]
+fn check_ray_tracing_pipeline_payload() {
+    for space in ["ray_payload", "incoming_ray_payload"] {
+        // ascii is a byte per char so length is fine
+        let space_arrows = "^".to_string().repeat(space.len());
+        check_extension_validation!(
+            Capabilities::RAY_TRACING_PIPELINE,
+            &format!("var<{space}> payload: u32;"),
+            &format!("error: the `wgpu_ray_tracing_pipeline` enable extension is not enabled
+  ┌─ wgsl:1:5
+  │
+1 │ var<{space}> payload: u32;
+  │     {space_arrows} the `wgpu_ray_tracing_pipeline` \"Enable Extension\" is needed for this functionality, but it is not currently enabled.
+  │
+  = note: You can enable this extension by adding `enable wgpu_ray_tracing_pipeline;` at the top of the shader, before any other items.
+
+"),
+            Err(naga::valid::ValidationError::GlobalVariable {
+                source: naga::valid::GlobalVariableError::UnsupportedCapability(naga::valid::Capabilities::RAY_TRACING_PIPELINE),
+                ..
+            },)
+        );
+    }
+}
+
+#[test]
+fn check_ray_tracing_pipeline_incoming_payload_required() {
+    for stage in ["any_hit", "closest_hit", "miss"] {
+        // ascii is a byte per char so length is fine
+        let stage_arrows = "^".to_string().repeat(stage.len());
+        check(
+            &format!("enable wgpu_ray_tracing_pipeline; @{stage} fn main() {{}}"),
+            &format!("error: incoming payload is missing on ray hit or miss shader entry point
+  ┌─ wgsl:1:36
+  │
+1 │ enable wgpu_ray_tracing_pipeline; @{stage} fn main() {{}}
+  │                                    {stage_arrows} must be paired with a `@incoming_payload` attribute
+
+"),
+        );
+    }
+}
+
+#[test]
+fn check_ray_tracing_pipeline_payload_disallowed() {
+    for (stage, output, stmt) in [
+        (
+            "var<incoming_ray_payload> incoming: u32; @any_hit @incoming_payload(incoming)",
+            "",
+            "",
+        ),
+        ("@compute @workgroup_size(1)", "", ""),
+        (
+            "@vertex",
+            " -> @builtin(position) vec4<f32>",
+            "return vec4();",
+        ),
+        ("@fragment", "", ""),
+    ] {
+        check_one_validation!(
+            &format!(
+                "enable wgpu_ray_tracing_pipeline;
+            @group(0) @binding(0) var acc_struct: acceleration_structure;
+            var<ray_payload> payload: u32;
+            
+            {stage} fn main() {output} {{_ = payload; {stmt}}}"
+            ),
+            Err(naga::valid::ValidationError::EntryPoint {
+                source: naga::valid::EntryPointError::RayPayloadInInvalidStage,
+                ..
+            },),
+            Capabilities::RAY_TRACING_PIPELINE
+        );
+    }
+}

Original file line number	Diff line number	Diff line change
`@@ -212,6 +212,7 @@ impl Capabilities {`
`212`	`212`	`Self::CLIP_DISTANCE => Some(Ext::ClipDistances),`
`213`	`213`	`Self::RAY_QUERY => Some(Ext::WgpuRayQuery),`
`214`	`214`	`Self::RAY_HIT_VERTEX_POSITION => Some(Ext::WgpuRayQueryVertexReturn),`
	`215`	`+ Self::RAY_TRACING_PIPELINE => Some(Ext::WgpuRayTracingPipeline),`
`215`	`216`	`_ => None,`
`216`	`217`	`}`
`217`	`218`	`}`