summaryrefslogtreecommitdiffstats
path: root/dom/webgpu/tests/cts/checkout/src/webgpu/shader/execution/expression/call/builtin/refract.spec.ts
diff options
context:
space:
mode:
Diffstat (limited to 'dom/webgpu/tests/cts/checkout/src/webgpu/shader/execution/expression/call/builtin/refract.spec.ts')
-rw-r--r--dom/webgpu/tests/cts/checkout/src/webgpu/shader/execution/expression/call/builtin/refract.spec.ts191
1 files changed, 62 insertions, 129 deletions
diff --git a/dom/webgpu/tests/cts/checkout/src/webgpu/shader/execution/expression/call/builtin/refract.spec.ts b/dom/webgpu/tests/cts/checkout/src/webgpu/shader/execution/expression/call/builtin/refract.spec.ts
index be1a76b437..5b51f30eee 100644
--- a/dom/webgpu/tests/cts/checkout/src/webgpu/shader/execution/expression/call/builtin/refract.spec.ts
+++ b/dom/webgpu/tests/cts/checkout/src/webgpu/shader/execution/expression/call/builtin/refract.spec.ts
@@ -2,7 +2,7 @@ export const description = `
Execution tests for the 'refract' builtin function
T is vecN<I>
-I is AbstractFloat, f32, or f16
+I is abstract-float, f32, or f16
@const fn refract(e1: T ,e2: T ,e3: I ) -> T
For the incident vector e1 and surface normal e2, and the ratio of indices of
refraction e3, let k = 1.0 -e3*e3* (1.0 - dot(e2,e1) * dot(e2,e1)).
@@ -11,129 +11,62 @@ vector e3*e1- (e3* dot(e2,e1) + sqrt(k)) *e2.
`;
import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
-import { ROArrayArray } from '../../../../../../common/util/types.js';
import { GPUTest } from '../../../../../gpu_test.js';
-import { toVector, TypeF32, TypeF16, TypeVec } from '../../../../../util/conversion.js';
-import { FP, FPKind } from '../../../../../util/floating_point.js';
-import {
- sparseVectorF32Range,
- sparseVectorF16Range,
- sparseF32Range,
- sparseF16Range,
-} from '../../../../../util/math.js';
-import { makeCaseCache } from '../../case_cache.js';
-import { allInputSources, Case, IntervalFilter, run } from '../../expression.js';
+import { Type } from '../../../../../util/conversion.js';
+import { allInputSources, onlyConstInputSource, run } from '../../expression.js';
-import { builtin } from './builtin.js';
+import { abstractFloatBuiltin, builtin } from './builtin.js';
+import { d } from './refract.cache.js';
export const g = makeTestGroup(GPUTest);
-// Using a bespoke implementation of make*Case and generate*Cases here
-// since refract is the only builtin with the API signature
-// (vec, vec, scalar) -> vec
-
-/**
- * @returns a Case for `refract`
- * @param kind what type of floating point numbers to operate on
- * @param i the `i` param for the case
- * @param s the `s` param for the case
- * @param r the `r` param for the case
- * @param check what interval checking to apply
- * */
-function makeCase(
- kind: FPKind,
- i: readonly number[],
- s: readonly number[],
- r: number,
- check: IntervalFilter
-): Case | undefined {
- const fp = FP[kind];
- i = i.map(fp.quantize);
- s = s.map(fp.quantize);
- r = fp.quantize(r);
-
- const vectors = fp.refractInterval(i, s, r);
- if (check === 'finite' && vectors.some(e => !e.isFinite())) {
- return undefined;
- }
-
- return {
- input: [toVector(i, fp.scalarBuilder), toVector(s, fp.scalarBuilder), fp.scalarBuilder(r)],
- expected: fp.refractInterval(i, s, r),
- };
-}
-
-/**
- * @returns an array of Cases for `refract`
- * @param kind what type of floating point numbers to operate on
- * @param param_is array of inputs to try for the `i` param
- * @param param_ss array of inputs to try for the `s` param
- * @param param_rs array of inputs to try for the `r` param
- * @param check what interval checking to apply
- */
-function generateCases(
- kind: FPKind,
- param_is: ROArrayArray<number>,
- param_ss: ROArrayArray<number>,
- param_rs: readonly number[],
- check: IntervalFilter
-): Case[] {
- // Cannot use `cartesianProduct` here due to heterogeneous param types
- return param_is
- .flatMap(i => {
- return param_ss.flatMap(s => {
- return param_rs.map(r => {
- return makeCase(kind, i, s, r, check);
- });
- });
- })
- .filter((c): c is Case => c !== undefined);
-}
-
-// Cases: f32_vecN_[non_]const
-const f32_vec_cases = ([2, 3, 4] as const)
- .flatMap(n =>
- ([true, false] as const).map(nonConst => ({
- [`f32_vec${n}_${nonConst ? 'non_const' : 'const'}`]: () => {
- return generateCases(
- 'f32',
- sparseVectorF32Range(n),
- sparseVectorF32Range(n),
- sparseF32Range(),
- nonConst ? 'unfiltered' : 'finite'
- );
- },
- }))
- )
- .reduce((a, b) => ({ ...a, ...b }), {});
-
-// Cases: f16_vecN_[non_]const
-const f16_vec_cases = ([2, 3, 4] as const)
- .flatMap(n =>
- ([true, false] as const).map(nonConst => ({
- [`f16_vec${n}_${nonConst ? 'non_const' : 'const'}`]: () => {
- return generateCases(
- 'f16',
- sparseVectorF16Range(n),
- sparseVectorF16Range(n),
- sparseF16Range(),
- nonConst ? 'unfiltered' : 'finite'
- );
- },
- }))
- )
- .reduce((a, b) => ({ ...a, ...b }), {});
+g.test('abstract_float_vec2')
+ .specURL('https://www.w3.org/TR/WGSL/#numeric-builtin-functions')
+ .desc(`abstract float tests using vec2s`)
+ .params(u => u.combine('inputSource', onlyConstInputSource))
+ .fn(async t => {
+ const cases = await d.get('abstract_vec2_const');
+ await run(
+ t,
+ abstractFloatBuiltin('refract'),
+ [Type.vec2af, Type.vec2af, Type.abstractFloat],
+ Type.vec2af,
+ t.params,
+ cases
+ );
+ });
-export const d = makeCaseCache('refract', {
- ...f32_vec_cases,
- ...f16_vec_cases,
-});
+g.test('abstract_float_vec3')
+ .specURL('https://www.w3.org/TR/WGSL/#numeric-builtin-functions')
+ .desc(`abstract float tests using vec3s`)
+ .params(u => u.combine('inputSource', onlyConstInputSource))
+ .fn(async t => {
+ const cases = await d.get('abstract_vec3_const');
+ await run(
+ t,
+ abstractFloatBuiltin('refract'),
+ [Type.vec3af, Type.vec3af, Type.abstractFloat],
+ Type.vec3af,
+ t.params,
+ cases
+ );
+ });
-g.test('abstract_float')
- .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
- .desc(`abstract float tests`)
- .params(u => u.combine('inputSource', allInputSources).combine('vectorize', [2, 3, 4] as const))
- .unimplemented();
+g.test('abstract_float_vec4')
+ .specURL('https://www.w3.org/TR/WGSL/#numeric-builtin-functions')
+ .desc(`abstract float tests using vec4s`)
+ .params(u => u.combine('inputSource', onlyConstInputSource))
+ .fn(async t => {
+ const cases = await d.get('abstract_vec4_const');
+ await run(
+ t,
+ abstractFloatBuiltin('refract'),
+ [Type.vec4af, Type.vec4af, Type.abstractFloat],
+ Type.vec4af,
+ t.params,
+ cases
+ );
+ });
g.test('f32_vec2')
.specURL('https://www.w3.org/TR/WGSL/#numeric-builtin-functions')
@@ -146,8 +79,8 @@ g.test('f32_vec2')
await run(
t,
builtin('refract'),
- [TypeVec(2, TypeF32), TypeVec(2, TypeF32), TypeF32],
- TypeVec(2, TypeF32),
+ [Type.vec2f, Type.vec2f, Type.f32],
+ Type.vec2f,
t.params,
cases
);
@@ -164,8 +97,8 @@ g.test('f32_vec3')
await run(
t,
builtin('refract'),
- [TypeVec(3, TypeF32), TypeVec(3, TypeF32), TypeF32],
- TypeVec(3, TypeF32),
+ [Type.vec3f, Type.vec3f, Type.f32],
+ Type.vec3f,
t.params,
cases
);
@@ -182,8 +115,8 @@ g.test('f32_vec4')
await run(
t,
builtin('refract'),
- [TypeVec(4, TypeF32), TypeVec(4, TypeF32), TypeF32],
- TypeVec(4, TypeF32),
+ [Type.vec4f, Type.vec4f, Type.f32],
+ Type.vec4f,
t.params,
cases
);
@@ -203,8 +136,8 @@ g.test('f16_vec2')
await run(
t,
builtin('refract'),
- [TypeVec(2, TypeF16), TypeVec(2, TypeF16), TypeF16],
- TypeVec(2, TypeF16),
+ [Type.vec2h, Type.vec2h, Type.f16],
+ Type.vec2h,
t.params,
cases
);
@@ -224,8 +157,8 @@ g.test('f16_vec3')
await run(
t,
builtin('refract'),
- [TypeVec(3, TypeF16), TypeVec(3, TypeF16), TypeF16],
- TypeVec(3, TypeF16),
+ [Type.vec3h, Type.vec3h, Type.f16],
+ Type.vec3h,
t.params,
cases
);
@@ -245,8 +178,8 @@ g.test('f16_vec4')
await run(
t,
builtin('refract'),
- [TypeVec(4, TypeF16), TypeVec(4, TypeF16), TypeF16],
- TypeVec(4, TypeF16),
+ [Type.vec4h, Type.vec4h, Type.f16],
+ Type.vec4h,
t.params,
cases
);
generated by cgit v1.2.3 (git 2.39.1) at 2024-07-23 04:20:40 +0000