| /* |
| * Copyright 2021 Google LLC |
| * |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| */ |
| |
| #include "include/core/SkCanvas.h" |
| #include "include/core/SkCustomMesh.h" |
| #include "tests/Test.h" |
| |
| using Attribute = SkCustomMeshSpecification::Attribute; |
| using Varying = SkCustomMeshSpecification::Varying; |
| |
| static const char* attr_type_str(const Attribute::Type type) { |
| switch (type) { |
| case Attribute::Type::kFloat: return "float"; |
| case Attribute::Type::kFloat2: return "float2"; |
| case Attribute::Type::kFloat3: return "float3"; |
| case Attribute::Type::kFloat4: return "float4"; |
| case Attribute::Type::kUByte4_unorm: return "ubyte4_unorm"; |
| } |
| SkUNREACHABLE; |
| } |
| |
| static const char* var_type_str(const Varying::Type type) { |
| switch (type) { |
| case Varying::Type::kFloat: return "float"; |
| case Varying::Type::kFloat2: return "float2"; |
| case Varying::Type::kFloat3: return "float3"; |
| case Varying::Type::kFloat4: return "float4"; |
| case Varying::Type::kHalf: return "half"; |
| case Varying::Type::kHalf2: return "half2"; |
| case Varying::Type::kHalf3: return "half3"; |
| case Varying::Type::kHalf4: return "half4"; |
| } |
| SkUNREACHABLE; |
| } |
| |
| static SkString make_description(SkSpan<const Attribute> attributes, |
| size_t stride, |
| SkSpan<const Varying> varyings, |
| const SkString& vs, |
| const SkString& fs) { |
| static constexpr size_t kMax = 10; |
| SkString result; |
| result.appendf("Attributes (count=%zu, stride=%zu):\n", attributes.size(), stride); |
| for (size_t i = 0; i < std::min(kMax, attributes.size()); ++i) { |
| const auto& a = attributes[i]; |
| result.appendf(" {%-10s, %3zu, \"%s\"}\n", |
| attr_type_str(a.type), |
| a.offset, |
| a.name.c_str()); |
| } |
| if (kMax < attributes.size()) { |
| result.append(" ...\n"); |
| } |
| |
| result.appendf("Varyings (count=%zu):\n", varyings.size()); |
| for (size_t i = 0; i < std::min(kMax, varyings.size()); ++i) { |
| const auto& v = varyings[i]; |
| result.appendf(" {%5s, \"%s\"}\n", var_type_str(v.type), v.name.c_str()); |
| } |
| if (kMax < varyings.size()) { |
| result.append(" ...\n"); |
| } |
| |
| result.appendf("\n--VS--\n%s\n------\n", vs.c_str()); |
| result.appendf("\n--FS--\n%s\n------\n", fs.c_str()); |
| return result; |
| } |
| |
| static bool check_for_failure(skiatest::Reporter* r, |
| SkSpan<const Attribute> attributes, |
| size_t stride, |
| SkSpan<const Varying> varyings, |
| const SkString& vs, |
| const SkString& fs) { |
| auto [spec, error] = SkCustomMeshSpecification::Make(attributes, stride, varyings, vs, fs); |
| SkString description; |
| if (!spec) { |
| return true; |
| } |
| ERRORF(r, |
| "Expected to fail but succeeded:\n%s", |
| make_description(attributes, stride, varyings, vs, fs).c_str()); |
| return false; |
| } |
| |
| static bool check_for_success(skiatest::Reporter* r, |
| SkSpan<const Attribute> attributes, |
| size_t stride, |
| SkSpan<const Varying> varyings, |
| const SkString& vs, |
| const SkString& fs) { |
| auto [spec, error] = SkCustomMeshSpecification::Make(attributes, stride, varyings, vs, fs); |
| if (spec) { |
| REPORTER_ASSERT(r, error.isEmpty()); |
| return true; |
| } |
| ERRORF(r, |
| "Expected to succeed but failed:\n%sError:\n%s", |
| make_description(attributes, stride, varyings, vs, fs).c_str(), |
| error.c_str()); |
| return false; |
| } |
| |
| // Simple valid strings to make specifications |
| static const SkString kValidVS |
| {"float2 main(Attributes attrs, out Varyings v) { return float2(10); }"}; |
| // There are multiple valid VS signatures. |
| static const SkString kValidFSes[] { |
| SkString{"void main(Varyings varyings) {}"}, |
| SkString{"float2 main(Varyings varyings) { return float2(10); }"}, |
| SkString{"void main(Varyings varyings, out half4 color) { color = half4(.2); }"}, |
| SkString{R"( |
| float2 main(Varyings varyings, out half4 color) { |
| color = half4(.2); |
| return float2(10); |
| } |
| )"}, |
| }; |
| |
| // Simple valid attributes, stride, and varyings to make specifications |
| static const Attribute kValidAttrs[] = { |
| {Attribute::Type::kFloat4, 0, SkString{"pos"}}, |
| }; |
| static constexpr size_t kValidStride = 4*4; |
| static const Varying kValidVaryings[] = { |
| {Varying::Type::kFloat2, SkString{"uv"}}, |
| }; |
| |
| static void test_good(skiatest::Reporter* r) { |
| for (const auto& validFS : kValidFSes) { |
| if (!check_for_success(r, |
| SkMakeSpan(kValidAttrs, SK_ARRAY_COUNT(kValidAttrs)), |
| kValidStride, |
| SkMakeSpan(kValidVaryings, SK_ARRAY_COUNT(kValidVaryings)), |
| kValidVS, |
| validFS)) { |
| return; |
| } |
| } |
| } |
| |
| static void test_bad_sig(skiatest::Reporter* r) { |
| static constexpr const char* kVSBody = "{ return float2(10); }"; |
| |
| static constexpr const char* kInvalidVSSigs[] { |
| "float3 main(Attributes attrs, out Varyings v)", // bad return |
| "float2 main(inout Attributes attrs, out Varyings v)", // inout Attributes |
| "float2 main(Attributes attrs, inout Varyings v)", // inout Varyings |
| "float2 main(Attributes attrs)", // no Varyings |
| "float2 main(out Varyings)", // no Attributes |
| "float2 main(out Varyings, in Attributes)", // wrong param order |
| "float2 main(Attributes attrs, out Varyings v, float2)" // extra arg |
| }; |
| |
| static constexpr const char* kNoColorFSBody = "{ return float2(10); }"; |
| |
| static constexpr const char* kInvalidNoColorFSSigs[] { |
| "half2 main(Varyings v)", // bad return |
| "float2 main(in Attributes v)", // wrong param type |
| "float2 main(out Varyings attrs)", // out Varyings |
| "float2 main()", // no args |
| "float2 main(Attributes attrs, float)" // extra arg |
| }; |
| |
| static constexpr const char* kColorFSBody = "{ color = half4(.2); return float2(10); }"; |
| |
| static constexpr const char* kInvalidColorFSSigs[] { |
| "half2 main(Varyings v, out half4 color)", // bad return |
| "float2 main(in Attributes v, out half4 color)", // wrong first param type |
| "float2 main(in Varyings v, out half3 color)", // wrong second param type |
| "float2 main(out Varyings attrs, out half4 color)", // out Varyings |
| "float2 main(Varyings attrs, half4 color)", // in color |
| "float2 main(Attributes attrs, out half4 color, float)" // extra arg |
| }; |
| |
| for (const char* vsSig : kInvalidVSSigs) { |
| SkString invalidVS; |
| invalidVS.appendf("%s %s", vsSig, kVSBody); |
| for (const auto& validFS : kValidFSes) { |
| if (!check_for_failure(r, |
| SkMakeSpan(kValidAttrs, SK_ARRAY_COUNT(kValidAttrs)), |
| kValidStride, |
| SkMakeSpan(kValidVaryings, SK_ARRAY_COUNT(kValidVaryings)), |
| invalidVS, |
| validFS)) { |
| return; |
| } |
| } |
| } |
| |
| for (const char* noColorFSSig : kInvalidNoColorFSSigs) { |
| SkString invalidFS; |
| invalidFS.appendf("%s %s", noColorFSSig, kNoColorFSBody); |
| if (!check_for_failure(r, |
| SkMakeSpan(kValidAttrs, SK_ARRAY_COUNT(kValidAttrs)), |
| kValidStride, |
| SkMakeSpan(kValidVaryings, SK_ARRAY_COUNT(kValidVaryings)), |
| kValidVS, |
| invalidFS)) { |
| return; |
| } |
| } |
| |
| for (const char* colorFSSig : kInvalidColorFSSigs) { |
| SkString invalidFS; |
| invalidFS.appendf("%s %s", colorFSSig, kColorFSBody); |
| if (!check_for_failure(r, |
| SkMakeSpan(kValidAttrs, SK_ARRAY_COUNT(kValidAttrs)), |
| kValidStride, |
| SkMakeSpan(kValidVaryings, SK_ARRAY_COUNT(kValidVaryings)), |
| kValidVS, |
| invalidFS)) { |
| return; |
| } |
| } |
| } |
| |
| // We allow the optional out color from the FS to either be float4 or half4 |
| static void test_float4_color(skiatest::Reporter* r) { |
| static const SkString kFloat4FS { |
| R"( |
| float2 main(Varyings varyings, out float4 color) { |
| color = float4(.2); return float2(10); |
| } |
| )" |
| }; |
| check_for_success(r, |
| SkMakeSpan(kValidAttrs, SK_ARRAY_COUNT(kValidAttrs)), |
| kValidStride, |
| SkMakeSpan(kValidVaryings, SK_ARRAY_COUNT(kValidVaryings)), |
| kValidVS, |
| kFloat4FS); |
| } |
| |
| // We don't allow value or child uniforms in custom meshes currently. |
| static void test_bad_globals(skiatest::Reporter* r) { |
| static constexpr const char* kBadGlobals[] { |
| "uniform float3 uni;" |
| "uniform shader myshader;" |
| }; |
| for (const auto& global : kBadGlobals) { |
| SkString badVS = kValidVS; |
| badVS.prepend(global); |
| if (!check_for_failure(r, |
| SkMakeSpan(kValidAttrs, SK_ARRAY_COUNT(kValidAttrs)), |
| kValidStride, |
| SkMakeSpan(kValidVaryings, SK_ARRAY_COUNT(kValidVaryings)), |
| badVS, |
| kValidFSes[0])) { |
| return; |
| } |
| } |
| for (const auto& global : kBadGlobals) { |
| SkString badFS = kValidFSes[0]; |
| badFS.prepend(global); |
| if (!check_for_failure(r, |
| SkMakeSpan(kValidAttrs, SK_ARRAY_COUNT(kValidAttrs)), |
| kValidStride, |
| SkMakeSpan(kValidVaryings, SK_ARRAY_COUNT(kValidVaryings)), |
| kValidVS, |
| badFS)) { |
| return; |
| } |
| } |
| } |
| |
| static void test_no_main(skiatest::Reporter* r) { |
| static const SkString kHelper{"float2 swiz(float2 x) { return z.yx; }"}; |
| |
| // Empty VS |
| if (!check_for_failure(r, |
| SkMakeSpan(kValidAttrs, SK_ARRAY_COUNT(kValidAttrs)), |
| kValidStride, |
| SkMakeSpan(kValidVaryings, SK_ARRAY_COUNT(kValidVaryings)), |
| SkString{}, |
| kValidFSes[0])) { |
| return; |
| } |
| |
| // VS with helper function but no main |
| if (!check_for_failure(r, |
| SkMakeSpan(kValidAttrs, SK_ARRAY_COUNT(kValidAttrs)), |
| kValidStride, |
| SkMakeSpan(kValidVaryings, SK_ARRAY_COUNT(kValidVaryings)), |
| kHelper, |
| kValidFSes[0])) { |
| return; |
| } |
| |
| // Empty FS |
| if (!check_for_failure(r, |
| SkMakeSpan(kValidAttrs, SK_ARRAY_COUNT(kValidAttrs)), |
| kValidStride, |
| SkMakeSpan(kValidVaryings, SK_ARRAY_COUNT(kValidVaryings)), |
| kValidVS, |
| SkString{})) { |
| return; |
| } |
| |
| // VS with helper function but no main |
| if (!check_for_failure(r, |
| SkMakeSpan(kValidAttrs, SK_ARRAY_COUNT(kValidAttrs)), |
| kValidStride, |
| SkMakeSpan(kValidVaryings, SK_ARRAY_COUNT(kValidVaryings)), |
| kValidVS, |
| kHelper)) { |
| return; |
| } |
| } |
| |
| static void test_zero_attrs(skiatest::Reporter* r) { |
| // We require at least one attribute |
| check_for_failure(r, |
| SkSpan<Attribute>(), |
| kValidStride, |
| SkMakeSpan(kValidVaryings, SK_ARRAY_COUNT(kValidVaryings)), |
| kValidVS, |
| kValidFSes[0]); |
| } |
| |
| static void test_zero_varyings(skiatest::Reporter* r) { |
| // Varyings are not required. |
| check_for_success(r, |
| SkMakeSpan(kValidAttrs, SK_ARRAY_COUNT(kValidAttrs)), |
| kValidStride, |
| SkSpan<Varying>(), |
| kValidVS, |
| kValidFSes[0]); |
| } |
| |
| static void test_bad_strides(skiatest::Reporter* r) { |
| // Zero stride |
| if (!check_for_failure(r, |
| SkMakeSpan(kValidAttrs, SK_ARRAY_COUNT(kValidAttrs)), |
| 0, |
| SkMakeSpan(kValidVaryings, SK_ARRAY_COUNT(kValidVaryings)), |
| kValidVS, |
| kValidFSes[0])) { |
| return; |
| } |
| |
| // Unaligned |
| if (!check_for_failure(r, |
| SkMakeSpan(kValidAttrs, SK_ARRAY_COUNT(kValidAttrs)), |
| kValidStride + 1, |
| SkMakeSpan(kValidVaryings, SK_ARRAY_COUNT(kValidVaryings)), |
| kValidVS, |
| kValidFSes[0])) { |
| return; |
| } |
| |
| // Too large |
| if (!check_for_failure(r, |
| SkMakeSpan(kValidAttrs, SK_ARRAY_COUNT(kValidAttrs)), |
| 1 << 20, |
| SkMakeSpan(kValidVaryings, SK_ARRAY_COUNT(kValidVaryings)), |
| kValidVS, |
| kValidFSes[0])) { |
| return; |
| } |
| } |
| |
| static void test_bad_offsets(skiatest::Reporter* r) { |
| { // offset isn't aligned |
| static const Attribute kAttributes[] { |
| {Attribute::Type::kFloat4, 1, SkString{"var"}}, |
| }; |
| if (!check_for_failure(r, |
| SkMakeSpan(kAttributes, SK_ARRAY_COUNT(kAttributes)), |
| 32, |
| SkMakeSpan(kValidVaryings, SK_ARRAY_COUNT(kValidVaryings)), |
| kValidVS, |
| kValidFSes[0])) { |
| return; |
| } |
| } |
| { // straddles stride boundary |
| static const Attribute kAttributes[] { |
| {Attribute::Type::kFloat4, 0, SkString{"var"}}, |
| {Attribute::Type::kFloat2, 16, SkString{"var"}}, |
| }; |
| if (!check_for_failure(r, |
| SkMakeSpan(kAttributes, SK_ARRAY_COUNT(kAttributes)), |
| 20, |
| SkMakeSpan(kValidVaryings, SK_ARRAY_COUNT(kValidVaryings)), |
| kValidVS, |
| kValidFSes[0])) { |
| return; |
| } |
| } |
| { // straddles stride boundary with attempt to overflow |
| static const Attribute kAttributes[] { |
| {Attribute::Type::kFloat, std::numeric_limits<size_t>::max() - 3, SkString{"var"}}, |
| }; |
| if (!check_for_failure(r, |
| SkMakeSpan(kAttributes, SK_ARRAY_COUNT(kAttributes)), |
| 4, |
| SkMakeSpan(kValidVaryings, SK_ARRAY_COUNT(kValidVaryings)), |
| kValidVS, |
| kValidFSes[0])) { |
| return; |
| } |
| } |
| } |
| |
| static void test_too_many_attrs(skiatest::Reporter* r) { |
| static constexpr size_t kN = 500; |
| std::vector<Attribute> attrs; |
| attrs.reserve(kN); |
| for (size_t i = 0; i < kN; ++i) { |
| attrs.push_back({Attribute::Type::kFloat4, 0, SkStringPrintf("attr%zu", i)}); |
| } |
| check_for_failure(r, |
| SkMakeSpan(attrs), |
| 4*4, |
| SkMakeSpan(kValidVaryings, SK_ARRAY_COUNT(kValidVaryings)), |
| kValidVS, |
| kValidFSes[0]); |
| } |
| |
| static void test_too_many_varyings(skiatest::Reporter* r) { |
| static constexpr size_t kN = 500; |
| std::vector<Varying> varyings; |
| varyings.reserve(kN); |
| for (size_t i = 0; i < kN; ++i) { |
| varyings.push_back({Varying::Type::kFloat4, SkStringPrintf("varying%zu", i)}); |
| } |
| check_for_failure(r, |
| SkMakeSpan(kValidAttrs, SK_ARRAY_COUNT(kValidAttrs)), |
| kValidStride, |
| SkMakeSpan(varyings), |
| kValidVS, |
| kValidFSes[0]); |
| } |
| |
| static void test_duplicate_attribute_names(skiatest::Reporter* r) { |
| static const Attribute kAttributes[] { |
| {Attribute::Type::kFloat4, 0, SkString{"var"}}, |
| {Attribute::Type::kFloat2, 16, SkString{"var"}} |
| }; |
| check_for_failure(r, |
| SkMakeSpan(kAttributes, SK_ARRAY_COUNT(kAttributes)), |
| 24, |
| SkMakeSpan(kValidVaryings, SK_ARRAY_COUNT(kValidVaryings)), |
| kValidVS, |
| kValidFSes[0]); |
| } |
| |
| static void test_duplicate_varying_names(skiatest::Reporter* r) { |
| static const Varying kVaryings[] { |
| {Varying::Type::kFloat4, SkString{"var"}}, |
| {Varying::Type::kFloat3, SkString{"var"}} |
| }; |
| check_for_failure(r, |
| SkMakeSpan(kValidAttrs, SK_ARRAY_COUNT(kValidAttrs)), |
| kValidStride, |
| SkMakeSpan(kVaryings, SK_ARRAY_COUNT(kVaryings)), |
| kValidVS, |
| kValidFSes[0]); |
| } |
| |
| static constexpr const char* kSneakyName = "name; float3 sneaky"; |
| |
| static void test_sneaky_attribute_name(skiatest::Reporter* r) { |
| static const Attribute kAttributes[] { |
| {Attribute::Type::kFloat4, 0, SkString{kSneakyName}}, |
| }; |
| check_for_failure(r, |
| SkMakeSpan(kAttributes, SK_ARRAY_COUNT(kAttributes)), |
| 16, |
| SkMakeSpan(kValidVaryings, SK_ARRAY_COUNT(kValidVaryings)), |
| kValidVS, |
| kValidFSes[0]); |
| } |
| |
| static void test_sneaky_varying_name(skiatest::Reporter* r) { |
| static const Varying kVaryings[] { |
| {Varying::Type::kFloat4, SkString{kSneakyName}}, |
| }; |
| check_for_failure(r, |
| SkMakeSpan(kValidAttrs, SK_ARRAY_COUNT(kValidAttrs)), |
| kValidStride, |
| SkMakeSpan(kVaryings, SK_ARRAY_COUNT(kVaryings)), |
| kValidVS, |
| kValidFSes[0]); |
| } |
| |
| static void test_empty_attribute_name(skiatest::Reporter* r) { |
| static const Attribute kAttributes[] { |
| {Attribute::Type::kFloat4, 0, SkString{}}, |
| }; |
| check_for_failure(r, |
| SkMakeSpan(kAttributes, SK_ARRAY_COUNT(kAttributes)), |
| 16, |
| SkMakeSpan(kValidVaryings, SK_ARRAY_COUNT(kValidVaryings)), |
| kValidVS, |
| kValidFSes[0]); |
| } |
| |
| static void test_empty_varying_name(skiatest::Reporter* r) { |
| static const Varying kVaryings[] { |
| {Varying::Type::kFloat4, SkString{}}, |
| }; |
| check_for_failure(r, |
| SkMakeSpan(kValidAttrs, SK_ARRAY_COUNT(kValidAttrs)), |
| kValidStride, |
| SkMakeSpan(kVaryings, SK_ARRAY_COUNT(kVaryings)), |
| kValidVS, |
| kValidFSes[0]); |
| } |
| |
| DEF_TEST(CustomMeshSpec, reporter) { |
| struct X {}; |
| test_good(reporter); |
| test_bad_sig(reporter); |
| test_float4_color(reporter); |
| test_bad_globals(reporter); |
| test_no_main(reporter); |
| test_zero_attrs(reporter); |
| test_zero_varyings(reporter); |
| test_bad_strides(reporter); |
| test_bad_offsets(reporter); |
| test_too_many_attrs(reporter); |
| test_too_many_varyings(reporter); |
| // skbug.com/12712 |
| if ((false)) { |
| test_duplicate_attribute_names(reporter); |
| test_duplicate_varying_names(reporter); |
| } |
| test_sneaky_attribute_name(reporter); |
| test_sneaky_varying_name(reporter); |
| test_empty_attribute_name(reporter); |
| test_empty_varying_name(reporter); |
| } |
