encounter/dawn-cmake
1
0
Fork 0
mirror of https://github.com/encounter/dawn-cmake.git synced 2025-12-11 14:41:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

[intrinsics] rm f32 overloads of reflect, faceForward

Browse Source 
These were removed from the spec in:
https://github.com/gpuweb/gpuweb/pull/1914

Bug: tint:921
Change-Id: I4e584fdee9cf540a192f12d1208595056e081410
Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/57300
Auto-Submit: Ben Clayton <bclayton@google.com>
Kokoro: Kokoro <noreply+kokoro@google.com>
Commit-Queue: James Price <jrprice@google.com>
Reviewed-by: James Price <jrprice@google.com>
This commit is contained in:
Ben Clayton
2021-07-08 15:08:53 +00:00
committed by Tint LUCI CQ
parent 99a78ad72f
commit 70a3fa1ee9
17 changed files with 1688 additions and 2037 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3125
src/intrinsic_table.inl
View File

File diff suppressed because it is too large Load Diff

2
src/intrinsics.def
View File

@@ -301,7 +301,6 @@ fn exp(f32) -> f32
fn exp<N: num>(vec<N, f32>) -> vec<N, f32>
fn exp2(f32) -> f32
fn exp2<N: num>(vec<N, f32>) -> vec<N, f32>
fn faceForward(f32, f32, f32) -> f32
fn faceForward<N: num>(vec<N, f32>, vec<N, f32>, vec<N, f32>) -> vec<N, f32>
fn floor(f32) -> f32
fn floor<N: num>(vec<N, f32>) -> vec<N, f32>
@@ -352,7 +351,6 @@ fn pack4x8snorm(vec4<f32>) -> u32
fn pack4x8unorm(vec4<f32>) -> u32
fn pow(f32, f32) -> f32
fn pow<N: num>(vec<N, f32>, vec<N, f32>) -> vec<N, f32>
fn reflect(f32, f32) -> f32
fn reflect<N: num>(vec<N, f32>, vec<N, f32>) -> vec<N, f32>
fn refract<N: num>(vec<N, f32>, vec<N, f32>, f32) -> vec<N, f32>
fn reverseBits<T: iu32>(T) -> T

2
src/resolver/builtins_validation_test.cc
View File

@@ -962,7 +962,6 @@ INSTANTIATE_TEST_SUITE_P(ResolverBuiltinsValidationTest,
std::make_tuple("dpdyFine", 1),
std::make_tuple("exp", 1),
std::make_tuple("exp2", 1),
std::make_tuple("faceForward", 3),
std::make_tuple("floor", 1),
std::make_tuple("fma", 3),
std::make_tuple("fract", 1),
@@ -976,7 +975,6 @@ INSTANTIATE_TEST_SUITE_P(ResolverBuiltinsValidationTest,
std::make_tuple("min", 2),
std::make_tuple("mix", 3),
std::make_tuple("pow", 2),
std::make_tuple("reflect", 2),
std::make_tuple("round", 1),
std::make_tuple("sign", 1),
std::make_tuple("sin", 1),

6
src/resolver/intrinsic_test.cc
View File

@@ -1190,8 +1190,7 @@ INSTANTIATE_TEST_SUITE_P(
ResolverIntrinsicTest_TwoParam,
testing::Values(IntrinsicData{"atan2", IntrinsicType::kAtan2},
IntrinsicData{"pow", IntrinsicType::kPow},
IntrinsicData{"step", IntrinsicType::kStep},
IntrinsicData{"reflect", IntrinsicType::kReflect}));
IntrinsicData{"step", IntrinsicType::kStep}));
TEST_F(ResolverIntrinsicTest, Distance_Scalar) {
auto* call = Call("distance", 1.f, 1.f);
@@ -1369,8 +1368,7 @@ INSTANTIATE_TEST_SUITE_P(
ResolverIntrinsicTest_ThreeParam,
testing::Values(IntrinsicData{"mix", IntrinsicType::kMix},
IntrinsicData{"smoothStep", IntrinsicType::kSmoothStep},
IntrinsicData{"fma", IntrinsicType::kFma},
IntrinsicData{"faceForward", IntrinsicType::kFaceForward}));
IntrinsicData{"fma", IntrinsicType::kFma}));
using ResolverIntrinsicTest_ThreeParam_FloatOrInt =
ResolverTestWithParam<IntrinsicData>;

49
src/writer/hlsl/generator_impl_import_test.cc
View File

