WIP: fix(core): add max_inter_stage_shader_variables validation

- add `StageError::VertexOutputLocationTooLarge`
- add `StageError::TooManyVertexOutputs`
- add `MaxInterStageShaderVariablesDeductions`

Author: ErichDonGubler

deno_webgpu/01_webgpu.js

@@ -273,8 +273,7 @@ ObjectDefineProperty(GPUSupportedLimitsPrototype, privateCustomInspect, {
           "maxBufferSize",
           "maxVertexAttributes",
           "maxVertexBufferArrayStride",
-          // TODO(@crowlKats): support max_inter_stage_shader_variables
-          // "maxInterStageShaderVariables",
+          "maxInterStageShaderVariables",
           "maxColorAttachments",
           "maxColorAttachmentBytesPerSample",
           "maxComputeWorkgroupStorageSize",

deno_webgpu/adapter.rs

@@ -344,7 +344,10 @@ impl GPUSupportedLimits {
     self.0.max_vertex_buffer_array_stride
   }
 
-  // TODO(@crowlKats): support max_inter_stage_shader_variables
+  #[getter]
+  fn maxInterStageShaderVariables(&self) -> u32 {
+    self.0.max_inter_stage_shader_variables
+  }
 
   #[getter]
   fn maxColorAttachments(&self) -> u32 {

wgpu-core/src/device/resource.rs

@@ -4225,7 +4225,7 @@ impl Device {
                 vertex_stage = {
                     let stage_desc = &vertex.stage;
                     let stage = validation::ShaderStageForValidation::Vertex {
-                        state: vertex,
+                        topology: desc.primitive.topology,
                         compare_function: desc.depth_stencil.as_ref().map(|d| d.depth_compare),
                     };
                     let stage_bit = stage.to_wgt_bit();

wgpu-core/src/validation.rs

@@ -1,7 +1,6 @@
 use alloc::{
     boxed::Box,
     string::{String, ToString as _},
-    sync::Arc,
     vec::Vec,
 };
 use core::fmt;
@@ -314,6 +313,25 @@ pub enum StageError {
     MultipleEntryPointsFound,
     #[error(transparent)]
     InvalidResource(#[from] InvalidResourceError),
+    #[error(
+        "Location[{location}]: {var}'s index exceeds the `max_inter_stage_shader_variables` limit \
+        ({limit}); note that some " // TODO
+    )]
+    VertexOutputLocationTooLarge {
+        location: u32,
+        var: InterfaceVar,
+        limit: u32,
+        deductions: Vec<MaxInterStageShaderVariablesDeduction>,
+    },
+    #[error(
+        "found {num_found} user-defined vertex shader output variables, which exceeds the \
+        `max_inter_stage_shader_variables` limit ({limit}); note that some " // TODO
+    )]
+    TooManyUserDefinedVertexOutputs {
+        num_found: u32,
+        limit: u32,
+        deductions: Vec<MaxInterStageShaderVariablesDeduction>,
+    },
     #[error(
         "Location[{location}] {var}'s index exceeds the `max_color_attachments` limit ({limit})"
     )]
@@ -344,12 +362,50 @@ impl WebGpuError for StageError {
             | Self::MissingEntryPoint(..)
             | Self::NoEntryPointFound
             | Self::MultipleEntryPointsFound
+            | Self::VertexOutputLocationTooLarge { .. }
+            | Self::TooManyUserDefinedVertexOutputs { .. }
             | Self::ColorAttachmentLocationTooLarge { .. } => return ErrorType::Validation,
         };
         e.webgpu_error_type()
     }
 }
 
