| // Copyright 2020 The Tint Authors. | |
| // | |
| // Licensed under the Apache License, Version 2.0 (the "License"); | |
| // you may not use this file except in compliance with the License. | |
| // You may obtain a copy of the License at | |
| // | |
| // http://www.apache.org/licenses/LICENSE-2.0 | |
| // | |
| // Unless required by applicable law or agreed to in writing, software | |
| // distributed under the License is distributed on an "AS IS" BASIS, | |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| // See the License for the specific language governing permissions and | |
| // limitations under the License. | |
| #include "src/tint/transform/first_index_offset.h" | |
| #include <memory> | |
| #include <utility> | |
| #include <vector> | |
| #include "src/tint/transform/test_helper.h" | |
| namespace tint::transform { | |
| namespace { | |
| using FirstIndexOffsetTest = TransformTest; | |
| TEST_F(FirstIndexOffsetTest, ShouldRunEmptyModule) { | |
| auto* src = R"()"; | |
| EXPECT_FALSE(ShouldRun<FirstIndexOffset>(src)); | |
| } | |
| TEST_F(FirstIndexOffsetTest, ShouldRunFragmentStage) { | |
| auto* src = R"( | |
| @stage(fragment) | |
| fn entry() { | |
| return; | |
| } | |
| )"; | |
| EXPECT_FALSE(ShouldRun<FirstIndexOffset>(src)); | |
| } | |
| TEST_F(FirstIndexOffsetTest, ShouldRunVertexStage) { | |
| auto* src = R"( | |
| @stage(vertex) | |
| fn entry() -> @builtin(position) vec4<f32> { | |
| return vec4<f32>(); | |
| } | |
| )"; | |
| EXPECT_TRUE(ShouldRun<FirstIndexOffset>(src)); | |
| } | |
| TEST_F(FirstIndexOffsetTest, EmptyModule) { | |
| auto* src = ""; | |
| auto* expect = ""; | |
| DataMap config; | |
| config.Add<FirstIndexOffset::BindingPoint>(0, 0); | |
| auto got = Run<FirstIndexOffset>(src, std::move(config)); | |
| EXPECT_EQ(expect, str(got)); | |
| auto* data = got.data.Get<FirstIndexOffset::Data>(); | |
| EXPECT_EQ(data, nullptr); | |
| } | |
| TEST_F(FirstIndexOffsetTest, BasicVertexShader) { | |
| auto* src = R"( | |
| @stage(vertex) | |
| fn entry() -> @builtin(position) vec4<f32> { | |
| return vec4<f32>(); | |
| } | |
| )"; | |
| auto* expect = src; | |
| DataMap config; | |
| config.Add<FirstIndexOffset::BindingPoint>(0, 0); | |
| auto got = Run<FirstIndexOffset>(src, std::move(config)); | |
| EXPECT_EQ(expect, str(got)); | |
| auto* data = got.data.Get<FirstIndexOffset::Data>(); | |
| ASSERT_NE(data, nullptr); | |
| EXPECT_EQ(data->has_vertex_or_instance_index, false); | |
| } | |
| TEST_F(FirstIndexOffsetTest, BasicModuleVertexIndex) { | |
| auto* src = R"( | |
| fn test(vert_idx : u32) -> u32 { | |
| return vert_idx; | |
| } | |
| @stage(vertex) | |
| fn entry(@builtin(vertex_index) vert_idx : u32) -> @builtin(position) vec4<f32> { | |
| test(vert_idx); | |
| return vec4<f32>(); | |
| } | |
| )"; | |
| auto* expect = R"( | |
| struct tint_symbol { | |
| first_vertex_index : u32, | |
| first_instance_index : u32, | |
| } | |
| @binding(1) @group(2) var<uniform> tint_symbol_1 : tint_symbol; | |
| fn test(vert_idx : u32) -> u32 { | |
| return vert_idx; | |
| } | |
| @stage(vertex) | |
| fn entry(@builtin(vertex_index) vert_idx : u32) -> @builtin(position) vec4<f32> { | |
| test((vert_idx + tint_symbol_1.first_vertex_index)); | |
| return vec4<f32>(); | |
| } | |
| )"; | |
| DataMap config; | |
| config.Add<FirstIndexOffset::BindingPoint>(1, 2); | |
| auto got = Run<FirstIndexOffset>(src, std::move(config)); | |
| EXPECT_EQ(expect, str(got)); | |
| auto* data = got.data.Get<FirstIndexOffset::Data>(); | |
| ASSERT_NE(data, nullptr); | |
| EXPECT_EQ(data->has_vertex_or_instance_index, true); | |
| } | |
| TEST_F(FirstIndexOffsetTest, BasicModuleVertexIndex_OutOfOrder) { | |
| auto* src = R"( | |
| @stage(vertex) | |
| fn entry(@builtin(vertex_index) vert_idx : u32) -> @builtin(position) vec4<f32> { | |
| test(vert_idx); | |
| return vec4<f32>(); | |
| } | |
| fn test(vert_idx : u32) -> u32 { | |
| return vert_idx; | |
| } | |
| )"; | |
| auto* expect = R"( | |
| struct tint_symbol { | |
| first_vertex_index : u32, | |
| first_instance_index : u32, | |
| } | |
| @binding(1) @group(2) var<uniform> tint_symbol_1 : tint_symbol; | |
| @stage(vertex) | |
| fn entry(@builtin(vertex_index) vert_idx : u32) -> @builtin(position) vec4<f32> { | |
| test((vert_idx + tint_symbol_1.first_vertex_index)); | |
| return vec4<f32>(); | |
| } | |
| fn test(vert_idx : u32) -> u32 { | |
| return vert_idx; | |
| } | |
| )"; | |
| DataMap config; | |
| config.Add<FirstIndexOffset::BindingPoint>(1, 2); | |
| auto got = Run<FirstIndexOffset>(src, std::move(config)); | |
| EXPECT_EQ(expect, str(got)); | |
| auto* data = got.data.Get<FirstIndexOffset::Data>(); | |
| ASSERT_NE(data, nullptr); | |
| EXPECT_EQ(data->has_vertex_or_instance_index, true); | |
| } | |
| TEST_F(FirstIndexOffsetTest, BasicModuleInstanceIndex) { | |
| auto* src = R"( | |
| fn test(inst_idx : u32) -> u32 { | |
| return inst_idx; | |
| } | |
| @stage(vertex) | |
| fn entry(@builtin(instance_index) inst_idx : u32) -> @builtin(position) vec4<f32> { | |
| test(inst_idx); | |
| return vec4<f32>(); | |
| } | |
| )"; | |
| auto* expect = R"( | |
| struct tint_symbol { | |
| first_vertex_index : u32, | |
| first_instance_index : u32, | |
| } | |
| @binding(1) @group(7) var<uniform> tint_symbol_1 : tint_symbol; | |
| fn test(inst_idx : u32) -> u32 { | |
| return inst_idx; | |
| } | |
| @stage(vertex) | |
| fn entry(@builtin(instance_index) inst_idx : u32) -> @builtin(position) vec4<f32> { | |
| test((inst_idx + tint_symbol_1.first_instance_index)); | |
| return vec4<f32>(); | |
| } | |
| )"; | |
| DataMap config; | |
| config.Add<FirstIndexOffset::BindingPoint>(1, 7); | |
| auto got = Run<FirstIndexOffset>(src, std::move(config)); | |
| EXPECT_EQ(expect, str(got)); | |
| auto* data = got.data.Get<FirstIndexOffset::Data>(); | |
| ASSERT_NE(data, nullptr); | |
| EXPECT_EQ(data->has_vertex_or_instance_index, true); | |
| } | |
| TEST_F(FirstIndexOffsetTest, BasicModuleInstanceIndex_OutOfOrder) { | |
| auto* src = R"( | |
| @stage(vertex) | |
| fn entry(@builtin(instance_index) inst_idx : u32) -> @builtin(position) vec4<f32> { | |
| test(inst_idx); | |
| return vec4<f32>(); | |
| } | |
| fn test(inst_idx : u32) -> u32 { | |
| return inst_idx; | |
| } | |
| )"; | |
| auto* expect = R"( | |
| struct tint_symbol { | |
| first_vertex_index : u32, | |
| first_instance_index : u32, | |
| } | |
| @binding(1) @group(7) var<uniform> tint_symbol_1 : tint_symbol; | |
| @stage(vertex) | |
| fn entry(@builtin(instance_index) inst_idx : u32) -> @builtin(position) vec4<f32> { | |
| test((inst_idx + tint_symbol_1.first_instance_index)); | |
| return vec4<f32>(); | |
| } | |
| fn test(inst_idx : u32) -> u32 { | |
| return inst_idx; | |
| } | |
| )"; | |
| DataMap config; | |
| config.Add<FirstIndexOffset::BindingPoint>(1, 7); | |
| auto got = Run<FirstIndexOffset>(src, std::move(config)); | |
| EXPECT_EQ(expect, str(got)); | |
| auto* data = got.data.Get<FirstIndexOffset::Data>(); | |
| ASSERT_NE(data, nullptr); | |
| EXPECT_EQ(data->has_vertex_or_instance_index, true); | |
| } | |
| TEST_F(FirstIndexOffsetTest, BasicModuleBothIndex) { | |
| auto* src = R"( | |
| fn test(instance_idx : u32, vert_idx : u32) -> u32 { | |
| return instance_idx + vert_idx; | |
| } | |
| struct Inputs { | |
| @builtin(instance_index) instance_idx : u32, | |
| @builtin(vertex_index) vert_idx : u32, | |
| }; | |
| @stage(vertex) | |
| fn entry(inputs : Inputs) -> @builtin(position) vec4<f32> { | |
| test(inputs.instance_idx, inputs.vert_idx); | |
| return vec4<f32>(); | |
| } | |
| )"; | |
| auto* expect = R"( | |
| struct tint_symbol { | |
| first_vertex_index : u32, | |
| first_instance_index : u32, | |
| } | |
| @binding(1) @group(2) var<uniform> tint_symbol_1 : tint_symbol; | |
| fn test(instance_idx : u32, vert_idx : u32) -> u32 { | |
| return (instance_idx + vert_idx); | |
| } | |
| struct Inputs { | |
| @builtin(instance_index) | |
| instance_idx : u32, | |
| @builtin(vertex_index) | |
| vert_idx : u32, | |
| } | |
| @stage(vertex) | |
| fn entry(inputs : Inputs) -> @builtin(position) vec4<f32> { | |
| test((inputs.instance_idx + tint_symbol_1.first_instance_index), (inputs.vert_idx + tint_symbol_1.first_vertex_index)); | |
| return vec4<f32>(); | |
| } | |
| )"; | |
| DataMap config; | |
| config.Add<FirstIndexOffset::BindingPoint>(1, 2); | |
| auto got = Run<FirstIndexOffset>(src, std::move(config)); | |
| EXPECT_EQ(expect, str(got)); | |
| auto* data = got.data.Get<FirstIndexOffset::Data>(); | |
| ASSERT_NE(data, nullptr); | |
| EXPECT_EQ(data->has_vertex_or_instance_index, true); | |
| } | |
| TEST_F(FirstIndexOffsetTest, BasicModuleBothIndex_OutOfOrder) { | |
| auto* src = R"( | |
| @stage(vertex) | |
| fn entry(inputs : Inputs) -> @builtin(position) vec4<f32> { | |
| test(inputs.instance_idx, inputs.vert_idx); | |
| return vec4<f32>(); | |
| } | |
| struct Inputs { | |
| @builtin(instance_index) instance_idx : u32, | |
| @builtin(vertex_index) vert_idx : u32, | |
| }; | |
| fn test(instance_idx : u32, vert_idx : u32) -> u32 { | |
| return instance_idx + vert_idx; | |
| } | |
| )"; | |
| auto* expect = R"( | |
| struct tint_symbol { | |
| first_vertex_index : u32, | |
| first_instance_index : u32, | |
| } | |
| @binding(1) @group(2) var<uniform> tint_symbol_1 : tint_symbol; | |
| @stage(vertex) | |
| fn entry(inputs : Inputs) -> @builtin(position) vec4<f32> { | |
| test((inputs.instance_idx + tint_symbol_1.first_instance_index), (inputs.vert_idx + tint_symbol_1.first_vertex_index)); | |
| return vec4<f32>(); | |
| } | |
| struct Inputs { | |
| @builtin(instance_index) | |
| instance_idx : u32, | |
| @builtin(vertex_index) | |
| vert_idx : u32, | |
| } | |
| fn test(instance_idx : u32, vert_idx : u32) -> u32 { | |
| return (instance_idx + vert_idx); | |
| } | |
| )"; | |
| DataMap config; | |
| config.Add<FirstIndexOffset::BindingPoint>(1, 2); | |
| auto got = Run<FirstIndexOffset>(src, std::move(config)); | |
| EXPECT_EQ(expect, str(got)); | |
| auto* data = got.data.Get<FirstIndexOffset::Data>(); | |
| ASSERT_NE(data, nullptr); | |
| EXPECT_EQ(data->has_vertex_or_instance_index, true); | |
| } | |
| TEST_F(FirstIndexOffsetTest, NestedCalls) { | |
| auto* src = R"( | |
| fn func1(vert_idx : u32) -> u32 { | |
| return vert_idx; | |
| } | |
| fn func2(vert_idx : u32) -> u32 { | |
| return func1(vert_idx); | |
| } | |
| @stage(vertex) | |
| fn entry(@builtin(vertex_index) vert_idx : u32) -> @builtin(position) vec4<f32> { | |
| func2(vert_idx); | |
| return vec4<f32>(); | |
| } | |
| )"; | |
| auto* expect = R"( | |
| struct tint_symbol { | |
| first_vertex_index : u32, | |
| first_instance_index : u32, | |
| } | |
| @binding(1) @group(2) var<uniform> tint_symbol_1 : tint_symbol; | |
| fn func1(vert_idx : u32) -> u32 { | |
| return vert_idx; | |
| } | |
| fn func2(vert_idx : u32) -> u32 { | |
| return func1(vert_idx); | |
| } | |
| @stage(vertex) | |
| fn entry(@builtin(vertex_index) vert_idx : u32) -> @builtin(position) vec4<f32> { | |
| func2((vert_idx + tint_symbol_1.first_vertex_index)); | |
| return vec4<f32>(); | |
| } | |
| )"; | |
| DataMap config; | |
| config.Add<FirstIndexOffset::BindingPoint>(1, 2); | |
| auto got = Run<FirstIndexOffset>(src, std::move(config)); | |
| EXPECT_EQ(expect, str(got)); | |
| auto* data = got.data.Get<FirstIndexOffset::Data>(); | |
| ASSERT_NE(data, nullptr); | |
| EXPECT_EQ(data->has_vertex_or_instance_index, true); | |
| } | |
| TEST_F(FirstIndexOffsetTest, NestedCalls_OutOfOrder) { | |
| auto* src = R"( | |
| @stage(vertex) | |
| fn entry(@builtin(vertex_index) vert_idx : u32) -> @builtin(position) vec4<f32> { | |
| func2(vert_idx); | |
| return vec4<f32>(); | |
| } | |
| fn func2(vert_idx : u32) -> u32 { | |
| return func1(vert_idx); | |
| } | |
| fn func1(vert_idx : u32) -> u32 { | |
| return vert_idx; | |
| } | |
| )"; | |
| auto* expect = R"( | |
| struct tint_symbol { | |
| first_vertex_index : u32, | |
| first_instance_index : u32, | |
| } | |
| @binding(1) @group(2) var<uniform> tint_symbol_1 : tint_symbol; | |
| @stage(vertex) | |
| fn entry(@builtin(vertex_index) vert_idx : u32) -> @builtin(position) vec4<f32> { | |
| func2((vert_idx + tint_symbol_1.first_vertex_index)); | |
| return vec4<f32>(); | |
| } | |
| fn func2(vert_idx : u32) -> u32 { | |
| return func1(vert_idx); | |
| } | |
| fn func1(vert_idx : u32) -> u32 { | |
| return vert_idx; | |
| } | |
| )"; | |
| DataMap config; | |
| config.Add<FirstIndexOffset::BindingPoint>(1, 2); | |
| auto got = Run<FirstIndexOffset>(src, std::move(config)); | |
| EXPECT_EQ(expect, str(got)); | |
| auto* data = got.data.Get<FirstIndexOffset::Data>(); | |
| ASSERT_NE(data, nullptr); | |
| EXPECT_EQ(data->has_vertex_or_instance_index, true); | |
| } | |
| TEST_F(FirstIndexOffsetTest, MultipleEntryPoints) { | |
| auto* src = R"( | |
| fn func(i : u32) -> u32 { | |
| return i; | |
| } | |
| @stage(vertex) | |
| fn entry_a(@builtin(vertex_index) vert_idx : u32) -> @builtin(position) vec4<f32> { | |
| func(vert_idx); | |
| return vec4<f32>(); | |
| } | |
| @stage(vertex) | |
| fn entry_b(@builtin(vertex_index) vert_idx : u32, @builtin(instance_index) inst_idx : u32) -> @builtin(position) vec4<f32> { | |
| func(vert_idx + inst_idx); | |
| return vec4<f32>(); | |
| } | |
| @stage(vertex) | |
| fn entry_c(@builtin(instance_index) inst_idx : u32) -> @builtin(position) vec4<f32> { | |
| func(inst_idx); | |
| return vec4<f32>(); | |
| } | |
| )"; | |
| auto* expect = R"( | |
| struct tint_symbol { | |
| first_vertex_index : u32, | |
| first_instance_index : u32, | |
| } | |
| @binding(1) @group(2) var<uniform> tint_symbol_1 : tint_symbol; | |
| fn func(i : u32) -> u32 { | |
| return i; | |
| } | |
| @stage(vertex) | |
| fn entry_a(@builtin(vertex_index) vert_idx : u32) -> @builtin(position) vec4<f32> { | |
| func((vert_idx + tint_symbol_1.first_vertex_index)); | |
| return vec4<f32>(); | |
| } | |
| @stage(vertex) | |
| fn entry_b(@builtin(vertex_index) vert_idx : u32, @builtin(instance_index) inst_idx : u32) -> @builtin(position) vec4<f32> { | |
| func(((vert_idx + tint_symbol_1.first_vertex_index) + (inst_idx + tint_symbol_1.first_instance_index))); | |
| return vec4<f32>(); | |
| } | |
| @stage(vertex) | |
| fn entry_c(@builtin(instance_index) inst_idx : u32) -> @builtin(position) vec4<f32> { | |
| func((inst_idx + tint_symbol_1.first_instance_index)); | |
| return vec4<f32>(); | |
| } | |
| )"; | |
| DataMap config; | |
| config.Add<FirstIndexOffset::BindingPoint>(1, 2); | |
| auto got = Run<FirstIndexOffset>(src, std::move(config)); | |
| EXPECT_EQ(expect, str(got)); | |
| auto* data = got.data.Get<FirstIndexOffset::Data>(); | |
| ASSERT_NE(data, nullptr); | |
| EXPECT_EQ(data->has_vertex_or_instance_index, true); | |
| } | |
| TEST_F(FirstIndexOffsetTest, MultipleEntryPoints_OutOfOrder) { | |
| auto* src = R"( | |
| @stage(vertex) | |
| fn entry_a(@builtin(vertex_index) vert_idx : u32) -> @builtin(position) vec4<f32> { | |
| func(vert_idx); | |
| return vec4<f32>(); | |
| } | |
| @stage(vertex) | |
| fn entry_b(@builtin(vertex_index) vert_idx : u32, @builtin(instance_index) inst_idx : u32) -> @builtin(position) vec4<f32> { | |
| func(vert_idx + inst_idx); | |
| return vec4<f32>(); | |
| } | |
| @stage(vertex) | |
| fn entry_c(@builtin(instance_index) inst_idx : u32) -> @builtin(position) vec4<f32> { | |
| func(inst_idx); | |
| return vec4<f32>(); | |
| } | |
| fn func(i : u32) -> u32 { | |
| return i; | |
| } | |
| )"; | |
| auto* expect = R"( | |
| struct tint_symbol { | |
| first_vertex_index : u32, | |
| first_instance_index : u32, | |
| } | |
| @binding(1) @group(2) var<uniform> tint_symbol_1 : tint_symbol; | |
| @stage(vertex) | |
| fn entry_a(@builtin(vertex_index) vert_idx : u32) -> @builtin(position) vec4<f32> { | |
| func((vert_idx + tint_symbol_1.first_vertex_index)); | |
| return vec4<f32>(); | |
| } | |
| @stage(vertex) | |
| fn entry_b(@builtin(vertex_index) vert_idx : u32, @builtin(instance_index) inst_idx : u32) -> @builtin(position) vec4<f32> { | |
| func(((vert_idx + tint_symbol_1.first_vertex_index) + (inst_idx + tint_symbol_1.first_instance_index))); | |
| return vec4<f32>(); | |
| } | |
| @stage(vertex) | |
| fn entry_c(@builtin(instance_index) inst_idx : u32) -> @builtin(position) vec4<f32> { | |
| func((inst_idx + tint_symbol_1.first_instance_index)); | |
| return vec4<f32>(); | |
| } | |
| fn func(i : u32) -> u32 { | |
| return i; | |
| } | |
| )"; | |
| DataMap config; | |
| config.Add<FirstIndexOffset::BindingPoint>(1, 2); | |
| auto got = Run<FirstIndexOffset>(src, std::move(config)); | |
| EXPECT_EQ(expect, str(got)); | |
| auto* data = got.data.Get<FirstIndexOffset::Data>(); | |
| ASSERT_NE(data, nullptr); | |
| EXPECT_EQ(data->has_vertex_or_instance_index, true); | |
| } | |
| } // namespace | |
| } // namespace tint::transform |