@@ -130,8 +130,8 @@ INSTANTIATE_TEST_SUITE_P(HlslGeneratorImplTest_Import,
HlslImportData{"tanh", "tanh"},
HlslImportData{"trunc", "trunc"}));
using HlslImportData_DualParamTest = TestParamHelper<HlslImportData>;
TEST_P(HlslImportData_DualParamTest, FloatScalar) {
using HlslImportData_DualParam_ScalarTest = TestParamHelper<HlslImportData>;
TEST_P(HlslImportData_DualParam_ScalarTest, Float) {
auto param = GetParam();
auto* expr = Call(param.name, 1.f, 2.f);
@@ -144,17 +144,16 @@ TEST_P(HlslImportData_DualParamTest, FloatScalar) {
EXPECT_EQ(out.str(), std::string(param.hlsl_name) + "(1.0f, 2.0f)");
}
INSTANTIATE_TEST_SUITE_P(HlslGeneratorImplTest_Import,
HlslImportData_DualParamTest,
HlslImportData_DualParam_ScalarTest,
testing::Values(HlslImportData{"atan2", "atan2"},
HlslImportData{"distance", "distance"},
HlslImportData{"max", "max"},
HlslImportData{"min", "min"},
HlslImportData{"pow", "pow"},
HlslImportData{"reflect", "reflect"},
HlslImportData{"step", "step"}));
using HlslImportData_DualParam_VectorTest = TestParamHelper<HlslImportData>;
TEST_P(HlslImportData_DualParam_VectorTest, FloatVector) {
TEST_P(HlslImportData_DualParam_VectorTest, Float) {
auto param = GetParam();
auto* expr =
@@ -171,7 +170,14 @@ TEST_P(HlslImportData_DualParam_VectorTest, FloatVector) {
}
INSTANTIATE_TEST_SUITE_P(HlslGeneratorImplTest_Import,
HlslImportData_DualParam_VectorTest,
testing::Values(HlslImportData{"cross", "cross"}));
testing::Values(HlslImportData{"atan2", "atan2"},
HlslImportData{"cross", "cross"},
HlslImportData{"distance", "distance"},
HlslImportData{"max", "max"},
HlslImportData{"min", "min"},
HlslImportData{"pow", "pow"},
HlslImportData{"reflect", "reflect"},
HlslImportData{"step", "step"}));
using HlslImportData_DualParam_Int_Test = TestParamHelper<HlslImportData>;
TEST_P(HlslImportData_DualParam_Int_Test, IntScalar) {
@@ -191,8 +197,8 @@ INSTANTIATE_TEST_SUITE_P(HlslGeneratorImplTest_Import,
testing::Values(HlslImportData{"max", "max"},
HlslImportData{"min", "min"}));
using HlslImportData_TripleParamTest = TestParamHelper<HlslImportData>;
TEST_P(HlslImportData_TripleParamTest, FloatScalar) {
using HlslImportData_TripleParam_ScalarTest = TestParamHelper<HlslImportData>;
TEST_P(HlslImportData_TripleParam_ScalarTest, Float) {
auto param = GetParam();
auto* expr = Call(param.name, 1.f, 2.f, 3.f);
@@ -204,9 +210,34 @@ TEST_P(HlslImportData_TripleParamTest, FloatScalar) {
ASSERT_TRUE(gen.EmitCall(out, expr)) << gen.error();
EXPECT_EQ(out.str(), std::string(param.hlsl_name) + "(1.0f, 2.0f, 3.0f)");
}
INSTANTIATE_TEST_SUITE_P(HlslGeneratorImplTest_Import,
HlslImportData_TripleParam_ScalarTest,
testing::Values(HlslImportData{"fma", "mad"},
HlslImportData{"mix", "lerp"},
HlslImportData{"clamp", "clamp"},
HlslImportData{"smoothStep",
"smoothstep"}));
using HlslImportData_TripleParam_VectorTest = TestParamHelper<HlslImportData>;
TEST_P(HlslImportData_TripleParam_VectorTest, Float) {
auto param = GetParam();
auto* expr = Call(param.name, vec3<f32>(1.f, 2.f, 3.f),
vec3<f32>(4.f, 5.f, 6.f), vec3<f32>(7.f, 8.f, 9.f));
WrapInFunction(expr);
GeneratorImpl& gen = Build();
std::stringstream out;
ASSERT_TRUE(gen.EmitCall(out, expr)) << gen.error();
EXPECT_EQ(
out.str(),
std::string(param.hlsl_name) +
R"((float3(1.0f, 2.0f, 3.0f), float3(4.0f, 5.0f, 6.0f), float3(7.0f, 8.0f, 9.0f)))");
}
INSTANTIATE_TEST_SUITE_P(
HlslGeneratorImplTest_Import,
HlslImportData_TripleParamTest,
HlslImportData_TripleParam_VectorTest,
testing::Values(HlslImportData{"faceForward", "faceforward"},
HlslImportData{"fma", "mad"},
HlslImportData{"clamp", "clamp"},

56
src/writer/msl/generator_impl_import_test.cc
View File

@@ -86,8 +86,8 @@ TEST_F(MslGeneratorImplTest, MslImportData_SingleParamTest_IntScalar) {
EXPECT_EQ(out.str(), R"(abs(1))");
}
using MslImportData_DualParamTest = TestParamHelper<MslImportData>;
TEST_P(MslImportData_DualParamTest, FloatScalar) {
using MslImportData_DualParam_ScalarTest = TestParamHelper<MslImportData>;
TEST_P(MslImportData_DualParam_ScalarTest, Float) {
auto param = GetParam();
auto* expr = Call(param.name, 1.0f, 2.0f);
@@ -100,17 +100,16 @@ TEST_P(MslImportData_DualParamTest, FloatScalar) {
EXPECT_EQ(out.str(), std::string(param.msl_name) + "(1.0f, 2.0f)");
}
INSTANTIATE_TEST_SUITE_P(MslGeneratorImplTest,
MslImportData_DualParamTest,
MslImportData_DualParam_ScalarTest,
testing::Values(MslImportData{"atan2", "atan2"},
MslImportData{"distance", "distance"},
MslImportData{"max", "fmax"},
MslImportData{"min", "fmin"},
MslImportData{"pow", "pow"},
MslImportData{"reflect", "reflect"},
MslImportData{"step", "step"}));
using MslImportData_DualParam_VectorTest = TestParamHelper<MslImportData>;
TEST_P(MslImportData_DualParam_VectorTest, FloatVector) {
TEST_P(MslImportData_DualParam_VectorTest, Float) {
auto param = GetParam();
auto* expr =
@@ -121,13 +120,20 @@ TEST_P(MslImportData_DualParam_VectorTest, FloatVector) {
std::stringstream out;
ASSERT_TRUE(gen.EmitCall(out, expr)) << gen.error();
EXPECT_EQ(out.str(), std::string(param.msl_name) +
"(float3(1.0f, 2.0f, 3.0f), "
"float3(4.0f, 5.0f, 6.0f))");
EXPECT_EQ(out.str(),
std::string(param.msl_name) +
R"((float3(1.0f, 2.0f, 3.0f), float3(4.0f, 5.0f, 6.0f)))");
}
INSTANTIATE_TEST_SUITE_P(MslGeneratorImplTest,
MslImportData_DualParam_VectorTest,
testing::Values(MslImportData{"cross", "cross"}));
testing::Values(MslImportData{"atan2", "atan2"},
MslImportData{"cross", "cross"},
MslImportData{"distance", "distance"},
MslImportData{"max", "fmax"},
MslImportData{"min", "fmin"},
MslImportData{"pow", "pow"},
MslImportData{"reflect", "reflect"},
MslImportData{"step", "step"}));
using MslImportData_DualParam_Int_Test = TestParamHelper<MslImportData>;
TEST_P(MslImportData_DualParam_Int_Test, IntScalar) {
@@ -147,8 +153,8 @@ INSTANTIATE_TEST_SUITE_P(MslGeneratorImplTest,
testing::Values(MslImportData{"max", "max"},
MslImportData{"min", "min"}));
using MslImportData_TripleParamTest = TestParamHelper<MslImportData>;
TEST_P(MslImportData_TripleParamTest, FloatScalar) {
using MslImportData_TripleParam_ScalarTest = TestParamHelper<MslImportData>;
TEST_P(MslImportData_TripleParam_ScalarTest, Float) {
auto param = GetParam();
auto* expr = Call(param.name, 1.f, 2.f, 3.f);
@@ -160,12 +166,36 @@ TEST_P(MslImportData_TripleParamTest, FloatScalar) {
ASSERT_TRUE(gen.EmitCall(out, expr)) << gen.error();
EXPECT_EQ(out.str(), std::string(param.msl_name) + "(1.0f, 2.0f, 3.0f)");
}
INSTANTIATE_TEST_SUITE_P(MslGeneratorImplTest,
MslImportData_TripleParam_ScalarTest,
testing::Values(MslImportData{"fma", "fma"},
MslImportData{"mix", "mix"},
MslImportData{"clamp", "clamp"},
MslImportData{"smoothStep",
"smoothstep"}));
using MslImportData_TripleParam_VectorTest = TestParamHelper<MslImportData>;
TEST_P(MslImportData_TripleParam_VectorTest, Float) {
auto param = GetParam();
auto* expr = Call(param.name, vec3<f32>(1.f, 2.f, 3.f),
vec3<f32>(4.f, 5.f, 6.f), vec3<f32>(7.f, 8.f, 9.f));
WrapInFunction(expr);
GeneratorImpl& gen = Build();
std::stringstream out;
ASSERT_TRUE(gen.EmitCall(out, expr)) << gen.error();
EXPECT_EQ(
out.str(),
std::string(param.msl_name) +
R"((float3(1.0f, 2.0f, 3.0f), float3(4.0f, 5.0f, 6.0f), float3(7.0f, 8.0f, 9.0f)))");
}
INSTANTIATE_TEST_SUITE_P(
MslGeneratorImplTest,
MslImportData_TripleParamTest,
MslImportData_TripleParam_VectorTest,
testing::Values(MslImportData{"faceForward", "faceforward"},
MslImportData{"fma", "fma"},
MslImportData{"mix", "mix"},
MslImportData{"clamp", "clamp"},
MslImportData{"smoothStep", "smoothstep"}));

75
src/writer/spirv/builder_intrinsic_test.cc
View File

@@ -849,9 +849,37 @@ INSTANTIATE_TEST_SUITE_P(IntrinsicBuilderTest,
IntrinsicData{"max", "NMax"},
IntrinsicData{"min", "NMin"},
IntrinsicData{"pow", "Pow"},
IntrinsicData{"reflect", "Reflect"},
IntrinsicData{"step", "Step"}));
TEST_F(IntrinsicBuilderTest, Call_Reflect_Vector) {
auto* expr = Call("reflect", vec2<f32>(1.0f, 1.0f), vec2<f32>(1.0f, 1.0f));
WrapInFunction(expr);
auto* func = Func("a_func", ast::VariableList{}, ty.void_(),
ast::StatementList{}, ast::DecorationList{});
spirv::Builder& b = Build();
ASSERT_TRUE(b.GenerateFunction(func)) << b.error();
EXPECT_EQ(b.GenerateCallExpression(expr), 5u) << b.error();
EXPECT_EQ(DumpBuilder(b), R"(%8 = OpExtInstImport "GLSL.std.450"
OpName %3 "a_func"
%2 = OpTypeVoid
%1 = OpTypeFunction %2
%7 = OpTypeFloat 32
%6 = OpTypeVector %7 2
%9 = OpConstant %7 1
%10 = OpConstantComposite %6 %9 %9
%3 = OpFunction %2 None %1
%4 = OpLabel
%5 = OpExtInst %6 %8 Reflect %10 %10
OpReturn
OpFunctionEnd
)");
}
TEST_F(IntrinsicBuilderTest, Call_Distance_Scalar) {
auto* expr = Call("distance", 1.0f, 1.0f);
@@ -1001,15 +1029,44 @@ OpReturn
OpFunctionEnd
)");
}
INSTANTIATE_TEST_SUITE_P(
IntrinsicBuilderTest,
Intrinsic_Builtin_ThreeParam_Float_Test,
testing::Values(IntrinsicData{"clamp", "NClamp"},
IntrinsicData{"faceForward", "FaceForward"},
IntrinsicData{"fma", "Fma"},
IntrinsicData{"mix", "FMix"},
INSTANTIATE_TEST_SUITE_P(IntrinsicBuilderTest,
Intrinsic_Builtin_ThreeParam_Float_Test,
testing::Values(IntrinsicData{"clamp", "NClamp"},
IntrinsicData{"fma", "Fma"},
IntrinsicData{"mix", "FMix"},
IntrinsicData{"smoothStep", "SmoothStep"}));
IntrinsicData{"smoothStep",
"SmoothStep"}));
TEST_F(IntrinsicBuilderTest, Call_FaceForward_Vector) {
auto* expr = Call("faceForward", vec2<f32>(1.0f, 1.0f), vec2<f32>(1.0f, 1.0f),
vec2<f32>(1.0f, 1.0f));
WrapInFunction(expr);
auto* func = Func("a_func", ast::VariableList{}, ty.void_(),
ast::StatementList{}, ast::DecorationList{});
spirv::Builder& b = Build();
ASSERT_TRUE(b.GenerateFunction(func)) << b.error();
EXPECT_EQ(b.GenerateCallExpression(expr), 5u) << b.error();
EXPECT_EQ(DumpBuilder(b), R"(%8 = OpExtInstImport "GLSL.std.450"
OpName %3 "a_func"
%2 = OpTypeVoid
%1 = OpTypeFunction %2
%7 = OpTypeFloat 32
%6 = OpTypeVector %7 2
%9 = OpConstant %7 1
%10 = OpConstantComposite %6 %9 %9
%3 = OpFunction %2 None %1
%4 = OpLabel
%5 = OpExtInst %6 %8 FaceForward %10 %10 %10
OpReturn
OpFunctionEnd
)");
}
using Intrinsic_Builtin_SingleParam_Sint_Test =
IntrinsicBuilderTestWithParam<IntrinsicData>;