+#[derive(Clone, Copy)]
+pub struct MaxInterStageShaderVariablesDeduction(MaxInterStageShaderVariablesDeductionImpl);
+
+impl fmt::Debug for MaxInterStageShaderVariablesDeduction {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let Self(inner) = self;
+        fmt::Debug::fmt(inner, f)
+    }
+}
+
+#[derive(Clone, Copy, Debug)]
+enum MaxInterStageShaderVariablesDeductionImpl {
+    PointLinePrimitiveTopology,
+    ClipDistance { count: u32 },
+}
+
+impl MaxInterStageShaderVariablesDeductionImpl {
+    fn variables_from_clip_distance_slot(num_slots: u32) -> u32 {
+        num_slots.div_ceil(4)
+    }
+
+    pub fn for_variables(self) -> u32 {
+        match self {
+            Self::PointLinePrimitiveTopology => 1,
+            Self::ClipDistance { count } => Self::variables_from_clip_distance_slot(count),
+        }
+    }
+
+    pub fn for_location(self) -> u32 {
+        match self {
+            Self::PointLinePrimitiveTopology => 0,
+            Self::ClipDistance { count } => Self::variables_from_clip_distance_slot(count),
+        }
+    }
+}
+
 pub fn map_storage_format_to_naga(format: wgt::TextureFormat) -> Option<naga::StorageFormat> {
     use naga::StorageFormat as Sf;
     use wgt::TextureFormat as Tf;
@@ -1095,7 +1151,7 @@ impl Interface {
         layouts: &mut BindingLayoutSource<'_>,
         shader_binding_sizes: &mut FastHashMap<naga::ResourceBinding, wgt::BufferSize>,
         entry_point_name: &str,
-        shader_stage: ShaderStageForValidation<'_, '_>,
+        shader_stage: ShaderStageForValidation,
         inputs: StageIo,
     ) -> Result<StageIo, StageError> {
         // Since a shader module can have multiple entry points with the same name,
@@ -1320,13 +1376,60 @@ impl Interface {
 
         match shader_stage {
             ShaderStageForValidation::Vertex {
+                topology,
                 compare_function,
             } => {
+                let mut max_vertex_shader_output_variables =
+                    self.limits.max_inter_stage_shader_variables;
+                let mut max_vertex_shader_output_location = max_vertex_shader_output_variables - 1;
+
+                let point_list_deduction = if topology == wgt::PrimitiveTopology::PointList {
+                    Some(MaxInterStageShaderVariablesDeductionImpl::PointLinePrimitiveTopology)
+                } else {
+                    None
+                };
+
+                let clip_distance_deductions = entry_point.outputs.iter().filter_map(|output| {
+                    if let Varying::BuiltIn(naga::BuiltIn::ClipDistance) = output {
+                        Some(MaxInterStageShaderVariablesDeductionImpl::ClipDistance {
+                            // NOTE: `clip_distances`' max array size is currently 8, so at most we deduct 2.
+                            count: todo!("get size of `clip_distances` binding"),
+                        })
+                    } else {
+                        None
+                    }
+                });
+
+                let deductions = point_list_deduction
+                    .into_iter()
+                    .chain(clip_distance_deductions);
+
+                for deduction in deductions.clone() {
+                    // NOTE: We assume that these will never get to 0.
+                    max_vertex_shader_output_variables -= deduction.for_variables();
+                    max_vertex_shader_output_location -= deduction.for_location();
+                }
+
+                let mut num_user_defined_outputs = 0;
+
                 for output in entry_point.outputs.iter() {
-                    //TODO: count builtins towards the limit?
-                    inter_stage_components += match *output {
-                        Varying::Local { ref iv, .. } => iv.ty.dim.num_components(),
-                        Varying::BuiltIn(_) => 0,
+                    match *output {
+                        Varying::Local { ref iv, location } => {
+                            if location > max_vertex_shader_output_location {
+                                // TODO: add diagnostics context for limit deductions
+                                return Err(StageError::VertexOutputLocationTooLarge {
+                                    location,
+                                    var: iv.clone(),
+                                    limit: self.limits.max_inter_stage_shader_variables,
+                                    deductions: deductions
+                                        .map(MaxInterStageShaderVariablesDeduction)
+                                        .collect(),
+                                });
+                            }
+                            num_user_defined_outputs += 1;
+                            inter_stage_components += iv.ty.dim.num_components()
+                        }
+                        Varying::BuiltIn(_) => {}
                     };
 
                     if let Some(
@@ -1353,6 +1456,16 @@ impl Interface {
                         }
                     }
                 }
+
+                if num_user_defined_outputs > max_vertex_shader_output_variables {
+                    return Err(StageError::TooManyUserDefinedVertexOutputs {
+                        num_found: num_user_defined_outputs,
+                        limit: self.limits.max_inter_stage_shader_variables - 1,
+                        deductions: deductions
+                            .map(MaxInterStageShaderVariablesDeduction)
+                            .collect(),
+                    });
+                }
             }
             ShaderStageForValidation::Fragment => {
                 for output in &entry_point.outputs {
@@ -1427,17 +1540,19 @@ pub fn validate_color_attachment_bytes_per_sample(
     Ok(())
 }
 
-pub enum ShaderStageForValidation<'a, 'vertex_state> {
+pub enum ShaderStageForValidation {
     Vertex {
+        topology: wgt::PrimitiveTopology,
         compare_function: Option<wgt::CompareFunction>,
     },
     Mesh,
     Fragment,
     Compute,
     Task,
+    // TODO: preserve ordering?
 }
 
-impl ShaderStageForValidation<'_, '_> {
+impl ShaderStageForValidation {
     pub fn to_naga(&self) -> naga::ShaderStage {
         match self {
             Self::Vertex { .. } => naga::ShaderStage::Vertex,

wgpu-hal/src/dx12/adapter.rs

@@ -717,6 +717,7 @@ impl super::Adapter {
                     //
                     // Source: https://learn.microsoft.com/en-us/windows/win32/direct3d12/root-signature-limits#memory-limits-and-costs
                     max_immediate_size: 128,
+                    max_inter_stage_shader_variables: 16,
                     min_uniform_buffer_offset_alignment:
                         Direct3D12::D3D12_CONSTANT_BUFFER_DATA_PLACEMENT_ALIGNMENT,
                     min_storage_buffer_offset_alignment: 4,

wgpu-hal/src/gles/adapter.rs

@@ -754,6 +754,7 @@ impl super::Adapter {
             min_subgroup_size: 0,
             max_subgroup_size: 0,
             max_immediate_size: super::MAX_IMMEDIATES as u32 * 4,
+            max_inter_stage_shader_variables: 16,
             min_uniform_buffer_offset_alignment,
             min_storage_buffer_offset_alignment,
             max_inter_stage_shader_components: {

wgpu-hal/src/metal/adapter.rs

@@ -1103,6 +1103,7 @@ impl super::PrivateCapabilities {
                 min_subgroup_size: 4,
                 max_subgroup_size: 64,
                 max_immediate_size: 0x1000,
+                max_inter_stage_shader_variables: 16,
                 min_uniform_buffer_offset_alignment: self.buffer_alignment as u32,
                 min_storage_buffer_offset_alignment: self.buffer_alignment as u32,
                 max_inter_stage_shader_components: self.max_varying_components,

wgpu-hal/src/noop/mod.rs

@@ -178,6 +178,7 @@ pub const CAPABILITIES: crate::Capabilities = {
             max_buffer_size: ALLOC_MAX_U32 as u64,
             max_vertex_attributes: ALLOC_MAX_U32,
             max_vertex_buffer_array_stride: ALLOC_MAX_U32,
+            max_inter_stage_shader_variables: ALLOC_MAX_U32,
             min_uniform_buffer_offset_alignment: 1,
             min_storage_buffer_offset_alignment: 1,
             max_inter_stage_shader_components: ALLOC_MAX_U32,

wgpu-hal/src/vulkan/adapter.rs

@@ -1340,6 +1340,7 @@ impl PhysicalDeviceProperties {
                 .map(|subgroup_size| subgroup_size.max_subgroup_size)
                 .unwrap_or(0),
             max_immediate_size: limits.max_push_constants_size,
+            max_inter_stage_shader_variables: 16,
             min_uniform_buffer_offset_alignment: limits.min_uniform_buffer_offset_alignment as u32,
             min_storage_buffer_offset_alignment: limits.min_storage_buffer_offset_alignment as u32,
             max_inter_stage_shader_components: limits

wgpu-info/src/human.rs

@@ -146,6 +146,7 @@ fn print_adapter(output: &mut impl io::Write, report: &AdapterReport, idx: usize
         max_buffer_size,
         max_vertex_attributes,
         max_vertex_buffer_array_stride,
+        max_inter_stage_shader_variables,
         min_uniform_buffer_offset_alignment,
         min_storage_buffer_offset_alignment,
         max_inter_stage_shader_components,
@@ -198,6 +199,7 @@ fn print_adapter(output: &mut impl io::Write, report: &AdapterReport, idx: usize
     writeln!(output, "\t\t                                  Min Subgroup Size: {min_subgroup_size}")?;
     writeln!(output, "\t\t                                  Max Subgroup Size: {max_subgroup_size}")?;
     writeln!(output, "\t\t                             Max Immediate data Size: {max_immediate_size}")?;
+    writeln!(output, "\t\t                   Max Inter-stage Shader Variables: {max_inter_stage_shader_variables}")?;
     writeln!(output, "\t\t                Min Uniform Buffer Offset Alignment: {min_uniform_buffer_offset_alignment}")?;
     writeln!(output, "\t\t                Min Storage Buffer Offset Alignment: {min_storage_buffer_offset_alignment}")?;
     writeln!(output, "\t\t                   Max Inter-Stage Shader Component: {max_inter_stage_shader_components}")?;