fix(core): cover clip_distances bindings in max_inter_stage_shader_variables limit check

Author: ErichDonGubler

wgpu-core/src/validation.rs

@@ -161,7 +161,7 @@ enum BuiltIn {
     ViewIndex,
     BaseInstance,
     BaseVertex,
-    ClipDistance,
+    ClipDistance { array_size: u32 },
     CullDistance,
     InstanceIndex,
     PointSize,
@@ -202,7 +202,7 @@ impl BuiltIn {
             Self::ViewIndex => naga::BuiltIn::ViewIndex,
             Self::BaseInstance => naga::BuiltIn::BaseInstance,
             Self::BaseVertex => naga::BuiltIn::BaseVertex,
-            Self::ClipDistance => naga::BuiltIn::ClipDistance,
+            Self::ClipDistance { .. } => naga::BuiltIn::ClipDistance,
             Self::CullDistance => naga::BuiltIn::CullDistance,
             Self::InstanceIndex => naga::BuiltIn::InstanceIndex,
             Self::PointSize => naga::BuiltIn::PointSize,
@@ -1127,6 +1127,28 @@ impl Interface {
                 }
                 return;
             }
+            naga::TypeInner::Array { base, size, stride }
+                if matches!(
+                    binding,
+                    Some(naga::Binding::BuiltIn(naga::BuiltIn::ClipDistance)),
+                ) =>
+            {
+                // NOTE: We should already have validated these in `naga`.
+                debug_assert_eq!(
+                    &arena[base].inner,
+                    &naga::TypeInner::Scalar(naga::Scalar::F32)
+                );
+                debug_assert_eq!(stride, 4);
+
+                let naga::ArraySize::Constant(array_size) = size else {
+                    // TODO: Should we accept override expressions?
+                    unreachable!("non-constant array size for `clip_distances`")
+                };
+                let array_size = array_size.get();
+
+                list.push(Varying::BuiltIn(BuiltIn::ClipDistance { array_size }));
+                return;
+            }
             ref other => {
                 //Note: technically this should be at least `log::error`, but
                 // the reality is - every shader coming from `glslc` outputs an array
@@ -1159,7 +1181,7 @@ impl Interface {
                 naga::BuiltIn::ViewIndex => BuiltIn::ViewIndex,
                 naga::BuiltIn::BaseInstance => BuiltIn::BaseInstance,
                 naga::BuiltIn::BaseVertex => BuiltIn::BaseVertex,
-                naga::BuiltIn::ClipDistance => BuiltIn::ClipDistance,
+                naga::BuiltIn::ClipDistance => unreachable!(),
                 naga::BuiltIn::CullDistance => BuiltIn::CullDistance,
                 naga::BuiltIn::InstanceIndex => BuiltIn::InstanceIndex,
                 naga::BuiltIn::PointSize => BuiltIn::PointSize,
@@ -1619,7 +1641,21 @@ impl Interface {
                     None
                 };
 
-                let deductions = point_list_deduction.into_iter();
+                let clip_distance_deductions = entry_point.outputs.iter().filter_map(|output| {
+                    if let &Varying::BuiltIn(BuiltIn::ClipDistance { array_size }) = output {
+                        Some(MaxVertexShaderOutputDeduction::ClipDistance { array_size })
+                    } else {
+                        None
+                    }
+                });
+                debug_assert!(
+                    clip_distance_deductions.clone().count() <= 1,
+                    "multiple `clip_distance` outputs found"
+                );
+
+                let deductions = point_list_deduction
+                    .into_iter()
+                    .chain(clip_distance_deductions);
 
                 for deduction in deductions.clone() {
                     // NOTE: Deductions, in the current version of the spec. we implement, do not

wgpu-core/src/validation/shader_io_deductions.rs

@@ -12,18 +12,33 @@ pub enum MaxVertexShaderOutputDeduction {
     /// When a pipeline's [`crate::pipeline::RenderPipelineDescriptor::primitive`] is set to
     /// [`wgt::PrimitiveTopology::PointList`].
     PointListPrimitiveTopology,
+    ClipDistance {
+        array_size: u32,
+    },
+}
+
+impl MaxVertexShaderOutputDeduction {
+    fn variables_from_clip_distance_slot(num_slots: u32) -> u32 {
+        num_slots.div_ceil(4)
+    }
 }
 
 impl MaxVertexShaderOutputDeduction {
     pub fn for_variables(self) -> u32 {
         match self {
             Self::PointListPrimitiveTopology => 1,
+            Self::ClipDistance { array_size } => {
+                Self::variables_from_clip_distance_slot(array_size)
+            }
         }
     }
 
     pub fn for_location(self) -> u32 {
         match self {
             Self::PointListPrimitiveTopology => 0,
+            Self::ClipDistance { array_size } => {
+                Self::variables_from_clip_distance_slot(array_size)
+            }
         }
     }
 }