From 3e950e11f46fa3d2a84f04345ea860907ae9715a Mon Sep 17 00:00:00 2001 From: Jay Kwak <82421531+jkwak-work@users.noreply.github.com> Date: Mon, 23 Sep 2024 16:32:47 -0700 Subject: Implemented Combined-texture for WGSL (#5130) * Implemented Combined-texture for WGSL * Remove unnecessary comment * Limit to std430 layout * Fix compiler warning for unused variable --------- Co-authored-by: Yong He --- tests/wgsl/texture-sampler-less.slang | 393 ++++++++++++++++++++++++++++++++++ 1 file changed, 393 insertions(+) create mode 100644 tests/wgsl/texture-sampler-less.slang (limited to 'tests') diff --git a/tests/wgsl/texture-sampler-less.slang b/tests/wgsl/texture-sampler-less.slang new file mode 100644 index 000000000..1a6cb5341 --- /dev/null +++ b/tests/wgsl/texture-sampler-less.slang @@ -0,0 +1,393 @@ +// WGSL supports "textureSample()" only in fragment shader +//TEST:SIMPLE(filecheck=WGSL): -stage fragment -entry fragMain -target wgsl + +// TODO: offset variants requires the offset value to be compile-time constant +// But the keyword, `constexpr`, doesn't seem to work for the combined-textures +#define TEST_WHEN_CONSTEXPR_WORKS_FOR_OFFSET 0 + +//WGSL:@binding(0) {{.*}}t1D_f32v3{{.*}} : texture_1d; +//WGSL:@binding(1) {{.*}}t1D_f32v3{{.*}} : sampler; +//TEST_INPUT: TextureSampler1D(size=4, content = zero):name t1D_f32v3 +Sampler1D t1D_f32v3; + +//WGSL:@binding(2) {{.*}}t2D_f32v3{{.*}} : texture_2d; +//WGSL:@binding(3) {{.*}}t2D_f32v3{{.*}} : sampler; +//TEST_INPUT: TextureSampler2D(size=4, content = zero):name t2D_f32v3 +Sampler2D t2D_f32v3; + +//TEST_INPUT: TextureSampler3D(size=4, content = zero):name t3D_f32v3 +Sampler3D t3D_f32v3; +//TEST_INPUT: TextureSamplerCube(size=4, content = zero):name tCube_f32v3 +SamplerCube tCube_f32v3; + +//TEST_INPUT: TextureSampler1D(size=4, content = zero, arrayLength=2):name t1DArray_f32v3 +Sampler1DArray t1DArray_f32v3; +//TEST_INPUT: TextureSampler2D(size=4, content = zero, arrayLength=2):name t2DArray_f32v3 +Sampler2DArray t2DArray_f32v3; +//TEST_INPUT: TextureSamplerCube(size=4, content = zero, arrayLength=2):name tCubeArray_f32v3 +SamplerCubeArray tCubeArray_f32v3; + +//TEST_INPUT: TextureSampler1D(size=4, content = zero):name t1D_f32v4 +Sampler1D t1D_f32v4; +//TEST_INPUT: TextureSampler2D(size=4, content = zero):name t2D_f32v4 +Sampler2D t2D_f32v4; +//TEST_INPUT: TextureSampler3D(size=4, content = zero):name t3D_f32v4 +Sampler3D t3D_f32v4; +//TEST_INPUT: TextureSamplerCube(size=4, content = zero):name tCube_f32v4 +SamplerCube tCube_f32v4; + +//TEST_INPUT: TextureSampler1D(size=4, content = zero, arrayLength=2):name t1DArray_f32v4 +Sampler1DArray t1DArray_f32v4; +//TEST_INPUT: TextureSampler2D(size=4, content = zero, arrayLength=2):name t2DArray_f32v4 +Sampler2DArray t2DArray_f32v4; +//TEST_INPUT: TextureSamplerCube(size=4, content = zero, arrayLength=2):name tCubeArray_f32v4 +SamplerCubeArray tCubeArray_f32v4; + +__generic +typealias CombinedDepth2d = __TextureImpl< + T, + __Shape2D, + 0, // isArray + 0, // isMS + sampleCount, + 0, // access + 1, // isShadow + 1, // isCombined + format +>; + +__generic +typealias CombinedDepth2d_array = __TextureImpl< + T, + __Shape2D, + 1, // isArray + 0, // isMS + sampleCount, + 0, // access + 1, // isShadow + 1, // isCombined + format +>; + +__generic +typealias CombinedDepthcube = __TextureImpl< + T, + __ShapeCube, + 0, // isArray + 0, // isMS + sampleCount, + 0, // access + 1, // isShadow + 1, // isCombined + format +>; + +__generic +typealias CombinedDepthcube_array = __TextureImpl< + T, + __ShapeCube, + 1, // isArray + 0, // isMS + sampleCount, + 0, // access + 1, // isShadow + 1, // isCombined + format +>; + +//TEST_INPUT: TextureSampler2D(size=4, content = zero):name d2D +CombinedDepth2d d2D; +//TEST_INPUT: TextureSamplerCube(size=4, content = zero):name dCube +CombinedDepthcube dCube; +//TEST_INPUT: TextureSampler2D(size=4, content = zero, arrayLength=2):name d2DArray +CombinedDepth2d_array d2DArray; +//TEST_INPUT: TextureSamplerCube(size=4, content = zero, arrayLength=2):name dCubeArray +CombinedDepthcube_array dCubeArray; + +//TEST_INPUT: ubuffer(data=[0], stride=4):out,name outputBuffer +RWStructuredBuffer outputBuffer; + + +__generic +bool TEST_texture( + Sampler1D> t1D, + Sampler2D> t2D, + Sampler3D> t3D, + SamplerCube> tCube, + Sampler1DArray> t1DArray, + Sampler2DArray> t2DArray, + SamplerCubeArray> tCubeArray +) +{ + // WGSL-LABEL: TEST_texture + typealias Tvn = vector; + typealias Tv4 = vector; + + float u = 0; + float u2 = 0.5; + constexpr const float ddx = 0.0f; + constexpr const float ddy = 0.0f; + + bool result = true + // =============================== + // float CalculateLevelOfDetail() + // =============================== + // WGSL doesn't have a way to calculate mip-map level for the given coordinate + + // ======================================== + // float CalculateLevelOfDetailUnclamped() + // ======================================== + // WGSL doesn't have a way to calculate mip-map level for the given coordinate + + // =========== + // T Sample() + // https://www.w3.org/TR/WGSL/#texturesample + // =========== + + // WGSL: textureSample({{\(*}}t1D + && all(Tvn(T(0)) == t1D.Sample(u)) + + // WGSL: textureSample({{\(*}}t2D + && all(Tvn(T(0)) == t2D.Sample(float2(u, u))) + + // WGSL: textureSample({{\(*}}t3D + && all(Tvn(T(0)) == t3D.Sample(float3(u, u, u))) + + // WGSL: textureSample({{\(*}}tCube + && all(Tvn(T(0)) == tCube.Sample(normalize(float3(u, 1 - u, u)))) + + // WGSL doesn't support textureSample for 1d_array and 3d_array; only 2d and cube + + // WGSL: textureSample({{\(*}}t2DArray + && all(Tvn(T(0)) == t2DArray.Sample(float3(u, u, 0))) + + // WGSL: textureSample({{\(*}}tCubeArray + && all(Tvn(T(0)) == tCubeArray.Sample(float4(normalize(float3(u, 1 - u, u)), 0))) + +#if TEST_WHEN_CONSTEXPR_WORKS_FOR_OFFSET + // Offset variant + + // WGSL: textureSample({{\(*}}t1D + && all(Tvn(T(0)) == t1D.Sample(u, 1)) + + // WGSL: textureSample({{\(*}}t2D + && all(Tvn(T(0)) == t2D.Sample(float2(u, u), int2(1, 1))) + + // WGSL: textureSample({{\(*}}t3D + && all(Tvn(T(0)) == t3D.Sample(float3(u, u, u), int3(1, 1, 1))) + + // WGSL doesn't support offset variant for cube and cube_array + + // WGSL: textureSample({{\(*}}t2DArray + && all(Tvn(T(0)) == t2DArray.Sample(float3(u, u, 0), int2(1, 1))) +#endif // #if TEST_WHEN_CONSTEXPR_WORKS_FOR_OFFSET + + // =============== + // T SampleBias() + // https://www.w3.org/TR/WGSL/#texturesamplebias + // =============== + + // WGSL doesn't support Bias for 1D texture + + // WGSL: textureSampleBias({{\(*}}t2D + && all(Tvn(T(0)) == t2D.SampleBias(float2(u, u), float(-1))) + + // WGSL: textureSampleBias({{\(*}}t3D + && all(Tvn(T(0)) == t3D.SampleBias(float3(u, u, u), float(-1))) + + // WGSL: textureSampleBias({{\(*}}tCube + && all(Tvn(T(0)) == tCube.SampleBias(normalize(float3(u, 1 - u, u)), float(-1))) + + // WGSL: textureSampleBias({{\(*}}t2DArray + && all(Tvn(T(0)) == t2DArray.SampleBias(float3(u, u, 0), float(-1))) + + // WGSL: textureSampleBias({{\(*}}tCubeArray + && all(Tvn(T(0)) == tCubeArray.SampleBias(float4(normalize(float3(u, 1 - u, u)), 0), float(-1))) + +#if TEST_WHEN_CONSTEXPR_WORKS_FOR_OFFSET + // Offset variant + + // W-GSL: textureSampleBias({{\(*}}t2D + && all(Tvn(T(0)) == t2D.SampleBias(float2(u, u), float(-1), int2(1, 1))) + + // W-GSL: textureSampleBias({{\(*}}t3D + && all(Tvn(T(0)) == t3D.SampleBias(float3(u, u, u), float(-1), int3(1, 1, 1))) + + // W-GSL: textureSampleBias({{\(*}}t2DArray + && all(Tvn(T(0)) == t2DArray.SampleBias(float3(u, u, 0), float(-1), int2(1, 1))) +#endif // #if TEST_WHEN_CONSTEXPR_WORKS_FOR_OFFSET + + // =================================== + // T SampleLevel() + // https://www.w3.org/TR/WGSL/#texturesamplelevel + // =================================== + + // WGSL doesn't support textureSampleLevel for 1D texture + + // WGSL: textureSampleLevel({{\(*}}t2D + && all(Tvn(T(0)) == t2D.SampleLevel(float2(u, u), 0)) + + // WGSL: textureSampleLevel({{\(*}}t3D + && all(Tvn(T(0)) == t3D.SampleLevel(float3(u, u, u), 0)) + + // WGSL: textureSampleLevel({{\(*}}tCube + && all(Tvn(T(0)) == tCube.SampleLevel(normalize(float3(u, 1 - u, u)), 0)) + + // WGSL: textureSampleLevel({{\(*}}t2DArray + && all(Tvn(T(0)) == t2DArray.SampleLevel(float3(u, u, 0), 0)) + + // WGSL: textureSampleLevel({{\(*}}tCubeArray + && all(Tvn(T(0)) == tCubeArray.SampleLevel(float4(normalize(float3(u, 1 - u, u)), 0), 0)) + +#if TEST_WHEN_CONSTEXPR_WORKS_FOR_OFFSET + // Offset variant + + // W-GSL: textureSampleLevel({{\(*}}t2D + && all(Tvn(T(0)) == t2D.SampleLevel(float2(u, u), 0, int2(1, 1))) + + // W-GSL: textureSampleLevel({{\(*}}t3D + && all(Tvn(T(0)) == t3D.SampleLevel(float3(u, u, u), 0, int3(1, 1, 1))) + + // W-GSL: textureSampleLevel({{\(*}}t2DArray + && all(Tvn(T(0)) == t2DArray.SampleLevel(float3(u, u, 0), 0, int2(1, 1))) +#endif // #if TEST_WHEN_CONSTEXPR_WORKS_FOR_OFFSET + + // ================== + // float SampleCmp() + // https://www.w3.org/TR/WGSL/#texturesamplecompare + // ================== + + // WGSL: textureSampleCompare({{\(*}}d2D + && float(0) == d2D.SampleCmp(float2(u, u), 0) + + // WGSL: textureSampleCompare({{\(*}}d2DArray + && float(0) == d2DArray.SampleCmp(float3(u, u, 0), 0) + + // WGSL: textureSampleCompare({{\(*}}dCube + && float(0) == dCube.SampleCmp(normalize(float3(u, 1 - u, u)), 0) + + // WGSL: textureSampleCompare({{\(*}}dCubeArray + && float(0) == dCubeArray.SampleCmp(float4(normalize(float3(u, 1 - u, u)), 0), 0) + +#if TEST_WHEN_CONSTEXPR_WORKS_FOR_OFFSET + // Offset variant + + // W-GSL: textureSampleCompare({{\(*}}d2D + && float(0) == d2D.SampleCmp(float2(u2, u), 0, int2(0, 0)) + + // W-GSL: textureSampleCompare({{\(*}}d2DArray + && float(0) == d2DArray.SampleCmp(float3(u2, u, u), 0, int2(0, 0)) +#endif // #if TEST_WHEN_CONSTEXPR_WORKS_FOR_OFFSET + + // =================================== + // float SampleCmpLevelZero() + // https://www.w3.org/TR/WGSL/#texturesamplecomparelevel + // =================================== + + // WGSL: textureSampleCompareLevel({{\(*}}d2D + && float(0) == d2D.SampleCmpLevelZero(float2(u, u), 0) + + // WGSL: textureSampleCompareLevel({{\(*}}d2DArray + && float(0) == d2DArray.SampleCmpLevelZero(float3(u, u, 0), 0) + + // WGSL: textureSampleCompareLevel({{\(*}}dCube + && float(0) == dCube.SampleCmpLevelZero(normalize(float3(u, 1 - u, u)), 0) + + // WGSL: textureSampleCompareLevel({{\(*}}dCubeArray + && float(0) == dCubeArray.SampleCmpLevelZero(float4(normalize(float3(u, 1-u, u)), 0), 0) + +#if TEST_WHEN_CONSTEXPR_WORKS_FOR_OFFSET + // Offset variant + + // W-GSL: textureSampleCompareLevel({{\(*}}d2D + && float(0) == d2D.SampleCmpLevelZero(float2(u2, u), 0, int2(0, 0)) + + // W-GSL: textureSampleCompareLevel({{\(*}}d2DArray + && float(0) == d2DArray.SampleCmpLevelZero(float3(u2, u, u), 0, int2(0, 0)) +#endif // #if TEST_WHEN_CONSTEXPR_WORKS_FOR_OFFSET + + // ================================== + // vector Gather() + // https://www.w3.org/TR/WGSL/#texturegather + // ================================== + +#if 0 + && all(Tv4(T(0)) == t2D.Gather(float2(u, u))) + + && all(Tv4(T(0)) == tCube.Gather(normalize(float3(u, 1 - u, u)))) + + && all(Tv4(T(0)) == t2DArray.Gather(float3(u, u, 0))) + + && all(Tv4(T(0)) == tCubeArray.Gather(float4(normalize(float3(u, 1 - u, u)), 0))) + +#if TEST_WHEN_CONSTEXPR_WORKS_FOR_OFFSET + // Offset variant + + && all(Tv4(T(0)) == t2D.Gather(float2(u2, u), int2(0, 0))) + + && all(Tv4(T(0)) == t2DArray.Gather(float3(u2, u, 0), int2(0, 0))) +#endif // #if TEST_WHEN_CONSTEXPR_WORKS_FOR_OFFSET +#endif + + // ===================================== + // T SampleGrad() + // https://www.w3.org/TR/WGSL/#texturesamplegrad + // ===================================== + + // WGSL doesn't support textureSampleGrad for 1D textures + + // WGSL: textureSampleGrad({{\(*}}t2D + && all(Tvn(T(0)) == t2D.SampleGrad(float2(u, u), float2(ddx, ddx), float2(ddy, ddy))) + + // WGSL: textureSampleGrad({{\(*}}t3D + && all(Tvn(T(0)) == t3D.SampleGrad(float3(u, u, u), float3(ddx, ddx, ddx), float3(ddy, ddy, ddy))) + + // WGSL: textureSampleGrad({{\(*}}tCube + && all(Tvn(T(0)) == tCube.SampleGrad(normalize(float3(u, 1 - u, u)), float3(ddx, ddx, ddx), float3(ddy, ddy, ddy))) + + // WGSL: textureSampleGrad({{\(*}}t2DArray + && all(Tvn(T(0)) == t2DArray.SampleGrad(float3(u, u, 0.0f), float2(ddx, ddx), float2(ddy, ddy))) + + // WGSL: textureSampleGrad({{\(*}}tCubeArray + && all(Tvn(T(0)) == tCubeArray.SampleGrad(float4(normalize(float3(u, 1 - u, u)), 0), float3(ddx, ddx, ddx), float3(ddy, ddy, ddy))) + +#if TEST_WHEN_CONSTEXPR_WORKS_FOR_OFFSET + // Offset variant + + // W-GSL: textureSampleGrad({{\(*}}t2D + && all(Tvn(T(0)) == t2D.SampleGrad(float2(u2, u), float2(ddx, ddx), float2(ddy, ddy), int2(0, 0))) + + // W-GSL: textureSampleGrad({{\(*}}t3D + && all(Tvn(T(0)) == t3D.SampleGrad(float3(u2, u, u), float3(ddx, ddx, ddx), float3(ddy, ddy, ddy), int3(0, 0, 0))) + + // W-GSL: textureSampleGrad({{\(*}}t2DArray + && all(Tvn(T(0)) == t2DArray.SampleGrad(float3(u2, u, 0.0f), float2(ddx, ddx), float2(ddy, ddy), int2(0, 0))) +#endif // #if TEST_WHEN_CONSTEXPR_WORKS_FOR_OFFSET + ; + + return result; +} + +void fragMain() +{ + bool result = true + && TEST_texture( + t1D_f32v3, + t2D_f32v3, + t3D_f32v3, + tCube_f32v3, + t1DArray_f32v3, + t2DArray_f32v3, + tCubeArray_f32v3) + && TEST_texture( + t1D_f32v4, + t2D_f32v4, + t3D_f32v4, + tCube_f32v4, + t1DArray_f32v4, + t2DArray_f32v4, + tCubeArray_f32v4) + ; + + outputBuffer[0] = int(result); +} -- cgit v1.2.3