Add validation tests on clip_distances and maxInterStageShaderVariables

src/webgpu/api/validation/capability_checks/features/clip_distances.spec.ts

@@ -0,0 +1,115 @@
+import { range } from '../../../../../common/util/util.js';
+import { align } from '../../../../util/math.js';
+import { kMaximumLimitBaseParams, makeLimitTestGroup } from '../limits/limit_utils.js';
+
+function getPipelineDescriptorWithClipDistances(
+  device: GPUDevice,
+  testValue: number,
+  pointList: boolean,
+  clipDistances: number
+): GPURenderPipelineDescriptor {
+  const vertexOutputVariables = testValue - (pointList ? 1 : 0) - align(clipDistances, 4) / 4;
+  const maxVertexOutputVariables =
+    device.limits.maxInterStageShaderVariables - (pointList ? 1 : 0) - align(clipDistances, 4) / 4;
+
+  const varyings = `
+      ${range(vertexOutputVariables, i => `@location(${i}) v4_${i}: vec4f,`).join('\n')}
+  `;
+
+  const code = `
+    // test value                        : ${testValue}
+    // maxInterStageShaderVariables     : ${device.limits.maxInterStageShaderVariables}
+    // num variables in vertex shader : ${vertexOutputVariables}${
+      pointList ? ' + point-list' : ''
+    }${
+      clipDistances > 0
+        ? ` + ${align(clipDistances, 4) / 4} (clip_distances[${clipDistances}])`
+        : ''
+    }
+    // maxInterStageVariables:           : ${maxVertexOutputVariables}
+    // num used inter stage variables    : ${vertexOutputVariables}
+
+    enable clip_distances;
+
+    struct VSOut {
+      @builtin(position) p: vec4f,
+      ${varyings}
+      ${
+        clipDistances > 0
+          ? `@builtin(clip_distances) clipDistances: array<f32, ${clipDistances}>,`
+          : ''
+      }
+    }
+    struct FSIn {
+      ${varyings}
+    }
+    struct FSOut {
+      @location(0) color: vec4f,
+    }
+    @vertex fn vs() -> VSOut {
+      var o: VSOut;
+      o.p = vec4f(0);
+      return o;
+    }
+    @fragment fn fs(i: FSIn) -> FSOut {
+      var o: FSOut;
+      o.color = vec4f(0);
+      return o;
+    }
+  `;
+  const module = device.createShaderModule({ code });
+  const pipelineDescriptor: GPURenderPipelineDescriptor = {
+    layout: 'auto',
+    primitive: {
+      topology: pointList ? 'point-list' : 'triangle-list',
+    },
+    vertex: {
+      module,
+      entryPoint: 'vs',
+    },
+    fragment: {
+      module,
+      entryPoint: 'fs',
+      targets: [
+        {
+          format: 'rgba8unorm',
+        },
+      ],
+    },
+  };
+  return pipelineDescriptor;
+}
+
+const limit = 'maxInterStageShaderVariables';
+export const { g, description } = makeLimitTestGroup(limit);
+
+g.test('createRenderPipeline,at_over')
+  .desc(`Test using at and over ${limit} limit with clip_distances in createRenderPipeline(Async)`)
+  .params(
+    kMaximumLimitBaseParams
+      .combine('async', [false, true])
+      .combine('pointList', [false, true])
+      .combine('clipDistances', [1, 2, 3, 4, 5, 6, 7, 8])
+  )
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('clip-distances');
+  })
+  .fn(async t => {
+    const { limitTest, testValueName, async, pointList, clipDistances } = t.params;
+    await t.testDeviceWithRequestedMaximumLimits(
+      limitTest,
+      testValueName,
+      async ({ device, testValue, shouldError }) => {
+        const pipelineDescriptor = getPipelineDescriptorWithClipDistances(
+          device,
+          testValue,
+          pointList,
+          clipDistances
+        );
+
+        await t.testCreateRenderPipeline(pipelineDescriptor, async, shouldError);
+      },
+      undefined,
+      ['clip-distances']
+    );
+  });

src/webgpu/api/validation/capability_checks/limits/limit_utils.ts

@@ -535,11 +535,16 @@ export class LimitTestsImpl extends GPUTestBase {
     limitTest: MaximumLimitValueTest,
     testValueName: MaximumTestValue,
     fn: (inputs: MaximumLimitTestInputs) => void | Promise<void>,
-    extraLimits?: LimitsRequest
+    extraLimits?: LimitsRequest,
+    extraFeatures: GPUFeatureName[] = []
   ) {
     assert(!this._device);
 
-    const deviceAndLimits = await this._getDeviceWithRequestedMaximumLimit(limitTest, extraLimits);
+    const deviceAndLimits = await this._getDeviceWithRequestedMaximumLimit(
+      limitTest,
+      extraLimits,
+      extraFeatures
+    );
     // If we request over the limit requestDevice will throw
     if (!deviceAndLimits) {
       return;

src/webgpu/listing_meta.json

@@ -283,6 +283,7 @@
   "webgpu:api,validation,capability_checks,features,texture_formats:texture_descriptor:*": { "subcaseMS": 3.830 },
   "webgpu:api,validation,capability_checks,features,texture_formats:texture_descriptor_view_formats:*": { "subcaseMS": 5.734 },
   "webgpu:api,validation,capability_checks,features,texture_formats:texture_view_descriptor:*": { "subcaseMS": 4.113 },
+  "webgpu:api,validation,capability_checks,features,clip_distances:createRenderPipeline,at_over:*": { "subcaseMS": 13.7 },
   "webgpu:api,validation,capability_checks,limits,maxBindGroups:createPipeline,at_over:*": { "subcaseMS": 10.990 },
   "webgpu:api,validation,capability_checks,limits,maxBindGroups:createPipelineLayout,at_over:*": { "subcaseMS": 9.310 },
   "webgpu:api,validation,capability_checks,limits,maxBindGroups:setBindGroup,at_over:*": { "subcaseMS": 9.984 },