f7082cb9fa
Also rename associated files, types, functions, etc. Bug: skia:12720 Change-Id: Ibebb4e7071fa19c5a81cd36d567c96a42cd824f3 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/538040 Commit-Queue: Brian Salomon <bsalomon@google.com> Reviewed-by: Greg Daniel <egdaniel@google.com>
536 lines
20 KiB
C++
536 lines
20 KiB
C++
/*
|
|
* 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/SkMesh.h"
|
|
#include "tests/Test.h"
|
|
|
|
using Attribute = SkMeshSpecification::Attribute;
|
|
using Varying = SkMeshSpecification::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] = SkMeshSpecification::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] = SkMeshSpecification::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(MeshSpec, 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);
|
|
}
|