tint: Allow signed / unsigned texture builtin params
Bug: tint:1526 Change-Id: I301a9ba6e94b162a1ffb436be3e3212b723b7401 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/106682 Reviewed-by: Dan Sinclair <dsinclair@chromium.org> Kokoro: Kokoro <noreply+kokoro@google.com> Commit-Queue: Ben Clayton <bclayton@google.com>
This commit is contained in:
parent
d96f7c22ed
commit
da5424b617
|
@ -464,7 +464,7 @@ std::vector<TextureOverloadCase> TextureOverloadCase::ValidCases() {
|
|||
},
|
||||
{
|
||||
ValidTextureOverload::kGather2dOffsetF32,
|
||||
"textureGather(component : i32,\n"
|
||||
"textureGather(component : u32,\n"
|
||||
" t : texture_2d<T>,\n"
|
||||
" s : sampler,\n"
|
||||
" coords : vec2<f32>,\n"
|
||||
|
@ -475,7 +475,7 @@ std::vector<TextureOverloadCase> TextureOverloadCase::ValidCases() {
|
|||
TextureDataType::kF32,
|
||||
"textureGather",
|
||||
[](ProgramBuilder* b) {
|
||||
return b->ExprList(0_i, // component
|
||||
return b->ExprList(0_u, // component
|
||||
"texture", // t
|
||||
"sampler", // s
|
||||
b->vec2<f32>(1_f, 2_f), // coords
|
||||
|
@ -504,11 +504,11 @@ std::vector<TextureOverloadCase> TextureOverloadCase::ValidCases() {
|
|||
},
|
||||
{
|
||||
ValidTextureOverload::kGather2dArrayOffsetF32,
|
||||
"textureGather(component : i32,\n"
|
||||
"textureGather(component : u32,\n"
|
||||
" t : texture_2d_array<T>,\n"
|
||||
" s : sampler,\n"
|
||||
" coords : vec2<f32>,\n"
|
||||
" array_index : i32,\n"
|
||||
" array_index : u32,\n"
|
||||
" offset : vec2<i32>) -> vec4<T>",
|
||||
TextureKind::kRegular,
|
||||
ast::SamplerKind::kSampler,
|
||||
|
@ -516,11 +516,11 @@ std::vector<TextureOverloadCase> TextureOverloadCase::ValidCases() {
|
|||
TextureDataType::kF32,
|
||||
"textureGather",
|
||||
[](ProgramBuilder* b) {
|
||||
return b->ExprList(0_i, // component
|
||||
return b->ExprList(0_u, // component
|
||||
"texture", // t
|
||||
"sampler", // s
|
||||
b->vec2<f32>(1_f, 2_f), // coords
|
||||
3_i, // array_index
|
||||
3_u, // array_index
|
||||
b->vec2<i32>(4_i, 5_i)); // offset
|
||||
},
|
||||
},
|
||||
|
@ -544,22 +544,22 @@ std::vector<TextureOverloadCase> TextureOverloadCase::ValidCases() {
|
|||
},
|
||||
{
|
||||
ValidTextureOverload::kGatherCubeArrayF32,
|
||||
"textureGather(component : i32,\n"
|
||||
"textureGather(component : u32,\n"
|
||||
" t : texture_cube_array<T>,\n"
|
||||
" s : sampler,\n"
|
||||
" coords : vec3<f32>,\n"
|
||||
" array_index : i32) -> vec4<T>",
|
||||
" array_index : u32) -> vec4<T>",
|
||||
TextureKind::kRegular,
|
||||
ast::SamplerKind::kSampler,
|
||||
ast::TextureDimension::kCubeArray,
|
||||
TextureDataType::kF32,
|
||||
"textureGather",
|
||||
[](ProgramBuilder* b) {
|
||||
return b->ExprList(0_i, // component
|
||||
return b->ExprList(0_u, // component
|
||||
"texture", // t
|
||||
"sampler", // s
|
||||
b->vec3<f32>(1_f, 2_f, 3_f), // coords
|
||||
4_i); // array_index
|
||||
4_u); // array_index
|
||||
},
|
||||
},
|
||||
{
|
||||
|
@ -601,7 +601,7 @@ std::vector<TextureOverloadCase> TextureOverloadCase::ValidCases() {
|
|||
"textureGather(t : texture_depth_2d_array,\n"
|
||||
" s : sampler,\n"
|
||||
" coords : vec2<f32>,\n"
|
||||
" array_index : i32) -> vec4<f32>",
|
||||
" array_index : u32) -> vec4<f32>",
|
||||
TextureKind::kDepth,
|
||||
ast::SamplerKind::kSampler,
|
||||
ast::TextureDimension::k2dArray,
|
||||
|
@ -611,7 +611,7 @@ std::vector<TextureOverloadCase> TextureOverloadCase::ValidCases() {
|
|||
return b->ExprList("texture", // t
|
||||
"sampler", // s
|
||||
b->vec2<f32>(1_f, 2_f), // coords
|
||||
3_i); // array_index
|
||||
3_u); // array_index
|
||||
},
|
||||
},
|
||||
{
|
||||
|
@ -655,7 +655,7 @@ std::vector<TextureOverloadCase> TextureOverloadCase::ValidCases() {
|
|||
"textureGather(t : texture_depth_cube_array,\n"
|
||||
" s : sampler,\n"
|
||||
" coords : vec3<f32>,\n"
|
||||
" array_index : i32) -> vec4<f32>",
|
||||
" array_index : u32) -> vec4<f32>",
|
||||
TextureKind::kDepth,
|
||||
ast::SamplerKind::kSampler,
|
||||
ast::TextureDimension::kCubeArray,
|
||||
|
@ -665,7 +665,7 @@ std::vector<TextureOverloadCase> TextureOverloadCase::ValidCases() {
|
|||
return b->ExprList("texture", // t
|
||||
"sampler", // s
|
||||
b->vec3<f32>(1_f, 2_f, 3_f), // coords
|
||||
4_i); // array_index
|
||||
4_u); // array_index
|
||||
},
|
||||
},
|
||||
{
|
||||
|
@ -771,7 +771,7 @@ std::vector<TextureOverloadCase> TextureOverloadCase::ValidCases() {
|
|||
"textureGatherCompare(t : texture_depth_cube_array,\n"
|
||||
" s : sampler_comparison,\n"
|
||||
" coords : vec3<f32>,\n"
|
||||
" array_index : i32,\n"
|
||||
" array_index : u32,\n"
|
||||
" depth_ref : f32) -> vec4<f32>",
|
||||
TextureKind::kDepth,
|
||||
ast::SamplerKind::kComparisonSampler,
|
||||
|
@ -782,7 +782,7 @@ std::vector<TextureOverloadCase> TextureOverloadCase::ValidCases() {
|
|||
return b->ExprList("texture", // t
|
||||
"sampler", // s
|
||||
b->vec3<f32>(1_f, 2_f, 3_f), // coords
|
||||
4_i, // array_index
|
||||
4_u, // array_index
|
||||
5_f); // depth_ref
|
||||
},
|
||||
},
|
||||
|
@ -1009,7 +1009,7 @@ std::vector<TextureOverloadCase> TextureOverloadCase::ValidCases() {
|
|||
"textureSample(t : texture_2d_array<f32>,\n"
|
||||
" s : sampler,\n"
|
||||
" coords : vec2<f32>,\n"
|
||||
" array_index : i32\n"
|
||||
" array_index : u32\n"
|
||||
" offset : vec2<i32>) -> vec4<f32>",
|
||||
TextureKind::kRegular,
|
||||
ast::SamplerKind::kSampler,
|
||||
|
@ -1020,7 +1020,7 @@ std::vector<TextureOverloadCase> TextureOverloadCase::ValidCases() {
|
|||
return b->ExprList("texture", // t
|
||||
"sampler", // s
|
||||
b->vec2<f32>(1_f, 2_f), // coords
|
||||
3_i, // array_index
|
||||
3_u, // array_index
|
||||
b->vec2<i32>(4_i, 5_i)); // offset
|
||||
},
|
||||
},
|
||||
|
@ -1185,7 +1185,7 @@ std::vector<TextureOverloadCase> TextureOverloadCase::ValidCases() {
|
|||
"textureSample(t : texture_depth_cube_array,\n"
|
||||
" s : sampler,\n"
|
||||
" coords : vec3<f32>,\n"
|
||||
" array_index : i32) -> f32",
|
||||
" array_index : u32) -> f32",
|
||||
TextureKind::kDepth,
|
||||
ast::SamplerKind::kSampler,
|
||||
ast::TextureDimension::kCubeArray,
|
||||
|
@ -1195,7 +1195,7 @@ std::vector<TextureOverloadCase> TextureOverloadCase::ValidCases() {
|
|||
return b->ExprList("texture", // t
|
||||
"sampler", // s
|
||||
b->vec3<f32>(1_f, 2_f, 3_f), // coords
|
||||
4_i); // array_index
|
||||
4_u); // array_index
|
||||
},
|
||||
},
|
||||
{
|
||||
|
@ -1241,7 +1241,7 @@ std::vector<TextureOverloadCase> TextureOverloadCase::ValidCases() {
|
|||
"textureSampleBias(t : texture_2d_array<f32>,\n"
|
||||
" s : sampler,\n"
|
||||
" coords : vec2<f32>,\n"
|
||||
" array_index : i32,\n"
|
||||
" array_index : u32,\n"
|
||||
" bias : f32) -> vec4<f32>",
|
||||
TextureKind::kRegular,
|
||||
ast::SamplerKind::kSampler,
|
||||
|
@ -1252,7 +1252,7 @@ std::vector<TextureOverloadCase> TextureOverloadCase::ValidCases() {
|
|||
return b->ExprList("texture", // t
|
||||
"sampler", // s
|
||||
b->vec2<f32>(1_f, 2_f), // coords
|
||||
4_i, // array_index
|
||||
4_u, // array_index
|
||||
3_f); // bias
|
||||
},
|
||||
},
|
||||
|
@ -1515,7 +1515,7 @@ std::vector<TextureOverloadCase> TextureOverloadCase::ValidCases() {
|
|||
"textureSampleLevel(t : texture_depth_2d,\n"
|
||||
" s : sampler,\n"
|
||||
" coords : vec2<f32>,\n"
|
||||
" level : i32) -> f32",
|
||||
" level : u32) -> f32",
|
||||
TextureKind::kDepth,
|
||||
ast::SamplerKind::kSampler,
|
||||
ast::TextureDimension::k2d,
|
||||
|
@ -1525,7 +1525,7 @@ std::vector<TextureOverloadCase> TextureOverloadCase::ValidCases() {
|
|||
return b->ExprList("texture", // t
|
||||
"sampler", // s
|
||||
b->vec2<f32>(1_f, 2_f), // coords
|
||||
3_i); // level
|
||||
3_u); // level
|
||||
},
|
||||
},
|
||||
{
|
||||
|
@ -1553,8 +1553,8 @@ std::vector<TextureOverloadCase> TextureOverloadCase::ValidCases() {
|
|||
"textureSampleLevel(t : texture_depth_2d_array,\n"
|
||||
" s : sampler,\n"
|
||||
" coords : vec2<f32>,\n"
|
||||
" array_index : i32,\n"
|
||||
" level : i32) -> f32",
|
||||
" array_index : u32,\n"
|
||||
" level : u32) -> f32",
|
||||
TextureKind::kDepth,
|
||||
ast::SamplerKind::kSampler,
|
||||
ast::TextureDimension::k2dArray,
|
||||
|
@ -1564,8 +1564,8 @@ std::vector<TextureOverloadCase> TextureOverloadCase::ValidCases() {
|
|||
return b->ExprList("texture", // t
|
||||
"sampler", // s
|
||||
b->vec2<f32>(1_f, 2_f), // coords
|
||||
3_i, // array_index
|
||||
4_i); // level
|
||||
3_u, // array_index
|
||||
4_u); // level
|
||||
},
|
||||
},
|
||||
{
|
||||
|
@ -1573,8 +1573,8 @@ std::vector<TextureOverloadCase> TextureOverloadCase::ValidCases() {
|
|||
"textureSampleLevel(t : texture_depth_2d_array,\n"
|
||||
" s : sampler,\n"
|
||||
" coords : vec2<f32>,\n"
|
||||
" array_index : i32,\n"
|
||||
" level : i32,\n"
|
||||
" array_index : u32,\n"
|
||||
" level : u32,\n"
|
||||
" offset : vec2<i32>) -> f32",
|
||||
TextureKind::kDepth,
|
||||
ast::SamplerKind::kSampler,
|
||||
|
@ -1585,8 +1585,8 @@ std::vector<TextureOverloadCase> TextureOverloadCase::ValidCases() {
|
|||
return b->ExprList("texture", // t
|
||||
"sampler", // s
|
||||
b->vec2<f32>(1_f, 2_f), // coords
|
||||
3_i, // array_index
|
||||
4_i, // level
|
||||
3_u, // array_index
|
||||
4_u, // level
|
||||
b->vec2<i32>(5_i, 6_i)); // offset
|
||||
},
|
||||
},
|
||||
|
@ -1697,7 +1697,7 @@ std::vector<TextureOverloadCase> TextureOverloadCase::ValidCases() {
|
|||
"textureSampleGrad(t : texture_2d_array<f32>,\n"
|
||||
" s : sampler,\n"
|
||||
" coords : vec2<f32>,\n"
|
||||
" array_index : i32,\n"
|
||||
" array_index : u32,\n"
|
||||
" ddx : vec2<f32>,\n"
|
||||
" ddy : vec2<f32>,\n"
|
||||
" offset : vec2<i32>) -> vec4<f32>",
|
||||
|
@ -1710,7 +1710,7 @@ std::vector<TextureOverloadCase> TextureOverloadCase::ValidCases() {
|
|||
return b->ExprList("texture", // t
|
||||
"sampler", // s
|
||||
b->vec2<f32>(1_f, 2_f), // coords
|
||||
3_i, // array_index
|
||||
3_u, // array_index
|
||||
b->vec2<f32>(4_f, 5_f), // ddx
|
||||
b->vec2<f32>(6_f, 7_f), // ddy
|
||||
b->vec2<i32>(6_i, 7_i)); // offset
|
||||
|
@ -1783,7 +1783,7 @@ std::vector<TextureOverloadCase> TextureOverloadCase::ValidCases() {
|
|||
"textureSampleGrad(t : texture_cube_array<f32>,\n"
|
||||
" s : sampler,\n"
|
||||
" coords : vec3<f32>,\n"
|
||||
" array_index : i32,\n"
|
||||
" array_index : u32,\n"
|
||||
" ddx : vec3<f32>,\n"
|
||||
" ddy : vec3<f32>) -> vec4<f32>",
|
||||
TextureKind::kRegular,
|
||||
|
@ -1795,7 +1795,7 @@ std::vector<TextureOverloadCase> TextureOverloadCase::ValidCases() {
|
|||
return b->ExprList("texture", // t
|
||||
"sampler", // s
|
||||
b->vec3<f32>(1_f, 2_f, 3_f), // coords
|
||||
4_i, // array_index
|
||||
4_u, // array_index
|
||||
b->vec3<f32>(5_f, 6_f, 7_f), // ddx
|
||||
b->vec3<f32>(8_f, 9_f, 10_f)); // ddy
|
||||
},
|
||||
|
@ -1863,7 +1863,7 @@ std::vector<TextureOverloadCase> TextureOverloadCase::ValidCases() {
|
|||
"textureSampleCompare(t : texture_depth_2d_array,\n"
|
||||
" s : sampler_comparison,\n"
|
||||
" coords : vec2<f32>,\n"
|
||||
" array_index : i32,\n"
|
||||
" array_index : u32,\n"
|
||||
" depth_ref : f32,\n"
|
||||
" offset : vec2<i32>) -> f32",
|
||||
TextureKind::kDepth,
|
||||
|
@ -1875,7 +1875,7 @@ std::vector<TextureOverloadCase> TextureOverloadCase::ValidCases() {
|
|||
return b->ExprList("texture", // t
|
||||
"sampler", // s
|
||||
b->vec2<f32>(1_f, 2_f), // coords
|
||||
4_i, // array_index
|
||||
4_u, // array_index
|
||||
3_f, // depth_ref
|
||||
b->vec2<i32>(5_i, 6_i)); // offset
|
||||
},
|
||||
|
@ -1921,16 +1921,16 @@ std::vector<TextureOverloadCase> TextureOverloadCase::ValidCases() {
|
|||
{
|
||||
ValidTextureOverload::kLoad1dLevelF32,
|
||||
"textureLoad(t : texture_1d<f32>,\n"
|
||||
" coords : i32,\n"
|
||||
" level : i32) -> vec4<f32>",
|
||||
" coords : u32,\n"
|
||||
" level : u32) -> vec4<f32>",
|
||||
TextureKind::kRegular,
|
||||
ast::TextureDimension::k1d,
|
||||
TextureDataType::kF32,
|
||||
"textureLoad",
|
||||
[](ProgramBuilder* b) {
|
||||
return b->ExprList("texture", // t
|
||||
1_i, // coords
|
||||
3_i); // level
|
||||
1_u, // coords
|
||||
3_u); // level
|
||||
},
|
||||
},
|
||||
{
|
||||
|
@ -1966,16 +1966,16 @@ std::vector<TextureOverloadCase> TextureOverloadCase::ValidCases() {
|
|||
{
|
||||
ValidTextureOverload::kLoad2dLevelF32,
|
||||
"textureLoad(t : texture_2d<f32>,\n"
|
||||
" coords : vec2<i32>,\n"
|
||||
" level : i32) -> vec4<f32>",
|
||||
" coords : vec2<u32>,\n"
|
||||
" level : u32) -> vec4<f32>",
|
||||
TextureKind::kRegular,
|
||||
ast::TextureDimension::k2d,
|
||||
TextureDataType::kF32,
|
||||
"textureLoad",
|
||||
[](ProgramBuilder* b) {
|
||||
return b->ExprList("texture", // t
|
||||
b->vec2<i32>(1_i, 2_i), // coords
|
||||
3_i); // level
|
||||
b->vec2<u32>(1_u, 2_u), // coords
|
||||
3_u); // level
|
||||
},
|
||||
},
|
||||
{
|
||||
|
@ -1996,16 +1996,16 @@ std::vector<TextureOverloadCase> TextureOverloadCase::ValidCases() {
|
|||
{
|
||||
ValidTextureOverload::kLoad2dLevelI32,
|
||||
"textureLoad(t : texture_2d<i32>,\n"
|
||||
" coords : vec2<i32>,\n"
|
||||
" level : i32) -> vec4<i32>",
|
||||
" coords : vec2<u32>,\n"
|
||||
" level : u32) -> vec4<i32>",
|
||||
TextureKind::kRegular,
|
||||
ast::TextureDimension::k2d,
|
||||
TextureDataType::kI32,
|
||||
"textureLoad",
|
||||
[](ProgramBuilder* b) {
|
||||
return b->ExprList("texture", // t
|
||||
b->vec2<i32>(1_i, 2_i), // coords
|
||||
3_i); // level
|
||||
b->vec2<u32>(1_u, 2_u), // coords
|
||||
3_u); // level
|
||||
},
|
||||
},
|
||||
{
|
||||
|
@ -2045,18 +2045,18 @@ std::vector<TextureOverloadCase> TextureOverloadCase::ValidCases() {
|
|||
{
|
||||
ValidTextureOverload::kLoad2dArrayLevelI32,
|
||||
"textureLoad(t : texture_2d_array<i32>,\n"
|
||||
" coords : vec2<i32>,\n"
|
||||
" array_index : i32,\n"
|
||||
" level : i32) -> vec4<i32>",
|
||||
" coords : vec2<u32>,\n"
|
||||
" array_index : u32,\n"
|
||||
" level : u32) -> vec4<i32>",
|
||||
TextureKind::kRegular,
|
||||
ast::TextureDimension::k2dArray,
|
||||
TextureDataType::kI32,
|
||||
"textureLoad",
|
||||
[](ProgramBuilder* b) {
|
||||
return b->ExprList("texture", // t
|
||||
b->vec2<i32>(1_i, 2_i), // coords
|
||||
3_i, // array_index
|
||||
4_i); // level
|
||||
b->vec2<u32>(1_u, 2_u), // coords
|
||||
3_u, // array_index
|
||||
4_u); // level
|
||||
},
|
||||
},
|
||||
{
|
||||
|
@ -2092,16 +2092,16 @@ std::vector<TextureOverloadCase> TextureOverloadCase::ValidCases() {
|
|||
{
|
||||
ValidTextureOverload::kLoad3dLevelI32,
|
||||
"textureLoad(t : texture_3d<i32>,\n"
|
||||
" coords : vec3<i32>,\n"
|
||||
" level : i32) -> vec4<i32>",
|
||||
" coords : vec3<u32>,\n"
|
||||
" level : u32) -> vec4<i32>",
|
||||
TextureKind::kRegular,
|
||||
ast::TextureDimension::k3d,
|
||||
TextureDataType::kI32,
|
||||
"textureLoad",
|
||||
[](ProgramBuilder* b) {
|
||||
return b->ExprList("texture", // t
|
||||
b->vec3<i32>(1_i, 2_i, 3_i), // coords
|
||||
4_i); // level
|
||||
b->vec3<u32>(1_u, 2_u, 3_u), // coords
|
||||
4_u); // level
|
||||
},
|
||||
},
|
||||
{
|
||||
|
@ -2137,16 +2137,16 @@ std::vector<TextureOverloadCase> TextureOverloadCase::ValidCases() {
|
|||
{
|
||||
ValidTextureOverload::kLoadMultisampled2dI32,
|
||||
"textureLoad(t : texture_multisampled_2d<i32>,\n"
|
||||
" coords : vec2<i32>,\n"
|
||||
" sample_index : i32) -> vec4<i32>",
|
||||
" coords : vec2<u32>,\n"
|
||||
" sample_index : u32) -> vec4<i32>",
|
||||
TextureKind::kMultisampled,
|
||||
ast::TextureDimension::k2d,
|
||||
TextureDataType::kI32,
|
||||
"textureLoad",
|
||||
[](ProgramBuilder* b) {
|
||||
return b->ExprList("texture", // t
|
||||
b->vec2<i32>(1_i, 2_i), // coords
|
||||
3_i); // sample_index
|
||||
b->vec2<u32>(1_u, 2_u), // coords
|
||||
3_u); // sample_index
|
||||
},
|
||||
},
|
||||
{
|
||||
|
@ -2167,18 +2167,18 @@ std::vector<TextureOverloadCase> TextureOverloadCase::ValidCases() {
|
|||
{
|
||||
ValidTextureOverload::kLoadDepth2dArrayLevelF32,
|
||||
"textureLoad(t : texture_depth_2d_array,\n"
|
||||
" coords : vec2<i32>,\n"
|
||||
" array_index : i32,\n"
|
||||
" level : i32) -> f32",
|
||||
" coords : vec2<u32>,\n"
|
||||
" array_index : u32,\n"
|
||||
" level : u32) -> f32",
|
||||
TextureKind::kDepth,
|
||||
ast::TextureDimension::k2dArray,
|
||||
TextureDataType::kF32,
|
||||
"textureLoad",
|
||||
[](ProgramBuilder* b) {
|
||||
return b->ExprList("texture", // t
|
||||
b->vec2<i32>(1_i, 2_i), // coords
|
||||
3_i, // array_index
|
||||
4_i); // level
|
||||
b->vec2<u32>(1_u, 2_u), // coords
|
||||
3_u, // array_index
|
||||
4_u); // level
|
||||
},
|
||||
},
|
||||
{
|
||||
|
@ -2216,8 +2216,8 @@ std::vector<TextureOverloadCase> TextureOverloadCase::ValidCases() {
|
|||
{
|
||||
ValidTextureOverload::kStoreWO2dArrayRgba32float,
|
||||
"textureStore(t : texture_storage_2d_array<rgba32float>,\n"
|
||||
" coords : vec2<i32>,\n"
|
||||
" array_index : i32,\n"
|
||||
" coords : vec2<u32>,\n"
|
||||
" array_index : u32,\n"
|
||||
" value : vec4<T>)",
|
||||
ast::Access::kWrite,
|
||||
ast::TexelFormat::kRgba32Float,
|
||||
|
@ -2226,15 +2226,15 @@ std::vector<TextureOverloadCase> TextureOverloadCase::ValidCases() {
|
|||
"textureStore",
|
||||
[](ProgramBuilder* b) {
|
||||
return b->ExprList("texture", // t
|
||||
b->vec2<i32>(1_i, 2_i), // coords
|
||||
3_i, // array_index
|
||||
b->vec2<u32>(1_u, 2_u), // coords
|
||||
3_u, // array_index
|
||||
b->vec4<f32>(4_f, 5_f, 6_f, 7_f)); // value
|
||||
},
|
||||
},
|
||||
{
|
||||
ValidTextureOverload::kStoreWO3dRgba32float,
|
||||
"textureStore(t : texture_storage_3d<rgba32float>,\n"
|
||||
" coords : vec3<i32>,\n"
|
||||
" coords : vec3<u32>,\n"
|
||||
" value : vec4<T>)",
|
||||
ast::Access::kWrite,
|
||||
ast::TexelFormat::kRgba32Float,
|
||||
|
@ -2243,7 +2243,7 @@ std::vector<TextureOverloadCase> TextureOverloadCase::ValidCases() {
|
|||
"textureStore",
|
||||
[](ProgramBuilder* b) {
|
||||
return b->ExprList("texture", // t
|
||||
b->vec3<i32>(1_i, 2_i, 3_i), // coords
|
||||
b->vec3<u32>(1_u, 2_u, 3_u), // coords
|
||||
b->vec4<f32>(4_f, 5_f, 6_f, 7_f)); // value
|
||||
},
|
||||
},
|
||||
|
|
|
@ -555,50 +555,50 @@ fn unpack4x8unorm(u32) -> vec4<f32>
|
|||
@stage("compute") fn workgroupBarrier()
|
||||
|
||||
fn textureDimensions<T: fiu32>(texture: texture_1d<T>) -> i32
|
||||
fn textureDimensions<T: fiu32>(texture: texture_1d<T>, level: i32) -> i32
|
||||
fn textureDimensions<T: fiu32, C: iu32>(texture: texture_1d<T>, level: C) -> i32
|
||||
fn textureDimensions<T: fiu32>(texture: texture_2d<T>) -> vec2<i32>
|
||||
fn textureDimensions<T: fiu32>(texture: texture_2d<T>, level: i32) -> vec2<i32>
|
||||
fn textureDimensions<T: fiu32, C: iu32>(texture: texture_2d<T>, level: C) -> vec2<i32>
|
||||
fn textureDimensions<T: fiu32>(texture: texture_2d_array<T>) -> vec2<i32>
|
||||
fn textureDimensions<T: fiu32>(texture: texture_2d_array<T>, level: i32) -> vec2<i32>
|
||||
fn textureDimensions<T: fiu32, C: iu32>(texture: texture_2d_array<T>, level: C) -> vec2<i32>
|
||||
fn textureDimensions<T: fiu32>(texture: texture_3d<T>) -> vec3<i32>
|
||||
fn textureDimensions<T: fiu32>(texture: texture_3d<T>, level: i32) -> vec3<i32>
|
||||
fn textureDimensions<T: fiu32, C: iu32>(texture: texture_3d<T>, level: C) -> vec3<i32>
|
||||
fn textureDimensions<T: fiu32>(texture: texture_cube<T>) -> vec2<i32>
|
||||
fn textureDimensions<T: fiu32>(texture: texture_cube<T>, level: i32) -> vec2<i32>
|
||||
fn textureDimensions<T: fiu32, C: iu32>(texture: texture_cube<T>, level: C) -> vec2<i32>
|
||||
fn textureDimensions<T: fiu32>(texture: texture_cube_array<T>) -> vec2<i32>
|
||||
fn textureDimensions<T: fiu32>(texture: texture_cube_array<T>, level: i32) -> vec2<i32>
|
||||
fn textureDimensions<T: fiu32, C: iu32>(texture: texture_cube_array<T>, level: C) -> vec2<i32>
|
||||
fn textureDimensions<T: fiu32>(texture: texture_multisampled_2d<T>) -> vec2<i32>
|
||||
fn textureDimensions(texture: texture_depth_2d) -> vec2<i32>
|
||||
fn textureDimensions(texture: texture_depth_2d, level: i32) -> vec2<i32>
|
||||
fn textureDimensions<C: iu32>(texture: texture_depth_2d, level: C) -> vec2<i32>
|
||||
fn textureDimensions(texture: texture_depth_2d_array) -> vec2<i32>
|
||||
fn textureDimensions(texture: texture_depth_2d_array, level: i32) -> vec2<i32>
|
||||
fn textureDimensions<C: iu32>(texture: texture_depth_2d_array, level: C) -> vec2<i32>
|
||||
fn textureDimensions(texture: texture_depth_cube) -> vec2<i32>
|
||||
fn textureDimensions(texture: texture_depth_cube, level: i32) -> vec2<i32>
|
||||
fn textureDimensions<C: iu32>(texture: texture_depth_cube, level: C) -> vec2<i32>
|
||||
fn textureDimensions(texture: texture_depth_cube_array) -> vec2<i32>
|
||||
fn textureDimensions(texture: texture_depth_cube_array, level: i32) -> vec2<i32>
|
||||
fn textureDimensions<C: iu32>(texture: texture_depth_cube_array, level: C) -> vec2<i32>
|
||||
fn textureDimensions(texture: texture_depth_multisampled_2d) -> vec2<i32>
|
||||
fn textureDimensions<F: texel_format, A: write>(texture: texture_storage_1d<F, A>) -> i32
|
||||
fn textureDimensions<F: texel_format, A: write>(texture: texture_storage_2d<F, A>) -> vec2<i32>
|
||||
fn textureDimensions<F: texel_format, A: write>(texture: texture_storage_2d_array<F, A>) -> vec2<i32>
|
||||
fn textureDimensions<F: texel_format, A: write>(texture: texture_storage_3d<F, A>) -> vec3<i32>
|
||||
fn textureDimensions(texture: texture_external) -> vec2<i32>
|
||||
fn textureGather<T: fiu32>(@const component: i32, texture: texture_2d<T>, sampler: sampler, coords: vec2<f32>) -> vec4<T>
|
||||
fn textureGather<T: fiu32>(@const component: i32, texture: texture_2d<T>, sampler: sampler, coords: vec2<f32>, @const offset: vec2<i32>) -> vec4<T>
|
||||
fn textureGather<T: fiu32>(@const component: i32, texture: texture_2d_array<T>, sampler: sampler, coords: vec2<f32>, array_index: i32) -> vec4<T>
|
||||
fn textureGather<T: fiu32>(@const component: i32, texture: texture_2d_array<T>, sampler: sampler, coords: vec2<f32>, array_index: i32, @const offset: vec2<i32>) -> vec4<T>
|
||||
fn textureGather<T: fiu32>(@const component: i32, texture: texture_cube<T>, sampler: sampler, coords: vec3<f32>) -> vec4<T>
|
||||
fn textureGather<T: fiu32>(@const component: i32, texture: texture_cube_array<T>, sampler: sampler, coords: vec3<f32>, array_index: i32) -> vec4<T>
|
||||
fn textureGather<T: fiu32, C: iu32>(@const component: C, texture: texture_2d<T>, sampler: sampler, coords: vec2<f32>) -> vec4<T>
|
||||
fn textureGather<T: fiu32, C: iu32>(@const component: C, texture: texture_2d<T>, sampler: sampler, coords: vec2<f32>, @const offset: vec2<i32>) -> vec4<T>
|
||||
fn textureGather<T: fiu32, C: iu32>(@const component: C, texture: texture_2d_array<T>, sampler: sampler, coords: vec2<f32>, array_index: C) -> vec4<T>
|
||||
fn textureGather<T: fiu32, C: iu32>(@const component: C, texture: texture_2d_array<T>, sampler: sampler, coords: vec2<f32>, array_index: C, @const offset: vec2<i32>) -> vec4<T>
|
||||
fn textureGather<T: fiu32, C: iu32>(@const component: C, texture: texture_cube<T>, sampler: sampler, coords: vec3<f32>) -> vec4<T>
|
||||
fn textureGather<T: fiu32, C: iu32>(@const component: C, texture: texture_cube_array<T>, sampler: sampler, coords: vec3<f32>, array_index: C) -> vec4<T>
|
||||
fn textureGather(texture: texture_depth_2d, sampler: sampler, coords: vec2<f32>) -> vec4<f32>
|
||||
fn textureGather(texture: texture_depth_2d, sampler: sampler, coords: vec2<f32>, @const offset: vec2<i32>) -> vec4<f32>
|
||||
fn textureGather(texture: texture_depth_2d_array, sampler: sampler, coords: vec2<f32>, array_index: i32) -> vec4<f32>
|
||||
fn textureGather(texture: texture_depth_2d_array, sampler: sampler, coords: vec2<f32>, array_index: i32, @const offset: vec2<i32>) -> vec4<f32>
|
||||
fn textureGather<C: iu32>(texture: texture_depth_2d_array, sampler: sampler, coords: vec2<f32>, array_index: C) -> vec4<f32>
|
||||
fn textureGather<C: iu32>(texture: texture_depth_2d_array, sampler: sampler, coords: vec2<f32>, array_index: C, @const offset: vec2<i32>) -> vec4<f32>
|
||||
fn textureGather(texture: texture_depth_cube, sampler: sampler, coords: vec3<f32>) -> vec4<f32>
|
||||
fn textureGather(texture: texture_depth_cube_array, sampler: sampler, coords: vec3<f32>, array_index: i32) -> vec4<f32>
|
||||
fn textureGather<C: iu32>(texture: texture_depth_cube_array, sampler: sampler, coords: vec3<f32>, array_index: C) -> vec4<f32>
|
||||
fn textureGatherCompare(texture: texture_depth_2d, sampler: sampler_comparison, coords: vec2<f32>, depth_ref: f32) -> vec4<f32>
|
||||
fn textureGatherCompare(texture: texture_depth_2d, sampler: sampler_comparison, coords: vec2<f32>, depth_ref: f32, @const offset: vec2<i32>) -> vec4<f32>
|
||||
fn textureGatherCompare(texture: texture_depth_2d_array, sampler: sampler_comparison, coords: vec2<f32>, array_index: i32, depth_ref: f32) -> vec4<f32>
|
||||
fn textureGatherCompare(texture: texture_depth_2d_array, sampler: sampler_comparison, coords: vec2<f32>, array_index: i32, depth_ref: f32, @const offset: vec2<i32>) -> vec4<f32>
|
||||
fn textureGatherCompare<C: iu32>(texture: texture_depth_2d_array, sampler: sampler_comparison, coords: vec2<f32>, array_index: C, depth_ref: f32) -> vec4<f32>
|
||||
fn textureGatherCompare<C: iu32>(texture: texture_depth_2d_array, sampler: sampler_comparison, coords: vec2<f32>, array_index: C, depth_ref: f32, @const offset: vec2<i32>) -> vec4<f32>
|
||||
fn textureGatherCompare(texture: texture_depth_cube, sampler: sampler_comparison, coords: vec3<f32>, depth_ref: f32) -> vec4<f32>
|
||||
fn textureGatherCompare(texture: texture_depth_cube_array, sampler: sampler_comparison, coords: vec3<f32>, array_index: i32, depth_ref: f32) -> vec4<f32>
|
||||
fn textureGatherCompare<C: iu32>(texture: texture_depth_cube_array, sampler: sampler_comparison, coords: vec3<f32>, array_index: C, depth_ref: f32) -> vec4<f32>
|
||||
fn textureNumLayers<T: fiu32>(texture: texture_2d_array<T>) -> i32
|
||||
fn textureNumLayers<T: fiu32>(texture: texture_cube_array<T>) -> i32
|
||||
fn textureNumLayers(texture: texture_depth_2d_array) -> i32
|
||||
|
@ -619,84 +619,84 @@ fn textureNumSamples(texture: texture_depth_multisampled_2d) -> i32
|
|||
@stage("fragment") fn textureSample(texture: texture_1d<f32>, sampler: sampler, coords: f32) -> vec4<f32>
|
||||
@stage("fragment") fn textureSample(texture: texture_2d<f32>, sampler: sampler, coords: vec2<f32>) -> vec4<f32>
|
||||
@stage("fragment") fn textureSample(texture: texture_2d<f32>, sampler: sampler, coords: vec2<f32>, @const offset: vec2<i32>) -> vec4<f32>
|
||||
@stage("fragment") fn textureSample(texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: i32) -> vec4<f32>
|
||||
@stage("fragment") fn textureSample(texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: i32, @const offset: vec2<i32>) -> vec4<f32>
|
||||
@stage("fragment") fn textureSample<C: iu32>(texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: C) -> vec4<f32>
|
||||
@stage("fragment") fn textureSample<C: iu32>(texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: C, @const offset: vec2<i32>) -> vec4<f32>
|
||||
@stage("fragment") fn textureSample(texture: texture_3d<f32>, sampler: sampler, coords: vec3<f32>) -> vec4<f32>
|
||||
@stage("fragment") fn textureSample(texture: texture_3d<f32>, sampler: sampler, coords: vec3<f32>, @const offset: vec3<i32>) -> vec4<f32>
|
||||
@stage("fragment") fn textureSample(texture: texture_cube<f32>, sampler: sampler, coords: vec3<f32>) -> vec4<f32>
|
||||
@stage("fragment") fn textureSample(texture: texture_cube_array<f32>, sampler: sampler, coords: vec3<f32>, array_index: i32) -> vec4<f32>
|
||||
@stage("fragment") fn textureSample<C: iu32>(texture: texture_cube_array<f32>, sampler: sampler, coords: vec3<f32>, array_index: C) -> vec4<f32>
|
||||
@stage("fragment") fn textureSample(texture: texture_depth_2d, sampler: sampler, coords: vec2<f32>) -> f32
|
||||
@stage("fragment") fn textureSample(texture: texture_depth_2d, sampler: sampler, coords: vec2<f32>, @const offset: vec2<i32>) -> f32
|
||||
@stage("fragment") fn textureSample(texture: texture_depth_2d_array, sampler: sampler, coords: vec2<f32>, array_index: i32) -> f32
|
||||
@stage("fragment") fn textureSample(texture: texture_depth_2d_array, sampler: sampler, coords: vec2<f32>, array_index: i32, @const offset: vec2<i32>) -> f32
|
||||
@stage("fragment") fn textureSample<C: iu32>(texture: texture_depth_2d_array, sampler: sampler, coords: vec2<f32>, array_index: C) -> f32
|
||||
@stage("fragment") fn textureSample<C: iu32>(texture: texture_depth_2d_array, sampler: sampler, coords: vec2<f32>, array_index: C, @const offset: vec2<i32>) -> f32
|
||||
@stage("fragment") fn textureSample(texture: texture_depth_cube, sampler: sampler, coords: vec3<f32>) -> f32
|
||||
@stage("fragment") fn textureSample(texture: texture_depth_cube_array, sampler: sampler, coords: vec3<f32>, array_index: i32) -> f32
|
||||
@stage("fragment") fn textureSample<C: iu32>(texture: texture_depth_cube_array, sampler: sampler, coords: vec3<f32>, array_index: C) -> f32
|
||||
@stage("fragment") fn textureSampleBias(texture: texture_2d<f32>, sampler: sampler, coords: vec2<f32>, bias: f32) -> vec4<f32>
|
||||
@stage("fragment") fn textureSampleBias(texture: texture_2d<f32>, sampler: sampler, coords: vec2<f32>, bias: f32, @const offset: vec2<i32>) -> vec4<f32>
|
||||
@stage("fragment") fn textureSampleBias(texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: i32, bias: f32) -> vec4<f32>
|
||||
@stage("fragment") fn textureSampleBias(texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: i32, bias: f32, @const offset: vec2<i32>) -> vec4<f32>
|
||||
@stage("fragment") fn textureSampleBias<C: iu32>(texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: C, bias: f32) -> vec4<f32>
|
||||
@stage("fragment") fn textureSampleBias<C: iu32>(texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: C, bias: f32, @const offset: vec2<i32>) -> vec4<f32>
|
||||
@stage("fragment") fn textureSampleBias(texture: texture_3d<f32>, sampler: sampler, coords: vec3<f32>, bias: f32) -> vec4<f32>
|
||||
@stage("fragment") fn textureSampleBias(texture: texture_3d<f32>, sampler: sampler, coords: vec3<f32>, bias: f32, @const offset: vec3<i32>) -> vec4<f32>
|
||||
@stage("fragment") fn textureSampleBias(texture: texture_cube<f32>, sampler: sampler, coords: vec3<f32>, bias: f32) -> vec4<f32>
|
||||
@stage("fragment") fn textureSampleBias(texture: texture_cube_array<f32>, sampler: sampler, coords: vec3<f32>, array_index: i32, bias: f32) -> vec4<f32>
|
||||
@stage("fragment") fn textureSampleBias<C: iu32>(texture: texture_cube_array<f32>, sampler: sampler, coords: vec3<f32>, array_index: C, bias: f32) -> vec4<f32>
|
||||
@stage("fragment") fn textureSampleCompare(texture: texture_depth_2d, sampler: sampler_comparison, coords: vec2<f32>, depth_ref: f32) -> f32
|
||||
@stage("fragment") fn textureSampleCompare(texture: texture_depth_2d, sampler: sampler_comparison, coords: vec2<f32>, depth_ref: f32, @const offset: vec2<i32>) -> f32
|
||||
@stage("fragment") fn textureSampleCompare(texture: texture_depth_2d_array, sampler: sampler_comparison, coords: vec2<f32>, array_index: i32, depth_ref: f32) -> f32
|
||||
@stage("fragment") fn textureSampleCompare(texture: texture_depth_2d_array, sampler: sampler_comparison, coords: vec2<f32>, array_index: i32, depth_ref: f32, @const offset: vec2<i32>) -> f32
|
||||
@stage("fragment") fn textureSampleCompare<C: iu32>(texture: texture_depth_2d_array, sampler: sampler_comparison, coords: vec2<f32>, array_index: C, depth_ref: f32) -> f32
|
||||
@stage("fragment") fn textureSampleCompare<C: iu32>(texture: texture_depth_2d_array, sampler: sampler_comparison, coords: vec2<f32>, array_index: C, depth_ref: f32, @const offset: vec2<i32>) -> f32
|
||||
@stage("fragment") fn textureSampleCompare(texture: texture_depth_cube, sampler: sampler_comparison, coords: vec3<f32>, depth_ref: f32) -> f32
|
||||
@stage("fragment") fn textureSampleCompare(texture: texture_depth_cube_array, sampler: sampler_comparison, coords: vec3<f32>, array_index: i32, depth_ref: f32) -> f32
|
||||
@stage("fragment") fn textureSampleCompare<C: iu32>(texture: texture_depth_cube_array, sampler: sampler_comparison, coords: vec3<f32>, array_index: C, depth_ref: f32) -> f32
|
||||
fn textureSampleCompareLevel(texture: texture_depth_2d, sampler: sampler_comparison, coords: vec2<f32>, depth_ref: f32) -> f32
|
||||
fn textureSampleCompareLevel(texture: texture_depth_2d, sampler: sampler_comparison, coords: vec2<f32>, depth_ref: f32, @const offset: vec2<i32>) -> f32
|
||||
fn textureSampleCompareLevel(texture: texture_depth_2d_array, sampler: sampler_comparison, coords: vec2<f32>, array_index: i32, depth_ref: f32) -> f32
|
||||
fn textureSampleCompareLevel(texture: texture_depth_2d_array, sampler: sampler_comparison, coords: vec2<f32>, array_index: i32, depth_ref: f32, @const offset: vec2<i32>) -> f32
|
||||
fn textureSampleCompareLevel<C: iu32>(texture: texture_depth_2d_array, sampler: sampler_comparison, coords: vec2<f32>, array_index: C, depth_ref: f32) -> f32
|
||||
fn textureSampleCompareLevel<C: iu32>(texture: texture_depth_2d_array, sampler: sampler_comparison, coords: vec2<f32>, array_index: C, depth_ref: f32, @const offset: vec2<i32>) -> f32
|
||||
fn textureSampleCompareLevel(texture: texture_depth_cube, sampler: sampler_comparison, coords: vec3<f32>, depth_ref: f32) -> f32
|
||||
fn textureSampleCompareLevel(texture: texture_depth_cube_array, sampler: sampler_comparison, coords: vec3<f32>, array_index: i32, depth_ref: f32) -> f32
|
||||
fn textureSampleCompareLevel<C: iu32>(texture: texture_depth_cube_array, sampler: sampler_comparison, coords: vec3<f32>, array_index: C, depth_ref: f32) -> f32
|
||||
fn textureSampleGrad(texture: texture_2d<f32>, sampler: sampler, coords: vec2<f32>, ddx: vec2<f32>, ddy: vec2<f32>) -> vec4<f32>
|
||||
fn textureSampleGrad(texture: texture_2d<f32>, sampler: sampler, coords: vec2<f32>, ddx: vec2<f32>, ddy: vec2<f32>, @const offset: vec2<i32>) -> vec4<f32>
|
||||
fn textureSampleGrad(texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: i32, ddx: vec2<f32>, ddy: vec2<f32>) -> vec4<f32>
|
||||
fn textureSampleGrad(texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: i32, ddx: vec2<f32>, ddy: vec2<f32>, @const offset: vec2<i32>) -> vec4<f32>
|
||||
fn textureSampleGrad<C: iu32>(texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: C, ddx: vec2<f32>, ddy: vec2<f32>) -> vec4<f32>
|
||||
fn textureSampleGrad<C: iu32>(texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: C, ddx: vec2<f32>, ddy: vec2<f32>, @const offset: vec2<i32>) -> vec4<f32>
|
||||
fn textureSampleGrad(texture: texture_3d<f32>, sampler: sampler, coords: vec3<f32>, ddx: vec3<f32>, ddy: vec3<f32>) -> vec4<f32>
|
||||
fn textureSampleGrad(texture: texture_3d<f32>, sampler: sampler, coords: vec3<f32>, ddx: vec3<f32>, ddy: vec3<f32>, @const offset: vec3<i32>) -> vec4<f32>
|
||||
fn textureSampleGrad(texture: texture_cube<f32>, sampler: sampler, coords: vec3<f32>, ddx: vec3<f32>, ddy: vec3<f32>) -> vec4<f32>
|
||||
fn textureSampleGrad(texture: texture_cube_array<f32>, sampler: sampler, coords: vec3<f32>, array_index: i32, ddx: vec3<f32>, ddy: vec3<f32>) -> vec4<f32>
|
||||
fn textureSampleGrad<C: iu32>(texture: texture_cube_array<f32>, sampler: sampler, coords: vec3<f32>, array_index: C, ddx: vec3<f32>, ddy: vec3<f32>) -> vec4<f32>
|
||||
fn textureSampleLevel(texture: texture_2d<f32>, sampler: sampler, coords: vec2<f32>, level: f32) -> vec4<f32>
|
||||
fn textureSampleLevel(texture: texture_2d<f32>, sampler: sampler, coords: vec2<f32>, level: f32, @const offset: vec2<i32>) -> vec4<f32>
|
||||
fn textureSampleLevel(texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: i32, level: f32) -> vec4<f32>
|
||||
fn textureSampleLevel(texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: i32, level: f32, @const offset: vec2<i32>) -> vec4<f32>
|
||||
fn textureSampleLevel<C: iu32>(texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: C, level: f32) -> vec4<f32>
|
||||
fn textureSampleLevel<C: iu32>(texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: C, level: f32, @const offset: vec2<i32>) -> vec4<f32>
|
||||
fn textureSampleLevel(texture: texture_3d<f32>, sampler: sampler, coords: vec3<f32>, level: f32) -> vec4<f32>
|
||||
fn textureSampleLevel(texture: texture_3d<f32>, sampler: sampler, coords: vec3<f32>, level: f32, @const offset: vec3<i32>) -> vec4<f32>
|
||||
fn textureSampleLevel(texture: texture_cube<f32>, sampler: sampler, coords: vec3<f32>, level: f32) -> vec4<f32>
|
||||
fn textureSampleLevel(texture: texture_cube_array<f32>, sampler: sampler, coords: vec3<f32>, array_index: i32, level: f32) -> vec4<f32>
|
||||
fn textureSampleLevel(texture: texture_depth_2d, sampler: sampler, coords: vec2<f32>, level: i32) -> f32
|
||||
fn textureSampleLevel(texture: texture_depth_2d, sampler: sampler, coords: vec2<f32>, level: i32, @const offset: vec2<i32>) -> f32
|
||||
fn textureSampleLevel(texture: texture_depth_2d_array, sampler: sampler, coords: vec2<f32>, array_index: i32, level: i32) -> f32
|
||||
fn textureSampleLevel(texture: texture_depth_2d_array, sampler: sampler, coords: vec2<f32>, array_index: i32, level: i32, @const offset: vec2<i32>) -> f32
|
||||
fn textureSampleLevel(texture: texture_depth_cube, sampler: sampler, coords: vec3<f32>, level: i32) -> f32
|
||||
fn textureSampleLevel(texture: texture_depth_cube_array,sampler: sampler, coords: vec3<f32>, array_index: i32, level: i32) -> f32
|
||||
fn textureSampleLevel<C: iu32>(texture: texture_cube_array<f32>, sampler: sampler, coords: vec3<f32>, array_index: C, level: f32) -> vec4<f32>
|
||||
fn textureSampleLevel<C: iu32>(texture: texture_depth_2d, sampler: sampler, coords: vec2<f32>, level: C) -> f32
|
||||
fn textureSampleLevel<C: iu32>(texture: texture_depth_2d, sampler: sampler, coords: vec2<f32>, level: C, @const offset: vec2<i32>) -> f32
|
||||
fn textureSampleLevel<C: iu32>(texture: texture_depth_2d_array, sampler: sampler, coords: vec2<f32>, array_index: C, level: C) -> f32
|
||||
fn textureSampleLevel<C: iu32>(texture: texture_depth_2d_array, sampler: sampler, coords: vec2<f32>, array_index: C, level: C, @const offset: vec2<i32>) -> f32
|
||||
fn textureSampleLevel<C: iu32>(texture: texture_depth_cube, sampler: sampler, coords: vec3<f32>, level: C) -> f32
|
||||
fn textureSampleLevel<C: iu32>(texture: texture_depth_cube_array,sampler: sampler, coords: vec3<f32>, array_index: C, level: C) -> f32
|
||||
@deprecated fn textureSampleLevel(texture: texture_external, sampler: sampler, coords: vec2<f32>) -> vec4<f32>
|
||||
fn textureSampleBaseClampToEdge(texture: texture_2d<f32>, sampler: sampler, coords: vec2<f32>) -> vec4<f32>
|
||||
fn textureSampleBaseClampToEdge(texture: texture_external, sampler: sampler, coords: vec2<f32>) -> vec4<f32>
|
||||
fn textureStore(texture: texture_storage_1d<f32_texel_format, write>, coords: i32, value: vec4<f32>)
|
||||
fn textureStore(texture: texture_storage_2d<f32_texel_format, write>, coords: vec2<i32>, value: vec4<f32>)
|
||||
fn textureStore(texture: texture_storage_2d_array<f32_texel_format, write>, coords: vec2<i32>, array_index: i32, value: vec4<f32>)
|
||||
fn textureStore(texture: texture_storage_3d<f32_texel_format, write>, coords: vec3<i32>, value: vec4<f32>)
|
||||
fn textureStore(texture: texture_storage_1d<i32_texel_format, write>, coords: i32, value: vec4<i32>)
|
||||
fn textureStore(texture: texture_storage_2d<i32_texel_format, write>, coords: vec2<i32>, value: vec4<i32>)
|
||||
fn textureStore(texture: texture_storage_2d_array<i32_texel_format, write>, coords: vec2<i32>, array_index: i32, value: vec4<i32>)
|
||||
fn textureStore(texture: texture_storage_3d<i32_texel_format, write>, coords: vec3<i32>, value: vec4<i32>)
|
||||
fn textureStore(texture: texture_storage_1d<u32_texel_format, write>, coords: i32, value: vec4<u32>)
|
||||
fn textureStore(texture: texture_storage_2d<u32_texel_format, write>, coords: vec2<i32>, value: vec4<u32>)
|
||||
fn textureStore(texture: texture_storage_2d_array<u32_texel_format, write>, coords: vec2<i32>, array_index: i32, value: vec4<u32>)
|
||||
fn textureStore<C: iu32>(texture: texture_storage_1d<f32_texel_format, write>, coords: C, value: vec4<f32>)
|
||||
fn textureStore<C: iu32>(texture: texture_storage_2d<f32_texel_format, write>, coords: vec2<C>, value: vec4<f32>)
|
||||
fn textureStore<C: iu32>(texture: texture_storage_2d_array<f32_texel_format, write>, coords: vec2<C>, array_index: C, value: vec4<f32>)
|
||||
fn textureStore<C: iu32>(texture: texture_storage_3d<f32_texel_format, write>, coords: vec3<C>, value: vec4<f32>)
|
||||
fn textureStore<C: iu32>(texture: texture_storage_1d<i32_texel_format, write>, coords: C, value: vec4<i32>)
|
||||
fn textureStore<C: iu32>(texture: texture_storage_2d<i32_texel_format, write>, coords: vec2<C>, value: vec4<i32>)
|
||||
fn textureStore<C: iu32>(texture: texture_storage_2d_array<i32_texel_format, write>, coords: vec2<C>, array_index: C, value: vec4<i32>)
|
||||
fn textureStore<C: iu32>(texture: texture_storage_3d<i32_texel_format, write>, coords: vec3<C>, value: vec4<i32>)
|
||||
fn textureStore<C: iu32>(texture: texture_storage_1d<u32_texel_format, write>, coords: C, value: vec4<u32>)
|
||||
fn textureStore<C: iu32>(texture: texture_storage_2d<u32_texel_format, write>, coords: vec2<C>, value: vec4<u32>)
|
||||
fn textureStore<C: iu32>(texture: texture_storage_2d_array<u32_texel_format, write>, coords: vec2<C>, array_index: C, value: vec4<u32>)
|
||||
fn textureStore(texture: texture_storage_3d<u32_texel_format, write>, coords: vec3<i32>, value: vec4<u32>)
|
||||
fn textureLoad<T: fiu32>(texture: texture_1d<T>, coords: i32, level: i32) -> vec4<T>
|
||||
fn textureLoad<T: fiu32>(texture: texture_2d<T>, coords: vec2<i32>, level: i32) -> vec4<T>
|
||||
fn textureLoad<T: fiu32>(texture: texture_2d_array<T>, coords: vec2<i32>, array_index: i32, level: i32) -> vec4<T>
|
||||
fn textureLoad<T: fiu32>(texture: texture_3d<T>, coords: vec3<i32>, level: i32) -> vec4<T>
|
||||
fn textureLoad<T: fiu32>(texture: texture_multisampled_2d<T>, coords: vec2<i32>, sample_index: i32) -> vec4<T>
|
||||
fn textureLoad(texture: texture_depth_2d, coords: vec2<i32>, level: i32) -> f32
|
||||
fn textureLoad(texture: texture_depth_2d_array, coords: vec2<i32>, array_index: i32, level: i32) -> f32
|
||||
fn textureLoad(texture: texture_depth_multisampled_2d, coords: vec2<i32>, sample_index: i32) -> f32
|
||||
fn textureLoad(texture: texture_external, coords: vec2<i32>) -> vec4<f32>
|
||||
fn textureLoad<T: fiu32, C: iu32>(texture: texture_1d<T>, coords: C, level: C) -> vec4<T>
|
||||
fn textureLoad<T: fiu32, C: iu32>(texture: texture_2d<T>, coords: vec2<C>, level: C) -> vec4<T>
|
||||
fn textureLoad<T: fiu32, C: iu32>(texture: texture_2d_array<T>, coords: vec2<C>, array_index: C, level: C) -> vec4<T>
|
||||
fn textureLoad<T: fiu32, C: iu32>(texture: texture_3d<T>, coords: vec3<C>, level: C) -> vec4<T>
|
||||
fn textureLoad<T: fiu32, C: iu32>(texture: texture_multisampled_2d<T>, coords: vec2<C>, sample_index: C) -> vec4<T>
|
||||
fn textureLoad<C: iu32>(texture: texture_depth_2d, coords: vec2<C>, level: C) -> f32
|
||||
fn textureLoad<C: iu32>(texture: texture_depth_2d_array, coords: vec2<C>, array_index: C, level: C) -> f32
|
||||
fn textureLoad<C: iu32>(texture: texture_depth_multisampled_2d, coords: vec2<C>, sample_index: C) -> f32
|
||||
fn textureLoad<C: iu32>(texture: texture_external, coords: vec2<C>) -> vec4<f32>
|
||||
|
||||
@stage("fragment", "compute") fn atomicLoad<T: iu32, S: workgroup_or_storage>(ptr<S, atomic<T>, read_write>) -> T
|
||||
@stage("fragment", "compute") fn atomicStore<T: iu32, S: workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T)
|
||||
|
|
|
@ -443,20 +443,23 @@ INSTANTIATE_TEST_SUITE_P(
|
|||
INSTANTIATE_TEST_SUITE_P(
|
||||
Component,
|
||||
BuiltinTextureConstExprArgValidationTest,
|
||||
testing::Combine(testing::ValuesIn(TextureCases({ValidTextureOverload::kGather2dF32,
|
||||
ValidTextureOverload::kGather2dOffsetF32,
|
||||
ValidTextureOverload::kGather2dArrayF32,
|
||||
ValidTextureOverload::kGather2dArrayOffsetF32,
|
||||
ValidTextureOverload::kGatherCubeF32,
|
||||
ValidTextureOverload::kGatherCubeArrayF32})),
|
||||
testing::Values(Parameter{"component", Position::kFirst, 0, 3}),
|
||||
testing::Values(Constexpr{Constexpr::kValid, Constexpr::Kind::kScalar, 0},
|
||||
Constexpr{Constexpr::kValid, Constexpr::Kind::kScalar, 1},
|
||||
Constexpr{Constexpr::kValid, Constexpr::Kind::kScalar, 2},
|
||||
Constexpr{Constexpr::kValid, Constexpr::Kind::kScalar, 3},
|
||||
Constexpr{0, Constexpr::Kind::kScalar, 4},
|
||||
Constexpr{0, Constexpr::Kind::kScalar, 123},
|
||||
Constexpr{0, Constexpr::Kind::kScalar, -1})));
|
||||
testing::Combine(
|
||||
testing::ValuesIn(TextureCases({
|
||||
ValidTextureOverload::kGather2dF32, ValidTextureOverload::kGather2dOffsetF32,
|
||||
ValidTextureOverload::kGather2dArrayF32, ValidTextureOverload::kGatherCubeF32,
|
||||
// The below require mixed integer signedness.
|
||||
// See https://github.com/gpuweb/gpuweb/issues/3536
|
||||
// ValidTextureOverload::kGather2dArrayOffsetF32,
|
||||
// ValidTextureOverload::kGatherCubeArrayF32,
|
||||
})),
|
||||
testing::Values(Parameter{"component", Position::kFirst, 0, 3}),
|
||||
testing::Values(Constexpr{Constexpr::kValid, Constexpr::Kind::kScalar, 0},
|
||||
Constexpr{Constexpr::kValid, Constexpr::Kind::kScalar, 1},
|
||||
Constexpr{Constexpr::kValid, Constexpr::Kind::kScalar, 2},
|
||||
Constexpr{Constexpr::kValid, Constexpr::Kind::kScalar, 3},
|
||||
Constexpr{0, Constexpr::Kind::kScalar, 4},
|
||||
Constexpr{0, Constexpr::Kind::kScalar, 123},
|
||||
Constexpr{0, Constexpr::Kind::kScalar, -1})));
|
||||
|
||||
} // namespace texture_constexpr_args
|
||||
|
||||
|
|
File diff suppressed because it is too large
Load Diff
|
@ -568,16 +568,16 @@ TEST_F(IntrinsicTableTest, OverloadOrderByNumberOfParameters) {
|
|||
R"(error: no matching call to textureDimensions(bool, bool)
|
||||
|
||||
27 candidate functions:
|
||||
textureDimensions(texture: texture_1d<T>, level: i32) -> i32 where: T is f32, i32 or u32
|
||||
textureDimensions(texture: texture_2d<T>, level: i32) -> vec2<i32> where: T is f32, i32 or u32
|
||||
textureDimensions(texture: texture_2d_array<T>, level: i32) -> vec2<i32> where: T is f32, i32 or u32
|
||||
textureDimensions(texture: texture_3d<T>, level: i32) -> vec3<i32> where: T is f32, i32 or u32
|
||||
textureDimensions(texture: texture_cube<T>, level: i32) -> vec2<i32> where: T is f32, i32 or u32
|
||||
textureDimensions(texture: texture_cube_array<T>, level: i32) -> vec2<i32> where: T is f32, i32 or u32
|
||||
textureDimensions(texture: texture_depth_2d, level: i32) -> vec2<i32>
|
||||
textureDimensions(texture: texture_depth_2d_array, level: i32) -> vec2<i32>
|
||||
textureDimensions(texture: texture_depth_cube, level: i32) -> vec2<i32>
|
||||
textureDimensions(texture: texture_depth_cube_array, level: i32) -> vec2<i32>
|
||||
textureDimensions(texture: texture_1d<T>, level: C) -> i32 where: T is f32, i32 or u32, C is i32 or u32
|
||||
textureDimensions(texture: texture_2d<T>, level: C) -> vec2<i32> where: T is f32, i32 or u32, C is i32 or u32
|
||||
textureDimensions(texture: texture_2d_array<T>, level: C) -> vec2<i32> where: T is f32, i32 or u32, C is i32 or u32
|
||||
textureDimensions(texture: texture_3d<T>, level: C) -> vec3<i32> where: T is f32, i32 or u32, C is i32 or u32
|
||||
textureDimensions(texture: texture_cube<T>, level: C) -> vec2<i32> where: T is f32, i32 or u32, C is i32 or u32
|
||||
textureDimensions(texture: texture_cube_array<T>, level: C) -> vec2<i32> where: T is f32, i32 or u32, C is i32 or u32
|
||||
textureDimensions(texture: texture_depth_2d, level: C) -> vec2<i32> where: C is i32 or u32
|
||||
textureDimensions(texture: texture_depth_2d_array, level: C) -> vec2<i32> where: C is i32 or u32
|
||||
textureDimensions(texture: texture_depth_cube, level: C) -> vec2<i32> where: C is i32 or u32
|
||||
textureDimensions(texture: texture_depth_cube_array, level: C) -> vec2<i32> where: C is i32 or u32
|
||||
textureDimensions(texture: texture_1d<T>) -> i32 where: T is f32, i32 or u32
|
||||
textureDimensions(texture: texture_2d<T>) -> vec2<i32> where: T is f32, i32 or u32
|
||||
textureDimensions(texture: texture_2d_array<T>) -> vec2<i32> where: T is f32, i32 or u32
|
||||
|
@ -607,17 +607,17 @@ TEST_F(IntrinsicTableTest, OverloadOrderByMatchingParameter) {
|
|||
R"(error: no matching call to textureDimensions(texture_depth_2d, bool)
|
||||
|
||||
27 candidate functions:
|
||||
textureDimensions(texture: texture_depth_2d, level: i32) -> vec2<i32>
|
||||
textureDimensions(texture: texture_depth_2d, level: C) -> vec2<i32> where: C is i32 or u32
|
||||
textureDimensions(texture: texture_1d<T>, level: C) -> i32 where: T is f32, i32 or u32, C is i32 or u32
|
||||
textureDimensions(texture: texture_2d<T>, level: C) -> vec2<i32> where: T is f32, i32 or u32, C is i32 or u32
|
||||
textureDimensions(texture: texture_2d_array<T>, level: C) -> vec2<i32> where: T is f32, i32 or u32, C is i32 or u32
|
||||
textureDimensions(texture: texture_3d<T>, level: C) -> vec3<i32> where: T is f32, i32 or u32, C is i32 or u32
|
||||
textureDimensions(texture: texture_cube<T>, level: C) -> vec2<i32> where: T is f32, i32 or u32, C is i32 or u32
|
||||
textureDimensions(texture: texture_cube_array<T>, level: C) -> vec2<i32> where: T is f32, i32 or u32, C is i32 or u32
|
||||
textureDimensions(texture: texture_depth_2d_array, level: C) -> vec2<i32> where: C is i32 or u32
|
||||
textureDimensions(texture: texture_depth_cube, level: C) -> vec2<i32> where: C is i32 or u32
|
||||
textureDimensions(texture: texture_depth_cube_array, level: C) -> vec2<i32> where: C is i32 or u32
|
||||
textureDimensions(texture: texture_depth_2d) -> vec2<i32>
|
||||
textureDimensions(texture: texture_1d<T>, level: i32) -> i32 where: T is f32, i32 or u32
|
||||
textureDimensions(texture: texture_2d<T>, level: i32) -> vec2<i32> where: T is f32, i32 or u32
|
||||
textureDimensions(texture: texture_2d_array<T>, level: i32) -> vec2<i32> where: T is f32, i32 or u32
|
||||
textureDimensions(texture: texture_3d<T>, level: i32) -> vec3<i32> where: T is f32, i32 or u32
|
||||
textureDimensions(texture: texture_cube<T>, level: i32) -> vec2<i32> where: T is f32, i32 or u32
|
||||
textureDimensions(texture: texture_cube_array<T>, level: i32) -> vec2<i32> where: T is f32, i32 or u32
|
||||
textureDimensions(texture: texture_depth_2d_array, level: i32) -> vec2<i32>
|
||||
textureDimensions(texture: texture_depth_cube, level: i32) -> vec2<i32>
|
||||
textureDimensions(texture: texture_depth_cube_array, level: i32) -> vec2<i32>
|
||||
textureDimensions(texture: texture_1d<T>) -> i32 where: T is f32, i32 or u32
|
||||
textureDimensions(texture: texture_2d<T>) -> vec2<i32> where: T is f32, i32 or u32
|
||||
textureDimensions(texture: texture_2d_array<T>) -> vec2<i32> where: T is f32, i32 or u32
|
||||
|
|
|
@ -58,8 +58,8 @@ struct MultiplanarExternalTexture::State {
|
|||
/// Symbol for the ExternalTextureParams struct
|
||||
Symbol params_struct_sym;
|
||||
|
||||
/// Symbol for the textureLoadExternal function
|
||||
Symbol texture_load_external_sym;
|
||||
/// Symbol for the textureLoadExternal functions
|
||||
utils::Hashmap<const sem::CallTarget*, Symbol, 2> texture_load_external_fns;
|
||||
|
||||
/// Symbol for the textureSampleExternal function
|
||||
Symbol texture_sample_external_sym;
|
||||
|
@ -199,7 +199,7 @@ struct MultiplanarExternalTexture::State {
|
|||
|
||||
switch (builtin->Type()) {
|
||||
case sem::BuiltinType::kTextureLoad:
|
||||
return createTextureLoad(expr, syms);
|
||||
return createTextureLoad(call, syms);
|
||||
case sem::BuiltinType::kTextureSampleLevel:
|
||||
return createTextureSampleLevel(expr, syms);
|
||||
case sem::BuiltinType::kTextureSampleBaseClampToEdge:
|
||||
|
@ -307,11 +307,11 @@ struct MultiplanarExternalTexture::State {
|
|||
case sem::BuiltinType::kTextureSampleLevel:
|
||||
// TODO(crbug.com/tint/1671): DEPRECATED
|
||||
// textureSampleLevel(plane0, smp, coord, 0.0);
|
||||
single_plane_call = b.Call("textureSampleLevel", "plane0", "smp", "coord", 0_f);
|
||||
single_plane_call = b.Call("textureSampleLevel", "plane0", "smp", "coord", 0_a);
|
||||
// textureSampleLevel(plane0, smp, coord, 0.0);
|
||||
plane_0_call = b.Call("textureSampleLevel", "plane0", "smp", "coord", 0_f);
|
||||
plane_0_call = b.Call("textureSampleLevel", "plane0", "smp", "coord", 0_a);
|
||||
// textureSampleLevel(plane1, smp, coord, 0.0);
|
||||
plane_1_call = b.Call("textureSampleLevel", "plane1", "smp", "coord", 0_f);
|
||||
plane_1_call = b.Call("textureSampleLevel", "plane1", "smp", "coord", 0_a);
|
||||
break;
|
||||
case sem::BuiltinType::kTextureSampleBaseClampToEdge:
|
||||
stmts.Push(b.Decl(b.Let(
|
||||
|
@ -333,19 +333,19 @@ struct MultiplanarExternalTexture::State {
|
|||
|
||||
// textureSampleLevel(plane0, smp, plane0_clamped, 0.0);
|
||||
single_plane_call =
|
||||
b.Call("textureSampleLevel", "plane0", "smp", "plane0_clamped", 0_f);
|
||||
b.Call("textureSampleLevel", "plane0", "smp", "plane0_clamped", 0_a);
|
||||
// textureSampleLevel(plane0, smp, plane0_clamped, 0.0);
|
||||
plane_0_call = b.Call("textureSampleLevel", "plane0", "smp", "plane0_clamped", 0_f);
|
||||
plane_0_call = b.Call("textureSampleLevel", "plane0", "smp", "plane0_clamped", 0_a);
|
||||
// textureSampleLevel(plane1, smp, plane1_clamped, 0.0);
|
||||
plane_1_call = b.Call("textureSampleLevel", "plane1", "smp", "plane1_clamped", 0_f);
|
||||
plane_1_call = b.Call("textureSampleLevel", "plane1", "smp", "plane1_clamped", 0_a);
|
||||
break;
|
||||
case sem::BuiltinType::kTextureLoad:
|
||||
// textureLoad(plane0, coord, 0);
|
||||
single_plane_call = b.Call("textureLoad", "plane0", "coord", 0_i);
|
||||
single_plane_call = b.Call("textureLoad", "plane0", "coord", 0_a);
|
||||
// textureLoad(plane0, coord, 0);
|
||||
plane_0_call = b.Call("textureLoad", "plane0", "coord", 0_i);
|
||||
plane_0_call = b.Call("textureLoad", "plane0", "coord", 0_a);
|
||||
// textureLoad(plane1, coord, 0);
|
||||
plane_1_call = b.Call("textureLoad", "plane1", "coord", 0_i);
|
||||
plane_1_call = b.Call("textureLoad", "plane1", "coord", 0_a);
|
||||
break;
|
||||
default:
|
||||
TINT_ICE(Transform, b.Diagnostics()) << "unhandled builtin: " << call_type;
|
||||
|
@ -356,7 +356,7 @@ struct MultiplanarExternalTexture::State {
|
|||
|
||||
// if ((params.numPlanes == 1u))
|
||||
stmts.Push(
|
||||
b.If(b.Equal(b.MemberAccessor("params", "numPlanes"), b.Expr(1_u)),
|
||||
b.If(b.Equal(b.MemberAccessor("params", "numPlanes"), b.Expr(1_a)),
|
||||
b.Block(
|
||||
// color = textureLoad(plane0, coord, 0).rgb;
|
||||
b.Assign("color", b.MemberAccessor(single_plane_call, "rgb"))),
|
||||
|
@ -365,12 +365,12 @@ struct MultiplanarExternalTexture::State {
|
|||
// params.yuvToRgbConversionMatrix;
|
||||
b.Assign("color",
|
||||
b.Mul(b.vec4<f32>(b.MemberAccessor(plane_0_call, "r"),
|
||||
b.MemberAccessor(plane_1_call, "rg"), 1_f),
|
||||
b.MemberAccessor(plane_1_call, "rg"), 1_a),
|
||||
b.MemberAccessor("params", "yuvToRgbConversionMatrix")))))));
|
||||
|
||||
// if (params.doYuvToRgbConversionOnly == 0u)
|
||||
stmts.Push(
|
||||
b.If(b.Equal(b.MemberAccessor("params", "doYuvToRgbConversionOnly"), b.Expr(0_u)),
|
||||
b.If(b.Equal(b.MemberAccessor("params", "doYuvToRgbConversionOnly"), b.Expr(0_a)),
|
||||
b.Block(
|
||||
// color = gammaConversion(color, gammaDecodeParams);
|
||||
b.Assign("color", b.Call("gammaCorrection", "color",
|
||||
|
@ -383,7 +383,7 @@ struct MultiplanarExternalTexture::State {
|
|||
b.MemberAccessor("params", "gammaEncodeParams"))))));
|
||||
|
||||
// return vec4<f32>(color, 1.f);
|
||||
stmts.Push(b.Return(b.vec4<f32>("color", 1_f)));
|
||||
stmts.Push(b.Return(b.vec4<f32>("color", 1_a)));
|
||||
|
||||
return stmts;
|
||||
}
|
||||
|
@ -485,44 +485,48 @@ struct MultiplanarExternalTexture::State {
|
|||
}
|
||||
|
||||
/// Creates the textureLoadExternal function if needed and returns a call expression to it.
|
||||
/// @param expr the call expression being transformed
|
||||
/// @param call the call expression being transformed
|
||||
/// @param syms the expanded symbols to be used in the new call
|
||||
/// @returns a call expression to textureLoadExternal
|
||||
const ast::CallExpression* createTextureLoad(const ast::CallExpression* expr,
|
||||
NewBindingSymbols syms) {
|
||||
const ast::Expression* plane_0_binding_param = ctx.Clone(expr->args[0]);
|
||||
|
||||
if (expr->args.Length() != 2) {
|
||||
const ast::CallExpression* createTextureLoad(const sem::Call* call, NewBindingSymbols syms) {
|
||||
if (call->Arguments().Length() != 2) {
|
||||
TINT_ICE(Transform, b.Diagnostics())
|
||||
<< "expected textureLoad call with a texture_external "
|
||||
"to have 2 parameters, found "
|
||||
<< expr->args.Length() << " parameters";
|
||||
<< "expected textureLoad call with a texture_external to have 2 arguments, found "
|
||||
<< call->Arguments().Length() << " arguments";
|
||||
}
|
||||
|
||||
// TextureLoadExternal calls the gammaCorrection function, so ensure it
|
||||
// exists.
|
||||
auto& args = call->Arguments();
|
||||
|
||||
// TextureLoadExternal calls the gammaCorrection function, so ensure it exists.
|
||||
if (!gamma_correction_sym.IsValid()) {
|
||||
createGammaCorrectionFn();
|
||||
}
|
||||
|
||||
if (!texture_load_external_sym.IsValid()) {
|
||||
texture_load_external_sym = b.Symbols().New("textureLoadExternal");
|
||||
auto texture_load_external_sym = texture_load_external_fns.GetOrCreate(call->Target(), [&] {
|
||||
auto& sig = call->Target()->Signature();
|
||||
auto* coord_ty = sig.Parameter(sem::ParameterUsage::kCoords)->Type();
|
||||
|
||||
// Emit the textureLoadExternal function.
|
||||
auto name = b.Symbols().New("textureLoadExternal");
|
||||
|
||||
// Emit the textureLoadExternal() function.
|
||||
b.Func(
|
||||
texture_load_external_sym,
|
||||
name,
|
||||
utils::Vector{
|
||||
b.Param("plane0", b.ty.sampled_texture(ast::TextureDimension::k2d, b.ty.f32())),
|
||||
b.Param("plane1", b.ty.sampled_texture(ast::TextureDimension::k2d, b.ty.f32())),
|
||||
b.Param("coord", b.ty.vec2(b.ty.i32())),
|
||||
b.Param("coord", CreateASTTypeFor(ctx, coord_ty)),
|
||||
b.Param("params", b.ty.type_name(params_struct_sym)),
|
||||
},
|
||||
b.ty.vec4(b.ty.f32()), //
|
||||
buildTextureBuiltinBody(sem::BuiltinType::kTextureLoad));
|
||||
}
|
||||
|
||||
return b.Call(texture_load_external_sym, plane_0_binding_param, syms.plane_1,
|
||||
ctx.Clone(expr->args[1]), syms.params);
|
||||
return name;
|
||||
});
|
||||
|
||||
auto plane_0_binding_arg = ctx.Clone(args[0]->Declaration());
|
||||
|
||||
return b.Call(texture_load_external_sym, plane_0_binding_arg, syms.plane_1,
|
||||
ctx.Clone(args[1]->Declaration()), syms.params);
|
||||
}
|
||||
};
|
||||
|
||||
|
|
|
@ -291,17 +291,17 @@ fn gammaCorrection(v : vec3<f32>, params : GammaTransferParams) -> vec3<f32> {
|
|||
|
||||
fn textureSampleExternal(plane0 : texture_2d<f32>, plane1 : texture_2d<f32>, smp : sampler, coord : vec2<f32>, params : ExternalTextureParams) -> vec4<f32> {
|
||||
var color : vec3<f32>;
|
||||
if ((params.numPlanes == 1u)) {
|
||||
color = textureSampleLevel(plane0, smp, coord, 0.0f).rgb;
|
||||
if ((params.numPlanes == 1)) {
|
||||
color = textureSampleLevel(plane0, smp, coord, 0).rgb;
|
||||
} else {
|
||||
color = (vec4<f32>(textureSampleLevel(plane0, smp, coord, 0.0f).r, textureSampleLevel(plane1, smp, coord, 0.0f).rg, 1.0f) * params.yuvToRgbConversionMatrix);
|
||||
color = (vec4<f32>(textureSampleLevel(plane0, smp, coord, 0).r, textureSampleLevel(plane1, smp, coord, 0).rg, 1) * params.yuvToRgbConversionMatrix);
|
||||
}
|
||||
if ((params.doYuvToRgbConversionOnly == 0u)) {
|
||||
if ((params.doYuvToRgbConversionOnly == 0)) {
|
||||
color = gammaCorrection(color, params.gammaDecodeParams);
|
||||
color = (params.gamutConversionMatrix * color);
|
||||
color = gammaCorrection(color, params.gammaEncodeParams);
|
||||
}
|
||||
return vec4<f32>(color, 1.0f);
|
||||
return vec4<f32>(color, 1);
|
||||
}
|
||||
|
||||
@fragment
|
||||
|
@ -373,17 +373,17 @@ fn textureSampleExternal(plane0 : texture_2d<f32>, plane1 : texture_2d<f32>, smp
|
|||
let plane1_half_texel = (vec2<f32>(0.5) / plane1_dims);
|
||||
let plane1_clamped = clamp(coord, plane1_half_texel, (1 - plane1_half_texel));
|
||||
var color : vec3<f32>;
|
||||
if ((params.numPlanes == 1u)) {
|
||||
color = textureSampleLevel(plane0, smp, plane0_clamped, 0.0f).rgb;
|
||||
if ((params.numPlanes == 1)) {
|
||||
color = textureSampleLevel(plane0, smp, plane0_clamped, 0).rgb;
|
||||
} else {
|
||||
color = (vec4<f32>(textureSampleLevel(plane0, smp, plane0_clamped, 0.0f).r, textureSampleLevel(plane1, smp, plane1_clamped, 0.0f).rg, 1.0f) * params.yuvToRgbConversionMatrix);
|
||||
color = (vec4<f32>(textureSampleLevel(plane0, smp, plane0_clamped, 0).r, textureSampleLevel(plane1, smp, plane1_clamped, 0).rg, 1) * params.yuvToRgbConversionMatrix);
|
||||
}
|
||||
if ((params.doYuvToRgbConversionOnly == 0u)) {
|
||||
if ((params.doYuvToRgbConversionOnly == 0)) {
|
||||
color = gammaCorrection(color, params.gammaDecodeParams);
|
||||
color = (params.gamutConversionMatrix * color);
|
||||
color = gammaCorrection(color, params.gammaEncodeParams);
|
||||
}
|
||||
return vec4<f32>(color, 1.0f);
|
||||
return vec4<f32>(color, 1);
|
||||
}
|
||||
|
||||
@fragment
|
||||
|
@ -445,17 +445,17 @@ fn gammaCorrection(v : vec3<f32>, params : GammaTransferParams) -> vec3<f32> {
|
|||
|
||||
fn textureSampleExternal(plane0 : texture_2d<f32>, plane1 : texture_2d<f32>, smp : sampler, coord : vec2<f32>, params : ExternalTextureParams) -> vec4<f32> {
|
||||
var color : vec3<f32>;
|
||||
if ((params.numPlanes == 1u)) {
|
||||
color = textureSampleLevel(plane0, smp, coord, 0.0f).rgb;
|
||||
if ((params.numPlanes == 1)) {
|
||||
color = textureSampleLevel(plane0, smp, coord, 0).rgb;
|
||||
} else {
|
||||
color = (vec4<f32>(textureSampleLevel(plane0, smp, coord, 0.0f).r, textureSampleLevel(plane1, smp, coord, 0.0f).rg, 1.0f) * params.yuvToRgbConversionMatrix);
|
||||
color = (vec4<f32>(textureSampleLevel(plane0, smp, coord, 0).r, textureSampleLevel(plane1, smp, coord, 0).rg, 1) * params.yuvToRgbConversionMatrix);
|
||||
}
|
||||
if ((params.doYuvToRgbConversionOnly == 0u)) {
|
||||
if ((params.doYuvToRgbConversionOnly == 0)) {
|
||||
color = gammaCorrection(color, params.gammaDecodeParams);
|
||||
color = (params.gamutConversionMatrix * color);
|
||||
color = gammaCorrection(color, params.gammaEncodeParams);
|
||||
}
|
||||
return vec4<f32>(color, 1.0f);
|
||||
return vec4<f32>(color, 1);
|
||||
}
|
||||
|
||||
@fragment
|
||||
|
@ -527,17 +527,17 @@ fn textureSampleExternal(plane0 : texture_2d<f32>, plane1 : texture_2d<f32>, smp
|
|||
let plane1_half_texel = (vec2<f32>(0.5) / plane1_dims);
|
||||
let plane1_clamped = clamp(coord, plane1_half_texel, (1 - plane1_half_texel));
|
||||
var color : vec3<f32>;
|
||||
if ((params.numPlanes == 1u)) {
|
||||
color = textureSampleLevel(plane0, smp, plane0_clamped, 0.0f).rgb;
|
||||
if ((params.numPlanes == 1)) {
|
||||
color = textureSampleLevel(plane0, smp, plane0_clamped, 0).rgb;
|
||||
} else {
|
||||
color = (vec4<f32>(textureSampleLevel(plane0, smp, plane0_clamped, 0.0f).r, textureSampleLevel(plane1, smp, plane1_clamped, 0.0f).rg, 1.0f) * params.yuvToRgbConversionMatrix);
|
||||
color = (vec4<f32>(textureSampleLevel(plane0, smp, plane0_clamped, 0).r, textureSampleLevel(plane1, smp, plane1_clamped, 0).rg, 1) * params.yuvToRgbConversionMatrix);
|
||||
}
|
||||
if ((params.doYuvToRgbConversionOnly == 0u)) {
|
||||
if ((params.doYuvToRgbConversionOnly == 0)) {
|
||||
color = gammaCorrection(color, params.gammaDecodeParams);
|
||||
color = (params.gamutConversionMatrix * color);
|
||||
color = gammaCorrection(color, params.gammaEncodeParams);
|
||||
}
|
||||
return vec4<f32>(color, 1.0f);
|
||||
return vec4<f32>(color, 1);
|
||||
}
|
||||
|
||||
@fragment
|
||||
|
@ -564,7 +564,9 @@ TEST_F(MultiplanarExternalTextureTest, BasicTextureLoad) {
|
|||
|
||||
@fragment
|
||||
fn main(@builtin(position) coord : vec4<f32>) -> @location(0) vec4<f32> {
|
||||
return textureLoad(ext_tex, vec2<i32>(1, 1));
|
||||
var signed = textureLoad(ext_tex, vec2<i32>(1));
|
||||
var unsigned = textureLoad(ext_tex, vec2<u32>(1));
|
||||
return signed + unsigned;
|
||||
}
|
||||
)";
|
||||
|
||||
|
@ -604,22 +606,39 @@ fn gammaCorrection(v : vec3<f32>, params : GammaTransferParams) -> vec3<f32> {
|
|||
|
||||
fn textureLoadExternal(plane0 : texture_2d<f32>, plane1 : texture_2d<f32>, coord : vec2<i32>, params : ExternalTextureParams) -> vec4<f32> {
|
||||
var color : vec3<f32>;
|
||||
if ((params.numPlanes == 1u)) {
|
||||
color = textureLoad(plane0, coord, 0i).rgb;
|
||||
if ((params.numPlanes == 1)) {
|
||||
color = textureLoad(plane0, coord, 0).rgb;
|
||||
} else {
|
||||
color = (vec4<f32>(textureLoad(plane0, coord, 0i).r, textureLoad(plane1, coord, 0i).rg, 1.0f) * params.yuvToRgbConversionMatrix);
|
||||
color = (vec4<f32>(textureLoad(plane0, coord, 0).r, textureLoad(plane1, coord, 0).rg, 1) * params.yuvToRgbConversionMatrix);
|
||||
}
|
||||
if ((params.doYuvToRgbConversionOnly == 0u)) {
|
||||
if ((params.doYuvToRgbConversionOnly == 0)) {
|
||||
color = gammaCorrection(color, params.gammaDecodeParams);
|
||||
color = (params.gamutConversionMatrix * color);
|
||||
color = gammaCorrection(color, params.gammaEncodeParams);
|
||||
}
|
||||
return vec4<f32>(color, 1.0f);
|
||||
return vec4<f32>(color, 1);
|
||||
}
|
||||
|
||||
fn textureLoadExternal_1(plane0 : texture_2d<f32>, plane1 : texture_2d<f32>, coord : vec2<u32>, params : ExternalTextureParams) -> vec4<f32> {
|
||||
var color : vec3<f32>;
|
||||
if ((params.numPlanes == 1)) {
|
||||
color = textureLoad(plane0, coord, 0).rgb;
|
||||
} else {
|
||||
color = (vec4<f32>(textureLoad(plane0, coord, 0).r, textureLoad(plane1, coord, 0).rg, 1) * params.yuvToRgbConversionMatrix);
|
||||
}
|
||||
if ((params.doYuvToRgbConversionOnly == 0)) {
|
||||
color = gammaCorrection(color, params.gammaDecodeParams);
|
||||
color = (params.gamutConversionMatrix * color);
|
||||
color = gammaCorrection(color, params.gammaEncodeParams);
|
||||
}
|
||||
return vec4<f32>(color, 1);
|
||||
}
|
||||
|
||||
@fragment
|
||||
fn main(@builtin(position) coord : vec4<f32>) -> @location(0) vec4<f32> {
|
||||
return textureLoadExternal(ext_tex, ext_tex_plane_1, vec2<i32>(1, 1), ext_tex_params);
|
||||
var signed = textureLoadExternal(ext_tex, ext_tex_plane_1, vec2<i32>(1), ext_tex_params);
|
||||
var unsigned = textureLoadExternal_1(ext_tex, ext_tex_plane_1, vec2<u32>(1), ext_tex_params);
|
||||
return (signed + unsigned);
|
||||
}
|
||||
)";
|
||||
|
||||
|
@ -635,7 +654,9 @@ TEST_F(MultiplanarExternalTextureTest, BasicTextureLoad_OutOfOrder) {
|
|||
auto* src = R"(
|
||||
@fragment
|
||||
fn main(@builtin(position) coord : vec4<f32>) -> @location(0) vec4<f32> {
|
||||
return textureLoad(ext_tex, vec2<i32>(1, 1));
|
||||
var signed = textureLoad(ext_tex, vec2<i32>(1));
|
||||
var unsigned = textureLoad(ext_tex, vec2<u32>(1));
|
||||
return signed + unsigned;
|
||||
}
|
||||
|
||||
@group(0) @binding(0) var ext_tex : texture_external;
|
||||
|
@ -675,22 +696,39 @@ fn gammaCorrection(v : vec3<f32>, params : GammaTransferParams) -> vec3<f32> {
|
|||
|
||||
fn textureLoadExternal(plane0 : texture_2d<f32>, plane1 : texture_2d<f32>, coord : vec2<i32>, params : ExternalTextureParams) -> vec4<f32> {
|
||||
var color : vec3<f32>;
|
||||
if ((params.numPlanes == 1u)) {
|
||||
color = textureLoad(plane0, coord, 0i).rgb;
|
||||
if ((params.numPlanes == 1)) {
|
||||
color = textureLoad(plane0, coord, 0).rgb;
|
||||
} else {
|
||||
color = (vec4<f32>(textureLoad(plane0, coord, 0i).r, textureLoad(plane1, coord, 0i).rg, 1.0f) * params.yuvToRgbConversionMatrix);
|
||||
color = (vec4<f32>(textureLoad(plane0, coord, 0).r, textureLoad(plane1, coord, 0).rg, 1) * params.yuvToRgbConversionMatrix);
|
||||
}
|
||||
if ((params.doYuvToRgbConversionOnly == 0u)) {
|
||||
if ((params.doYuvToRgbConversionOnly == 0)) {
|
||||
color = gammaCorrection(color, params.gammaDecodeParams);
|
||||
color = (params.gamutConversionMatrix * color);
|
||||
color = gammaCorrection(color, params.gammaEncodeParams);
|
||||
}
|
||||
return vec4<f32>(color, 1.0f);
|
||||
return vec4<f32>(color, 1);
|
||||
}
|
||||
|
||||
fn textureLoadExternal_1(plane0 : texture_2d<f32>, plane1 : texture_2d<f32>, coord : vec2<u32>, params : ExternalTextureParams) -> vec4<f32> {
|
||||
var color : vec3<f32>;
|
||||
if ((params.numPlanes == 1)) {
|
||||
color = textureLoad(plane0, coord, 0).rgb;
|
||||
} else {
|
||||
color = (vec4<f32>(textureLoad(plane0, coord, 0).r, textureLoad(plane1, coord, 0).rg, 1) * params.yuvToRgbConversionMatrix);
|
||||
}
|
||||
if ((params.doYuvToRgbConversionOnly == 0)) {
|
||||
color = gammaCorrection(color, params.gammaDecodeParams);
|
||||
color = (params.gamutConversionMatrix * color);
|
||||
color = gammaCorrection(color, params.gammaEncodeParams);
|
||||
}
|
||||
return vec4<f32>(color, 1);
|
||||
}
|
||||
|
||||
@fragment
|
||||
fn main(@builtin(position) coord : vec4<f32>) -> @location(0) vec4<f32> {
|
||||
return textureLoadExternal(ext_tex, ext_tex_plane_1, vec2<i32>(1, 1), ext_tex_params);
|
||||
var signed = textureLoadExternal(ext_tex, ext_tex_plane_1, vec2<i32>(1), ext_tex_params);
|
||||
var unsigned = textureLoadExternal_1(ext_tex, ext_tex_plane_1, vec2<u32>(1), ext_tex_params);
|
||||
return (signed + unsigned);
|
||||
}
|
||||
|
||||
@group(0) @binding(0) var ext_tex : texture_2d<f32>;
|
||||
|
@ -753,32 +791,32 @@ fn gammaCorrection(v : vec3<f32>, params : GammaTransferParams) -> vec3<f32> {
|
|||
|
||||
fn textureSampleExternal(plane0 : texture_2d<f32>, plane1 : texture_2d<f32>, smp : sampler, coord : vec2<f32>, params : ExternalTextureParams) -> vec4<f32> {
|
||||
var color : vec3<f32>;
|
||||
if ((params.numPlanes == 1u)) {
|
||||
color = textureSampleLevel(plane0, smp, coord, 0.0f).rgb;
|
||||
if ((params.numPlanes == 1)) {
|
||||
color = textureSampleLevel(plane0, smp, coord, 0).rgb;
|
||||
} else {
|
||||
color = (vec4<f32>(textureSampleLevel(plane0, smp, coord, 0.0f).r, textureSampleLevel(plane1, smp, coord, 0.0f).rg, 1.0f) * params.yuvToRgbConversionMatrix);
|
||||
color = (vec4<f32>(textureSampleLevel(plane0, smp, coord, 0).r, textureSampleLevel(plane1, smp, coord, 0).rg, 1) * params.yuvToRgbConversionMatrix);
|
||||
}
|
||||
if ((params.doYuvToRgbConversionOnly == 0u)) {
|
||||
if ((params.doYuvToRgbConversionOnly == 0)) {
|
||||
color = gammaCorrection(color, params.gammaDecodeParams);
|
||||
color = (params.gamutConversionMatrix * color);
|
||||
color = gammaCorrection(color, params.gammaEncodeParams);
|
||||
}
|
||||
return vec4<f32>(color, 1.0f);
|
||||
return vec4<f32>(color, 1);
|
||||
}
|
||||
|
||||
fn textureLoadExternal(plane0 : texture_2d<f32>, plane1 : texture_2d<f32>, coord : vec2<i32>, params : ExternalTextureParams) -> vec4<f32> {
|
||||
var color : vec3<f32>;
|
||||
if ((params.numPlanes == 1u)) {
|
||||
color = textureLoad(plane0, coord, 0i).rgb;
|
||||
if ((params.numPlanes == 1)) {
|
||||
color = textureLoad(plane0, coord, 0).rgb;
|
||||
} else {
|
||||
color = (vec4<f32>(textureLoad(plane0, coord, 0i).r, textureLoad(plane1, coord, 0i).rg, 1.0f) * params.yuvToRgbConversionMatrix);
|
||||
color = (vec4<f32>(textureLoad(plane0, coord, 0).r, textureLoad(plane1, coord, 0).rg, 1) * params.yuvToRgbConversionMatrix);
|
||||
}
|
||||
if ((params.doYuvToRgbConversionOnly == 0u)) {
|
||||
if ((params.doYuvToRgbConversionOnly == 0)) {
|
||||
color = gammaCorrection(color, params.gammaDecodeParams);
|
||||
color = (params.gamutConversionMatrix * color);
|
||||
color = gammaCorrection(color, params.gammaEncodeParams);
|
||||
}
|
||||
return vec4<f32>(color, 1.0f);
|
||||
return vec4<f32>(color, 1);
|
||||
}
|
||||
|
||||
@fragment
|
||||
|
@ -850,32 +888,32 @@ fn textureSampleExternal(plane0 : texture_2d<f32>, plane1 : texture_2d<f32>, smp
|
|||
let plane1_half_texel = (vec2<f32>(0.5) / plane1_dims);
|
||||
let plane1_clamped = clamp(coord, plane1_half_texel, (1 - plane1_half_texel));
|
||||
var color : vec3<f32>;
|
||||
if ((params.numPlanes == 1u)) {
|
||||
color = textureSampleLevel(plane0, smp, plane0_clamped, 0.0f).rgb;
|
||||
if ((params.numPlanes == 1)) {
|
||||
color = textureSampleLevel(plane0, smp, plane0_clamped, 0).rgb;
|
||||
} else {
|
||||
color = (vec4<f32>(textureSampleLevel(plane0, smp, plane0_clamped, 0.0f).r, textureSampleLevel(plane1, smp, plane1_clamped, 0.0f).rg, 1.0f) * params.yuvToRgbConversionMatrix);
|
||||
color = (vec4<f32>(textureSampleLevel(plane0, smp, plane0_clamped, 0).r, textureSampleLevel(plane1, smp, plane1_clamped, 0).rg, 1) * params.yuvToRgbConversionMatrix);
|
||||
}
|
||||
if ((params.doYuvToRgbConversionOnly == 0u)) {
|
||||
if ((params.doYuvToRgbConversionOnly == 0)) {
|
||||
color = gammaCorrection(color, params.gammaDecodeParams);
|
||||
color = (params.gamutConversionMatrix * color);
|
||||
color = gammaCorrection(color, params.gammaEncodeParams);
|
||||
}
|
||||
return vec4<f32>(color, 1.0f);
|
||||
return vec4<f32>(color, 1);
|
||||
}
|
||||
|
||||
fn textureLoadExternal(plane0 : texture_2d<f32>, plane1 : texture_2d<f32>, coord : vec2<i32>, params : ExternalTextureParams) -> vec4<f32> {
|
||||
var color : vec3<f32>;
|
||||
if ((params.numPlanes == 1u)) {
|
||||
color = textureLoad(plane0, coord, 0i).rgb;
|
||||
if ((params.numPlanes == 1)) {
|
||||
color = textureLoad(plane0, coord, 0).rgb;
|
||||
} else {
|
||||
color = (vec4<f32>(textureLoad(plane0, coord, 0i).r, textureLoad(plane1, coord, 0i).rg, 1.0f) * params.yuvToRgbConversionMatrix);
|
||||
color = (vec4<f32>(textureLoad(plane0, coord, 0).r, textureLoad(plane1, coord, 0).rg, 1) * params.yuvToRgbConversionMatrix);
|
||||
}
|
||||
if ((params.doYuvToRgbConversionOnly == 0u)) {
|
||||
if ((params.doYuvToRgbConversionOnly == 0)) {
|
||||
color = gammaCorrection(color, params.gammaDecodeParams);
|
||||
color = (params.gamutConversionMatrix * color);
|
||||
color = gammaCorrection(color, params.gammaEncodeParams);
|
||||
}
|
||||
return vec4<f32>(color, 1.0f);
|
||||
return vec4<f32>(color, 1);
|
||||
}
|
||||
|
||||
@fragment
|
||||
|
@ -937,32 +975,32 @@ fn gammaCorrection(v : vec3<f32>, params : GammaTransferParams) -> vec3<f32> {
|
|||
|
||||
fn textureSampleExternal(plane0 : texture_2d<f32>, plane1 : texture_2d<f32>, smp : sampler, coord : vec2<f32>, params : ExternalTextureParams) -> vec4<f32> {
|
||||
var color : vec3<f32>;
|
||||
if ((params.numPlanes == 1u)) {
|
||||
color = textureSampleLevel(plane0, smp, coord, 0.0f).rgb;
|
||||
if ((params.numPlanes == 1)) {
|
||||
color = textureSampleLevel(plane0, smp, coord, 0).rgb;
|
||||
} else {
|
||||
color = (vec4<f32>(textureSampleLevel(plane0, smp, coord, 0.0f).r, textureSampleLevel(plane1, smp, coord, 0.0f).rg, 1.0f) * params.yuvToRgbConversionMatrix);
|
||||
color = (vec4<f32>(textureSampleLevel(plane0, smp, coord, 0).r, textureSampleLevel(plane1, smp, coord, 0).rg, 1) * params.yuvToRgbConversionMatrix);
|
||||
}
|
||||
if ((params.doYuvToRgbConversionOnly == 0u)) {
|
||||
if ((params.doYuvToRgbConversionOnly == 0)) {
|
||||
color = gammaCorrection(color, params.gammaDecodeParams);
|
||||
color = (params.gamutConversionMatrix * color);
|
||||
color = gammaCorrection(color, params.gammaEncodeParams);
|
||||
}
|
||||
return vec4<f32>(color, 1.0f);
|
||||
return vec4<f32>(color, 1);
|
||||
}
|
||||
|
||||
fn textureLoadExternal(plane0 : texture_2d<f32>, plane1 : texture_2d<f32>, coord : vec2<i32>, params : ExternalTextureParams) -> vec4<f32> {
|
||||
var color : vec3<f32>;
|
||||
if ((params.numPlanes == 1u)) {
|
||||
color = textureLoad(plane0, coord, 0i).rgb;
|
||||
if ((params.numPlanes == 1)) {
|
||||
color = textureLoad(plane0, coord, 0).rgb;
|
||||
} else {
|
||||
color = (vec4<f32>(textureLoad(plane0, coord, 0i).r, textureLoad(plane1, coord, 0i).rg, 1.0f) * params.yuvToRgbConversionMatrix);
|
||||
color = (vec4<f32>(textureLoad(plane0, coord, 0).r, textureLoad(plane1, coord, 0).rg, 1) * params.yuvToRgbConversionMatrix);
|
||||
}
|
||||
if ((params.doYuvToRgbConversionOnly == 0u)) {
|
||||
if ((params.doYuvToRgbConversionOnly == 0)) {
|
||||
color = gammaCorrection(color, params.gammaDecodeParams);
|
||||
color = (params.gamutConversionMatrix * color);
|
||||
color = gammaCorrection(color, params.gammaEncodeParams);
|
||||
}
|
||||
return vec4<f32>(color, 1.0f);
|
||||
return vec4<f32>(color, 1);
|
||||
}
|
||||
|
||||
@fragment
|
||||
|
@ -1034,32 +1072,32 @@ fn textureSampleExternal(plane0 : texture_2d<f32>, plane1 : texture_2d<f32>, smp
|
|||
let plane1_half_texel = (vec2<f32>(0.5) / plane1_dims);
|
||||
let plane1_clamped = clamp(coord, plane1_half_texel, (1 - plane1_half_texel));
|
||||
var color : vec3<f32>;
|
||||
if ((params.numPlanes == 1u)) {
|
||||
color = textureSampleLevel(plane0, smp, plane0_clamped, 0.0f).rgb;
|
||||
if ((params.numPlanes == 1)) {
|
||||
color = textureSampleLevel(plane0, smp, plane0_clamped, 0).rgb;
|
||||
} else {
|
||||
color = (vec4<f32>(textureSampleLevel(plane0, smp, plane0_clamped, 0.0f).r, textureSampleLevel(plane1, smp, plane1_clamped, 0.0f).rg, 1.0f) * params.yuvToRgbConversionMatrix);
|
||||
color = (vec4<f32>(textureSampleLevel(plane0, smp, plane0_clamped, 0).r, textureSampleLevel(plane1, smp, plane1_clamped, 0).rg, 1) * params.yuvToRgbConversionMatrix);
|
||||
}
|
||||
if ((params.doYuvToRgbConversionOnly == 0u)) {
|
||||
if ((params.doYuvToRgbConversionOnly == 0)) {
|
||||
color = gammaCorrection(color, params.gammaDecodeParams);
|
||||
color = (params.gamutConversionMatrix * color);
|
||||
color = gammaCorrection(color, params.gammaEncodeParams);
|
||||
}
|
||||
return vec4<f32>(color, 1.0f);
|
||||
return vec4<f32>(color, 1);
|
||||
}
|
||||
|
||||
fn textureLoadExternal(plane0 : texture_2d<f32>, plane1 : texture_2d<f32>, coord : vec2<i32>, params : ExternalTextureParams) -> vec4<f32> {
|
||||
var color : vec3<f32>;
|
||||
if ((params.numPlanes == 1u)) {
|
||||
color = textureLoad(plane0, coord, 0i).rgb;
|
||||
if ((params.numPlanes == 1)) {
|
||||
color = textureLoad(plane0, coord, 0).rgb;
|
||||
} else {
|
||||
color = (vec4<f32>(textureLoad(plane0, coord, 0i).r, textureLoad(plane1, coord, 0i).rg, 1.0f) * params.yuvToRgbConversionMatrix);
|
||||
color = (vec4<f32>(textureLoad(plane0, coord, 0).r, textureLoad(plane1, coord, 0).rg, 1) * params.yuvToRgbConversionMatrix);
|
||||
}
|
||||
if ((params.doYuvToRgbConversionOnly == 0u)) {
|
||||
if ((params.doYuvToRgbConversionOnly == 0)) {
|
||||
color = gammaCorrection(color, params.gammaDecodeParams);
|
||||
color = (params.gamutConversionMatrix * color);
|
||||
color = gammaCorrection(color, params.gammaEncodeParams);
|
||||
}
|
||||
return vec4<f32>(color, 1.0f);
|
||||
return vec4<f32>(color, 1);
|
||||
}
|
||||
|
||||
@fragment
|
||||
|
@ -1150,17 +1188,17 @@ fn gammaCorrection(v : vec3<f32>, params : GammaTransferParams) -> vec3<f32> {
|
|||
|
||||
fn textureSampleExternal(plane0 : texture_2d<f32>, plane1 : texture_2d<f32>, smp : sampler, coord : vec2<f32>, params : ExternalTextureParams) -> vec4<f32> {
|
||||
var color : vec3<f32>;
|
||||
if ((params.numPlanes == 1u)) {
|
||||
color = textureSampleLevel(plane0, smp, coord, 0.0f).rgb;
|
||||
if ((params.numPlanes == 1)) {
|
||||
color = textureSampleLevel(plane0, smp, coord, 0).rgb;
|
||||
} else {
|
||||
color = (vec4<f32>(textureSampleLevel(plane0, smp, coord, 0.0f).r, textureSampleLevel(plane1, smp, coord, 0.0f).rg, 1.0f) * params.yuvToRgbConversionMatrix);
|
||||
color = (vec4<f32>(textureSampleLevel(plane0, smp, coord, 0).r, textureSampleLevel(plane1, smp, coord, 0).rg, 1) * params.yuvToRgbConversionMatrix);
|
||||
}
|
||||
if ((params.doYuvToRgbConversionOnly == 0u)) {
|
||||
if ((params.doYuvToRgbConversionOnly == 0)) {
|
||||
color = gammaCorrection(color, params.gammaDecodeParams);
|
||||
color = (params.gamutConversionMatrix * color);
|
||||
color = gammaCorrection(color, params.gammaEncodeParams);
|
||||
}
|
||||
return vec4<f32>(color, 1.0f);
|
||||
return vec4<f32>(color, 1);
|
||||
}
|
||||
|
||||
@fragment
|
||||
|
@ -1260,17 +1298,17 @@ fn textureSampleExternal(plane0 : texture_2d<f32>, plane1 : texture_2d<f32>, smp
|
|||
let plane1_half_texel = (vec2<f32>(0.5) / plane1_dims);
|
||||
let plane1_clamped = clamp(coord, plane1_half_texel, (1 - plane1_half_texel));
|
||||
var color : vec3<f32>;
|
||||
if ((params.numPlanes == 1u)) {
|
||||
color = textureSampleLevel(plane0, smp, plane0_clamped, 0.0f).rgb;
|
||||
if ((params.numPlanes == 1)) {
|
||||
color = textureSampleLevel(plane0, smp, plane0_clamped, 0).rgb;
|
||||
} else {
|
||||
color = (vec4<f32>(textureSampleLevel(plane0, smp, plane0_clamped, 0.0f).r, textureSampleLevel(plane1, smp, plane1_clamped, 0.0f).rg, 1.0f) * params.yuvToRgbConversionMatrix);
|
||||
color = (vec4<f32>(textureSampleLevel(plane0, smp, plane0_clamped, 0).r, textureSampleLevel(plane1, smp, plane1_clamped, 0).rg, 1) * params.yuvToRgbConversionMatrix);
|
||||
}
|
||||
if ((params.doYuvToRgbConversionOnly == 0u)) {
|
||||
if ((params.doYuvToRgbConversionOnly == 0)) {
|
||||
color = gammaCorrection(color, params.gammaDecodeParams);
|
||||
color = (params.gamutConversionMatrix * color);
|
||||
color = gammaCorrection(color, params.gammaEncodeParams);
|
||||
}
|
||||
return vec4<f32>(color, 1.0f);
|
||||
return vec4<f32>(color, 1);
|
||||
}
|
||||
|
||||
@fragment
|
||||
|
@ -1347,17 +1385,17 @@ fn textureSampleExternal(plane0 : texture_2d<f32>, plane1 : texture_2d<f32>, smp
|
|||
let plane1_half_texel = (vec2<f32>(0.5) / plane1_dims);
|
||||
let plane1_clamped = clamp(coord, plane1_half_texel, (1 - plane1_half_texel));
|
||||
var color : vec3<f32>;
|
||||
if ((params.numPlanes == 1u)) {
|
||||
color = textureSampleLevel(plane0, smp, plane0_clamped, 0.0f).rgb;
|
||||
if ((params.numPlanes == 1)) {
|
||||
color = textureSampleLevel(plane0, smp, plane0_clamped, 0).rgb;
|
||||
} else {
|
||||
color = (vec4<f32>(textureSampleLevel(plane0, smp, plane0_clamped, 0.0f).r, textureSampleLevel(plane1, smp, plane1_clamped, 0.0f).rg, 1.0f) * params.yuvToRgbConversionMatrix);
|
||||
color = (vec4<f32>(textureSampleLevel(plane0, smp, plane0_clamped, 0).r, textureSampleLevel(plane1, smp, plane1_clamped, 0).rg, 1) * params.yuvToRgbConversionMatrix);
|
||||
}
|
||||
if ((params.doYuvToRgbConversionOnly == 0u)) {
|
||||
if ((params.doYuvToRgbConversionOnly == 0)) {
|
||||
color = gammaCorrection(color, params.gammaDecodeParams);
|
||||
color = (params.gamutConversionMatrix * color);
|
||||
color = gammaCorrection(color, params.gammaEncodeParams);
|
||||
}
|
||||
return vec4<f32>(color, 1.0f);
|
||||
return vec4<f32>(color, 1);
|
||||
}
|
||||
|
||||
fn f(t : texture_2d<f32>, ext_tex_plane_1_1 : texture_2d<f32>, ext_tex_params_1 : ExternalTextureParams, s : sampler) {
|
||||
|
@ -1443,17 +1481,17 @@ fn textureSampleExternal(plane0 : texture_2d<f32>, plane1 : texture_2d<f32>, smp
|
|||
let plane1_half_texel = (vec2<f32>(0.5) / plane1_dims);
|
||||
let plane1_clamped = clamp(coord, plane1_half_texel, (1 - plane1_half_texel));
|
||||
var color : vec3<f32>;
|
||||
if ((params.numPlanes == 1u)) {
|
||||
color = textureSampleLevel(plane0, smp, plane0_clamped, 0.0f).rgb;
|
||||
if ((params.numPlanes == 1)) {
|
||||
color = textureSampleLevel(plane0, smp, plane0_clamped, 0).rgb;
|
||||
} else {
|
||||
color = (vec4<f32>(textureSampleLevel(plane0, smp, plane0_clamped, 0.0f).r, textureSampleLevel(plane1, smp, plane1_clamped, 0.0f).rg, 1.0f) * params.yuvToRgbConversionMatrix);
|
||||
color = (vec4<f32>(textureSampleLevel(plane0, smp, plane0_clamped, 0).r, textureSampleLevel(plane1, smp, plane1_clamped, 0).rg, 1) * params.yuvToRgbConversionMatrix);
|
||||
}
|
||||
if ((params.doYuvToRgbConversionOnly == 0u)) {
|
||||
if ((params.doYuvToRgbConversionOnly == 0)) {
|
||||
color = gammaCorrection(color, params.gammaDecodeParams);
|
||||
color = (params.gamutConversionMatrix * color);
|
||||
color = gammaCorrection(color, params.gammaEncodeParams);
|
||||
}
|
||||
return vec4<f32>(color, 1.0f);
|
||||
return vec4<f32>(color, 1);
|
||||
}
|
||||
|
||||
fn f(t : texture_2d<f32>, ext_tex_plane_1_1 : texture_2d<f32>, ext_tex_params_1 : ExternalTextureParams, s : sampler) {
|
||||
|
@ -1529,17 +1567,17 @@ fn textureSampleExternal(plane0 : texture_2d<f32>, plane1 : texture_2d<f32>, smp
|
|||
let plane1_half_texel = (vec2<f32>(0.5) / plane1_dims);
|
||||
let plane1_clamped = clamp(coord, plane1_half_texel, (1 - plane1_half_texel));
|
||||
var color : vec3<f32>;
|
||||
if ((params.numPlanes == 1u)) {
|
||||
color = textureSampleLevel(plane0, smp, plane0_clamped, 0.0f).rgb;
|
||||
if ((params.numPlanes == 1)) {
|
||||
color = textureSampleLevel(plane0, smp, plane0_clamped, 0).rgb;
|
||||
} else {
|
||||
color = (vec4<f32>(textureSampleLevel(plane0, smp, plane0_clamped, 0.0f).r, textureSampleLevel(plane1, smp, plane1_clamped, 0.0f).rg, 1.0f) * params.yuvToRgbConversionMatrix);
|
||||
color = (vec4<f32>(textureSampleLevel(plane0, smp, plane0_clamped, 0).r, textureSampleLevel(plane1, smp, plane1_clamped, 0).rg, 1) * params.yuvToRgbConversionMatrix);
|
||||
}
|
||||
if ((params.doYuvToRgbConversionOnly == 0u)) {
|
||||
if ((params.doYuvToRgbConversionOnly == 0)) {
|
||||
color = gammaCorrection(color, params.gammaDecodeParams);
|
||||
color = (params.gamutConversionMatrix * color);
|
||||
color = gammaCorrection(color, params.gammaEncodeParams);
|
||||
}
|
||||
return vec4<f32>(color, 1.0f);
|
||||
return vec4<f32>(color, 1);
|
||||
}
|
||||
|
||||
fn f(s : sampler, t : texture_2d<f32>, ext_tex_plane_1_1 : texture_2d<f32>, ext_tex_params_1 : ExternalTextureParams) {
|
||||
|
@ -1626,17 +1664,17 @@ fn textureSampleExternal(plane0 : texture_2d<f32>, plane1 : texture_2d<f32>, smp
|
|||
let plane1_half_texel = (vec2<f32>(0.5) / plane1_dims);
|
||||
let plane1_clamped = clamp(coord, plane1_half_texel, (1 - plane1_half_texel));
|
||||
var color : vec3<f32>;
|
||||
if ((params.numPlanes == 1u)) {
|
||||
color = textureSampleLevel(plane0, smp, plane0_clamped, 0.0f).rgb;
|
||||
if ((params.numPlanes == 1)) {
|
||||
color = textureSampleLevel(plane0, smp, plane0_clamped, 0).rgb;
|
||||
} else {
|
||||
color = (vec4<f32>(textureSampleLevel(plane0, smp, plane0_clamped, 0.0f).r, textureSampleLevel(plane1, smp, plane1_clamped, 0.0f).rg, 1.0f) * params.yuvToRgbConversionMatrix);
|
||||
color = (vec4<f32>(textureSampleLevel(plane0, smp, plane0_clamped, 0).r, textureSampleLevel(plane1, smp, plane1_clamped, 0).rg, 1) * params.yuvToRgbConversionMatrix);
|
||||
}
|
||||
if ((params.doYuvToRgbConversionOnly == 0u)) {
|
||||
if ((params.doYuvToRgbConversionOnly == 0)) {
|
||||
color = gammaCorrection(color, params.gammaDecodeParams);
|
||||
color = (params.gamutConversionMatrix * color);
|
||||
color = gammaCorrection(color, params.gammaEncodeParams);
|
||||
}
|
||||
return vec4<f32>(color, 1.0f);
|
||||
return vec4<f32>(color, 1);
|
||||
}
|
||||
|
||||
fn f(t : texture_2d<f32>, ext_tex_plane_1_2 : texture_2d<f32>, ext_tex_params_2 : ExternalTextureParams, s : sampler, t2 : texture_2d<f32>, ext_tex_plane_1_3 : texture_2d<f32>, ext_tex_params_3 : ExternalTextureParams) {
|
||||
|
@ -1733,17 +1771,17 @@ fn textureSampleExternal(plane0 : texture_2d<f32>, plane1 : texture_2d<f32>, smp
|
|||
let plane1_half_texel = (vec2<f32>(0.5) / plane1_dims);
|
||||
let plane1_clamped = clamp(coord, plane1_half_texel, (1 - plane1_half_texel));
|
||||
var color : vec3<f32>;
|
||||
if ((params.numPlanes == 1u)) {
|
||||
color = textureSampleLevel(plane0, smp, plane0_clamped, 0.0f).rgb;
|
||||
if ((params.numPlanes == 1)) {
|
||||
color = textureSampleLevel(plane0, smp, plane0_clamped, 0).rgb;
|
||||
} else {
|
||||
color = (vec4<f32>(textureSampleLevel(plane0, smp, plane0_clamped, 0.0f).r, textureSampleLevel(plane1, smp, plane1_clamped, 0.0f).rg, 1.0f) * params.yuvToRgbConversionMatrix);
|
||||
color = (vec4<f32>(textureSampleLevel(plane0, smp, plane0_clamped, 0).r, textureSampleLevel(plane1, smp, plane1_clamped, 0).rg, 1) * params.yuvToRgbConversionMatrix);
|
||||
}
|
||||
if ((params.doYuvToRgbConversionOnly == 0u)) {
|
||||
if ((params.doYuvToRgbConversionOnly == 0)) {
|
||||
color = gammaCorrection(color, params.gammaDecodeParams);
|
||||
color = (params.gamutConversionMatrix * color);
|
||||
color = gammaCorrection(color, params.gammaEncodeParams);
|
||||
}
|
||||
return vec4<f32>(color, 1.0f);
|
||||
return vec4<f32>(color, 1);
|
||||
}
|
||||
|
||||
fn f(t : texture_2d<f32>, ext_tex_plane_1_2 : texture_2d<f32>, ext_tex_params_2 : ExternalTextureParams, s : sampler, t2 : texture_2d<f32>, ext_tex_plane_1_3 : texture_2d<f32>, ext_tex_params_3 : ExternalTextureParams) {
|
||||
|
@ -1827,17 +1865,17 @@ fn textureSampleExternal(plane0 : texture_2d<f32>, plane1 : texture_2d<f32>, smp
|
|||
let plane1_half_texel = (vec2<f32>(0.5) / plane1_dims);
|
||||
let plane1_clamped = clamp(coord, plane1_half_texel, (1 - plane1_half_texel));
|
||||
var color : vec3<f32>;
|
||||
if ((params.numPlanes == 1u)) {
|
||||
color = textureSampleLevel(plane0, smp, plane0_clamped, 0.0f).rgb;
|
||||
if ((params.numPlanes == 1)) {
|
||||
color = textureSampleLevel(plane0, smp, plane0_clamped, 0).rgb;
|
||||
} else {
|
||||
color = (vec4<f32>(textureSampleLevel(plane0, smp, plane0_clamped, 0.0f).r, textureSampleLevel(plane1, smp, plane1_clamped, 0.0f).rg, 1.0f) * params.yuvToRgbConversionMatrix);
|
||||
color = (vec4<f32>(textureSampleLevel(plane0, smp, plane0_clamped, 0).r, textureSampleLevel(plane1, smp, plane1_clamped, 0).rg, 1) * params.yuvToRgbConversionMatrix);
|
||||
}
|
||||
if ((params.doYuvToRgbConversionOnly == 0u)) {
|
||||
if ((params.doYuvToRgbConversionOnly == 0)) {
|
||||
color = gammaCorrection(color, params.gammaDecodeParams);
|
||||
color = (params.gamutConversionMatrix * color);
|
||||
color = gammaCorrection(color, params.gammaEncodeParams);
|
||||
}
|
||||
return vec4<f32>(color, 1.0f);
|
||||
return vec4<f32>(color, 1);
|
||||
}
|
||||
|
||||
fn nested(t : texture_2d<f32>, ext_tex_plane_1_1 : texture_2d<f32>, ext_tex_params_1 : ExternalTextureParams, s : sampler) {
|
||||
|
@ -1926,17 +1964,17 @@ fn textureSampleExternal(plane0 : texture_2d<f32>, plane1 : texture_2d<f32>, smp
|
|||
let plane1_half_texel = (vec2<f32>(0.5) / plane1_dims);
|
||||
let plane1_clamped = clamp(coord, plane1_half_texel, (1 - plane1_half_texel));
|
||||
var color : vec3<f32>;
|
||||
if ((params.numPlanes == 1u)) {
|
||||
color = textureSampleLevel(plane0, smp, plane0_clamped, 0.0f).rgb;
|
||||
if ((params.numPlanes == 1)) {
|
||||
color = textureSampleLevel(plane0, smp, plane0_clamped, 0).rgb;
|
||||
} else {
|
||||
color = (vec4<f32>(textureSampleLevel(plane0, smp, plane0_clamped, 0.0f).r, textureSampleLevel(plane1, smp, plane1_clamped, 0.0f).rg, 1.0f) * params.yuvToRgbConversionMatrix);
|
||||
color = (vec4<f32>(textureSampleLevel(plane0, smp, plane0_clamped, 0).r, textureSampleLevel(plane1, smp, plane1_clamped, 0).rg, 1) * params.yuvToRgbConversionMatrix);
|
||||
}
|
||||
if ((params.doYuvToRgbConversionOnly == 0u)) {
|
||||
if ((params.doYuvToRgbConversionOnly == 0)) {
|
||||
color = gammaCorrection(color, params.gammaDecodeParams);
|
||||
color = (params.gamutConversionMatrix * color);
|
||||
color = gammaCorrection(color, params.gammaEncodeParams);
|
||||
}
|
||||
return vec4<f32>(color, 1.0f);
|
||||
return vec4<f32>(color, 1);
|
||||
}
|
||||
|
||||
fn nested(t : texture_2d<f32>, ext_tex_plane_1_1 : texture_2d<f32>, ext_tex_params_1 : ExternalTextureParams, s : sampler) {
|
||||
|
@ -2066,17 +2104,17 @@ fn textureSampleExternal(plane0 : texture_2d<f32>, plane1 : texture_2d<f32>, smp
|
|||
let plane1_half_texel = (vec2<f32>(0.5) / plane1_dims);
|
||||
let plane1_clamped = clamp(coord, plane1_half_texel, (1 - plane1_half_texel));
|
||||
var color : vec3<f32>;
|
||||
if ((params.numPlanes == 1u)) {
|
||||
color = textureSampleLevel(plane0, smp, plane0_clamped, 0.0f).rgb;
|
||||
if ((params.numPlanes == 1)) {
|
||||
color = textureSampleLevel(plane0, smp, plane0_clamped, 0).rgb;
|
||||
} else {
|
||||
color = (vec4<f32>(textureSampleLevel(plane0, smp, plane0_clamped, 0.0f).r, textureSampleLevel(plane1, smp, plane1_clamped, 0.0f).rg, 1.0f) * params.yuvToRgbConversionMatrix);
|
||||
color = (vec4<f32>(textureSampleLevel(plane0, smp, plane0_clamped, 0).r, textureSampleLevel(plane1, smp, plane1_clamped, 0).rg, 1) * params.yuvToRgbConversionMatrix);
|
||||
}
|
||||
if ((params.doYuvToRgbConversionOnly == 0u)) {
|
||||
if ((params.doYuvToRgbConversionOnly == 0)) {
|
||||
color = gammaCorrection(color, params.gammaDecodeParams);
|
||||
color = (params.gamutConversionMatrix * color);
|
||||
color = gammaCorrection(color, params.gammaEncodeParams);
|
||||
}
|
||||
return vec4<f32>(color, 1.0f);
|
||||
return vec4<f32>(color, 1);
|
||||
}
|
||||
|
||||
fn f(t : texture_2d<f32>, ext_tex_plane_1_1 : texture_2d<f32>, ext_tex_params_1 : ExternalTextureParams, s : sampler) {
|
||||
|
@ -2163,17 +2201,17 @@ fn textureSampleExternal(plane0 : texture_2d<f32>, plane1 : texture_2d<f32>, smp
|
|||
let plane1_half_texel = (vec2<f32>(0.5) / plane1_dims);
|
||||
let plane1_clamped = clamp(coord, plane1_half_texel, (1 - plane1_half_texel));
|
||||
var color : vec3<f32>;
|
||||
if ((params.numPlanes == 1u)) {
|
||||
color = textureSampleLevel(plane0, smp, plane0_clamped, 0.0f).rgb;
|
||||
if ((params.numPlanes == 1)) {
|
||||
color = textureSampleLevel(plane0, smp, plane0_clamped, 0).rgb;
|
||||
} else {
|
||||
color = (vec4<f32>(textureSampleLevel(plane0, smp, plane0_clamped, 0.0f).r, textureSampleLevel(plane1, smp, plane1_clamped, 0.0f).rg, 1.0f) * params.yuvToRgbConversionMatrix);
|
||||
color = (vec4<f32>(textureSampleLevel(plane0, smp, plane0_clamped, 0).r, textureSampleLevel(plane1, smp, plane1_clamped, 0).rg, 1) * params.yuvToRgbConversionMatrix);
|
||||
}
|
||||
if ((params.doYuvToRgbConversionOnly == 0u)) {
|
||||
if ((params.doYuvToRgbConversionOnly == 0)) {
|
||||
color = gammaCorrection(color, params.gammaDecodeParams);
|
||||
color = (params.gamutConversionMatrix * color);
|
||||
color = gammaCorrection(color, params.gammaEncodeParams);
|
||||
}
|
||||
return vec4<f32>(color, 1.0f);
|
||||
return vec4<f32>(color, 1);
|
||||
}
|
||||
|
||||
fn f(t : texture_2d<f32>, ext_tex_plane_1_1 : texture_2d<f32>, ext_tex_params_1 : ExternalTextureParams, s : sampler) {
|
||||
|
|
|
@ -166,6 +166,32 @@ struct Robustness::State {
|
|||
auto* coords_arg = expr->args[static_cast<size_t>(coords_idx)];
|
||||
auto* coords_ty = builtin->Parameters()[static_cast<size_t>(coords_idx)]->Type();
|
||||
|
||||
auto width_of = [&](const sem::Type* ty) {
|
||||
if (auto* vec = ty->As<sem::Vector>()) {
|
||||
return vec->Width();
|
||||
}
|
||||
return 1u;
|
||||
};
|
||||
auto scalar_or_vec_ty = [&](const ast::Type* scalar, uint32_t width) -> const ast::Type* {
|
||||
if (width > 1) {
|
||||
return b.ty.vec(scalar, width);
|
||||
}
|
||||
return scalar;
|
||||
};
|
||||
auto scalar_or_vec = [&](const ast::Expression* scalar,
|
||||
uint32_t width) -> const ast::Expression* {
|
||||
if (width > 1) {
|
||||
return b.Construct(b.ty.vec(nullptr, width), scalar);
|
||||
}
|
||||
return scalar;
|
||||
};
|
||||
auto cast_to_signed = [&](const ast::Expression* val, uint32_t width) {
|
||||
return b.Construct(scalar_or_vec_ty(b.ty.i32(), width), val);
|
||||
};
|
||||
auto cast_to_unsigned = [&](const ast::Expression* val, uint32_t width) {
|
||||
return b.Construct(scalar_or_vec_ty(b.ty.u32(), width), val);
|
||||
};
|
||||
|
||||
// If the level is provided, then we need to clamp this. As the level is
|
||||
// used by textureDimensions() and the texture[Load|Store]() calls, we need
|
||||
// to clamp both usages.
|
||||
|
@ -174,41 +200,68 @@ struct Robustness::State {
|
|||
std::function<const ast::Expression*()> level_arg;
|
||||
if (level_idx >= 0) {
|
||||
level_arg = [&] {
|
||||
auto* arg = expr->args[static_cast<size_t>(level_idx)];
|
||||
auto* num_levels = b.Call("textureNumLevels", ctx.Clone(texture_arg));
|
||||
auto* zero = b.Expr(0_i);
|
||||
auto* max = ctx.dst->Sub(num_levels, 1_i);
|
||||
auto* clamped = b.Call("clamp", ctx.Clone(arg), zero, max);
|
||||
return clamped;
|
||||
const auto* arg = expr->args[static_cast<size_t>(level_idx)];
|
||||
const auto* target_ty =
|
||||
builtin->Parameters()[static_cast<size_t>(level_idx)]->Type();
|
||||
const auto* num_levels = b.Call("textureNumLevels", ctx.Clone(texture_arg));
|
||||
|
||||
// TODO(crbug.com/tint/1526) remove when num_levels returns u32
|
||||
num_levels = cast_to_unsigned(num_levels, 1u);
|
||||
|
||||
const auto* unsigned_max = b.Sub(num_levels, 1_a);
|
||||
if (target_ty->is_signed_integer_scalar()) {
|
||||
const auto* signed_max = cast_to_signed(unsigned_max, 1u);
|
||||
return b.Call("clamp", ctx.Clone(arg), 0_a, signed_max);
|
||||
} else {
|
||||
return b.Call("min", ctx.Clone(arg), unsigned_max);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
// Clamp the coordinates argument
|
||||
{
|
||||
auto* texture_dims =
|
||||
const auto* target_ty = coords_ty;
|
||||
const auto width = width_of(target_ty);
|
||||
const auto* texture_dims =
|
||||
level_arg ? b.Call("textureDimensions", ctx.Clone(texture_arg), level_arg())
|
||||
: b.Call("textureDimensions", ctx.Clone(texture_arg));
|
||||
auto* zero = b.Construct(CreateASTTypeFor(ctx, coords_ty));
|
||||
auto* max =
|
||||
ctx.dst->Sub(texture_dims, b.Construct(CreateASTTypeFor(ctx, coords_ty), 1_i));
|
||||
auto* clamped_coords = b.Call("clamp", ctx.Clone(coords_arg), zero, max);
|
||||
ctx.Replace(coords_arg, clamped_coords);
|
||||
|
||||
// TODO(crbug.com/tint/1526) remove when texture_dims returns u32 or vecN<u32>
|
||||
texture_dims = cast_to_unsigned(texture_dims, width);
|
||||
|
||||
// texture_dims is u32 or vecN<u32>
|
||||
const auto* unsigned_max = b.Sub(texture_dims, scalar_or_vec(b.Expr(1_a), width));
|
||||
if (target_ty->is_signed_scalar_or_vector()) {
|
||||
const auto* zero = scalar_or_vec(b.Expr(0_a), width);
|
||||
const auto* signed_max = cast_to_signed(unsigned_max, width);
|
||||
ctx.Replace(coords_arg, b.Call("clamp", ctx.Clone(coords_arg), zero, signed_max));
|
||||
} else {
|
||||
ctx.Replace(coords_arg, b.Call("min", ctx.Clone(coords_arg), unsigned_max));
|
||||
}
|
||||
}
|
||||
|
||||
// Clamp the array_index argument, if provided
|
||||
if (array_idx >= 0) {
|
||||
auto* target_ty = builtin->Parameters()[static_cast<size_t>(array_idx)]->Type();
|
||||
auto* arg = expr->args[static_cast<size_t>(array_idx)];
|
||||
auto* num_layers = b.Call("textureNumLayers", ctx.Clone(texture_arg));
|
||||
auto* zero = b.Expr(0_i);
|
||||
auto* max = ctx.dst->Sub(num_layers, 1_i);
|
||||
auto* clamped = b.Call("clamp", ctx.Clone(arg), zero, max);
|
||||
ctx.Replace(arg, clamped);
|
||||
|
||||
// TODO(crbug.com/tint/1526) remove when num_layers returns u32
|
||||
num_layers = cast_to_unsigned(num_layers, 1u);
|
||||
|
||||
const auto* unsigned_max = b.Sub(num_layers, 1_a);
|
||||
if (target_ty->is_signed_integer_scalar()) {
|
||||
const auto* signed_max = cast_to_signed(unsigned_max, 1u);
|
||||
ctx.Replace(arg, b.Call("clamp", ctx.Clone(arg), 0_a, signed_max));
|
||||
} else {
|
||||
ctx.Replace(arg, b.Call("min", ctx.Clone(arg), unsigned_max));
|
||||
}
|
||||
}
|
||||
|
||||
// Clamp the level argument, if provided
|
||||
if (level_idx >= 0) {
|
||||
auto* arg = expr->args[static_cast<size_t>(level_idx)];
|
||||
ctx.Replace(arg, level_arg ? level_arg() : ctx.dst->Expr(0_i));
|
||||
ctx.Replace(arg, level_arg ? level_arg() : ctx.dst->Expr(0_a));
|
||||
}
|
||||
|
||||
return nullptr; // Clone, which will use the argument replacements above.
|
||||
|
|
|
@ -787,12 +787,12 @@ TEST_F(RobustnessTest, TextureLoad_Clamp) {
|
|||
@group(0) @binding(0) var tex_depth_2d_arr : texture_depth_2d_array;
|
||||
@group(0) @binding(0) var tex_external : texture_external;
|
||||
|
||||
fn f() {
|
||||
fn signed() {
|
||||
var array_idx : i32;
|
||||
var level_idx : i32;
|
||||
var sample_idx : i32;
|
||||
|
||||
textureLoad(tex_1d, 1, level_idx);
|
||||
textureLoad(tex_1d, 1i, level_idx);
|
||||
textureLoad(tex_2d, vec2<i32>(1, 2), level_idx);
|
||||
textureLoad(tex_2d_arr, vec2<i32>(1, 2), array_idx, level_idx);
|
||||
textureLoad(tex_3d, vec3<i32>(1, 2, 3), level_idx);
|
||||
|
@ -801,6 +801,21 @@ fn f() {
|
|||
textureLoad(tex_depth_2d_arr, vec2<i32>(1, 2), array_idx, level_idx);
|
||||
textureLoad(tex_external, vec2<i32>(1, 2));
|
||||
}
|
||||
|
||||
fn unsigned() {
|
||||
var array_idx : u32;
|
||||
var level_idx : u32;
|
||||
var sample_idx : u32;
|
||||
|
||||
textureLoad(tex_1d, 1u, level_idx);
|
||||
textureLoad(tex_2d, vec2<u32>(1, 2), level_idx);
|
||||
textureLoad(tex_2d_arr, vec2<u32>(1, 2), array_idx, level_idx);
|
||||
textureLoad(tex_3d, vec3<u32>(1, 2, 3), level_idx);
|
||||
textureLoad(tex_ms_2d, vec2<u32>(1, 2), sample_idx);
|
||||
textureLoad(tex_depth_2d, vec2<u32>(1, 2), level_idx);
|
||||
textureLoad(tex_depth_2d_arr, vec2<u32>(1, 2), array_idx, level_idx);
|
||||
textureLoad(tex_external, vec2<u32>(1, 2));
|
||||
}
|
||||
)";
|
||||
|
||||
auto* expect =
|
||||
|
@ -821,18 +836,32 @@ fn f() {
|
|||
|
||||
@group(0) @binding(0) var tex_external : texture_external;
|
||||
|
||||
fn f() {
|
||||
fn signed() {
|
||||
var array_idx : i32;
|
||||
var level_idx : i32;
|
||||
var sample_idx : i32;
|
||||
textureLoad(tex_1d, clamp(1, i32(), (textureDimensions(tex_1d, clamp(level_idx, 0i, (textureNumLevels(tex_1d) - 1i))) - i32(1i))), clamp(level_idx, 0i, (textureNumLevels(tex_1d) - 1i)));
|
||||
textureLoad(tex_2d, clamp(vec2<i32>(1, 2), vec2<i32>(), (textureDimensions(tex_2d, clamp(level_idx, 0i, (textureNumLevels(tex_2d) - 1i))) - vec2<i32>(1i))), clamp(level_idx, 0i, (textureNumLevels(tex_2d) - 1i)));
|
||||
textureLoad(tex_2d_arr, clamp(vec2<i32>(1, 2), vec2<i32>(), (textureDimensions(tex_2d_arr, clamp(level_idx, 0i, (textureNumLevels(tex_2d_arr) - 1i))) - vec2<i32>(1i))), clamp(array_idx, 0i, (textureNumLayers(tex_2d_arr) - 1i)), clamp(level_idx, 0i, (textureNumLevels(tex_2d_arr) - 1i)));
|
||||
textureLoad(tex_3d, clamp(vec3<i32>(1, 2, 3), vec3<i32>(), (textureDimensions(tex_3d, clamp(level_idx, 0i, (textureNumLevels(tex_3d) - 1i))) - vec3<i32>(1i))), clamp(level_idx, 0i, (textureNumLevels(tex_3d) - 1i)));
|
||||
textureLoad(tex_ms_2d, clamp(vec2<i32>(1, 2), vec2<i32>(), (textureDimensions(tex_ms_2d) - vec2<i32>(1i))), sample_idx);
|
||||
textureLoad(tex_depth_2d, clamp(vec2<i32>(1, 2), vec2<i32>(), (textureDimensions(tex_depth_2d, clamp(level_idx, 0i, (textureNumLevels(tex_depth_2d) - 1i))) - vec2<i32>(1i))), clamp(level_idx, 0i, (textureNumLevels(tex_depth_2d) - 1i)));
|
||||
textureLoad(tex_depth_2d_arr, clamp(vec2<i32>(1, 2), vec2<i32>(), (textureDimensions(tex_depth_2d_arr, clamp(level_idx, 0i, (textureNumLevels(tex_depth_2d_arr) - 1i))) - vec2<i32>(1i))), clamp(array_idx, 0i, (textureNumLayers(tex_depth_2d_arr) - 1i)), clamp(level_idx, 0i, (textureNumLevels(tex_depth_2d_arr) - 1i)));
|
||||
textureLoad(tex_external, clamp(vec2<i32>(1, 2), vec2<i32>(), (textureDimensions(tex_external) - vec2<i32>(1i))));
|
||||
textureLoad(tex_1d, clamp(1i, 0, i32((u32(textureDimensions(tex_1d, clamp(level_idx, 0, i32((u32(textureNumLevels(tex_1d)) - 1))))) - 1))), clamp(level_idx, 0, i32((u32(textureNumLevels(tex_1d)) - 1))));
|
||||
textureLoad(tex_2d, clamp(vec2<i32>(1, 2), vec2(0), vec2<i32>((vec2<u32>(textureDimensions(tex_2d, clamp(level_idx, 0, i32((u32(textureNumLevels(tex_2d)) - 1))))) - vec2(1)))), clamp(level_idx, 0, i32((u32(textureNumLevels(tex_2d)) - 1))));
|
||||
textureLoad(tex_2d_arr, clamp(vec2<i32>(1, 2), vec2(0), vec2<i32>((vec2<u32>(textureDimensions(tex_2d_arr, clamp(level_idx, 0, i32((u32(textureNumLevels(tex_2d_arr)) - 1))))) - vec2(1)))), clamp(array_idx, 0, i32((u32(textureNumLayers(tex_2d_arr)) - 1))), clamp(level_idx, 0, i32((u32(textureNumLevels(tex_2d_arr)) - 1))));
|
||||
textureLoad(tex_3d, clamp(vec3<i32>(1, 2, 3), vec3(0), vec3<i32>((vec3<u32>(textureDimensions(tex_3d, clamp(level_idx, 0, i32((u32(textureNumLevels(tex_3d)) - 1))))) - vec3(1)))), clamp(level_idx, 0, i32((u32(textureNumLevels(tex_3d)) - 1))));
|
||||
textureLoad(tex_ms_2d, clamp(vec2<i32>(1, 2), vec2(0), vec2<i32>((vec2<u32>(textureDimensions(tex_ms_2d)) - vec2(1)))), sample_idx);
|
||||
textureLoad(tex_depth_2d, clamp(vec2<i32>(1, 2), vec2(0), vec2<i32>((vec2<u32>(textureDimensions(tex_depth_2d, clamp(level_idx, 0, i32((u32(textureNumLevels(tex_depth_2d)) - 1))))) - vec2(1)))), clamp(level_idx, 0, i32((u32(textureNumLevels(tex_depth_2d)) - 1))));
|
||||
textureLoad(tex_depth_2d_arr, clamp(vec2<i32>(1, 2), vec2(0), vec2<i32>((vec2<u32>(textureDimensions(tex_depth_2d_arr, clamp(level_idx, 0, i32((u32(textureNumLevels(tex_depth_2d_arr)) - 1))))) - vec2(1)))), clamp(array_idx, 0, i32((u32(textureNumLayers(tex_depth_2d_arr)) - 1))), clamp(level_idx, 0, i32((u32(textureNumLevels(tex_depth_2d_arr)) - 1))));
|
||||
textureLoad(tex_external, clamp(vec2<i32>(1, 2), vec2(0), vec2<i32>((vec2<u32>(textureDimensions(tex_external)) - vec2(1)))));
|
||||
}
|
||||
|
||||
fn unsigned() {
|
||||
var array_idx : u32;
|
||||
var level_idx : u32;
|
||||
var sample_idx : u32;
|
||||
textureLoad(tex_1d, min(1u, (u32(textureDimensions(tex_1d, min(level_idx, (u32(textureNumLevels(tex_1d)) - 1)))) - 1)), min(level_idx, (u32(textureNumLevels(tex_1d)) - 1)));
|
||||
textureLoad(tex_2d, min(vec2<u32>(1, 2), (vec2<u32>(textureDimensions(tex_2d, min(level_idx, (u32(textureNumLevels(tex_2d)) - 1)))) - vec2(1))), min(level_idx, (u32(textureNumLevels(tex_2d)) - 1)));
|
||||
textureLoad(tex_2d_arr, min(vec2<u32>(1, 2), (vec2<u32>(textureDimensions(tex_2d_arr, min(level_idx, (u32(textureNumLevels(tex_2d_arr)) - 1)))) - vec2(1))), min(array_idx, (u32(textureNumLayers(tex_2d_arr)) - 1)), min(level_idx, (u32(textureNumLevels(tex_2d_arr)) - 1)));
|
||||
textureLoad(tex_3d, min(vec3<u32>(1, 2, 3), (vec3<u32>(textureDimensions(tex_3d, min(level_idx, (u32(textureNumLevels(tex_3d)) - 1)))) - vec3(1))), min(level_idx, (u32(textureNumLevels(tex_3d)) - 1)));
|
||||
textureLoad(tex_ms_2d, min(vec2<u32>(1, 2), (vec2<u32>(textureDimensions(tex_ms_2d)) - vec2(1))), sample_idx);
|
||||
textureLoad(tex_depth_2d, min(vec2<u32>(1, 2), (vec2<u32>(textureDimensions(tex_depth_2d, min(level_idx, (u32(textureNumLevels(tex_depth_2d)) - 1)))) - vec2(1))), min(level_idx, (u32(textureNumLevels(tex_depth_2d)) - 1)));
|
||||
textureLoad(tex_depth_2d_arr, min(vec2<u32>(1, 2), (vec2<u32>(textureDimensions(tex_depth_2d_arr, min(level_idx, (u32(textureNumLevels(tex_depth_2d_arr)) - 1)))) - vec2(1))), min(array_idx, (u32(textureNumLayers(tex_depth_2d_arr)) - 1)), min(level_idx, (u32(textureNumLevels(tex_depth_2d_arr)) - 1)));
|
||||
textureLoad(tex_external, min(vec2<u32>(1, 2), (vec2<u32>(textureDimensions(tex_external)) - vec2(1))));
|
||||
}
|
||||
)";
|
||||
|
||||
|
@ -844,12 +873,12 @@ fn f() {
|
|||
// Clamp textureLoad() coord, array_index and level values
|
||||
TEST_F(RobustnessTest, TextureLoad_Clamp_OutOfOrder) {
|
||||
auto* src = R"(
|
||||
fn f() {
|
||||
fn signed() {
|
||||
var array_idx : i32;
|
||||
var level_idx : i32;
|
||||
var sample_idx : i32;
|
||||
|
||||
textureLoad(tex_1d, 1, level_idx);
|
||||
textureLoad(tex_1d, 1i, level_idx);
|
||||
textureLoad(tex_2d, vec2<i32>(1, 2), level_idx);
|
||||
textureLoad(tex_2d_arr, vec2<i32>(1, 2), array_idx, level_idx);
|
||||
textureLoad(tex_3d, vec3<i32>(1, 2, 3), level_idx);
|
||||
|
@ -859,6 +888,21 @@ fn f() {
|
|||
textureLoad(tex_external, vec2<i32>(1, 2));
|
||||
}
|
||||
|
||||
fn unsigned() {
|
||||
var array_idx : u32;
|
||||
var level_idx : u32;
|
||||
var sample_idx : u32;
|
||||
|
||||
textureLoad(tex_1d, 1u, level_idx);
|
||||
textureLoad(tex_2d, vec2<u32>(1, 2), level_idx);
|
||||
textureLoad(tex_2d_arr, vec2<u32>(1, 2), array_idx, level_idx);
|
||||
textureLoad(tex_3d, vec3<u32>(1, 2, 3), level_idx);
|
||||
textureLoad(tex_ms_2d, vec2<u32>(1, 2), sample_idx);
|
||||
textureLoad(tex_depth_2d, vec2<u32>(1, 2), level_idx);
|
||||
textureLoad(tex_depth_2d_arr, vec2<u32>(1, 2), array_idx, level_idx);
|
||||
textureLoad(tex_external, vec2<u32>(1, 2));
|
||||
}
|
||||
|
||||
@group(0) @binding(0) var tex_1d : texture_1d<f32>;
|
||||
@group(0) @binding(0) var tex_2d : texture_2d<f32>;
|
||||
@group(0) @binding(0) var tex_2d_arr : texture_2d_array<f32>;
|
||||
|
@ -871,18 +915,32 @@ fn f() {
|
|||
|
||||
auto* expect =
|
||||
R"(
|
||||
fn f() {
|
||||
fn signed() {
|
||||
var array_idx : i32;
|
||||
var level_idx : i32;
|
||||
var sample_idx : i32;
|
||||
textureLoad(tex_1d, clamp(1, i32(), (textureDimensions(tex_1d, clamp(level_idx, 0i, (textureNumLevels(tex_1d) - 1i))) - i32(1i))), clamp(level_idx, 0i, (textureNumLevels(tex_1d) - 1i)));
|
||||
textureLoad(tex_2d, clamp(vec2<i32>(1, 2), vec2<i32>(), (textureDimensions(tex_2d, clamp(level_idx, 0i, (textureNumLevels(tex_2d) - 1i))) - vec2<i32>(1i))), clamp(level_idx, 0i, (textureNumLevels(tex_2d) - 1i)));
|
||||
textureLoad(tex_2d_arr, clamp(vec2<i32>(1, 2), vec2<i32>(), (textureDimensions(tex_2d_arr, clamp(level_idx, 0i, (textureNumLevels(tex_2d_arr) - 1i))) - vec2<i32>(1i))), clamp(array_idx, 0i, (textureNumLayers(tex_2d_arr) - 1i)), clamp(level_idx, 0i, (textureNumLevels(tex_2d_arr) - 1i)));
|
||||
textureLoad(tex_3d, clamp(vec3<i32>(1, 2, 3), vec3<i32>(), (textureDimensions(tex_3d, clamp(level_idx, 0i, (textureNumLevels(tex_3d) - 1i))) - vec3<i32>(1i))), clamp(level_idx, 0i, (textureNumLevels(tex_3d) - 1i)));
|
||||
textureLoad(tex_ms_2d, clamp(vec2<i32>(1, 2), vec2<i32>(), (textureDimensions(tex_ms_2d) - vec2<i32>(1i))), sample_idx);
|
||||
textureLoad(tex_depth_2d, clamp(vec2<i32>(1, 2), vec2<i32>(), (textureDimensions(tex_depth_2d, clamp(level_idx, 0i, (textureNumLevels(tex_depth_2d) - 1i))) - vec2<i32>(1i))), clamp(level_idx, 0i, (textureNumLevels(tex_depth_2d) - 1i)));
|
||||
textureLoad(tex_depth_2d_arr, clamp(vec2<i32>(1, 2), vec2<i32>(), (textureDimensions(tex_depth_2d_arr, clamp(level_idx, 0i, (textureNumLevels(tex_depth_2d_arr) - 1i))) - vec2<i32>(1i))), clamp(array_idx, 0i, (textureNumLayers(tex_depth_2d_arr) - 1i)), clamp(level_idx, 0i, (textureNumLevels(tex_depth_2d_arr) - 1i)));
|
||||
textureLoad(tex_external, clamp(vec2<i32>(1, 2), vec2<i32>(), (textureDimensions(tex_external) - vec2<i32>(1i))));
|
||||
textureLoad(tex_1d, clamp(1i, 0, i32((u32(textureDimensions(tex_1d, clamp(level_idx, 0, i32((u32(textureNumLevels(tex_1d)) - 1))))) - 1))), clamp(level_idx, 0, i32((u32(textureNumLevels(tex_1d)) - 1))));
|
||||
textureLoad(tex_2d, clamp(vec2<i32>(1, 2), vec2(0), vec2<i32>((vec2<u32>(textureDimensions(tex_2d, clamp(level_idx, 0, i32((u32(textureNumLevels(tex_2d)) - 1))))) - vec2(1)))), clamp(level_idx, 0, i32((u32(textureNumLevels(tex_2d)) - 1))));
|
||||
textureLoad(tex_2d_arr, clamp(vec2<i32>(1, 2), vec2(0), vec2<i32>((vec2<u32>(textureDimensions(tex_2d_arr, clamp(level_idx, 0, i32((u32(textureNumLevels(tex_2d_arr)) - 1))))) - vec2(1)))), clamp(array_idx, 0, i32((u32(textureNumLayers(tex_2d_arr)) - 1))), clamp(level_idx, 0, i32((u32(textureNumLevels(tex_2d_arr)) - 1))));
|
||||
textureLoad(tex_3d, clamp(vec3<i32>(1, 2, 3), vec3(0), vec3<i32>((vec3<u32>(textureDimensions(tex_3d, clamp(level_idx, 0, i32((u32(textureNumLevels(tex_3d)) - 1))))) - vec3(1)))), clamp(level_idx, 0, i32((u32(textureNumLevels(tex_3d)) - 1))));
|
||||
textureLoad(tex_ms_2d, clamp(vec2<i32>(1, 2), vec2(0), vec2<i32>((vec2<u32>(textureDimensions(tex_ms_2d)) - vec2(1)))), sample_idx);
|
||||
textureLoad(tex_depth_2d, clamp(vec2<i32>(1, 2), vec2(0), vec2<i32>((vec2<u32>(textureDimensions(tex_depth_2d, clamp(level_idx, 0, i32((u32(textureNumLevels(tex_depth_2d)) - 1))))) - vec2(1)))), clamp(level_idx, 0, i32((u32(textureNumLevels(tex_depth_2d)) - 1))));
|
||||
textureLoad(tex_depth_2d_arr, clamp(vec2<i32>(1, 2), vec2(0), vec2<i32>((vec2<u32>(textureDimensions(tex_depth_2d_arr, clamp(level_idx, 0, i32((u32(textureNumLevels(tex_depth_2d_arr)) - 1))))) - vec2(1)))), clamp(array_idx, 0, i32((u32(textureNumLayers(tex_depth_2d_arr)) - 1))), clamp(level_idx, 0, i32((u32(textureNumLevels(tex_depth_2d_arr)) - 1))));
|
||||
textureLoad(tex_external, clamp(vec2<i32>(1, 2), vec2(0), vec2<i32>((vec2<u32>(textureDimensions(tex_external)) - vec2(1)))));
|
||||
}
|
||||
|
||||
fn unsigned() {
|
||||
var array_idx : u32;
|
||||
var level_idx : u32;
|
||||
var sample_idx : u32;
|
||||
textureLoad(tex_1d, min(1u, (u32(textureDimensions(tex_1d, min(level_idx, (u32(textureNumLevels(tex_1d)) - 1)))) - 1)), min(level_idx, (u32(textureNumLevels(tex_1d)) - 1)));
|
||||
textureLoad(tex_2d, min(vec2<u32>(1, 2), (vec2<u32>(textureDimensions(tex_2d, min(level_idx, (u32(textureNumLevels(tex_2d)) - 1)))) - vec2(1))), min(level_idx, (u32(textureNumLevels(tex_2d)) - 1)));
|
||||
textureLoad(tex_2d_arr, min(vec2<u32>(1, 2), (vec2<u32>(textureDimensions(tex_2d_arr, min(level_idx, (u32(textureNumLevels(tex_2d_arr)) - 1)))) - vec2(1))), min(array_idx, (u32(textureNumLayers(tex_2d_arr)) - 1)), min(level_idx, (u32(textureNumLevels(tex_2d_arr)) - 1)));
|
||||
textureLoad(tex_3d, min(vec3<u32>(1, 2, 3), (vec3<u32>(textureDimensions(tex_3d, min(level_idx, (u32(textureNumLevels(tex_3d)) - 1)))) - vec3(1))), min(level_idx, (u32(textureNumLevels(tex_3d)) - 1)));
|
||||
textureLoad(tex_ms_2d, min(vec2<u32>(1, 2), (vec2<u32>(textureDimensions(tex_ms_2d)) - vec2(1))), sample_idx);
|
||||
textureLoad(tex_depth_2d, min(vec2<u32>(1, 2), (vec2<u32>(textureDimensions(tex_depth_2d, min(level_idx, (u32(textureNumLevels(tex_depth_2d)) - 1)))) - vec2(1))), min(level_idx, (u32(textureNumLevels(tex_depth_2d)) - 1)));
|
||||
textureLoad(tex_depth_2d_arr, min(vec2<u32>(1, 2), (vec2<u32>(textureDimensions(tex_depth_2d_arr, min(level_idx, (u32(textureNumLevels(tex_depth_2d_arr)) - 1)))) - vec2(1))), min(array_idx, (u32(textureNumLayers(tex_depth_2d_arr)) - 1)), min(level_idx, (u32(textureNumLevels(tex_depth_2d_arr)) - 1)));
|
||||
textureLoad(tex_external, min(vec2<u32>(1, 2), (vec2<u32>(textureDimensions(tex_external)) - vec2(1))));
|
||||
}
|
||||
|
||||
@group(0) @binding(0) var tex_1d : texture_1d<f32>;
|
||||
|
@ -918,12 +976,19 @@ TEST_F(RobustnessTest, TextureStore_Clamp) {
|
|||
|
||||
@group(0) @binding(3) var tex3d : texture_storage_3d<rgba8sint, write>;
|
||||
|
||||
fn f() {
|
||||
textureStore(tex1d, 10, vec4<i32>());
|
||||
fn signed() {
|
||||
textureStore(tex1d, 10i, vec4<i32>());
|
||||
textureStore(tex2d, vec2<i32>(10, 20), vec4<i32>());
|
||||
textureStore(tex2d_arr, vec2<i32>(10, 20), 50, vec4<i32>());
|
||||
textureStore(tex2d_arr, vec2<i32>(10, 20), 50i, vec4<i32>());
|
||||
textureStore(tex3d, vec3<i32>(10, 20, 30), vec4<i32>());
|
||||
}
|
||||
|
||||
fn unsigned() {
|
||||
textureStore(tex1d, 10u, vec4<i32>());
|
||||
textureStore(tex2d, vec2<u32>(10, 20), vec4<i32>());
|
||||
textureStore(tex2d_arr, vec2<u32>(10, 20), 50u, vec4<i32>());
|
||||
textureStore(tex3d, vec3<u32>(10, 20, 30), vec4<i32>());
|
||||
}
|
||||
)";
|
||||
|
||||
auto* expect = R"(
|
||||
|
@ -935,11 +1000,18 @@ fn f() {
|
|||
|
||||
@group(0) @binding(3) var tex3d : texture_storage_3d<rgba8sint, write>;
|
||||
|
||||
fn f() {
|
||||
textureStore(tex1d, clamp(10, i32(), (textureDimensions(tex1d) - i32(1i))), vec4<i32>());
|
||||
textureStore(tex2d, clamp(vec2<i32>(10, 20), vec2<i32>(), (textureDimensions(tex2d) - vec2<i32>(1i))), vec4<i32>());
|
||||
textureStore(tex2d_arr, clamp(vec2<i32>(10, 20), vec2<i32>(), (textureDimensions(tex2d_arr) - vec2<i32>(1i))), clamp(50, 0i, (textureNumLayers(tex2d_arr) - 1i)), vec4<i32>());
|
||||
textureStore(tex3d, clamp(vec3<i32>(10, 20, 30), vec3<i32>(), (textureDimensions(tex3d) - vec3<i32>(1i))), vec4<i32>());
|
||||
fn signed() {
|
||||
textureStore(tex1d, clamp(10i, 0, i32((u32(textureDimensions(tex1d)) - 1))), vec4<i32>());
|
||||
textureStore(tex2d, clamp(vec2<i32>(10, 20), vec2(0), vec2<i32>((vec2<u32>(textureDimensions(tex2d)) - vec2(1)))), vec4<i32>());
|
||||
textureStore(tex2d_arr, clamp(vec2<i32>(10, 20), vec2(0), vec2<i32>((vec2<u32>(textureDimensions(tex2d_arr)) - vec2(1)))), clamp(50i, 0, i32((u32(textureNumLayers(tex2d_arr)) - 1))), vec4<i32>());
|
||||
textureStore(tex3d, clamp(vec3<i32>(10, 20, 30), vec3(0), vec3<i32>((vec3<u32>(textureDimensions(tex3d)) - vec3(1)))), vec4<i32>());
|
||||
}
|
||||
|
||||
fn unsigned() {
|
||||
textureStore(tex1d, min(10u, (u32(textureDimensions(tex1d)) - 1)), vec4<i32>());
|
||||
textureStore(tex2d, min(vec2<u32>(10, 20), (vec2<u32>(textureDimensions(tex2d)) - vec2(1))), vec4<i32>());
|
||||
textureStore(tex2d_arr, min(vec2<u32>(10, 20), (vec2<u32>(textureDimensions(tex2d_arr)) - vec2(1))), min(50u, (u32(textureNumLayers(tex2d_arr)) - 1)), vec4<i32>());
|
||||
textureStore(tex3d, min(vec3<u32>(10, 20, 30), (vec3<u32>(textureDimensions(tex3d)) - vec3(1))), vec4<i32>());
|
||||
}
|
||||
)";
|
||||
|
||||
|
@ -951,13 +1023,20 @@ fn f() {
|
|||
// Clamp textureStore() coord, array_index and level values
|
||||
TEST_F(RobustnessTest, TextureStore_Clamp_OutOfOrder) {
|
||||
auto* src = R"(
|
||||
fn f() {
|
||||
textureStore(tex1d, 10, vec4<i32>());
|
||||
fn signed() {
|
||||
textureStore(tex1d, 10i, vec4<i32>());
|
||||
textureStore(tex2d, vec2<i32>(10, 20), vec4<i32>());
|
||||
textureStore(tex2d_arr, vec2<i32>(10, 20), 50, vec4<i32>());
|
||||
textureStore(tex2d_arr, vec2<i32>(10, 20), 50i, vec4<i32>());
|
||||
textureStore(tex3d, vec3<i32>(10, 20, 30), vec4<i32>());
|
||||
}
|
||||
|
||||
fn unsigned() {
|
||||
textureStore(tex1d, 10u, vec4<i32>());
|
||||
textureStore(tex2d, vec2<u32>(10, 20), vec4<i32>());
|
||||
textureStore(tex2d_arr, vec2<u32>(10, 20), 50u, vec4<i32>());
|
||||
textureStore(tex3d, vec3<u32>(10, 20, 30), vec4<i32>());
|
||||
}
|
||||
|
||||
@group(0) @binding(0) var tex1d : texture_storage_1d<rgba8sint, write>;
|
||||
|
||||
@group(0) @binding(1) var tex2d : texture_storage_2d<rgba8sint, write>;
|
||||
|
@ -969,11 +1048,18 @@ fn f() {
|
|||
)";
|
||||
|
||||
auto* expect = R"(
|
||||
fn f() {
|
||||
textureStore(tex1d, clamp(10, i32(), (textureDimensions(tex1d) - i32(1i))), vec4<i32>());
|
||||
textureStore(tex2d, clamp(vec2<i32>(10, 20), vec2<i32>(), (textureDimensions(tex2d) - vec2<i32>(1i))), vec4<i32>());
|
||||
textureStore(tex2d_arr, clamp(vec2<i32>(10, 20), vec2<i32>(), (textureDimensions(tex2d_arr) - vec2<i32>(1i))), clamp(50, 0i, (textureNumLayers(tex2d_arr) - 1i)), vec4<i32>());
|
||||
textureStore(tex3d, clamp(vec3<i32>(10, 20, 30), vec3<i32>(), (textureDimensions(tex3d) - vec3<i32>(1i))), vec4<i32>());
|
||||
fn signed() {
|
||||
textureStore(tex1d, clamp(10i, 0, i32((u32(textureDimensions(tex1d)) - 1))), vec4<i32>());
|
||||
textureStore(tex2d, clamp(vec2<i32>(10, 20), vec2(0), vec2<i32>((vec2<u32>(textureDimensions(tex2d)) - vec2(1)))), vec4<i32>());
|
||||
textureStore(tex2d_arr, clamp(vec2<i32>(10, 20), vec2(0), vec2<i32>((vec2<u32>(textureDimensions(tex2d_arr)) - vec2(1)))), clamp(50i, 0, i32((u32(textureNumLayers(tex2d_arr)) - 1))), vec4<i32>());
|
||||
textureStore(tex3d, clamp(vec3<i32>(10, 20, 30), vec3(0), vec3<i32>((vec3<u32>(textureDimensions(tex3d)) - vec3(1)))), vec4<i32>());
|
||||
}
|
||||
|
||||
fn unsigned() {
|
||||
textureStore(tex1d, min(10u, (u32(textureDimensions(tex1d)) - 1)), vec4<i32>());
|
||||
textureStore(tex2d, min(vec2<u32>(10, 20), (vec2<u32>(textureDimensions(tex2d)) - vec2(1))), vec4<i32>());
|
||||
textureStore(tex2d_arr, min(vec2<u32>(10, 20), (vec2<u32>(textureDimensions(tex2d_arr)) - vec2(1))), min(50u, (u32(textureNumLayers(tex2d_arr)) - 1)), vec4<i32>());
|
||||
textureStore(tex3d, min(vec3<u32>(10, 20, 30), (vec3<u32>(textureDimensions(tex3d)) - vec3(1))), vec4<i32>());
|
||||
}
|
||||
|
||||
@group(0) @binding(0) var tex1d : texture_storage_1d<rgba8sint, write>;
|
||||
|
|
|
@ -1335,6 +1335,26 @@ bool GeneratorImpl::EmitTextureCall(std::ostream& out,
|
|||
|
||||
auto* texture_type = TypeOf(texture)->UnwrapRef()->As<sem::Texture>();
|
||||
|
||||
auto emit_signed_int_type = [&](const sem::Type* ty) {
|
||||
uint32_t width = 0;
|
||||
sem::Type::ElementOf(ty, &width);
|
||||
if (width > 1) {
|
||||
out << "ivec" << width;
|
||||
} else {
|
||||
out << "int";
|
||||
}
|
||||
};
|
||||
|
||||
auto emit_expr_as_signed = [&](const ast::Expression* e) {
|
||||
auto* ty = TypeOf(e)->UnwrapRef();
|
||||
if (!ty->is_unsigned_scalar_or_vector()) {
|
||||
return EmitExpression(out, e);
|
||||
}
|
||||
emit_signed_int_type(ty);
|
||||
ScopedParen sp(out);
|
||||
return EmitExpression(out, e);
|
||||
};
|
||||
|
||||
switch (builtin->Type()) {
|
||||
case sem::BuiltinType::kTextureDimensions: {
|
||||
if (texture_type->Is<sem::StorageTexture>()) {
|
||||
|
@ -1353,7 +1373,7 @@ bool GeneratorImpl::EmitTextureCall(std::ostream& out,
|
|||
!texture_type->Is<sem::DepthMultisampledTexture>()) {
|
||||
out << ", ";
|
||||
if (auto* level_arg = arg(Usage::kLevel)) {
|
||||
if (!EmitExpression(out, level_arg)) {
|
||||
if (!emit_expr_as_signed(level_arg)) {
|
||||
return false;
|
||||
}
|
||||
} else {
|
||||
|
@ -1387,7 +1407,7 @@ bool GeneratorImpl::EmitTextureCall(std::ostream& out,
|
|||
!texture_type->Is<sem::DepthMultisampledTexture>()) {
|
||||
out << ", ";
|
||||
if (auto* level_arg = arg(Usage::kLevel)) {
|
||||
if (!EmitExpression(out, level_arg)) {
|
||||
if (!emit_expr_as_signed(level_arg)) {
|
||||
return false;
|
||||
}
|
||||
} else {
|
||||
|
@ -1501,12 +1521,11 @@ bool GeneratorImpl::EmitTextureCall(std::ostream& out,
|
|||
param_coords = AppendVector(&builder_, param_coords, depth_ref)->Declaration();
|
||||
}
|
||||
|
||||
if (!EmitExpression(out, param_coords)) {
|
||||
if (!emit_expr_as_signed(param_coords)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
for (auto usage :
|
||||
{Usage::kLevel, Usage::kDdx, Usage::kDdy, Usage::kSampleIndex, Usage::kValue}) {
|
||||
for (auto usage : {Usage::kLevel, Usage::kDdx, Usage::kDdy, Usage::kSampleIndex}) {
|
||||
if (auto* e = arg(usage)) {
|
||||
out << ", ";
|
||||
if (usage == Usage::kLevel && is_depth) {
|
||||
|
@ -1517,12 +1536,19 @@ bool GeneratorImpl::EmitTextureCall(std::ostream& out,
|
|||
return false;
|
||||
}
|
||||
out << ")";
|
||||
} else if (!EmitExpression(out, e)) {
|
||||
} else if (!emit_expr_as_signed(e)) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (auto* e = arg(Usage::kValue)) {
|
||||
out << ", ";
|
||||
if (!EmitExpression(out, e)) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// GLSL's textureGather always requires a refZ parameter.
|
||||
if (is_depth && builtin->Type() == sem::BuiltinType::kTextureGather) {
|
||||
out << ", 0.0";
|
||||
|
@ -1543,7 +1569,7 @@ bool GeneratorImpl::EmitTextureCall(std::ostream& out,
|
|||
for (auto usage : {Usage::kOffset, Usage::kComponent, Usage::kBias}) {
|
||||
if (auto* e = arg(usage)) {
|
||||
out << ", ";
|
||||
if (!EmitExpression(out, e)) {
|
||||
if (!emit_expr_as_signed(e)) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -63,27 +63,27 @@ ExpectedResult expected_texture_overload(ast::builtin::test::ValidTextureOverloa
|
|||
case ValidTextureOverload::kGather2dF32:
|
||||
return R"(textureGather(tint_symbol_sampler, vec2(1.0f, 2.0f), 0))";
|
||||
case ValidTextureOverload::kGather2dOffsetF32:
|
||||
return R"(textureGatherOffset(tint_symbol_sampler, vec2(1.0f, 2.0f), ivec2(3, 4), 0))";
|
||||
return R"(textureGatherOffset(tint_symbol_sampler, vec2(1.0f, 2.0f), ivec2(3, 4), int(0u)))";
|
||||
case ValidTextureOverload::kGather2dArrayF32:
|
||||
return R"(textureGather(tint_symbol_sampler, vec3(1.0f, 2.0f, float(3)), 0))";
|
||||
case ValidTextureOverload::kGather2dArrayOffsetF32:
|
||||
return R"(textureGatherOffset(tint_symbol_sampler, vec3(1.0f, 2.0f, float(3)), ivec2(4, 5), 0))";
|
||||
return R"(textureGatherOffset(tint_symbol_sampler, vec3(1.0f, 2.0f, float(3u)), ivec2(4, 5), int(0u)))";
|
||||
case ValidTextureOverload::kGatherCubeF32:
|
||||
return R"(textureGather(tint_symbol_sampler, vec3(1.0f, 2.0f, 3.0f), 0))";
|
||||
case ValidTextureOverload::kGatherCubeArrayF32:
|
||||
return R"(textureGather(tint_symbol_sampler, vec4(1.0f, 2.0f, 3.0f, float(4)), 0))";
|
||||
return R"(textureGather(tint_symbol_sampler, vec4(1.0f, 2.0f, 3.0f, float(4u)), int(0u))";
|
||||
case ValidTextureOverload::kGatherDepth2dF32:
|
||||
return R"(textureGather(tint_symbol_sampler, vec2(1.0f, 2.0f), 0.0))";
|
||||
case ValidTextureOverload::kGatherDepth2dOffsetF32:
|
||||
return R"(textureGatherOffset(tint_symbol_sampler, vec2(1.0f, 2.0f), 0.0, ivec2(3, 4))";
|
||||
case ValidTextureOverload::kGatherDepth2dArrayF32:
|
||||
return R"(textureGather(tint_symbol_sampler, vec3(1.0f, 2.0f, float(3)), 0.0))";
|
||||
return R"(textureGather(tint_symbol_sampler, vec3(1.0f, 2.0f, float(3u)), 0.0))";
|
||||
case ValidTextureOverload::kGatherDepth2dArrayOffsetF32:
|
||||
return R"(textureGatherOffset(tint_symbol_sampler, vec3(1.0f, 2.0f, float(3)), 0.0, ivec2(4, 5)))";
|
||||
case ValidTextureOverload::kGatherDepthCubeF32:
|
||||
return R"(textureGather(tint_symbol_sampler, vec3(1.0f, 2.0f, 3.0f), 0.0))";
|
||||
case ValidTextureOverload::kGatherDepthCubeArrayF32:
|
||||
return R"(textureGather(tint_symbol_sampler, vec4(1.0f, 2.0f, 3.0f, float(4)), 0.0))";
|
||||
return R"(textureGather(tint_symbol_sampler, vec4(1.0f, 2.0f, 3.0f, float(4u)), 0.0))";
|
||||
case ValidTextureOverload::kGatherCompareDepth2dF32:
|
||||
return R"(textureGather(tint_symbol_sampler, vec2(1.0f, 2.0f), 3.0f))";
|
||||
case ValidTextureOverload::kGatherCompareDepth2dOffsetF32:
|
||||
|
@ -95,7 +95,7 @@ ExpectedResult expected_texture_overload(ast::builtin::test::ValidTextureOverloa
|
|||
case ValidTextureOverload::kGatherCompareDepthCubeF32:
|
||||
return R"(textureGather(tint_symbol_sampler, vec3(1.0f, 2.0f, 3.0f), 4.0f))";
|
||||
case ValidTextureOverload::kGatherCompareDepthCubeArrayF32:
|
||||
return R"(textureGather(tint_symbol_sampler, vec4(1.0f, 2.0f, 3.0f, float(4)), 5.0f))";
|
||||
return R"(textureGather(tint_symbol_sampler, vec4(1.0f, 2.0f, 3.0f, float(4u)), 5.0f))";
|
||||
case ValidTextureOverload::kNumLayers2dArray:
|
||||
case ValidTextureOverload::kNumLayersDepth2dArray:
|
||||
case ValidTextureOverload::kNumLayersCubeArray:
|
||||
|
@ -125,7 +125,7 @@ ExpectedResult expected_texture_overload(ast::builtin::test::ValidTextureOverloa
|
|||
case ValidTextureOverload::kSample2dArrayF32:
|
||||
return R"(texture(tint_symbol_sampler, vec3(1.0f, 2.0f, float(3)));)";
|
||||
case ValidTextureOverload::kSample2dArrayOffsetF32:
|
||||
return R"(textureOffset(tint_symbol_sampler, vec3(1.0f, 2.0f, float(3)), ivec2(4, 5));)";
|
||||
return R"(textureOffset(tint_symbol_sampler, vec3(1.0f, 2.0f, float(3u)), ivec2(4, 5));)";
|
||||
case ValidTextureOverload::kSample3dF32:
|
||||
return R"(texture(tint_symbol_sampler, vec3(1.0f, 2.0f, 3.0f));)";
|
||||
case ValidTextureOverload::kSample3dOffsetF32:
|
||||
|
@ -145,13 +145,13 @@ ExpectedResult expected_texture_overload(ast::builtin::test::ValidTextureOverloa
|
|||
case ValidTextureOverload::kSampleDepthCubeF32:
|
||||
return R"(texture(tint_symbol_sampler, vec4(1.0f, 2.0f, 3.0f, 0.0f));)";
|
||||
case ValidTextureOverload::kSampleDepthCubeArrayF32:
|
||||
return R"(texture(tint_symbol_sampler, vec4(1.0f, 2.0f, 3.0f, float(4)), 0.0f);)";
|
||||
return R"(texture(tint_symbol_sampler, vec4(1.0f, 2.0f, 3.0f, float(4u)), 0.0f);)";
|
||||
case ValidTextureOverload::kSampleBias2dF32:
|
||||
return R"(texture(tint_symbol_sampler, vec2(1.0f, 2.0f), 3.0f);)";
|
||||
case ValidTextureOverload::kSampleBias2dOffsetF32:
|
||||
return R"(textureOffset(tint_symbol_sampler, vec2(1.0f, 2.0f), ivec2(4, 5), 3.0f);)";
|
||||
case ValidTextureOverload::kSampleBias2dArrayF32:
|
||||
return R"(texture(tint_symbol_sampler, vec3(1.0f, 2.0f, float(4)), 3.0f);)";
|
||||
return R"(texture(tint_symbol_sampler, vec3(1.0f, 2.0f, float(4u)), 3.0f);)";
|
||||
case ValidTextureOverload::kSampleBias2dArrayOffsetF32:
|
||||
return R"(textureOffset(tint_symbol_sampler, vec3(1.0f, 2.0f, float(3)), ivec2(5, 6), 4.0f);)";
|
||||
case ValidTextureOverload::kSampleBias3dF32:
|
||||
|
@ -179,13 +179,13 @@ ExpectedResult expected_texture_overload(ast::builtin::test::ValidTextureOverloa
|
|||
case ValidTextureOverload::kSampleLevelCubeArrayF32:
|
||||
return R"(textureLod(tint_symbol_sampler, vec4(1.0f, 2.0f, 3.0f, float(4)), 5.0f);)";
|
||||
case ValidTextureOverload::kSampleLevelDepth2dF32:
|
||||
return R"(textureLod(tint_symbol_sampler, vec3(1.0f, 2.0f, 0.0f), float(3));)";
|
||||
return R"(textureLod(tint_symbol_sampler, vec3(1.0f, 2.0f, 0.0f), float(3u));)";
|
||||
case ValidTextureOverload::kSampleLevelDepth2dOffsetF32:
|
||||
return R"(textureLodOffset(tint_symbol_sampler, vec3(1.0f, 2.0f, 0.0f), float(3), ivec2(4, 5));)";
|
||||
case ValidTextureOverload::kSampleLevelDepth2dArrayF32:
|
||||
return R"(textureLod(tint_symbol_sampler, vec4(1.0f, 2.0f, float(3), 0.0f), float(4));)";
|
||||
return R"(textureLod(tint_symbol_sampler, vec4(1.0f, 2.0f, float(3u), 0.0f), float(4u));)";
|
||||
case ValidTextureOverload::kSampleLevelDepth2dArrayOffsetF32:
|
||||
return R"(textureLodOffset(tint_symbol_sampler, vec4(1.0f, 2.0f, float(3), 0.0f), float(4), ivec2(5, 6));)";
|
||||
return R"(textureLodOffset(tint_symbol_sampler, vec4(1.0f, 2.0f, float(3u), 0.0f), float(4u), ivec2(5, 6));)";
|
||||
case ValidTextureOverload::kSampleLevelDepthCubeF32:
|
||||
return R"(textureLod(tint_symbol_sampler, vec4(1.0f, 2.0f, 3.0f, 0.0f), float(4)))";
|
||||
case ValidTextureOverload::kSampleLevelDepthCubeArrayF32:
|
||||
|
@ -197,7 +197,7 @@ ExpectedResult expected_texture_overload(ast::builtin::test::ValidTextureOverloa
|
|||
case ValidTextureOverload::kSampleGrad2dArrayF32:
|
||||
return R"(textureGrad(tint_symbol_sampler, vec3(1.0f, 2.0f, float(3)), vec2(4.0f, 5.0f), vec2(6.0f, 7.0f));)";
|
||||
case ValidTextureOverload::kSampleGrad2dArrayOffsetF32:
|
||||
return R"(textureGradOffset(tint_symbol_sampler, vec3(1.0f, 2.0f, float(3)), vec2(4.0f, 5.0f), vec2(6.0f, 7.0f), ivec2(6, 7));)";
|
||||
return R"(textureGradOffset(tint_symbol_sampler, vec3(1.0f, 2.0f, float(3u)), vec2(4.0f, 5.0f), vec2(6.0f, 7.0f), ivec2(6, 7));)";
|
||||
case ValidTextureOverload::kSampleGrad3dF32:
|
||||
return R"(textureGrad(tint_symbol_sampler, vec3(1.0f, 2.0f, 3.0f), vec3(4.0f, 5.0f, 6.0f), vec3(7.0f, 8.0f, 9.0f));)";
|
||||
case ValidTextureOverload::kSampleGrad3dOffsetF32:
|
||||
|
@ -205,7 +205,7 @@ ExpectedResult expected_texture_overload(ast::builtin::test::ValidTextureOverloa
|
|||
case ValidTextureOverload::kSampleGradCubeF32:
|
||||
return R"(textureGrad(tint_symbol_sampler, vec3(1.0f, 2.0f, 3.0f), vec3(4.0f, 5.0f, 6.0f), vec3(7.0f, 8.0f, 9.0f));)";
|
||||
case ValidTextureOverload::kSampleGradCubeArrayF32:
|
||||
return R"(textureGrad(tint_symbol_sampler, vec4(1.0f, 2.0f, 3.0f, float(4)), vec3(5.0f, 6.0f, 7.0f), vec3(8.0f, 9.0f, 10.0f));)";
|
||||
return R"(textureGrad(tint_symbol_sampler, vec4(1.0f, 2.0f, 3.0f, float(4u)), vec3(5.0f, 6.0f, 7.0f), vec3(8.0f, 9.0f, 10.0f));)";
|
||||
case ValidTextureOverload::kSampleCompareDepth2dF32:
|
||||
return R"(texture(tint_symbol_sampler, vec3(1.0f, 2.0f, 3.0f));)";
|
||||
case ValidTextureOverload::kSampleCompareDepth2dOffsetF32:
|
||||
|
@ -213,7 +213,7 @@ ExpectedResult expected_texture_overload(ast::builtin::test::ValidTextureOverloa
|
|||
case ValidTextureOverload::kSampleCompareDepth2dArrayF32:
|
||||
return R"(texture(tint_symbol_sampler, vec4(1.0f, 2.0f, float(4), 3.0f));)";
|
||||
case ValidTextureOverload::kSampleCompareDepth2dArrayOffsetF32:
|
||||
return R"(textureOffset(tint_symbol_sampler, vec4(1.0f, 2.0f, float(4), 3.0f), ivec2(5, 6));)";
|
||||
return R"(textureOffset(tint_symbol_sampler, vec4(1.0f, 2.0f, float(4u), 3.0f), ivec2(5, 6));)";
|
||||
case ValidTextureOverload::kSampleCompareDepthCubeF32:
|
||||
return R"(texture(tint_symbol_sampler, vec4(1.0f, 2.0f, 3.0f, 4.0f));)";
|
||||
case ValidTextureOverload::kSampleCompareDepthCubeArrayF32:
|
||||
|
@ -231,37 +231,41 @@ ExpectedResult expected_texture_overload(ast::builtin::test::ValidTextureOverloa
|
|||
case ValidTextureOverload::kSampleCompareLevelDepthCubeArrayF32:
|
||||
return R"(texture(tint_symbol_sampler, vec4(1.0f, 2.0f, 3.0f, float(4)), 5.0f);)";
|
||||
case ValidTextureOverload::kLoad1dLevelF32:
|
||||
return R"(texelFetch(tint_symbol_2, int(1u), int(3u));)";
|
||||
case ValidTextureOverload::kLoad1dLevelU32:
|
||||
case ValidTextureOverload::kLoad1dLevelI32:
|
||||
return R"(texelFetch(tint_symbol_2, 1, 3);)";
|
||||
case ValidTextureOverload::kLoad2dLevelF32:
|
||||
case ValidTextureOverload::kLoad2dLevelU32:
|
||||
case ValidTextureOverload::kLoad2dLevelI32:
|
||||
return R"(texelFetch(tint_symbol_2, ivec2(1, 2), 3);)";
|
||||
case ValidTextureOverload::kLoad2dLevelF32:
|
||||
case ValidTextureOverload::kLoad2dLevelI32:
|
||||
return R"(texelFetch(tint_symbol_2, ivec2(uvec2(1u, 2u)), int(3u));)";
|
||||
case ValidTextureOverload::kLoad2dArrayLevelF32:
|
||||
case ValidTextureOverload::kLoad2dArrayLevelU32:
|
||||
case ValidTextureOverload::kLoad2dArrayLevelI32:
|
||||
case ValidTextureOverload::kLoad3dLevelF32:
|
||||
case ValidTextureOverload::kLoad3dLevelU32:
|
||||
case ValidTextureOverload::kLoad3dLevelI32:
|
||||
return R"(texelFetch(tint_symbol_2, ivec3(1, 2, 3), 4);)";
|
||||
case ValidTextureOverload::kLoad2dArrayLevelI32:
|
||||
case ValidTextureOverload::kLoad3dLevelI32:
|
||||
return R"(texelFetch(tint_symbol_2, ivec3(uvec3(1u, 2u, 3u)), int(4u));)";
|
||||
case ValidTextureOverload::kLoadDepthMultisampled2dF32:
|
||||
case ValidTextureOverload::kLoadMultisampled2dF32:
|
||||
case ValidTextureOverload::kLoadMultisampled2dU32:
|
||||
case ValidTextureOverload::kLoadMultisampled2dI32:
|
||||
return R"(texelFetch(tint_symbol_2, ivec2(1, 2), 3);)";
|
||||
case ValidTextureOverload::kLoadMultisampled2dI32:
|
||||
return R"(texelFetch(tint_symbol_2, ivec2(uvec2(1u, 2u)), int(3u));)";
|
||||
case ValidTextureOverload::kLoadDepth2dLevelF32:
|
||||
return R"(texelFetch(tint_symbol_2, ivec2(1, 2), 3);)";
|
||||
case ValidTextureOverload::kLoadDepth2dArrayLevelF32:
|
||||
return R"(texelFetch(tint_symbol_2, ivec3(1, 2, 3), 4);)";
|
||||
return R"(texelFetch(tint_symbol_2, ivec3(uvec3(1u, 2u, 3u)), int(4u));)";
|
||||
case ValidTextureOverload::kStoreWO1dRgba32float:
|
||||
return R"(imageStore(tint_symbol, 1, vec4(2.0f, 3.0f, 4.0f, 5.0f));)";
|
||||
case ValidTextureOverload::kStoreWO2dRgba32float:
|
||||
return R"(imageStore(tint_symbol, ivec2(1, 2), vec4(3.0f, 4.0f, 5.0f, 6.0f));)";
|
||||
case ValidTextureOverload::kStoreWO2dArrayRgba32float:
|
||||
return R"(imageStore(tint_symbol, ivec3(1, 2, 3), vec4(4.0f, 5.0f, 6.0f, 7.0f));)";
|
||||
return R"(imageStore(tint_symbol, ivec3(uvec3(1u, 2u, 3u)), vec4(4.0f, 5.0f, 6.0f, 7.0f));)";
|
||||
case ValidTextureOverload::kStoreWO3dRgba32float:
|
||||
return R"(imageStore(tint_symbol, ivec3(1, 2, 3), vec4(4.0f, 5.0f, 6.0f, 7.0f));)";
|
||||
return R"(imageStore(tint_symbol, ivec3(uvec3(1u, 2u, 3u)), vec4(4.0f, 5.0f, 6.0f, 7.0f));)";
|
||||
}
|
||||
return "<unmatched texture overload>";
|
||||
} // NOLINT - Ignore the length of this function
|
||||
|
|
|
@ -139,23 +139,23 @@ ExpectedResult expected_texture_overload(ast::builtin::test::ValidTextureOverloa
|
|||
case ValidTextureOverload::kGather2dArrayF32:
|
||||
return R"(tint_symbol.GatherRed(tint_symbol_1, float3(1.0f, 2.0f, float(3))))";
|
||||
case ValidTextureOverload::kGather2dArrayOffsetF32:
|
||||
return R"(tint_symbol.GatherRed(tint_symbol_1, float3(1.0f, 2.0f, float(3)), int2(4, 5)))";
|
||||
return R"(tint_symbol.GatherRed(tint_symbol_1, float3(1.0f, 2.0f, float(3u)), int2(4, 5)))";
|
||||
case ValidTextureOverload::kGatherCubeF32:
|
||||
return R"(tint_symbol.GatherRed(tint_symbol_1, float3(1.0f, 2.0f, 3.0f)))";
|
||||
case ValidTextureOverload::kGatherCubeArrayF32:
|
||||
return R"(tint_symbol.GatherRed(tint_symbol_1, float4(1.0f, 2.0f, 3.0f, float(4))))";
|
||||
return R"(tint_symbol.GatherRed(tint_symbol_1, float4(1.0f, 2.0f, 3.0f, float(4u))))";
|
||||
case ValidTextureOverload::kGatherDepth2dF32:
|
||||
return R"(tint_symbol.Gather(tint_symbol_1, float2(1.0f, 2.0f)))";
|
||||
case ValidTextureOverload::kGatherDepth2dOffsetF32:
|
||||
return R"(tint_symbol.Gather(tint_symbol_1, float2(1.0f, 2.0f), int2(3, 4)))";
|
||||
case ValidTextureOverload::kGatherDepth2dArrayF32:
|
||||
return R"(tint_symbol.Gather(tint_symbol_1, float3(1.0f, 2.0f, float(3))))";
|
||||
return R"(tint_symbol.Gather(tint_symbol_1, float3(1.0f, 2.0f, float(3u))))";
|
||||
case ValidTextureOverload::kGatherDepth2dArrayOffsetF32:
|
||||
return R"(tint_symbol.Gather(tint_symbol_1, float3(1.0f, 2.0f, float(3)), int2(4, 5)))";
|
||||
case ValidTextureOverload::kGatherDepthCubeF32:
|
||||
return R"(tint_symbol.Gather(tint_symbol_1, float3(1.0f, 2.0f, 3.0f)))";
|
||||
case ValidTextureOverload::kGatherDepthCubeArrayF32:
|
||||
return R"(tint_symbol.Gather(tint_symbol_1, float4(1.0f, 2.0f, 3.0f, float(4))))";
|
||||
return R"(tint_symbol.Gather(tint_symbol_1, float4(1.0f, 2.0f, 3.0f, float(4u))))";
|
||||
case ValidTextureOverload::kGatherCompareDepth2dF32:
|
||||
return R"(tint_symbol.GatherCmp(tint_symbol_1, float2(1.0f, 2.0f), 3.0f))";
|
||||
case ValidTextureOverload::kGatherCompareDepth2dOffsetF32:
|
||||
|
@ -167,7 +167,7 @@ ExpectedResult expected_texture_overload(ast::builtin::test::ValidTextureOverloa
|
|||
case ValidTextureOverload::kGatherCompareDepthCubeF32:
|
||||
return R"(tint_symbol.GatherCmp(tint_symbol_1, float3(1.0f, 2.0f, 3.0f), 4.0f))";
|
||||
case ValidTextureOverload::kGatherCompareDepthCubeArrayF32:
|
||||
return R"(tint_symbol.GatherCmp(tint_symbol_1, float4(1.0f, 2.0f, 3.0f, float(4)), 5.0f))";
|
||||
return R"(tint_symbol.GatherCmp(tint_symbol_1, float4(1.0f, 2.0f, 3.0f, float(4u)), 5.0f))";
|
||||
case ValidTextureOverload::kNumLayers2dArray:
|
||||
case ValidTextureOverload::kNumLayersDepth2dArray:
|
||||
case ValidTextureOverload::kNumLayersCubeArray:
|
||||
|
@ -217,7 +217,7 @@ ExpectedResult expected_texture_overload(ast::builtin::test::ValidTextureOverloa
|
|||
case ValidTextureOverload::kSample2dArrayF32:
|
||||
return R"(tint_symbol.Sample(tint_symbol_1, float3(1.0f, 2.0f, float(3)));)";
|
||||
case ValidTextureOverload::kSample2dArrayOffsetF32:
|
||||
return R"(tint_symbol.Sample(tint_symbol_1, float3(1.0f, 2.0f, float(3)), int2(4, 5));)";
|
||||
return R"(tint_symbol.Sample(tint_symbol_1, float3(1.0f, 2.0f, float(3u)), int2(4, 5));)";
|
||||
case ValidTextureOverload::kSample3dF32:
|
||||
return R"(tint_symbol.Sample(tint_symbol_1, float3(1.0f, 2.0f, 3.0f));)";
|
||||
case ValidTextureOverload::kSample3dOffsetF32:
|
||||
|
@ -237,13 +237,13 @@ ExpectedResult expected_texture_overload(ast::builtin::test::ValidTextureOverloa
|
|||
case ValidTextureOverload::kSampleDepthCubeF32:
|
||||
return R"(tint_symbol.Sample(tint_symbol_1, float3(1.0f, 2.0f, 3.0f)).x;)";
|
||||
case ValidTextureOverload::kSampleDepthCubeArrayF32:
|
||||
return R"(tint_symbol.Sample(tint_symbol_1, float4(1.0f, 2.0f, 3.0f, float(4))).x;)";
|
||||
return R"(tint_symbol.Sample(tint_symbol_1, float4(1.0f, 2.0f, 3.0f, float(4u))).x;)";
|
||||
case ValidTextureOverload::kSampleBias2dF32:
|
||||
return R"(tint_symbol.SampleBias(tint_symbol_1, float2(1.0f, 2.0f), 3.0f);)";
|
||||
case ValidTextureOverload::kSampleBias2dOffsetF32:
|
||||
return R"(tint_symbol.SampleBias(tint_symbol_1, float2(1.0f, 2.0f), 3.0f, int2(4, 5));)";
|
||||
case ValidTextureOverload::kSampleBias2dArrayF32:
|
||||
return R"(tint_symbol.SampleBias(tint_symbol_1, float3(1.0f, 2.0f, float(4)), 3.0f);)";
|
||||
return R"(tint_symbol.SampleBias(tint_symbol_1, float3(1.0f, 2.0f, float(4u)), 3.0f);)";
|
||||
case ValidTextureOverload::kSampleBias2dArrayOffsetF32:
|
||||
return R"(tint_symbol.SampleBias(tint_symbol_1, float3(1.0f, 2.0f, float(3)), 4.0f, int2(5, 6));)";
|
||||
case ValidTextureOverload::kSampleBias3dF32:
|
||||
|
@ -271,13 +271,13 @@ ExpectedResult expected_texture_overload(ast::builtin::test::ValidTextureOverloa
|
|||
case ValidTextureOverload::kSampleLevelCubeArrayF32:
|
||||
return R"(tint_symbol.SampleLevel(tint_symbol_1, float4(1.0f, 2.0f, 3.0f, float(4)), 5.0f);)";
|
||||
case ValidTextureOverload::kSampleLevelDepth2dF32:
|
||||
return R"(tint_symbol.SampleLevel(tint_symbol_1, float2(1.0f, 2.0f), 3).x;)";
|
||||
return R"(tint_symbol.SampleLevel(tint_symbol_1, float2(1.0f, 2.0f), 3u).x;)";
|
||||
case ValidTextureOverload::kSampleLevelDepth2dOffsetF32:
|
||||
return R"(tint_symbol.SampleLevel(tint_symbol_1, float2(1.0f, 2.0f), 3, int2(4, 5)).x;)";
|
||||
case ValidTextureOverload::kSampleLevelDepth2dArrayF32:
|
||||
return R"(tint_symbol.SampleLevel(tint_symbol_1, float3(1.0f, 2.0f, float(3)), 4).x;)";
|
||||
return R"(tint_symbol.SampleLevel(tint_symbol_1, float3(1.0f, 2.0f, float(3u)), 4u).x;)";
|
||||
case ValidTextureOverload::kSampleLevelDepth2dArrayOffsetF32:
|
||||
return R"(tint_symbol.SampleLevel(tint_symbol_1, float3(1.0f, 2.0f, float(3)), 4, int2(5, 6)).x;)";
|
||||
return R"(tint_symbol.SampleLevel(tint_symbol_1, float3(1.0f, 2.0f, float(3u)), 4u, int2(5, 6)).x;)";
|
||||
case ValidTextureOverload::kSampleLevelDepthCubeF32:
|
||||
return R"(tint_symbol.SampleLevel(tint_symbol_1, float3(1.0f, 2.0f, 3.0f), 4).x;)";
|
||||
case ValidTextureOverload::kSampleLevelDepthCubeArrayF32:
|
||||
|
@ -289,7 +289,7 @@ ExpectedResult expected_texture_overload(ast::builtin::test::ValidTextureOverloa
|
|||
case ValidTextureOverload::kSampleGrad2dArrayF32:
|
||||
return R"(tint_symbol.SampleGrad(tint_symbol_1, float3(1.0f, 2.0f, float(3)), float2(4.0f, 5.0f), float2(6.0f, 7.0f));)";
|
||||
case ValidTextureOverload::kSampleGrad2dArrayOffsetF32:
|
||||
return R"(tint_symbol.SampleGrad(tint_symbol_1, float3(1.0f, 2.0f, float(3)), float2(4.0f, 5.0f), float2(6.0f, 7.0f), int2(6, 7));)";
|
||||
return R"(tint_symbol.SampleGrad(tint_symbol_1, float3(1.0f, 2.0f, float(3u)), float2(4.0f, 5.0f), float2(6.0f, 7.0f), int2(6, 7));)";
|
||||
case ValidTextureOverload::kSampleGrad3dF32:
|
||||
return R"(tint_symbol.SampleGrad(tint_symbol_1, float3(1.0f, 2.0f, 3.0f), float3(4.0f, 5.0f, 6.0f), float3(7.0f, 8.0f, 9.0f));)";
|
||||
case ValidTextureOverload::kSampleGrad3dOffsetF32:
|
||||
|
@ -297,7 +297,7 @@ ExpectedResult expected_texture_overload(ast::builtin::test::ValidTextureOverloa
|
|||
case ValidTextureOverload::kSampleGradCubeF32:
|
||||
return R"(tint_symbol.SampleGrad(tint_symbol_1, float3(1.0f, 2.0f, 3.0f), float3(4.0f, 5.0f, 6.0f), float3(7.0f, 8.0f, 9.0f));)";
|
||||
case ValidTextureOverload::kSampleGradCubeArrayF32:
|
||||
return R"(tint_symbol.SampleGrad(tint_symbol_1, float4(1.0f, 2.0f, 3.0f, float(4)), float3(5.0f, 6.0f, 7.0f), float3(8.0f, 9.0f, 10.0f));)";
|
||||
return R"(tint_symbol.SampleGrad(tint_symbol_1, float4(1.0f, 2.0f, 3.0f, float(4u)), float3(5.0f, 6.0f, 7.0f), float3(8.0f, 9.0f, 10.0f));)";
|
||||
case ValidTextureOverload::kSampleCompareDepth2dF32:
|
||||
return R"(tint_symbol.SampleCmp(tint_symbol_1, float2(1.0f, 2.0f), 3.0f);)";
|
||||
case ValidTextureOverload::kSampleCompareDepth2dOffsetF32:
|
||||
|
@ -305,7 +305,7 @@ ExpectedResult expected_texture_overload(ast::builtin::test::ValidTextureOverloa
|
|||
case ValidTextureOverload::kSampleCompareDepth2dArrayF32:
|
||||
return R"(tint_symbol.SampleCmp(tint_symbol_1, float3(1.0f, 2.0f, float(4)), 3.0f);)";
|
||||
case ValidTextureOverload::kSampleCompareDepth2dArrayOffsetF32:
|
||||
return R"(tint_symbol.SampleCmp(tint_symbol_1, float3(1.0f, 2.0f, float(4)), 3.0f, int2(5, 6));)";
|
||||
return R"(tint_symbol.SampleCmp(tint_symbol_1, float3(1.0f, 2.0f, float(4u)), 3.0f, int2(5, 6));)";
|
||||
case ValidTextureOverload::kSampleCompareDepthCubeF32:
|
||||
return R"(tint_symbol.SampleCmp(tint_symbol_1, float3(1.0f, 2.0f, 3.0f), 4.0f);)";
|
||||
case ValidTextureOverload::kSampleCompareDepthCubeArrayF32:
|
||||
|
@ -323,37 +323,41 @@ ExpectedResult expected_texture_overload(ast::builtin::test::ValidTextureOverloa
|
|||
case ValidTextureOverload::kSampleCompareLevelDepthCubeArrayF32:
|
||||
return R"(tint_symbol.SampleCmpLevelZero(tint_symbol_1, float4(1.0f, 2.0f, 3.0f, float(4)), 5.0f);)";
|
||||
case ValidTextureOverload::kLoad1dLevelF32:
|
||||
return R"(tint_symbol.Load(uint2(1u, 3u));)";
|
||||
case ValidTextureOverload::kLoad1dLevelU32:
|
||||
case ValidTextureOverload::kLoad1dLevelI32:
|
||||
return R"(tint_symbol.Load(int2(1, 3));)";
|
||||
case ValidTextureOverload::kLoad2dLevelF32:
|
||||
case ValidTextureOverload::kLoad2dLevelU32:
|
||||
case ValidTextureOverload::kLoad2dLevelI32:
|
||||
return R"(tint_symbol.Load(int3(1, 2, 3));)";
|
||||
case ValidTextureOverload::kLoad2dLevelF32:
|
||||
case ValidTextureOverload::kLoad2dLevelI32:
|
||||
return R"(tint_symbol.Load(uint3(1u, 2u, 3u));)";
|
||||
case ValidTextureOverload::kLoad2dArrayLevelF32:
|
||||
case ValidTextureOverload::kLoad2dArrayLevelU32:
|
||||
case ValidTextureOverload::kLoad2dArrayLevelI32:
|
||||
case ValidTextureOverload::kLoad3dLevelF32:
|
||||
case ValidTextureOverload::kLoad3dLevelU32:
|
||||
case ValidTextureOverload::kLoad3dLevelI32:
|
||||
return R"(tint_symbol.Load(int4(1, 2, 3, 4));)";
|
||||
case ValidTextureOverload::kLoad2dArrayLevelI32:
|
||||
case ValidTextureOverload::kLoad3dLevelI32:
|
||||
return R"(tint_symbol.Load(uint4(1u, 2u, 3u, 4u));)";
|
||||
case ValidTextureOverload::kLoadDepthMultisampled2dF32:
|
||||
case ValidTextureOverload::kLoadMultisampled2dF32:
|
||||
case ValidTextureOverload::kLoadMultisampled2dU32:
|
||||
case ValidTextureOverload::kLoadMultisampled2dI32:
|
||||
return R"(tint_symbol.Load(int2(1, 2), 3);)";
|
||||
case ValidTextureOverload::kLoadMultisampled2dI32:
|
||||
return R"(tint_symbol.Load(uint2(1u, 2u), 3u);)";
|
||||
case ValidTextureOverload::kLoadDepth2dLevelF32:
|
||||
return R"(tint_symbol.Load(int3(1, 2, 3)).x;)";
|
||||
case ValidTextureOverload::kLoadDepth2dArrayLevelF32:
|
||||
return R"(tint_symbol.Load(int4(1, 2, 3, 4)).x;)";
|
||||
return R"(tint_symbol.Load(uint4(1u, 2u, 3u, 4u)).x;)";
|
||||
case ValidTextureOverload::kStoreWO1dRgba32float:
|
||||
return R"(tint_symbol[1] = float4(2.0f, 3.0f, 4.0f, 5.0f);)";
|
||||
case ValidTextureOverload::kStoreWO2dRgba32float:
|
||||
return R"(tint_symbol[int2(1, 2)] = float4(3.0f, 4.0f, 5.0f, 6.0f);)";
|
||||
case ValidTextureOverload::kStoreWO2dArrayRgba32float:
|
||||
return R"(tint_symbol[int3(1, 2, 3)] = float4(4.0f, 5.0f, 6.0f, 7.0f);)";
|
||||
return R"(tint_symbol[uint3(1u, 2u, 3u)] = float4(4.0f, 5.0f, 6.0f, 7.0f);)";
|
||||
case ValidTextureOverload::kStoreWO3dRgba32float:
|
||||
return R"(tint_symbol[int3(1, 2, 3)] = float4(4.0f, 5.0f, 6.0f, 7.0f);)";
|
||||
return R"(tint_symbol[uint3(1u, 2u, 3u)] = float4(4.0f, 5.0f, 6.0f, 7.0f);)";
|
||||
}
|
||||
return "<unmatched texture overload>";
|
||||
} // NOLINT - Ignore the length of this function
|
||||
|
|
|
@ -59,23 +59,23 @@ std::string expected_texture_overload(ast::builtin::test::ValidTextureOverload o
|
|||
case ValidTextureOverload::kGather2dArrayF32:
|
||||
return R"(texture.gather(sampler, float2(1.0f, 2.0f), 3, int2(0), component::x))";
|
||||
case ValidTextureOverload::kGather2dArrayOffsetF32:
|
||||
return R"(texture.gather(sampler, float2(1.0f, 2.0f), 3, int2(4, 5), component::x))";
|
||||
return R"(texture.gather(sampler, float2(1.0f, 2.0f), 3u, int2(4, 5), component::x))";
|
||||
case ValidTextureOverload::kGatherCubeF32:
|
||||
return R"(texture.gather(sampler, float3(1.0f, 2.0f, 3.0f), component::x))";
|
||||
case ValidTextureOverload::kGatherCubeArrayF32:
|
||||
return R"(texture.gather(sampler, float3(1.0f, 2.0f, 3.0f), 4, component::x))";
|
||||
return R"(texture.gather(sampler, float3(1.0f, 2.0f, 3.0f), 4u, component::x))";
|
||||
case ValidTextureOverload::kGatherDepth2dF32:
|
||||
return R"(texture.gather(sampler, float2(1.0f, 2.0f)))";
|
||||
case ValidTextureOverload::kGatherDepth2dOffsetF32:
|
||||
return R"(texture.gather(sampler, float2(1.0f, 2.0f), int2(3, 4)))";
|
||||
case ValidTextureOverload::kGatherDepth2dArrayF32:
|
||||
return R"(texture.gather(sampler, float2(1.0f, 2.0f), 3))";
|
||||
return R"(texture.gather(sampler, float2(1.0f, 2.0f), 3u))";
|
||||
case ValidTextureOverload::kGatherDepth2dArrayOffsetF32:
|
||||
return R"(texture.gather(sampler, float2(1.0f, 2.0f), 3, int2(4, 5)))";
|
||||
case ValidTextureOverload::kGatherDepthCubeF32:
|
||||
return R"(texture.gather(sampler, float3(1.0f, 2.0f, 3.0f)))";
|
||||
case ValidTextureOverload::kGatherDepthCubeArrayF32:
|
||||
return R"(texture.gather(sampler, float3(1.0f, 2.0f, 3.0f), 4))";
|
||||
return R"(texture.gather(sampler, float3(1.0f, 2.0f, 3.0f), 4u))";
|
||||
case ValidTextureOverload::kGatherCompareDepth2dF32:
|
||||
return R"(texture.gather_compare(sampler, float2(1.0f, 2.0f), 3.0f))";
|
||||
case ValidTextureOverload::kGatherCompareDepth2dOffsetF32:
|
||||
|
@ -87,7 +87,7 @@ std::string expected_texture_overload(ast::builtin::test::ValidTextureOverload o
|
|||
case ValidTextureOverload::kGatherCompareDepthCubeF32:
|
||||
return R"(texture.gather_compare(sampler, float3(1.0f, 2.0f, 3.0f), 4.0f))";
|
||||
case ValidTextureOverload::kGatherCompareDepthCubeArrayF32:
|
||||
return R"(texture.gather_compare(sampler, float3(1.0f, 2.0f, 3.0f), 4, 5.0f))";
|
||||
return R"(texture.gather_compare(sampler, float3(1.0f, 2.0f, 3.0f), 4u, 5.0f))";
|
||||
case ValidTextureOverload::kNumLayers2dArray:
|
||||
case ValidTextureOverload::kNumLayersCubeArray:
|
||||
case ValidTextureOverload::kNumLayersDepth2dArray:
|
||||
|
@ -116,7 +116,7 @@ std::string expected_texture_overload(ast::builtin::test::ValidTextureOverload o
|
|||
case ValidTextureOverload::kSample2dArrayF32:
|
||||
return R"(texture.sample(sampler, float2(1.0f, 2.0f), 3))";
|
||||
case ValidTextureOverload::kSample2dArrayOffsetF32:
|
||||
return R"(texture.sample(sampler, float2(1.0f, 2.0f), 3, int2(4, 5)))";
|
||||
return R"(texture.sample(sampler, float2(1.0f, 2.0f), 3u, int2(4, 5)))";
|
||||
case ValidTextureOverload::kSample3dF32:
|
||||
return R"(texture.sample(sampler, float3(1.0f, 2.0f, 3.0f)))";
|
||||
case ValidTextureOverload::kSample3dOffsetF32:
|
||||
|
@ -136,13 +136,13 @@ std::string expected_texture_overload(ast::builtin::test::ValidTextureOverload o
|
|||
case ValidTextureOverload::kSampleDepthCubeF32:
|
||||
return R"(texture.sample(sampler, float3(1.0f, 2.0f, 3.0f)))";
|
||||
case ValidTextureOverload::kSampleDepthCubeArrayF32:
|
||||
return R"(texture.sample(sampler, float3(1.0f, 2.0f, 3.0f), 4))";
|
||||
return R"(texture.sample(sampler, float3(1.0f, 2.0f, 3.0f), 4u))";
|
||||
case ValidTextureOverload::kSampleBias2dF32:
|
||||
return R"(texture.sample(sampler, float2(1.0f, 2.0f), bias(3.0f)))";
|
||||
case ValidTextureOverload::kSampleBias2dOffsetF32:
|
||||
return R"(texture.sample(sampler, float2(1.0f, 2.0f), bias(3.0f), int2(4, 5)))";
|
||||
case ValidTextureOverload::kSampleBias2dArrayF32:
|
||||
return R"(texture.sample(sampler, float2(1.0f, 2.0f), 4, bias(3.0f)))";
|
||||
return R"(texture.sample(sampler, float2(1.0f, 2.0f), 4u, bias(3.0f)))";
|
||||
case ValidTextureOverload::kSampleBias2dArrayOffsetF32:
|
||||
return R"(texture.sample(sampler, float2(1.0f, 2.0f), 3, bias(4.0f), int2(5, 6)))";
|
||||
case ValidTextureOverload::kSampleBias3dF32:
|
||||
|
@ -170,13 +170,13 @@ std::string expected_texture_overload(ast::builtin::test::ValidTextureOverload o
|
|||
case ValidTextureOverload::kSampleLevelCubeArrayF32:
|
||||
return R"(texture.sample(sampler, float3(1.0f, 2.0f, 3.0f), 4, level(5.0f)))";
|
||||
case ValidTextureOverload::kSampleLevelDepth2dF32:
|
||||
return R"(texture.sample(sampler, float2(1.0f, 2.0f), level(3)))";
|
||||
return R"(texture.sample(sampler, float2(1.0f, 2.0f), level(3u)))";
|
||||
case ValidTextureOverload::kSampleLevelDepth2dOffsetF32:
|
||||
return R"(texture.sample(sampler, float2(1.0f, 2.0f), level(3), int2(4, 5)))";
|
||||
case ValidTextureOverload::kSampleLevelDepth2dArrayF32:
|
||||
return R"(texture.sample(sampler, float2(1.0f, 2.0f), 3, level(4)))";
|
||||
return R"(texture.sample(sampler, float2(1.0f, 2.0f), 3u, level(4u)))";
|
||||
case ValidTextureOverload::kSampleLevelDepth2dArrayOffsetF32:
|
||||
return R"(texture.sample(sampler, float2(1.0f, 2.0f), 3, level(4), int2(5, 6)))";
|
||||
return R"(texture.sample(sampler, float2(1.0f, 2.0f), 3u, level(4u), int2(5, 6)))";
|
||||
case ValidTextureOverload::kSampleLevelDepthCubeF32:
|
||||
return R"(texture.sample(sampler, float3(1.0f, 2.0f, 3.0f), level(4)))";
|
||||
case ValidTextureOverload::kSampleLevelDepthCubeArrayF32:
|
||||
|
@ -188,7 +188,7 @@ std::string expected_texture_overload(ast::builtin::test::ValidTextureOverload o
|
|||
case ValidTextureOverload::kSampleGrad2dArrayF32:
|
||||
return R"(texture.sample(sampler, float2(1.0f, 2.0f), 3, gradient2d(float2(4.0f, 5.0f), float2(6.0f, 7.0f))))";
|
||||
case ValidTextureOverload::kSampleGrad2dArrayOffsetF32:
|
||||
return R"(texture.sample(sampler, float2(1.0f, 2.0f), 3, gradient2d(float2(4.0f, 5.0f), float2(6.0f, 7.0f)), int2(6, 7)))";
|
||||
return R"(texture.sample(sampler, float2(1.0f, 2.0f), 3u, gradient2d(float2(4.0f, 5.0f), float2(6.0f, 7.0f)), int2(6, 7)))";
|
||||
case ValidTextureOverload::kSampleGrad3dF32:
|
||||
return R"(texture.sample(sampler, float3(1.0f, 2.0f, 3.0f), gradient3d(float3(4.0f, 5.0f, 6.0f), float3(7.0f, 8.0f, 9.0f))))";
|
||||
case ValidTextureOverload::kSampleGrad3dOffsetF32:
|
||||
|
@ -196,7 +196,7 @@ std::string expected_texture_overload(ast::builtin::test::ValidTextureOverload o
|
|||
case ValidTextureOverload::kSampleGradCubeF32:
|
||||
return R"(texture.sample(sampler, float3(1.0f, 2.0f, 3.0f), gradientcube(float3(4.0f, 5.0f, 6.0f), float3(7.0f, 8.0f, 9.0f))))";
|
||||
case ValidTextureOverload::kSampleGradCubeArrayF32:
|
||||
return R"(texture.sample(sampler, float3(1.0f, 2.0f, 3.0f), 4, gradientcube(float3(5.0f, 6.0f, 7.0f), float3(8.0f, 9.0f, 10.0f))))";
|
||||
return R"(texture.sample(sampler, float3(1.0f, 2.0f, 3.0f), 4u, gradientcube(float3(5.0f, 6.0f, 7.0f), float3(8.0f, 9.0f, 10.0f))))";
|
||||
case ValidTextureOverload::kSampleCompareDepth2dF32:
|
||||
return R"(texture.sample_compare(sampler, float2(1.0f, 2.0f), 3.0f))";
|
||||
case ValidTextureOverload::kSampleCompareDepth2dOffsetF32:
|
||||
|
@ -204,7 +204,7 @@ std::string expected_texture_overload(ast::builtin::test::ValidTextureOverload o
|
|||
case ValidTextureOverload::kSampleCompareDepth2dArrayF32:
|
||||
return R"(texture.sample_compare(sampler, float2(1.0f, 2.0f), 4, 3.0f))";
|
||||
case ValidTextureOverload::kSampleCompareDepth2dArrayOffsetF32:
|
||||
return R"(texture.sample_compare(sampler, float2(1.0f, 2.0f), 4, 3.0f, int2(5, 6)))";
|
||||
return R"(texture.sample_compare(sampler, float2(1.0f, 2.0f), 4u, 3.0f, int2(5, 6)))";
|
||||
case ValidTextureOverload::kSampleCompareDepthCubeF32:
|
||||
return R"(texture.sample_compare(sampler, float3(1.0f, 2.0f, 3.0f), 4.0f))";
|
||||
case ValidTextureOverload::kSampleCompareDepthCubeArrayF32:
|
||||
|
@ -222,48 +222,46 @@ std::string expected_texture_overload(ast::builtin::test::ValidTextureOverload o
|
|||
case ValidTextureOverload::kSampleCompareLevelDepthCubeArrayF32:
|
||||
return R"(texture.sample_compare(sampler, float3(1.0f, 2.0f, 3.0f), 4, 5.0f))";
|
||||
case ValidTextureOverload::kLoad1dLevelF32:
|
||||
return R"(texture.read(uint(1), 0))";
|
||||
return R"(texture.read(uint(1u), 0))";
|
||||
case ValidTextureOverload::kLoad1dLevelU32:
|
||||
return R"(texture.read(uint(1), 0))";
|
||||
case ValidTextureOverload::kLoad1dLevelI32:
|
||||
return R"(texture.read(uint(1), 0))";
|
||||
case ValidTextureOverload::kLoad2dLevelF32:
|
||||
return R"(texture.read(uint2(int2(1, 2)), 3))";
|
||||
return R"(texture.read(uint2(uint2(1u, 2u)), 3u))";
|
||||
case ValidTextureOverload::kLoad2dLevelU32:
|
||||
return R"(texture.read(uint2(int2(1, 2)), 3))";
|
||||
case ValidTextureOverload::kLoad2dLevelI32:
|
||||
return R"(texture.read(uint2(int2(1, 2)), 3))";
|
||||
case ValidTextureOverload::kLoad2dArrayLevelF32:
|
||||
return R"(texture.read(uint2(int2(1, 2)), 3, 4))";
|
||||
case ValidTextureOverload::kLoad2dArrayLevelU32:
|
||||
return R"(texture.read(uint2(int2(1, 2)), 3, 4))";
|
||||
case ValidTextureOverload::kLoad2dArrayLevelI32:
|
||||
return R"(texture.read(uint2(int2(1, 2)), 3, 4))";
|
||||
return R"(texture.read(uint2(uint2(1u, 2u)), 3u, 4u))";
|
||||
case ValidTextureOverload::kLoad3dLevelF32:
|
||||
return R"(texture.read(uint3(int3(1, 2, 3)), 4))";
|
||||
case ValidTextureOverload::kLoad3dLevelU32:
|
||||
return R"(texture.read(uint3(int3(1, 2, 3)), 4))";
|
||||
case ValidTextureOverload::kLoad3dLevelI32:
|
||||
return R"(texture.read(uint3(int3(1, 2, 3)), 4))";
|
||||
return R"(texture.read(uint3(uint3(1u, 2u, 3u)), 4u))";
|
||||
case ValidTextureOverload::kLoadMultisampled2dF32:
|
||||
return R"(texture.read(uint2(int2(1, 2)), 3))";
|
||||
case ValidTextureOverload::kLoadMultisampled2dU32:
|
||||
return R"(texture.read(uint2(int2(1, 2)), 3))";
|
||||
case ValidTextureOverload::kLoad2dLevelI32:
|
||||
case ValidTextureOverload::kLoadMultisampled2dI32:
|
||||
return R"(texture.read(uint2(int2(1, 2)), 3))";
|
||||
return R"(texture.read(uint2(uint2(1u, 2u)), 3u))";
|
||||
case ValidTextureOverload::kLoadDepth2dLevelF32:
|
||||
case ValidTextureOverload::kLoadDepthMultisampled2dF32:
|
||||
return R"(texture.read(uint2(int2(1, 2)), 3))";
|
||||
case ValidTextureOverload::kLoadDepth2dArrayLevelF32:
|
||||
return R"(texture.read(uint2(int2(1, 2)), 3, 4))";
|
||||
return R"(texture.read(uint2(uint2(1u, 2u)), 3u, 4u))";
|
||||
case ValidTextureOverload::kStoreWO1dRgba32float:
|
||||
return R"(texture.write(float4(2.0f, 3.0f, 4.0f, 5.0f), uint(1)))";
|
||||
case ValidTextureOverload::kStoreWO2dRgba32float:
|
||||
return R"(texture.write(float4(3.0f, 4.0f, 5.0f, 6.0f), uint2(int2(1, 2))))";
|
||||
case ValidTextureOverload::kStoreWO2dArrayRgba32float:
|
||||
return R"(texture.write(float4(4.0f, 5.0f, 6.0f, 7.0f), uint2(int2(1, 2)), 3))";
|
||||
return R"(texture.write(float4(4.0f, 5.0f, 6.0f, 7.0f), uint2(uint2(1u, 2u)), 3u))";
|
||||
case ValidTextureOverload::kStoreWO3dRgba32float:
|
||||
return R"(texture.write(float4(4.0f, 5.0f, 6.0f, 7.0f), uint3(int3(1, 2, 3))))";
|
||||
return R"(texture.write(float4(4.0f, 5.0f, 6.0f, 7.0f), uint3(uint3(1u, 2u, 3u))))";
|
||||
}
|
||||
return "<unmatched texture overload>";
|
||||
} // NOLINT - Ignore the length of this function
|
||||
|
|
|
@ -2937,9 +2937,9 @@ bool Builder::GenerateTextureBuiltin(const sem::Call* call,
|
|||
return false;
|
||||
}
|
||||
auto level = Operand(0u);
|
||||
if (arg(Usage::kLevel)->Type()->UnwrapRef()->Is<sem::I32>()) {
|
||||
// Depth textures have i32 parameters for the level, but SPIR-V expects
|
||||
// F32. Cast.
|
||||
if (arg(Usage::kLevel)->Type()->UnwrapRef()->IsAnyOf<sem::I32, sem::U32>()) {
|
||||
// Depth textures have i32 or u32 parameters for the level, but SPIR-V expects f32.
|
||||
// Cast.
|
||||
auto f32_type_id = GenerateTypeIfNeeded(builder_.create<sem::F32>());
|
||||
if (f32_type_id == 0) {
|
||||
return 0;
|
||||
|
|
|
@ -614,18 +614,19 @@ OpCapability ImageQuery
|
|||
%15 = OpConstant %4 1
|
||||
%16 = OpConstant %4 2
|
||||
%17 = OpConstantComposite %14 %15 %16
|
||||
%18 = OpTypeInt 32 1
|
||||
%18 = OpTypeInt 32 0
|
||||
%19 = OpConstantNull %18
|
||||
%20 = OpTypeVector %18 2
|
||||
%21 = OpConstant %18 3
|
||||
%22 = OpConstant %18 4
|
||||
%23 = OpConstantComposite %20 %21 %22
|
||||
%21 = OpTypeInt 32 1
|
||||
%20 = OpTypeVector %21 2
|
||||
%22 = OpConstant %21 3
|
||||
%23 = OpConstant %21 4
|
||||
%24 = OpConstantComposite %20 %22 %23
|
||||
)",
|
||||
R"(
|
||||
%10 = OpLoad %7 %5
|
||||
%11 = OpLoad %3 %1
|
||||
%13 = OpSampledImage %12 %11 %10
|
||||
%8 = OpImageGather %9 %13 %17 %19 ConstOffset %23
|
||||
%8 = OpImageGather %9 %13 %17 %19 ConstOffset %24
|
||||
)",
|
||||
R"(
|
||||
)"};
|
||||
|
@ -671,21 +672,22 @@ OpCapability ImageQuery
|
|||
%14 = OpTypeVector %4 3
|
||||
%15 = OpConstant %4 1
|
||||
%16 = OpConstant %4 2
|
||||
%18 = OpTypeInt 32 1
|
||||
%18 = OpTypeInt 32 0
|
||||
%19 = OpConstant %18 3
|
||||
%21 = OpConstantNull %18
|
||||
%22 = OpTypeVector %18 2
|
||||
%23 = OpConstant %18 4
|
||||
%24 = OpConstant %18 5
|
||||
%25 = OpConstantComposite %22 %23 %24
|
||||
%23 = OpTypeInt 32 1
|
||||
%22 = OpTypeVector %23 2
|
||||
%24 = OpConstant %23 4
|
||||
%25 = OpConstant %23 5
|
||||
%26 = OpConstantComposite %22 %24 %25
|
||||
)",
|
||||
R"(
|
||||
%10 = OpLoad %7 %5
|
||||
%11 = OpLoad %3 %1
|
||||
%13 = OpSampledImage %12 %11 %10
|
||||
%17 = OpConvertSToF %4 %19
|
||||
%17 = OpConvertUToF %4 %19
|
||||
%20 = OpCompositeConstruct %14 %15 %16 %17
|
||||
%8 = OpImageGather %9 %13 %20 %21 ConstOffset %25
|
||||
%8 = OpImageGather %9 %13 %20 %21 ConstOffset %26
|
||||
)",
|
||||
R"(
|
||||
)"};
|
||||
|
@ -730,7 +732,7 @@ OpCapability ImageQuery
|
|||
%14 = OpConstant %4 1
|
||||
%15 = OpConstant %4 2
|
||||
%16 = OpConstant %4 3
|
||||
%18 = OpTypeInt 32 1
|
||||
%18 = OpTypeInt 32 0
|
||||
%19 = OpConstant %18 4
|
||||
%21 = OpConstantNull %18
|
||||
)",
|
||||
|
@ -738,7 +740,7 @@ OpCapability ImageQuery
|
|||
%10 = OpLoad %7 %5
|
||||
%11 = OpLoad %3 %1
|
||||
%13 = OpSampledImage %12 %11 %10
|
||||
%17 = OpConvertSToF %4 %19
|
||||
%17 = OpConvertUToF %4 %19
|
||||
%20 = OpCompositeConstruct %9 %14 %15 %16 %17
|
||||
%8 = OpImageGather %9 %13 %20 %21
|
||||
)",
|
||||
|
@ -815,17 +817,18 @@ OpCapability SampledCubeArray
|
|||
%14 = OpTypeVector %4 3
|
||||
%15 = OpConstant %4 1
|
||||
%16 = OpConstant %4 2
|
||||
%18 = OpTypeInt 32 1
|
||||
%18 = OpTypeInt 32 0
|
||||
%19 = OpConstant %18 3
|
||||
%21 = OpConstant %18 0
|
||||
%21 = OpTypeInt 32 1
|
||||
%22 = OpConstant %21 0
|
||||
)",
|
||||
R"(
|
||||
%10 = OpLoad %7 %5
|
||||
%11 = OpLoad %3 %1
|
||||
%13 = OpSampledImage %12 %11 %10
|
||||
%17 = OpConvertSToF %4 %19
|
||||
%17 = OpConvertUToF %4 %19
|
||||
%20 = OpCompositeConstruct %14 %15 %16 %17
|
||||
%8 = OpImageGather %9 %13 %20 %21
|
||||
%8 = OpImageGather %9 %13 %20 %22
|
||||
)",
|
||||
R"(
|
||||
)"};
|
||||
|
@ -902,17 +905,18 @@ OpCapability SampledCubeArray
|
|||
%14 = OpConstant %4 1
|
||||
%15 = OpConstant %4 2
|
||||
%16 = OpConstant %4 3
|
||||
%18 = OpTypeInt 32 1
|
||||
%18 = OpTypeInt 32 0
|
||||
%19 = OpConstant %18 4
|
||||
%21 = OpConstant %18 0
|
||||
%21 = OpTypeInt 32 1
|
||||
%22 = OpConstant %21 0
|
||||
)",
|
||||
R"(
|
||||
%10 = OpLoad %7 %5
|
||||
%11 = OpLoad %3 %1
|
||||
%13 = OpSampledImage %12 %11 %10
|
||||
%17 = OpConvertSToF %4 %19
|
||||
%17 = OpConvertUToF %4 %19
|
||||
%20 = OpCompositeConstruct %9 %14 %15 %16 %17
|
||||
%8 = OpImageGather %9 %13 %20 %21
|
||||
%8 = OpImageGather %9 %13 %20 %22
|
||||
)",
|
||||
R"(
|
||||
OpCapability SampledCubeArray
|
||||
|
@ -1072,7 +1076,7 @@ OpCapability SampledCubeArray
|
|||
%14 = OpConstant %4 1
|
||||
%15 = OpConstant %4 2
|
||||
%16 = OpConstant %4 3
|
||||
%18 = OpTypeInt 32 1
|
||||
%18 = OpTypeInt 32 0
|
||||
%19 = OpConstant %18 4
|
||||
%21 = OpConstant %4 5
|
||||
)",
|
||||
|
@ -1080,7 +1084,7 @@ OpCapability SampledCubeArray
|
|||
%10 = OpLoad %7 %5
|
||||
%11 = OpLoad %3 %1
|
||||
%13 = OpSampledImage %12 %11 %10
|
||||
%17 = OpConvertSToF %4 %19
|
||||
%17 = OpConvertUToF %4 %19
|
||||
%20 = OpCompositeConstruct %9 %14 %15 %16 %17
|
||||
%8 = OpImageDrefGather %9 %13 %20 %21
|
||||
)",
|
||||
|
@ -1514,20 +1518,21 @@ OpCapability Sampled1D
|
|||
%14 = OpTypeVector %4 3
|
||||
%15 = OpConstant %4 1
|
||||
%16 = OpConstant %4 2
|
||||
%18 = OpTypeInt 32 1
|
||||
%18 = OpTypeInt 32 0
|
||||
%19 = OpConstant %18 3
|
||||
%21 = OpTypeVector %18 2
|
||||
%22 = OpConstant %18 4
|
||||
%23 = OpConstant %18 5
|
||||
%24 = OpConstantComposite %21 %22 %23
|
||||
%22 = OpTypeInt 32 1
|
||||
%21 = OpTypeVector %22 2
|
||||
%23 = OpConstant %22 4
|
||||
%24 = OpConstant %22 5
|
||||
%25 = OpConstantComposite %21 %23 %24
|
||||
)",
|
||||
R"(
|
||||
%10 = OpLoad %7 %5
|
||||
%11 = OpLoad %3 %1
|
||||
%13 = OpSampledImage %12 %11 %10
|
||||
%17 = OpConvertSToF %4 %19
|
||||
%17 = OpConvertUToF %4 %19
|
||||
%20 = OpCompositeConstruct %14 %15 %16 %17
|
||||
%8 = OpImageSampleImplicitLod %9 %13 %20 ConstOffset %24
|
||||
%8 = OpImageSampleImplicitLod %9 %13 %20 ConstOffset %25
|
||||
)",
|
||||
R"(
|
||||
)"};
|
||||
|
@ -1805,14 +1810,14 @@ OpCapability SampledCubeArray
|
|||
%15 = OpConstant %4 1
|
||||
%16 = OpConstant %4 2
|
||||
%17 = OpConstant %4 3
|
||||
%19 = OpTypeInt 32 1
|
||||
%19 = OpTypeInt 32 0
|
||||
%20 = OpConstant %19 4
|
||||
)",
|
||||
R"(
|
||||
%11 = OpLoad %7 %5
|
||||
%12 = OpLoad %3 %1
|
||||
%14 = OpSampledImage %13 %12 %11
|
||||
%18 = OpConvertSToF %4 %20
|
||||
%18 = OpConvertUToF %4 %20
|
||||
%21 = OpCompositeConstruct %10 %15 %16 %17 %18
|
||||
%9 = OpImageSampleImplicitLod %10 %14 %21
|
||||
%8 = OpCompositeExtract %4 %9 0
|
||||
|
@ -1892,7 +1897,7 @@ OpCapability SampledCubeArray
|
|||
%14 = OpTypeVector %4 3
|
||||
%15 = OpConstant %4 1
|
||||
%16 = OpConstant %4 2
|
||||
%18 = OpTypeInt 32 1
|
||||
%18 = OpTypeInt 32 0
|
||||
%19 = OpConstant %18 4
|
||||
%21 = OpConstant %4 3
|
||||
)",
|
||||
|
@ -1900,7 +1905,7 @@ OpCapability SampledCubeArray
|
|||
%10 = OpLoad %7 %5
|
||||
%11 = OpLoad %3 %1
|
||||
%13 = OpSampledImage %12 %11 %10
|
||||
%17 = OpConvertSToF %4 %19
|
||||
%17 = OpConvertUToF %4 %19
|
||||
%20 = OpCompositeConstruct %14 %15 %16 %17
|
||||
%8 = OpImageSampleImplicitLod %9 %13 %20 Bias %21
|
||||
)",
|
||||
|
@ -2308,7 +2313,7 @@ OpCapability SampledCubeArray
|
|||
%16 = OpConstant %4 1
|
||||
%17 = OpConstant %4 2
|
||||
%18 = OpConstantComposite %15 %16 %17
|
||||
%20 = OpTypeInt 32 1
|
||||
%20 = OpTypeInt 32 0
|
||||
%21 = OpConstant %20 3
|
||||
)",
|
||||
R"(
|
||||
|
@ -2369,7 +2374,7 @@ OpCapability SampledCubeArray
|
|||
%15 = OpTypeVector %4 3
|
||||
%16 = OpConstant %4 1
|
||||
%17 = OpConstant %4 2
|
||||
%19 = OpTypeInt 32 1
|
||||
%19 = OpTypeInt 32 0
|
||||
%20 = OpConstant %19 3
|
||||
%23 = OpConstant %19 4
|
||||
)",
|
||||
|
@ -2377,7 +2382,7 @@ OpCapability SampledCubeArray
|
|||
%11 = OpLoad %7 %5
|
||||
%12 = OpLoad %3 %1
|
||||
%14 = OpSampledImage %13 %12 %11
|
||||
%18 = OpConvertSToF %4 %20
|
||||
%18 = OpConvertUToF %4 %20
|
||||
%21 = OpCompositeConstruct %15 %16 %17 %18
|
||||
%22 = OpConvertSToF %4 %23
|
||||
%9 = OpImageSampleExplicitLod %10 %14 %21 Lod %22
|
||||
|
@ -2400,22 +2405,23 @@ OpCapability SampledCubeArray
|
|||
%15 = OpTypeVector %4 3
|
||||
%16 = OpConstant %4 1
|
||||
%17 = OpConstant %4 2
|
||||
%19 = OpTypeInt 32 1
|
||||
%19 = OpTypeInt 32 0
|
||||
%20 = OpConstant %19 3
|
||||
%23 = OpConstant %19 4
|
||||
%24 = OpTypeVector %19 2
|
||||
%25 = OpConstant %19 5
|
||||
%26 = OpConstant %19 6
|
||||
%27 = OpConstantComposite %24 %25 %26
|
||||
%25 = OpTypeInt 32 1
|
||||
%24 = OpTypeVector %25 2
|
||||
%26 = OpConstant %25 5
|
||||
%27 = OpConstant %25 6
|
||||
%28 = OpConstantComposite %24 %26 %27
|
||||
)",
|
||||
R"(
|
||||
%11 = OpLoad %7 %5
|
||||
%12 = OpLoad %3 %1
|
||||
%14 = OpSampledImage %13 %12 %11
|
||||
%18 = OpConvertSToF %4 %20
|
||||
%18 = OpConvertUToF %4 %20
|
||||
%21 = OpCompositeConstruct %15 %16 %17 %18
|
||||
%22 = OpConvertSToF %4 %23
|
||||
%9 = OpImageSampleExplicitLod %10 %14 %21 Lod|ConstOffset %22 %27
|
||||
%9 = OpImageSampleExplicitLod %10 %14 %21 Lod|ConstOffset %22 %28
|
||||
%8 = OpCompositeExtract %4 %9 0
|
||||
)",
|
||||
R"(
|
||||
|
@ -2598,7 +2604,7 @@ OpCapability SampledCubeArray
|
|||
%14 = OpTypeVector %4 3
|
||||
%15 = OpConstant %4 1
|
||||
%16 = OpConstant %4 2
|
||||
%18 = OpTypeInt 32 1
|
||||
%18 = OpTypeInt 32 0
|
||||
%19 = OpConstant %18 3
|
||||
%21 = OpTypeVector %4 2
|
||||
%22 = OpConstant %4 4
|
||||
|
@ -2607,18 +2613,19 @@ OpCapability SampledCubeArray
|
|||
%25 = OpConstant %4 6
|
||||
%26 = OpConstant %4 7
|
||||
%27 = OpConstantComposite %21 %25 %26
|
||||
%28 = OpTypeVector %18 2
|
||||
%29 = OpConstant %18 6
|
||||
%30 = OpConstant %18 7
|
||||
%31 = OpConstantComposite %28 %29 %30
|
||||
%29 = OpTypeInt 32 1
|
||||
%28 = OpTypeVector %29 2
|
||||
%30 = OpConstant %29 6
|
||||
%31 = OpConstant %29 7
|
||||
%32 = OpConstantComposite %28 %30 %31
|
||||
)",
|
||||
R"(
|
||||
%10 = OpLoad %7 %5
|
||||
%11 = OpLoad %3 %1
|
||||
%13 = OpSampledImage %12 %11 %10
|
||||
%17 = OpConvertSToF %4 %19
|
||||
%17 = OpConvertUToF %4 %19
|
||||
%20 = OpCompositeConstruct %14 %15 %16 %17
|
||||
%8 = OpImageSampleExplicitLod %9 %13 %20 Grad|ConstOffset %24 %27 %31
|
||||
%8 = OpImageSampleExplicitLod %9 %13 %20 Grad|ConstOffset %24 %27 %32
|
||||
)",
|
||||
R"(
|
||||
)"};
|
||||
|
@ -2745,7 +2752,7 @@ OpCapability SampledCubeArray
|
|||
%14 = OpConstant %4 1
|
||||
%15 = OpConstant %4 2
|
||||
%16 = OpConstant %4 3
|
||||
%18 = OpTypeInt 32 1
|
||||
%18 = OpTypeInt 32 0
|
||||
%19 = OpConstant %18 4
|
||||
%21 = OpTypeVector %4 3
|
||||
%22 = OpConstant %4 5
|
||||
|
@ -2761,7 +2768,7 @@ OpCapability SampledCubeArray
|
|||
%10 = OpLoad %7 %5
|
||||
%11 = OpLoad %3 %1
|
||||
%13 = OpSampledImage %12 %11 %10
|
||||
%17 = OpConvertSToF %4 %19
|
||||
%17 = OpConvertUToF %4 %19
|
||||
%20 = OpCompositeConstruct %9 %14 %15 %16 %17
|
||||
%8 = OpImageSampleExplicitLod %9 %13 %20 Grad %25 %29
|
||||
)",
|
||||
|
@ -2865,21 +2872,22 @@ OpCapability SampledCubeArray
|
|||
%13 = OpTypeVector %4 3
|
||||
%14 = OpConstant %4 1
|
||||
%15 = OpConstant %4 2
|
||||
%17 = OpTypeInt 32 1
|
||||
%17 = OpTypeInt 32 0
|
||||
%18 = OpConstant %17 4
|
||||
%20 = OpConstant %4 3
|
||||
%21 = OpTypeVector %17 2
|
||||
%22 = OpConstant %17 5
|
||||
%23 = OpConstant %17 6
|
||||
%24 = OpConstantComposite %21 %22 %23
|
||||
%22 = OpTypeInt 32 1
|
||||
%21 = OpTypeVector %22 2
|
||||
%23 = OpConstant %22 5
|
||||
%24 = OpConstant %22 6
|
||||
%25 = OpConstantComposite %21 %23 %24
|
||||
)",
|
||||
R"(
|
||||
%9 = OpLoad %7 %5
|
||||
%10 = OpLoad %3 %1
|
||||
%12 = OpSampledImage %11 %10 %9
|
||||
%16 = OpConvertSToF %4 %18
|
||||
%16 = OpConvertUToF %4 %18
|
||||
%19 = OpCompositeConstruct %13 %14 %15 %16
|
||||
%8 = OpImageSampleDrefImplicitLod %4 %12 %19 %20 ConstOffset %24
|
||||
%8 = OpImageSampleDrefImplicitLod %4 %12 %19 %20 ConstOffset %25
|
||||
)",
|
||||
R"(
|
||||
)"};
|
||||
|
@ -3127,7 +3135,7 @@ OpCapability SampledCubeArray
|
|||
%6 = OpTypePointer UniformConstant %7
|
||||
%5 = OpVariable %6 UniformConstant
|
||||
%9 = OpTypeVector %4 4
|
||||
%11 = OpTypeInt 32 1
|
||||
%11 = OpTypeInt 32 0
|
||||
%12 = OpConstant %11 1
|
||||
%13 = OpConstant %11 3
|
||||
)",
|
||||
|
@ -3192,7 +3200,7 @@ OpCapability Sampled1D
|
|||
%6 = OpTypePointer UniformConstant %7
|
||||
%5 = OpVariable %6 UniformConstant
|
||||
%9 = OpTypeVector %4 4
|
||||
%12 = OpTypeInt 32 1
|
||||
%12 = OpTypeInt 32 0
|
||||
%11 = OpTypeVector %12 2
|
||||
%13 = OpConstant %12 1
|
||||
%14 = OpConstant %12 2
|
||||
|
@ -3240,15 +3248,16 @@ OpCapability Sampled1D
|
|||
%6 = OpTypePointer UniformConstant %7
|
||||
%5 = OpVariable %6 UniformConstant
|
||||
%9 = OpTypeVector %4 4
|
||||
%11 = OpTypeVector %4 2
|
||||
%12 = OpConstant %4 1
|
||||
%13 = OpConstant %4 2
|
||||
%14 = OpConstantComposite %11 %12 %13
|
||||
%15 = OpConstant %4 3
|
||||
%12 = OpTypeInt 32 0
|
||||
%11 = OpTypeVector %12 2
|
||||
%13 = OpConstant %12 1
|
||||
%14 = OpConstant %12 2
|
||||
%15 = OpConstantComposite %11 %13 %14
|
||||
%16 = OpConstant %12 3
|
||||
)",
|
||||
R"(
|
||||
%10 = OpLoad %3 %1
|
||||
%8 = OpImageFetch %9 %10 %14 Lod %15
|
||||
%8 = OpImageFetch %9 %10 %15 Lod %16
|
||||
)",
|
||||
R"(
|
||||
)"};
|
||||
|
@ -3313,16 +3322,17 @@ OpCapability Sampled1D
|
|||
%6 = OpTypePointer UniformConstant %7
|
||||
%5 = OpVariable %6 UniformConstant
|
||||
%9 = OpTypeVector %4 4
|
||||
%11 = OpTypeVector %4 3
|
||||
%12 = OpConstant %4 1
|
||||
%13 = OpConstant %4 2
|
||||
%14 = OpConstant %4 3
|
||||
%15 = OpConstantComposite %11 %12 %13 %14
|
||||
%16 = OpConstant %4 4
|
||||
%12 = OpTypeInt 32 0
|
||||
%11 = OpTypeVector %12 3
|
||||
%13 = OpConstant %12 1
|
||||
%14 = OpConstant %12 2
|
||||
%15 = OpConstant %12 3
|
||||
%16 = OpConstantComposite %11 %13 %14 %15
|
||||
%17 = OpConstant %12 4
|
||||
)",
|
||||
R"(
|
||||
%10 = OpLoad %3 %1
|
||||
%8 = OpImageFetch %9 %10 %15 Lod %16
|
||||
%8 = OpImageFetch %9 %10 %16 Lod %17
|
||||
)",
|
||||
R"(
|
||||
)"};
|
||||
|
@ -3387,16 +3397,17 @@ OpCapability Sampled1D
|
|||
%6 = OpTypePointer UniformConstant %7
|
||||
%5 = OpVariable %6 UniformConstant
|
||||
%9 = OpTypeVector %4 4
|
||||
%11 = OpTypeVector %4 3
|
||||
%12 = OpConstant %4 1
|
||||
%13 = OpConstant %4 2
|
||||
%14 = OpConstant %4 3
|
||||
%15 = OpConstantComposite %11 %12 %13 %14
|
||||
%16 = OpConstant %4 4
|
||||
%12 = OpTypeInt 32 0
|
||||
%11 = OpTypeVector %12 3
|
||||
%13 = OpConstant %12 1
|
||||
%14 = OpConstant %12 2
|
||||
%15 = OpConstant %12 3
|
||||
%16 = OpConstantComposite %11 %13 %14 %15
|
||||
%17 = OpConstant %12 4
|
||||
)",
|
||||
R"(
|
||||
%10 = OpLoad %3 %1
|
||||
%8 = OpImageFetch %9 %10 %15 Lod %16
|
||||
%8 = OpImageFetch %9 %10 %16 Lod %17
|
||||
)",
|
||||
R"(
|
||||
)"};
|
||||
|
@ -3459,15 +3470,16 @@ OpCapability Sampled1D
|
|||
%6 = OpTypePointer UniformConstant %7
|
||||
%5 = OpVariable %6 UniformConstant
|
||||
%9 = OpTypeVector %4 4
|
||||
%11 = OpTypeVector %4 2
|
||||
%12 = OpConstant %4 1
|
||||
%13 = OpConstant %4 2
|
||||
%14 = OpConstantComposite %11 %12 %13
|
||||
%15 = OpConstant %4 3
|
||||
%12 = OpTypeInt 32 0
|
||||
%11 = OpTypeVector %12 2
|
||||
%13 = OpConstant %12 1
|
||||
%14 = OpConstant %12 2
|
||||
%15 = OpConstantComposite %11 %13 %14
|
||||
%16 = OpConstant %12 3
|
||||
)",
|
||||
R"(
|
||||
%10 = OpLoad %3 %1
|
||||
%8 = OpImageFetch %9 %10 %14 Sample %15
|
||||
%8 = OpImageFetch %9 %10 %15 Sample %16
|
||||
)",
|
||||
R"(
|
||||
)"};
|
||||
|
@ -3507,7 +3519,7 @@ OpCapability Sampled1D
|
|||
%6 = OpTypePointer UniformConstant %7
|
||||
%5 = OpVariable %6 UniformConstant
|
||||
%10 = OpTypeVector %4 4
|
||||
%13 = OpTypeInt 32 1
|
||||
%13 = OpTypeInt 32 0
|
||||
%12 = OpTypeVector %13 3
|
||||
%14 = OpConstant %13 1
|
||||
%15 = OpConstant %13 2
|
||||
|
@ -3615,7 +3627,7 @@ OpImageWrite %10 %15 %21
|
|||
%6 = OpTypePointer UniformConstant %7
|
||||
%5 = OpVariable %6 UniformConstant
|
||||
%9 = OpTypeVoid
|
||||
%12 = OpTypeInt 32 1
|
||||
%12 = OpTypeInt 32 0
|
||||
%11 = OpTypeVector %12 3
|
||||
%13 = OpConstant %12 1
|
||||
%14 = OpConstant %12 2
|
||||
|
@ -3645,7 +3657,7 @@ OpImageWrite %10 %16 %22
|
|||
%6 = OpTypePointer UniformConstant %7
|
||||
%5 = OpVariable %6 UniformConstant
|
||||
%9 = OpTypeVoid
|
||||
%12 = OpTypeInt 32 1
|
||||
%12 = OpTypeInt 32 0
|
||||
%11 = OpTypeVector %12 3
|
||||
%13 = OpConstant %12 1
|
||||
%14 = OpConstant %12 2
|
||||
|
|
|
@ -30,6 +30,3 @@ void compute_main() {
|
|||
abs_421ca3();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x000001D461B57CF0(2,10-18): error X3000: syntax error: unexpected token 'float16_t'
|
||||
|
||||
|
|
|
@ -30,6 +30,3 @@ void compute_main() {
|
|||
abs_538d29();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x000001C4B2837D80(2,10-18): error X3000: syntax error: unexpected token 'float16_t'
|
||||
|
||||
|
|
|
@ -30,6 +30,3 @@ void compute_main() {
|
|||
abs_5ae4fe();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x0000026FB61B87E0(2,10-18): error X3000: syntax error: unexpected token 'float16_t'
|
||||
|
||||
|
|
|
@ -30,7 +30,3 @@ void compute_main() {
|
|||
abs_fd247f();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x000001C7205F8830(2,3-11): error X3000: unrecognized identifier 'float16_t'
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x000001C7205F8830(2,13-15): error X3000: unrecognized identifier 'res'
|
||||
|
||||
|
|
|
@ -30,6 +30,3 @@ void compute_main() {
|
|||
acos_004aff();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x000001B9F5C6E5B0(2,10-18): error X3000: syntax error: unexpected token 'float16_t'
|
||||
|
||||
|
|
|
@ -30,6 +30,3 @@ void compute_main() {
|
|||
acos_203628();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x0000019D14DE1160(2,10-18): error X3000: syntax error: unexpected token 'float16_t'
|
||||
|
||||
|
|
|
@ -30,7 +30,3 @@ void compute_main() {
|
|||
acos_303e3d();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x0000021AE9120540(2,3-11): error X3000: unrecognized identifier 'float16_t'
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x0000021AE9120540(2,13-15): error X3000: unrecognized identifier 'res'
|
||||
|
||||
|
|
|
@ -30,6 +30,3 @@ void compute_main() {
|
|||
acos_f47057();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x0000020584057560(2,10-18): error X3000: syntax error: unexpected token 'float16_t'
|
||||
|
||||
|
|
|
@ -34,6 +34,3 @@ void compute_main() {
|
|||
acosh_5f49d8();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x000001641C7488B0(1,8-16): error X3000: syntax error: unexpected token 'float16_t'
|
||||
|
||||
|
|
|
@ -34,6 +34,3 @@ void compute_main() {
|
|||
acosh_a37dfe();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x00000285D7A33130(1,1-9): error X3000: unrecognized identifier 'float16_t'
|
||||
|
||||
|
|
|
@ -34,6 +34,3 @@ void compute_main() {
|
|||
acosh_de60d8();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x0000027AF4D645C0(1,8-16): error X3000: syntax error: unexpected token 'float16_t'
|
||||
|
||||
|
|
|
@ -34,6 +34,3 @@ void compute_main() {
|
|||
acosh_f56574();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x00000221246484D0(1,8-16): error X3000: syntax error: unexpected token 'float16_t'
|
||||
|
||||
|
|
|
@ -1,17 +1,17 @@
|
|||
SKIP: FAILED
|
||||
|
||||
gen/literal/arrayLength/8421b9.wgsl:26:10 error: using f16 types in 'storage' address space is not implemented yet
|
||||
builtins/gen/literal/arrayLength/8421b9.wgsl:26:10 error: using f16 types in 'storage' address space is not implemented yet
|
||||
arg_0: array<f16>,
|
||||
^^^^^^^^^^
|
||||
|
||||
gen/literal/arrayLength/8421b9.wgsl:25:1 note: see layout of struct:
|
||||
builtins/gen/literal/arrayLength/8421b9.wgsl:25:1 note: see layout of struct:
|
||||
/* align(2) size(2) */ struct SB_RO {
|
||||
/* offset(0) align(2) size(2) */ arg_0 : array<f16>;
|
||||
/* */ };
|
||||
struct SB_RO {
|
||||
^^^^^^
|
||||
|
||||
gen/literal/arrayLength/8421b9.wgsl:28:42 note: see declaration of variable
|
||||
builtins/gen/literal/arrayLength/8421b9.wgsl:28:42 note: see declaration of variable
|
||||
@group(0) @binding(1) var<storage, read> sb_ro : SB_RO;
|
||||
^^^^^
|
||||
|
||||
|
|
|
@ -1,17 +1,17 @@
|
|||
SKIP: FAILED
|
||||
|
||||
gen/literal/arrayLength/8421b9.wgsl:26:10 error: using f16 types in 'storage' address space is not implemented yet
|
||||
builtins/gen/literal/arrayLength/8421b9.wgsl:26:10 error: using f16 types in 'storage' address space is not implemented yet
|
||||
arg_0: array<f16>,
|
||||
^^^^^^^^^^
|
||||
|
||||
gen/literal/arrayLength/8421b9.wgsl:25:1 note: see layout of struct:
|
||||
builtins/gen/literal/arrayLength/8421b9.wgsl:25:1 note: see layout of struct:
|
||||
/* align(2) size(2) */ struct SB_RO {
|
||||
/* offset(0) align(2) size(2) */ arg_0 : array<f16>;
|
||||
/* */ };
|
||||
struct SB_RO {
|
||||
^^^^^^
|
||||
|
||||
gen/literal/arrayLength/8421b9.wgsl:28:42 note: see declaration of variable
|
||||
builtins/gen/literal/arrayLength/8421b9.wgsl:28:42 note: see declaration of variable
|
||||
@group(0) @binding(1) var<storage, read> sb_ro : SB_RO;
|
||||
^^^^^
|
||||
|
||||
|
|
|
@ -1,17 +1,17 @@
|
|||
SKIP: FAILED
|
||||
|
||||
gen/literal/arrayLength/8421b9.wgsl:26:10 error: using f16 types in 'storage' address space is not implemented yet
|
||||
builtins/gen/literal/arrayLength/8421b9.wgsl:26:10 error: using f16 types in 'storage' address space is not implemented yet
|
||||
arg_0: array<f16>,
|
||||
^^^^^^^^^^
|
||||
|
||||
gen/literal/arrayLength/8421b9.wgsl:25:1 note: see layout of struct:
|
||||
builtins/gen/literal/arrayLength/8421b9.wgsl:25:1 note: see layout of struct:
|
||||
/* align(2) size(2) */ struct SB_RO {
|
||||
/* offset(0) align(2) size(2) */ arg_0 : array<f16>;
|
||||
/* */ };
|
||||
struct SB_RO {
|
||||
^^^^^^
|
||||
|
||||
gen/literal/arrayLength/8421b9.wgsl:28:42 note: see declaration of variable
|
||||
builtins/gen/literal/arrayLength/8421b9.wgsl:28:42 note: see declaration of variable
|
||||
@group(0) @binding(1) var<storage, read> sb_ro : SB_RO;
|
||||
^^^^^
|
||||
|
||||
|
|
|
@ -1,17 +1,17 @@
|
|||
SKIP: FAILED
|
||||
|
||||
gen/literal/arrayLength/8421b9.wgsl:26:10 error: using f16 types in 'storage' address space is not implemented yet
|
||||
builtins/gen/literal/arrayLength/8421b9.wgsl:26:10 error: using f16 types in 'storage' address space is not implemented yet
|
||||
arg_0: array<f16>,
|
||||
^^^^^^^^^^
|
||||
|
||||
gen/literal/arrayLength/8421b9.wgsl:25:1 note: see layout of struct:
|
||||
builtins/gen/literal/arrayLength/8421b9.wgsl:25:1 note: see layout of struct:
|
||||
/* align(2) size(2) */ struct SB_RO {
|
||||
/* offset(0) align(2) size(2) */ arg_0 : array<f16>;
|
||||
/* */ };
|
||||
struct SB_RO {
|
||||
^^^^^^
|
||||
|
||||
gen/literal/arrayLength/8421b9.wgsl:28:42 note: see declaration of variable
|
||||
builtins/gen/literal/arrayLength/8421b9.wgsl:28:42 note: see declaration of variable
|
||||
@group(0) @binding(1) var<storage, read> sb_ro : SB_RO;
|
||||
^^^^^
|
||||
|
||||
|
|
|
@ -1,17 +1,17 @@
|
|||
SKIP: FAILED
|
||||
|
||||
gen/literal/arrayLength/8421b9.wgsl:26:10 error: using f16 types in 'storage' address space is not implemented yet
|
||||
builtins/gen/literal/arrayLength/8421b9.wgsl:26:10 error: using f16 types in 'storage' address space is not implemented yet
|
||||
arg_0: array<f16>,
|
||||
^^^^^^^^^^
|
||||
|
||||
gen/literal/arrayLength/8421b9.wgsl:25:1 note: see layout of struct:
|
||||
builtins/gen/literal/arrayLength/8421b9.wgsl:25:1 note: see layout of struct:
|
||||
/* align(2) size(2) */ struct SB_RO {
|
||||
/* offset(0) align(2) size(2) */ arg_0 : array<f16>;
|
||||
/* */ };
|
||||
struct SB_RO {
|
||||
^^^^^^
|
||||
|
||||
gen/literal/arrayLength/8421b9.wgsl:28:42 note: see declaration of variable
|
||||
builtins/gen/literal/arrayLength/8421b9.wgsl:28:42 note: see declaration of variable
|
||||
@group(0) @binding(1) var<storage, read> sb_ro : SB_RO;
|
||||
^^^^^
|
||||
|
||||
|
|
|
@ -1,17 +1,17 @@
|
|||
SKIP: FAILED
|
||||
|
||||
gen/literal/arrayLength/cbd6b5.wgsl:26:10 error: using f16 types in 'storage' address space is not implemented yet
|
||||
builtins/gen/literal/arrayLength/cbd6b5.wgsl:26:10 error: using f16 types in 'storage' address space is not implemented yet
|
||||
arg_0: array<f16>,
|
||||
^^^^^^^^^^
|
||||
|
||||
gen/literal/arrayLength/cbd6b5.wgsl:25:1 note: see layout of struct:
|
||||
builtins/gen/literal/arrayLength/cbd6b5.wgsl:25:1 note: see layout of struct:
|
||||
/* align(2) size(2) */ struct SB_RW {
|
||||
/* offset(0) align(2) size(2) */ arg_0 : array<f16>;
|
||||
/* */ };
|
||||
struct SB_RW {
|
||||
^^^^^^
|
||||
|
||||
gen/literal/arrayLength/cbd6b5.wgsl:28:48 note: see declaration of variable
|
||||
builtins/gen/literal/arrayLength/cbd6b5.wgsl:28:48 note: see declaration of variable
|
||||
@group(0) @binding(0) var<storage, read_write> sb_rw : SB_RW;
|
||||
^^^^^
|
||||
|
||||
|
|
|
@ -1,17 +1,17 @@
|
|||
SKIP: FAILED
|
||||
|
||||
gen/literal/arrayLength/cbd6b5.wgsl:26:10 error: using f16 types in 'storage' address space is not implemented yet
|
||||
builtins/gen/literal/arrayLength/cbd6b5.wgsl:26:10 error: using f16 types in 'storage' address space is not implemented yet
|
||||
arg_0: array<f16>,
|
||||
^^^^^^^^^^
|
||||
|
||||
gen/literal/arrayLength/cbd6b5.wgsl:25:1 note: see layout of struct:
|
||||
builtins/gen/literal/arrayLength/cbd6b5.wgsl:25:1 note: see layout of struct:
|
||||
/* align(2) size(2) */ struct SB_RW {
|
||||
/* offset(0) align(2) size(2) */ arg_0 : array<f16>;
|
||||
/* */ };
|
||||
struct SB_RW {
|
||||
^^^^^^
|
||||
|
||||
gen/literal/arrayLength/cbd6b5.wgsl:28:48 note: see declaration of variable
|
||||
builtins/gen/literal/arrayLength/cbd6b5.wgsl:28:48 note: see declaration of variable
|
||||
@group(0) @binding(0) var<storage, read_write> sb_rw : SB_RW;
|
||||
^^^^^
|
||||
|
||||
|
|
|
@ -1,17 +1,17 @@
|
|||
SKIP: FAILED
|
||||
|
||||
gen/literal/arrayLength/cbd6b5.wgsl:26:10 error: using f16 types in 'storage' address space is not implemented yet
|
||||
builtins/gen/literal/arrayLength/cbd6b5.wgsl:26:10 error: using f16 types in 'storage' address space is not implemented yet
|
||||
arg_0: array<f16>,
|
||||
^^^^^^^^^^
|
||||
|
||||
gen/literal/arrayLength/cbd6b5.wgsl:25:1 note: see layout of struct:
|
||||
builtins/gen/literal/arrayLength/cbd6b5.wgsl:25:1 note: see layout of struct:
|
||||
/* align(2) size(2) */ struct SB_RW {
|
||||
/* offset(0) align(2) size(2) */ arg_0 : array<f16>;
|
||||
/* */ };
|
||||
struct SB_RW {
|
||||
^^^^^^
|
||||
|
||||
gen/literal/arrayLength/cbd6b5.wgsl:28:48 note: see declaration of variable
|
||||
builtins/gen/literal/arrayLength/cbd6b5.wgsl:28:48 note: see declaration of variable
|
||||
@group(0) @binding(0) var<storage, read_write> sb_rw : SB_RW;
|
||||
^^^^^
|
||||
|
||||
|
|
|
@ -1,17 +1,17 @@
|
|||
SKIP: FAILED
|
||||
|
||||
gen/literal/arrayLength/cbd6b5.wgsl:26:10 error: using f16 types in 'storage' address space is not implemented yet
|
||||
builtins/gen/literal/arrayLength/cbd6b5.wgsl:26:10 error: using f16 types in 'storage' address space is not implemented yet
|
||||
arg_0: array<f16>,
|
||||
^^^^^^^^^^
|
||||
|
||||
gen/literal/arrayLength/cbd6b5.wgsl:25:1 note: see layout of struct:
|
||||
builtins/gen/literal/arrayLength/cbd6b5.wgsl:25:1 note: see layout of struct:
|
||||
/* align(2) size(2) */ struct SB_RW {
|
||||
/* offset(0) align(2) size(2) */ arg_0 : array<f16>;
|
||||
/* */ };
|
||||
struct SB_RW {
|
||||
^^^^^^
|
||||
|
||||
gen/literal/arrayLength/cbd6b5.wgsl:28:48 note: see declaration of variable
|
||||
builtins/gen/literal/arrayLength/cbd6b5.wgsl:28:48 note: see declaration of variable
|
||||
@group(0) @binding(0) var<storage, read_write> sb_rw : SB_RW;
|
||||
^^^^^
|
||||
|
||||
|
|
|
@ -1,17 +1,17 @@
|
|||
SKIP: FAILED
|
||||
|
||||
gen/literal/arrayLength/cbd6b5.wgsl:26:10 error: using f16 types in 'storage' address space is not implemented yet
|
||||
builtins/gen/literal/arrayLength/cbd6b5.wgsl:26:10 error: using f16 types in 'storage' address space is not implemented yet
|
||||
arg_0: array<f16>,
|
||||
^^^^^^^^^^
|
||||
|
||||
gen/literal/arrayLength/cbd6b5.wgsl:25:1 note: see layout of struct:
|
||||
builtins/gen/literal/arrayLength/cbd6b5.wgsl:25:1 note: see layout of struct:
|
||||
/* align(2) size(2) */ struct SB_RW {
|
||||
/* offset(0) align(2) size(2) */ arg_0 : array<f16>;
|
||||
/* */ };
|
||||
struct SB_RW {
|
||||
^^^^^^
|
||||
|
||||
gen/literal/arrayLength/cbd6b5.wgsl:28:48 note: see declaration of variable
|
||||
builtins/gen/literal/arrayLength/cbd6b5.wgsl:28:48 note: see declaration of variable
|
||||
@group(0) @binding(0) var<storage, read_write> sb_rw : SB_RW;
|
||||
^^^^^
|
||||
|
||||
|
|
|
@ -30,7 +30,3 @@ void compute_main() {
|
|||
asin_11dfda();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x000001FA9E277D20(2,3-11): error X3000: unrecognized identifier 'float16_t'
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x000001FA9E277D20(2,13-15): error X3000: unrecognized identifier 'res'
|
||||
|
||||
|
|
|
@ -30,6 +30,3 @@ void compute_main() {
|
|||
asin_2d8e29();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x00000140BC7EE140(2,10-18): error X3000: syntax error: unexpected token 'float16_t'
|
||||
|
||||
|
|
|
@ -30,6 +30,3 @@ void compute_main() {
|
|||
asin_3cfbd4();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x0000022B4BDC88B0(2,10-18): error X3000: syntax error: unexpected token 'float16_t'
|
||||
|
||||
|
|
|
@ -30,6 +30,3 @@ void compute_main() {
|
|||
asin_b4aced();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x00000138E6B7E9E0(2,10-18): error X3000: syntax error: unexpected token 'float16_t'
|
||||
|
||||
|
|
|
@ -34,6 +34,3 @@ void compute_main() {
|
|||
asinh_468a48();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x0000024C0A8E8450(1,1-9): error X3000: unrecognized identifier 'float16_t'
|
||||
|
||||
|
|
|
@ -34,6 +34,3 @@ void compute_main() {
|
|||
asinh_95ab2b();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x0000017880279490(1,8-16): error X3000: syntax error: unexpected token 'float16_t'
|
||||
|
||||
|
|
|
@ -34,6 +34,3 @@ void compute_main() {
|
|||
asinh_ad8f8b();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x000002AC790D84D0(1,8-16): error X3000: syntax error: unexpected token 'float16_t'
|
||||
|
||||
|
|
|
@ -34,6 +34,3 @@ void compute_main() {
|
|||
asinh_fb5e8c();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x000001E444F93560(1,8-16): error X3000: syntax error: unexpected token 'float16_t'
|
||||
|
||||
|
|
|
@ -30,6 +30,3 @@ void compute_main() {
|
|||
atan_19faea();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x000002329F308C50(2,10-18): error X3000: syntax error: unexpected token 'float16_t'
|
||||
|
||||
|
|
|
@ -30,6 +30,3 @@ void compute_main() {
|
|||
atan_1e1764();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x000001C856E61160(2,10-18): error X3000: syntax error: unexpected token 'float16_t'
|
||||
|
||||
|
|
|
@ -30,6 +30,3 @@ void compute_main() {
|
|||
atan_a5f421();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x00000186B9618C70(2,10-18): error X3000: syntax error: unexpected token 'float16_t'
|
||||
|
||||
|
|
|
@ -30,7 +30,3 @@ void compute_main() {
|
|||
atan_a7ba61();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x00000211ADB21160(2,3-11): error X3000: unrecognized identifier 'float16_t'
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x00000211ADB21160(2,13-15): error X3000: unrecognized identifier 'res'
|
||||
|
||||
|
|
|
@ -30,6 +30,3 @@ void compute_main() {
|
|||
atan2_21dfea();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x0000020C31CCD060(2,10-18): error X3000: syntax error: unexpected token 'float16_t'
|
||||
|
||||
|
|
|
@ -30,6 +30,3 @@ void compute_main() {
|
|||
atan2_93febc();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x0000029435E06D30(2,10-18): error X3000: syntax error: unexpected token 'float16_t'
|
||||
|
||||
|
|
|
@ -30,7 +30,3 @@ void compute_main() {
|
|||
atan2_ca698e();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x00000221D39B1200(2,3-11): error X3000: unrecognized identifier 'float16_t'
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x00000221D39B1200(2,13-15): error X3000: unrecognized identifier 'res'
|
||||
|
||||
|
|
|
@ -30,6 +30,3 @@ void compute_main() {
|
|||
atan2_d983ab();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x00000259F9C66DF0(2,10-18): error X3000: syntax error: unexpected token 'float16_t'
|
||||
|
||||
|
|
|
@ -34,6 +34,3 @@ void compute_main() {
|
|||
atanh_5bf88d();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x000001F6B2FD2F70(1,8-16): error X3000: syntax error: unexpected token 'float16_t'
|
||||
|
||||
|
|
|
@ -34,6 +34,3 @@ void compute_main() {
|
|||
atanh_d2d8cd();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x000001760B391820(1,1-9): error X3000: unrecognized identifier 'float16_t'
|
||||
|
||||
|
|
|
@ -34,6 +34,3 @@ void compute_main() {
|
|||
atanh_e3b450();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x00000176443384D0(1,8-16): error X3000: syntax error: unexpected token 'float16_t'
|
||||
|
||||
|
|
|
@ -34,6 +34,3 @@ void compute_main() {
|
|||
atanh_ec4b06();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x000001899EE63220(1,8-16): error X3000: syntax error: unexpected token 'float16_t'
|
||||
|
||||
|
|
|
@ -30,6 +30,3 @@ void compute_main() {
|
|||
ceil_09bf52();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x0000013DAD2D1160(2,10-18): error X3000: syntax error: unexpected token 'float16_t'
|
||||
|
||||
|
|
|
@ -30,6 +30,3 @@ void compute_main() {
|
|||
ceil_18c240();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x0000024369541160(2,10-18): error X3000: syntax error: unexpected token 'float16_t'
|
||||
|
||||
|
|
|
@ -30,6 +30,3 @@ void compute_main() {
|
|||
ceil_4bca2a();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x0000016D987AB790(2,10-18): error X3000: syntax error: unexpected token 'float16_t'
|
||||
|
||||
|
|
|
@ -30,7 +30,3 @@ void compute_main() {
|
|||
ceil_f3f889();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x00000190A1B47CF0(2,3-11): error X3000: unrecognized identifier 'float16_t'
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x00000190A1B47CF0(2,13-15): error X3000: unrecognized identifier 'res'
|
||||
|
||||
|
|
|
@ -30,6 +30,3 @@ void compute_main() {
|
|||
clamp_235b29();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x0000017FE0738160(2,10-18): error X3000: syntax error: unexpected token 'float16_t'
|
||||
|
||||
|
|
|
@ -30,6 +30,3 @@ void compute_main() {
|
|||
clamp_2c251b();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x00000225C8376D90(2,10-18): error X3000: syntax error: unexpected token 'float16_t'
|
||||
|
||||
|
|
|
@ -30,7 +30,3 @@ void compute_main() {
|
|||
clamp_553ffb();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x000002581C620540(2,3-11): error X3000: unrecognized identifier 'float16_t'
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x000002581C620540(2,13-15): error X3000: unrecognized identifier 'res'
|
||||
|
||||
|
|
|
@ -30,6 +30,3 @@ void compute_main() {
|
|||
clamp_b195eb();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x000001F44BFDB000(2,10-18): error X3000: syntax error: unexpected token 'float16_t'
|
||||
|
||||
|
|
|
@ -30,6 +30,3 @@ void compute_main() {
|
|||
cos_0835a8();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x0000012E9639AC20(2,10-18): error X3000: syntax error: unexpected token 'float16_t'
|
||||
|
||||
|
|
|
@ -30,6 +30,3 @@ void compute_main() {
|
|||
cos_0a89f7();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x0000016E7F3887E0(2,10-18): error X3000: syntax error: unexpected token 'float16_t'
|
||||
|
||||
|
|
|
@ -30,6 +30,3 @@ void compute_main() {
|
|||
cos_5bc2c6();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x0000024E8E5A87E0(2,10-18): error X3000: syntax error: unexpected token 'float16_t'
|
||||
|
||||
|
|
|
@ -30,7 +30,3 @@ void compute_main() {
|
|||
cos_fc047d();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x0000015329BF7D10(2,3-11): error X3000: unrecognized identifier 'float16_t'
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x0000015329BF7D10(2,13-15): error X3000: unrecognized identifier 'res'
|
||||
|
||||
|
|
|
@ -30,7 +30,3 @@ void compute_main() {
|
|||
cosh_2ed778();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x0000021F3BD88850(2,3-11): error X3000: unrecognized identifier 'float16_t'
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x0000021F3BD88850(2,13-15): error X3000: unrecognized identifier 'res'
|
||||
|
||||
|
|
|
@ -30,6 +30,3 @@ void compute_main() {
|
|||
cosh_3b7bbf();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x0000020A6F400DB0(2,10-18): error X3000: syntax error: unexpected token 'float16_t'
|
||||
|
||||
|
|
|
@ -30,6 +30,3 @@ void compute_main() {
|
|||
cosh_43b672();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x000002ACB9EB1160(2,10-18): error X3000: syntax error: unexpected token 'float16_t'
|
||||
|
||||
|
|
|
@ -30,6 +30,3 @@ void compute_main() {
|
|||
cosh_b1b8a0();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x000001D169B6EAF0(2,10-18): error X3000: syntax error: unexpected token 'float16_t'
|
||||
|
||||
|
|
|
@ -30,6 +30,3 @@ void compute_main() {
|
|||
cross_9857cb();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x000001ABE1B9A830(2,10-18): error X3000: syntax error: unexpected token 'float16_t'
|
||||
|
||||
|
|
|
@ -34,6 +34,3 @@ void compute_main() {
|
|||
degrees_3055d3();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x0000020615990520(1,8-16): error X3000: syntax error: unexpected token 'float16_t'
|
||||
|
||||
|
|
|
@ -34,6 +34,3 @@ void compute_main() {
|
|||
degrees_5e9805();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x0000021D8DD40440(1,1-9): error X3000: unrecognized identifier 'float16_t'
|
||||
|
||||
|
|
|
@ -34,6 +34,3 @@ void compute_main() {
|
|||
degrees_dfe8f4();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x000001BA47346FD0(1,8-16): error X3000: syntax error: unexpected token 'float16_t'
|
||||
|
||||
|
|
|
@ -34,6 +34,3 @@ void compute_main() {
|
|||
degrees_f59715();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x0000025AB33F0650(1,8-16): error X3000: syntax error: unexpected token 'float16_t'
|
||||
|
||||
|
|
|
@ -30,7 +30,3 @@ void compute_main() {
|
|||
determinant_32bfde();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x0000028760CE9820(2,3-11): error X3000: unrecognized identifier 'float16_t'
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x0000028760CE9820(2,13-15): error X3000: unrecognized identifier 'res'
|
||||
|
||||
|
|
|
@ -30,7 +30,3 @@ void compute_main() {
|
|||
determinant_d7c86f();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x0000017F01F7E050(2,3-11): error X3000: unrecognized identifier 'float16_t'
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x0000017F01F7E050(2,13-15): error X3000: unrecognized identifier 'res'
|
||||
|
||||
|
|
|
@ -30,7 +30,3 @@ void compute_main() {
|
|||
determinant_fc12a5();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x000002949F67AAF0(2,3-11): error X3000: unrecognized identifier 'float16_t'
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x000002949F67AAF0(2,13-15): error X3000: unrecognized identifier 'res'
|
||||
|
||||
|
|
|
@ -30,7 +30,3 @@ void compute_main() {
|
|||
distance_7272f3();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x000002AF01F7D600(2,3-11): error X3000: unrecognized identifier 'float16_t'
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x000002AF01F7D600(2,13-15): error X3000: unrecognized identifier 'res'
|
||||
|
||||
|
|
|
@ -30,7 +30,3 @@ void compute_main() {
|
|||
distance_7d201f();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x000001D5BC336FD0(2,3-11): error X3000: unrecognized identifier 'float16_t'
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x000001D5BC336FD0(2,13-15): error X3000: unrecognized identifier 'res'
|
||||
|
||||
|
|
|
@ -30,7 +30,3 @@ void compute_main() {
|
|||
distance_892a5d();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x0000026F67541620(2,3-11): error X3000: unrecognized identifier 'float16_t'
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x0000026F67541620(2,13-15): error X3000: unrecognized identifier 'res'
|
||||
|
||||
|
|
|
@ -30,7 +30,3 @@ void compute_main() {
|
|||
distance_928fa0();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x000001ECED3C83A0(2,3-11): error X3000: unrecognized identifier 'float16_t'
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x000001ECED3C83A0(2,13-15): error X3000: unrecognized identifier 'res'
|
||||
|
||||
|
|
|
@ -30,7 +30,3 @@ void compute_main() {
|
|||
dot_8e40f1();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x000001E9C49996F0(2,3-11): error X3000: unrecognized identifier 'float16_t'
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x000001E9C49996F0(2,13-15): error X3000: unrecognized identifier 'res'
|
||||
|
||||
|
|
|
@ -30,7 +30,3 @@ void compute_main() {
|
|||
dot_cd5a04();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x000001B52BF97850(2,3-11): error X3000: unrecognized identifier 'float16_t'
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x000001B52BF97850(2,13-15): error X3000: unrecognized identifier 'res'
|
||||
|
||||
|
|
|
@ -30,7 +30,3 @@ void compute_main() {
|
|||
dot_d0d179();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x000001E77FD80D40(2,3-11): error X3000: unrecognized identifier 'float16_t'
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x000001E77FD80D40(2,13-15): error X3000: unrecognized identifier 'res'
|
||||
|
||||
|
|
|
@ -35,6 +35,3 @@ void compute_main() {
|
|||
dot4I8Packed_881e62();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x00000239A33210B0(3,10-56): error X3004: undeclared identifier 'dot4add_i8packed'
|
||||
|
||||
|
|
|
@ -23,4 +23,7 @@ fn compute_main() {
|
|||
dot4I8Packed_881e62();
|
||||
}
|
||||
|
||||
Failed to generate: error: Unknown import method: dot4I8Packed
|
||||
Failed to generate: builtins/gen/literal/dot4I8Packed/881e62.wgsl:24:8 error: MSL backend does not support extension 'chromium_experimental_dp4a'
|
||||
enable chromium_experimental_dp4a;
|
||||
^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
|
|
|
@ -35,6 +35,3 @@ void compute_main() {
|
|||
dot4U8Packed_fbed7b();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x000001D2469D6CD0(3,10-56): error X3004: undeclared identifier 'dot4add_u8packed'
|
||||
|
||||
|
|
|
@ -23,4 +23,7 @@ fn compute_main() {
|
|||
dot4U8Packed_fbed7b();
|
||||
}
|
||||
|
||||
Failed to generate: error: Unknown import method: dot4U8Packed
|
||||
Failed to generate: builtins/gen/literal/dot4U8Packed/fbed7b.wgsl:24:8 error: MSL backend does not support extension 'chromium_experimental_dp4a'
|
||||
enable chromium_experimental_dp4a;
|
||||
^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
|
|
|
@ -30,6 +30,3 @@ void compute_main() {
|
|||
exp_13806d();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x000001F8343687E0(2,10-18): error X3000: syntax error: unexpected token 'float16_t'
|
||||
|
||||
|
|
|
@ -30,6 +30,3 @@ void compute_main() {
|
|||
exp_2e08e2();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x000001E5CBC9ECC0(2,10-18): error X3000: syntax error: unexpected token 'float16_t'
|
||||
|
||||
|
|
|
@ -30,6 +30,3 @@ void compute_main() {
|
|||
exp_611a87();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x000001865DDB0AC0(2,10-18): error X3000: syntax error: unexpected token 'float16_t'
|
||||
|
||||
|
|
|
@ -30,7 +30,3 @@ void compute_main() {
|
|||
exp_c18fe9();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x00000189289FB7F0(2,3-11): error X3000: unrecognized identifier 'float16_t'
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x00000189289FB7F0(2,13-15): error X3000: unrecognized identifier 'res'
|
||||
|
||||
|
|
|
@ -30,6 +30,3 @@ void compute_main() {
|
|||
exp2_151a4c();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x000001D4AAF5DCB0(2,10-18): error X3000: syntax error: unexpected token 'float16_t'
|
||||
|
||||
|
|
|
@ -30,6 +30,3 @@ void compute_main() {
|
|||
exp2_751377();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x0000023A7CDE1160(2,10-18): error X3000: syntax error: unexpected token 'float16_t'
|
||||
|
||||
|
|
|
@ -30,7 +30,3 @@ void compute_main() {
|
|||
exp2_b408e4();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x0000029A9E5D1160(2,3-11): error X3000: unrecognized identifier 'float16_t'
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x0000029A9E5D1160(2,13-15): error X3000: unrecognized identifier 'res'
|
||||
|
||||
|
|
|
@ -30,6 +30,3 @@ void compute_main() {
|
|||
exp2_ffa827();
|
||||
return;
|
||||
}
|
||||
FXC validation failure:
|
||||
D:\Projects\RampUp\dawn\test\tint\builtins\Shader@0x000001D88F07E620(2,10-18): error X3000: syntax error: unexpected token 'float16_t'
|
||||
|
||||
|
|
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue