2017-06-29 14:03:38 +00:00
|
|
|
/*
|
|
|
|
* Copyright 2017 Google Inc.
|
|
|
|
*
|
|
|
|
* Use of this source code is governed by a BSD-style license that can be
|
|
|
|
* found in the LICENSE file.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "SkSLCompiler.h"
|
|
|
|
|
|
|
|
#include "Test.h"
|
|
|
|
|
|
|
|
static void test(skiatest::Reporter* r, const char* src, const GrShaderCaps& caps,
|
|
|
|
std::vector<const char*> expectedH, std::vector<const char*> expectedCPP) {
|
|
|
|
SkSL::Program::Settings settings;
|
|
|
|
settings.fCaps = ∩︀
|
|
|
|
SkSL::Compiler compiler;
|
|
|
|
SkSL::StringStream output;
|
|
|
|
std::unique_ptr<SkSL::Program> program = compiler.convertProgram(
|
|
|
|
SkSL::Program::kFragmentProcessor_Kind,
|
2017-08-14 18:48:10 +00:00
|
|
|
SkSL::String(src),
|
2017-06-29 14:03:38 +00:00
|
|
|
settings);
|
|
|
|
if (!program) {
|
|
|
|
SkDebugf("Unexpected error compiling %s\n%s", src, compiler.errorText().c_str());
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
REPORTER_ASSERT(r, program);
|
|
|
|
bool success = compiler.toH(*program, "Test", output);
|
|
|
|
if (!success) {
|
|
|
|
SkDebugf("Unexpected error compiling %s\n%s", src, compiler.errorText().c_str());
|
|
|
|
}
|
|
|
|
REPORTER_ASSERT(r, success);
|
|
|
|
if (success) {
|
|
|
|
for (const char* expected : expectedH) {
|
|
|
|
bool found = strstr(output.str().c_str(), expected);
|
|
|
|
if (!found) {
|
|
|
|
SkDebugf("HEADER MISMATCH:\nsource:\n%s\n\nexpected:\n'%s'\n\nreceived:\n'%s'", src,
|
|
|
|
expected, output.str().c_str());
|
|
|
|
}
|
|
|
|
REPORTER_ASSERT(r, found);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
output.reset();
|
|
|
|
success = compiler.toCPP(*program, "Test", output);
|
|
|
|
if (!success) {
|
|
|
|
SkDebugf("Unexpected error compiling %s\n%s", src, compiler.errorText().c_str());
|
|
|
|
}
|
|
|
|
REPORTER_ASSERT(r, success);
|
|
|
|
if (success) {
|
|
|
|
for (const char* expected : expectedCPP) {
|
|
|
|
bool found = strstr(output.str().c_str(), expected);
|
|
|
|
if (!found) {
|
|
|
|
SkDebugf("CPP MISMATCH:\nsource:\n%s\n\nexpected:\n'%s'\n\nreceived:\n'%s'", src,
|
|
|
|
expected, output.str().c_str());
|
|
|
|
}
|
|
|
|
REPORTER_ASSERT(r, found);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
DEF_TEST(SkSLFPHelloWorld, r) {
|
|
|
|
test(r,
|
2018-02-01 17:14:34 +00:00
|
|
|
"/* HEADER */"
|
2017-06-29 14:03:38 +00:00
|
|
|
"void main() {"
|
2017-09-18 18:10:39 +00:00
|
|
|
"sk_OutColor = half4(1);"
|
2017-06-29 14:03:38 +00:00
|
|
|
"}",
|
|
|
|
*SkSL::ShaderCapsFactory::Default(),
|
|
|
|
{
|
2018-02-01 17:14:34 +00:00
|
|
|
"/* HEADER */\n"
|
2017-06-29 14:03:38 +00:00
|
|
|
"\n"
|
2018-02-01 17:14:34 +00:00
|
|
|
"/**************************************************************************************************\n"
|
|
|
|
" *** This file was autogenerated from GrTest.fp; do not modify.\n"
|
|
|
|
" **************************************************************************************************/\n"
|
2017-06-29 14:03:38 +00:00
|
|
|
"#ifndef GrTest_DEFINED\n"
|
|
|
|
"#define GrTest_DEFINED\n"
|
2017-07-10 19:40:20 +00:00
|
|
|
"#include \"SkTypes.h\"\n"
|
2017-06-29 14:03:38 +00:00
|
|
|
"#include \"GrFragmentProcessor.h\"\n"
|
|
|
|
"#include \"GrCoordTransform.h\"\n"
|
|
|
|
"class GrTest : public GrFragmentProcessor {\n"
|
|
|
|
"public:\n"
|
2017-08-11 13:40:37 +00:00
|
|
|
" static std::unique_ptr<GrFragmentProcessor> Make() {\n"
|
|
|
|
" return std::unique_ptr<GrFragmentProcessor>(new GrTest());\n"
|
2017-06-29 14:03:38 +00:00
|
|
|
" }\n"
|
2017-07-31 15:18:22 +00:00
|
|
|
" GrTest(const GrTest& src);\n"
|
2017-08-11 13:40:37 +00:00
|
|
|
" std::unique_ptr<GrFragmentProcessor> clone() const override;\n"
|
2017-06-29 14:03:38 +00:00
|
|
|
" const char* name() const override { return \"Test\"; }\n"
|
|
|
|
"private:\n"
|
|
|
|
" GrTest()\n"
|
2017-10-09 14:54:08 +00:00
|
|
|
" : INHERITED(kGrTest_ClassID, kNone_OptimizationFlags) {\n"
|
2017-06-29 14:03:38 +00:00
|
|
|
" }\n"
|
|
|
|
" GrGLSLFragmentProcessor* onCreateGLSLInstance() const override;\n"
|
|
|
|
" void onGetGLSLProcessorKey(const GrShaderCaps&,GrProcessorKeyBuilder*) "
|
|
|
|
"const override;\n"
|
|
|
|
" bool onIsEqual(const GrFragmentProcessor&) const override;\n"
|
2017-07-06 14:09:38 +00:00
|
|
|
" GR_DECLARE_FRAGMENT_PROCESSOR_TEST\n"
|
2017-06-29 14:03:38 +00:00
|
|
|
" typedef GrFragmentProcessor INHERITED;\n"
|
|
|
|
"};\n"
|
|
|
|
"#endif\n"
|
|
|
|
},
|
|
|
|
{
|
2018-02-01 17:14:34 +00:00
|
|
|
"/* HEADER */\n"
|
2017-06-29 14:03:38 +00:00
|
|
|
"\n"
|
2018-02-01 17:14:34 +00:00
|
|
|
"/**************************************************************************************************\n"
|
|
|
|
" *** This file was autogenerated from GrTest.fp; do not modify.\n"
|
|
|
|
" **************************************************************************************************/\n"
|
2017-06-29 14:03:38 +00:00
|
|
|
"#include \"GrTest.h\"\n"
|
|
|
|
"#include \"glsl/GrGLSLFragmentProcessor.h\"\n"
|
|
|
|
"#include \"glsl/GrGLSLFragmentShaderBuilder.h\"\n"
|
|
|
|
"#include \"glsl/GrGLSLProgramBuilder.h\"\n"
|
2017-12-13 19:36:14 +00:00
|
|
|
"#include \"GrTexture.h\"\n"
|
2017-06-29 14:03:38 +00:00
|
|
|
"#include \"SkSLCPP.h\"\n"
|
|
|
|
"#include \"SkSLUtil.h\"\n"
|
|
|
|
"class GrGLSLTest : public GrGLSLFragmentProcessor {\n"
|
|
|
|
"public:\n"
|
|
|
|
" GrGLSLTest() {}\n"
|
|
|
|
" void emitCode(EmitArgs& args) override {\n"
|
|
|
|
" GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;\n"
|
|
|
|
" const GrTest& _outer = args.fFp.cast<GrTest>();\n"
|
|
|
|
" (void) _outer;\n"
|
2017-09-18 18:10:39 +00:00
|
|
|
" fragBuilder->codeAppendf(\"%s = half4(1.0);\\n\", args.fOutputColor);\n"
|
2017-06-29 14:03:38 +00:00
|
|
|
" }\n"
|
|
|
|
"private:\n"
|
|
|
|
" void onSetData(const GrGLSLProgramDataManager& pdman, "
|
|
|
|
"const GrFragmentProcessor& _proc) override {\n"
|
|
|
|
" }\n"
|
|
|
|
"};\n"
|
|
|
|
"GrGLSLFragmentProcessor* GrTest::onCreateGLSLInstance() const {\n"
|
|
|
|
" return new GrGLSLTest();\n"
|
|
|
|
"}\n"
|
|
|
|
"void GrTest::onGetGLSLProcessorKey(const GrShaderCaps& caps, "
|
|
|
|
"GrProcessorKeyBuilder* b) const {\n"
|
|
|
|
"}\n"
|
|
|
|
"bool GrTest::onIsEqual(const GrFragmentProcessor& other) const {\n"
|
|
|
|
" const GrTest& that = other.cast<GrTest>();\n"
|
|
|
|
" (void) that;\n"
|
|
|
|
" return true;\n"
|
|
|
|
"}\n"
|
2017-07-31 15:18:22 +00:00
|
|
|
"GrTest::GrTest(const GrTest& src)\n"
|
2017-10-09 14:54:08 +00:00
|
|
|
": INHERITED(kGrTest_ClassID, src.optimizationFlags()) {\n"
|
2017-07-31 15:18:22 +00:00
|
|
|
"}\n"
|
2017-08-11 13:40:37 +00:00
|
|
|
"std::unique_ptr<GrFragmentProcessor> GrTest::clone() const {\n"
|
|
|
|
" return std::unique_ptr<GrFragmentProcessor>(new GrTest(*this));\n"
|
2017-07-31 15:18:22 +00:00
|
|
|
"}\n"
|
2017-06-29 14:03:38 +00:00
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
DEF_TEST(SkSLFPInput, r) {
|
|
|
|
test(r,
|
2017-09-18 18:10:39 +00:00
|
|
|
"in half2 point;"
|
2017-06-29 14:03:38 +00:00
|
|
|
"void main() {"
|
2017-09-18 18:10:39 +00:00
|
|
|
"sk_OutColor = half4(point, point);"
|
2017-06-29 14:03:38 +00:00
|
|
|
"}",
|
|
|
|
*SkSL::ShaderCapsFactory::Default(),
|
|
|
|
{
|
2018-08-31 14:52:47 +00:00
|
|
|
"const SkPoint& point() const { return fPoint; }",
|
2017-08-11 13:40:37 +00:00
|
|
|
"static std::unique_ptr<GrFragmentProcessor> Make(SkPoint point) {",
|
|
|
|
"return std::unique_ptr<GrFragmentProcessor>(new GrTest(point));",
|
2017-06-29 14:03:38 +00:00
|
|
|
"GrTest(SkPoint point)",
|
|
|
|
", fPoint(point)"
|
|
|
|
},
|
|
|
|
{
|
2017-09-18 18:10:39 +00:00
|
|
|
"fragBuilder->codeAppendf(\"%s = half4(half2(%f, %f), half2(%f, %f));\\n\", "
|
2017-06-29 14:03:38 +00:00
|
|
|
"args.fOutputColor, _outer.point().fX, _outer.point().fY, "
|
|
|
|
"_outer.point().fX, _outer.point().fY);",
|
|
|
|
"if (fPoint != that.fPoint) return false;"
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
DEF_TEST(SkSLFPUniform, r) {
|
|
|
|
test(r,
|
2017-09-18 18:10:39 +00:00
|
|
|
"uniform half4 color;"
|
2017-06-29 14:03:38 +00:00
|
|
|
"void main() {"
|
|
|
|
"sk_OutColor = color;"
|
|
|
|
"}",
|
|
|
|
*SkSL::ShaderCapsFactory::Default(),
|
|
|
|
{
|
2017-08-11 13:40:37 +00:00
|
|
|
"static std::unique_ptr<GrFragmentProcessor> Make()"
|
2017-06-29 14:03:38 +00:00
|
|
|
},
|
|
|
|
{
|
2017-09-18 18:10:39 +00:00
|
|
|
"fColorVar = args.fUniformHandler->addUniform(kFragment_GrShaderFlag, kHalf4_GrSLType, "
|
2017-06-29 14:03:38 +00:00
|
|
|
"kDefault_GrSLPrecision, \"color\");",
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2018-08-31 14:52:47 +00:00
|
|
|
// SkSLFPInUniform tests the simplest plumbing case, default type, no tracking
|
|
|
|
// with a setUniform template that supports inlining the value call with no
|
|
|
|
// local variable.
|
2017-06-29 14:03:38 +00:00
|
|
|
DEF_TEST(SkSLFPInUniform, r) {
|
|
|
|
test(r,
|
2017-09-18 18:10:39 +00:00
|
|
|
"in uniform half4 color;"
|
2017-06-29 14:03:38 +00:00
|
|
|
"void main() {"
|
|
|
|
"sk_OutColor = color;"
|
|
|
|
"}",
|
|
|
|
*SkSL::ShaderCapsFactory::Default(),
|
|
|
|
{
|
2017-08-11 13:40:37 +00:00
|
|
|
"static std::unique_ptr<GrFragmentProcessor> Make(SkRect color) {",
|
2017-06-29 14:03:38 +00:00
|
|
|
},
|
|
|
|
{
|
2017-09-18 18:10:39 +00:00
|
|
|
"fColorVar = args.fUniformHandler->addUniform(kFragment_GrShaderFlag, kHalf4_GrSLType, "
|
2017-06-29 14:03:38 +00:00
|
|
|
"kDefault_GrSLPrecision, \"color\");",
|
2018-08-31 14:52:47 +00:00
|
|
|
"pdman.set4fv(fColorVar, 1, reinterpret_cast<const float*>(&(_outer.color())));"
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
// As above, but tests in uniform's ability to override the default ctype.
|
|
|
|
DEF_TEST(SkSLFPInUniformCType, r) {
|
|
|
|
test(r,
|
2018-10-16 19:45:55 +00:00
|
|
|
"layout(ctype=SkPMColor4f) in uniform half4 color;"
|
2018-08-31 14:52:47 +00:00
|
|
|
"void main() {"
|
|
|
|
"sk_OutColor = color;"
|
|
|
|
"}",
|
|
|
|
*SkSL::ShaderCapsFactory::Default(),
|
|
|
|
{
|
2018-10-16 19:45:55 +00:00
|
|
|
"static std::unique_ptr<GrFragmentProcessor> Make(SkPMColor4f color) {",
|
2018-08-31 14:52:47 +00:00
|
|
|
},
|
|
|
|
{
|
|
|
|
"fColorVar = args.fUniformHandler->addUniform(kFragment_GrShaderFlag, kHalf4_GrSLType, "
|
|
|
|
"kDefault_GrSLPrecision, \"color\");",
|
2018-10-16 19:45:55 +00:00
|
|
|
"pdman.set4fv(fColorVar, 1, (_outer.color()).vec());"
|
2018-08-31 14:52:47 +00:00
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
// Add state tracking to the default typed SkRect <-> half4 uniform. But since
|
|
|
|
// it now has to track state, the value inlining previously done for the
|
|
|
|
// setUniform call is removed in favor of a local variable.
|
|
|
|
DEF_TEST(SkSLFPTrackedInUniform, r) {
|
|
|
|
test(r,
|
|
|
|
"layout(tracked) in uniform half4 color;"
|
|
|
|
"void main() {"
|
|
|
|
"sk_OutColor = color;"
|
|
|
|
"}",
|
|
|
|
*SkSL::ShaderCapsFactory::Default(),
|
|
|
|
{
|
|
|
|
"static std::unique_ptr<GrFragmentProcessor> Make(SkRect color) {",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"SkRect fColorPrev = SkRect::MakeEmpty();",
|
|
|
|
"fColorVar = args.fUniformHandler->addUniform(kFragment_GrShaderFlag, kHalf4_GrSLType, "
|
|
|
|
"kDefault_GrSLPrecision, \"color\");",
|
|
|
|
"const SkRect& colorValue = _outer.color();",
|
|
|
|
"if (fColorPrev.isEmpty() || fColorPrev != colorValue) {",
|
|
|
|
"fColorPrev = colorValue;",
|
|
|
|
"pdman.set4fv(fColorVar, 1, reinterpret_cast<const float*>(&colorValue));"
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
// Test the case where the template does not support variable inlining in
|
|
|
|
// setUniform (i.e. it references the value multiple times).
|
|
|
|
DEF_TEST(SkSLFPNonInlinedInUniform, r) {
|
|
|
|
test(r,
|
|
|
|
"in uniform half2 point;"
|
|
|
|
"void main() {"
|
|
|
|
"sk_OutColor = half4(point, point);"
|
|
|
|
"}",
|
|
|
|
*SkSL::ShaderCapsFactory::Default(),
|
|
|
|
{
|
|
|
|
"static std::unique_ptr<GrFragmentProcessor> Make(SkPoint point) {",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"fPointVar = args.fUniformHandler->addUniform(kFragment_GrShaderFlag, kHalf2_GrSLType, "
|
|
|
|
"kDefault_GrSLPrecision, \"point\");",
|
|
|
|
"const SkPoint& pointValue = _outer.point();",
|
|
|
|
"pdman.set2f(fPointVar, pointValue.fX, pointValue.fY);"
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
// Test handling conditional uniforms (that use when= in layout), combined with
|
|
|
|
// state tracking and custom ctypes to really put the code generation through its paces.
|
|
|
|
DEF_TEST(SkSLFPConditionalInUniform, r) {
|
|
|
|
test(r,
|
|
|
|
"in bool test;"
|
2018-10-16 19:45:55 +00:00
|
|
|
"layout(ctype=SkPMColor4f, tracked, when=test) in uniform half4 color;"
|
2018-08-31 14:52:47 +00:00
|
|
|
"void main() {"
|
|
|
|
" if (test) {"
|
|
|
|
" sk_OutColor = color;"
|
|
|
|
" } else {"
|
|
|
|
" sk_OutColor = half4(1);"
|
|
|
|
" }"
|
|
|
|
"}",
|
|
|
|
*SkSL::ShaderCapsFactory::Default(),
|
|
|
|
{
|
2018-10-16 19:45:55 +00:00
|
|
|
"static std::unique_ptr<GrFragmentProcessor> Make(bool test, SkPMColor4f color) {",
|
2018-08-31 14:52:47 +00:00
|
|
|
},
|
|
|
|
{
|
2018-10-16 19:45:55 +00:00
|
|
|
"SkPMColor4f fColorPrev = {SK_FloatNaN, SK_FloatNaN, SK_FloatNaN, SK_FloatNaN}",
|
2018-08-31 14:52:47 +00:00
|
|
|
"auto test = _outer.test();",
|
|
|
|
"if (test) {",
|
|
|
|
"fColorVar = args.fUniformHandler->addUniform(kFragment_GrShaderFlag, kHalf4_GrSLType, "
|
|
|
|
"kDefault_GrSLPrecision, \"color\");",
|
|
|
|
"if (fColorVar.isValid()) {",
|
2018-10-16 19:45:55 +00:00
|
|
|
"const SkPMColor4f& colorValue = _outer.color();",
|
2018-08-31 14:52:47 +00:00
|
|
|
"if (fColorPrev != colorValue) {",
|
|
|
|
"fColorPrev = colorValue;",
|
2018-10-16 19:45:55 +00:00
|
|
|
"pdman.set4fv(fColorVar, 1, colorValue.vec());"
|
2017-06-29 14:03:38 +00:00
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
DEF_TEST(SkSLFPSections, r) {
|
|
|
|
test(r,
|
|
|
|
"@header { header section }"
|
|
|
|
"void main() {"
|
2017-09-18 18:10:39 +00:00
|
|
|
"sk_OutColor = half4(1);"
|
2017-06-29 14:03:38 +00:00
|
|
|
"}",
|
|
|
|
*SkSL::ShaderCapsFactory::Default(),
|
|
|
|
{
|
2018-04-06 14:37:55 +00:00
|
|
|
"header section"
|
2017-06-29 14:03:38 +00:00
|
|
|
},
|
|
|
|
{});
|
|
|
|
test(r,
|
|
|
|
"@class { class section }"
|
|
|
|
"void main() {"
|
2017-09-18 18:10:39 +00:00
|
|
|
"sk_OutColor = half4(1);"
|
2017-06-29 14:03:38 +00:00
|
|
|
"}",
|
|
|
|
*SkSL::ShaderCapsFactory::Default(),
|
|
|
|
{
|
|
|
|
"class GrTest : public GrFragmentProcessor {\n"
|
|
|
|
"public:\n"
|
|
|
|
" class section"
|
|
|
|
},
|
|
|
|
{});
|
|
|
|
test(r,
|
|
|
|
"@cpp { cpp section }"
|
|
|
|
"void main() {"
|
2017-09-18 18:10:39 +00:00
|
|
|
"sk_OutColor = half4(1);"
|
2017-06-29 14:03:38 +00:00
|
|
|
"}",
|
|
|
|
*SkSL::ShaderCapsFactory::Default(),
|
|
|
|
{},
|
|
|
|
{"cpp section"});
|
|
|
|
test(r,
|
|
|
|
"@constructorParams { int x, float y, std::vector<float> z }"
|
2017-09-20 15:24:15 +00:00
|
|
|
"in float w;"
|
2017-06-29 14:03:38 +00:00
|
|
|
"void main() {"
|
2017-09-20 15:24:15 +00:00
|
|
|
"sk_OutColor = float4(1);"
|
2017-06-29 14:03:38 +00:00
|
|
|
"}",
|
|
|
|
*SkSL::ShaderCapsFactory::Default(),
|
|
|
|
{
|
|
|
|
"Make(float w, int x, float y, std::vector<float> z )",
|
2017-08-11 13:40:37 +00:00
|
|
|
"return std::unique_ptr<GrFragmentProcessor>(new GrTest(w, x, y, z));",
|
2017-06-29 14:03:38 +00:00
|
|
|
"GrTest(float w, int x, float y, std::vector<float> z )",
|
|
|
|
", fW(w) {"
|
|
|
|
},
|
|
|
|
{});
|
|
|
|
test(r,
|
|
|
|
"@constructor { constructor section }"
|
|
|
|
"void main() {"
|
2017-09-18 18:10:39 +00:00
|
|
|
"sk_OutColor = half4(1);"
|
2017-06-29 14:03:38 +00:00
|
|
|
"}",
|
|
|
|
*SkSL::ShaderCapsFactory::Default(),
|
|
|
|
{
|
|
|
|
"private:\n constructor section"
|
|
|
|
},
|
|
|
|
{});
|
|
|
|
test(r,
|
|
|
|
"@initializers { initializers section }"
|
|
|
|
"void main() {"
|
2017-09-18 18:10:39 +00:00
|
|
|
"sk_OutColor = half4(1);"
|
2017-06-29 14:03:38 +00:00
|
|
|
"}",
|
|
|
|
*SkSL::ShaderCapsFactory::Default(),
|
|
|
|
{
|
2017-10-09 14:54:08 +00:00
|
|
|
": INHERITED(kGrTest_ClassID, kNone_OptimizationFlags)\n , initializers section"
|
2017-06-29 14:03:38 +00:00
|
|
|
},
|
|
|
|
{});
|
|
|
|
test(r,
|
2017-09-18 18:10:39 +00:00
|
|
|
"half x = 10;"
|
|
|
|
"@emitCode { fragBuilder->codeAppendf(\"half y = %d\\n\", x * 2); }"
|
2017-06-29 14:03:38 +00:00
|
|
|
"void main() {"
|
2017-09-18 18:10:39 +00:00
|
|
|
"sk_OutColor = half4(1);"
|
2017-06-29 14:03:38 +00:00
|
|
|
"}",
|
|
|
|
*SkSL::ShaderCapsFactory::Default(),
|
|
|
|
{},
|
|
|
|
{
|
|
|
|
"x = 10.0;\n"
|
2017-09-18 18:10:39 +00:00
|
|
|
" fragBuilder->codeAppendf(\"half y = %d\\n\", x * 2);"
|
2017-06-29 14:03:38 +00:00
|
|
|
});
|
|
|
|
test(r,
|
|
|
|
"@fields { fields section }"
|
2017-07-31 15:18:22 +00:00
|
|
|
"@clone { }"
|
2017-06-29 14:03:38 +00:00
|
|
|
"void main() {"
|
2017-09-18 18:10:39 +00:00
|
|
|
"sk_OutColor = half4(1);"
|
2017-06-29 14:03:38 +00:00
|
|
|
"}",
|
|
|
|
*SkSL::ShaderCapsFactory::Default(),
|
|
|
|
{
|
2017-07-06 14:09:38 +00:00
|
|
|
"GR_DECLARE_FRAGMENT_PROCESSOR_TEST\n"
|
2017-06-29 14:03:38 +00:00
|
|
|
" fields section typedef GrFragmentProcessor INHERITED;"
|
|
|
|
},
|
|
|
|
{});
|
|
|
|
test(r,
|
|
|
|
"@make { make section }"
|
|
|
|
"void main() {"
|
2017-09-18 18:10:39 +00:00
|
|
|
"sk_OutColor = half4(1);"
|
2017-06-29 14:03:38 +00:00
|
|
|
"}",
|
|
|
|
*SkSL::ShaderCapsFactory::Default(),
|
|
|
|
{
|
|
|
|
"public:\n"
|
|
|
|
" make section"
|
|
|
|
},
|
|
|
|
{});
|
|
|
|
test(r,
|
2017-09-18 18:10:39 +00:00
|
|
|
"uniform half calculated;"
|
|
|
|
"in half provided;"
|
2017-06-29 14:03:38 +00:00
|
|
|
"@setData(varName) { varName.set1f(calculated, provided * 2); }"
|
|
|
|
"void main() {"
|
2017-09-18 18:10:39 +00:00
|
|
|
"sk_OutColor = half4(1);"
|
2017-06-29 14:03:38 +00:00
|
|
|
"}",
|
|
|
|
*SkSL::ShaderCapsFactory::Default(),
|
|
|
|
{},
|
|
|
|
{
|
|
|
|
"void onSetData(const GrGLSLProgramDataManager& varName, "
|
|
|
|
"const GrFragmentProcessor& _proc) override {\n",
|
|
|
|
"UniformHandle& calculated = fCalculatedVar;",
|
|
|
|
"auto provided = _outer.provided();",
|
|
|
|
"varName.set1f(calculated, provided * 2);"
|
|
|
|
});
|
|
|
|
test(r,
|
|
|
|
"@test(testDataName) { testDataName section }"
|
|
|
|
"void main() {"
|
2017-09-18 18:10:39 +00:00
|
|
|
"sk_OutColor = half4(1);"
|
2017-06-29 14:03:38 +00:00
|
|
|
"}",
|
|
|
|
*SkSL::ShaderCapsFactory::Default(),
|
|
|
|
{},
|
|
|
|
{
|
|
|
|
"#if GR_TEST_UTILS\n"
|
2017-08-11 13:40:37 +00:00
|
|
|
"std::unique_ptr<GrFragmentProcessor> GrTest::TestCreate(GrProcessorTestData* testDataName) {\n"
|
2017-06-29 14:03:38 +00:00
|
|
|
" testDataName section }\n"
|
|
|
|
"#endif"
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
DEF_TEST(SkSLFPTransformedCoords, r) {
|
|
|
|
test(r,
|
|
|
|
"void main() {"
|
2017-09-18 18:10:39 +00:00
|
|
|
"sk_OutColor = half4(sk_TransformedCoords2D[0], sk_TransformedCoords2D[0]);"
|
2017-06-29 14:03:38 +00:00
|
|
|
"}",
|
|
|
|
*SkSL::ShaderCapsFactory::Default(),
|
|
|
|
{},
|
|
|
|
{
|
2017-08-15 13:19:53 +00:00
|
|
|
"SkString sk_TransformedCoords2D_0 = "
|
2017-06-29 14:03:38 +00:00
|
|
|
"fragBuilder->ensureCoords2D(args.fTransformedCoords[0]);",
|
2017-09-18 18:10:39 +00:00
|
|
|
"fragBuilder->codeAppendf(\"%s = half4(%s, %s);\\n\", args.fOutputColor, "
|
2017-06-29 14:03:38 +00:00
|
|
|
"sk_TransformedCoords2D_0.c_str(), sk_TransformedCoords2D_0.c_str());"
|
|
|
|
});
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
DEF_TEST(SkSLFPLayoutWhen, r) {
|
|
|
|
test(r,
|
2017-09-18 18:10:39 +00:00
|
|
|
"layout(when=someExpression(someOtherExpression())) uniform half sometimes;"
|
2017-06-29 14:03:38 +00:00
|
|
|
"void main() {"
|
|
|
|
"}",
|
|
|
|
*SkSL::ShaderCapsFactory::Default(),
|
|
|
|
{},
|
|
|
|
{
|
|
|
|
"if (someExpression(someOtherExpression())) {\n"
|
|
|
|
" fSometimesVar = args.fUniformHandler->addUniform"
|
|
|
|
});
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2017-10-10 20:30:21 +00:00
|
|
|
DEF_TEST(SkSLFPChildProcessors, r) {
|
|
|
|
test(r,
|
|
|
|
"in fragmentProcessor child1;"
|
|
|
|
"in fragmentProcessor child2;"
|
|
|
|
"void main() {"
|
|
|
|
" sk_OutColor = process(child1) * process(child2);"
|
|
|
|
"}",
|
|
|
|
*SkSL::ShaderCapsFactory::Default(),
|
|
|
|
{
|
|
|
|
"this->registerChildProcessor(std::move(child1));",
|
|
|
|
"this->registerChildProcessor(std::move(child2));"
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"SkString _child0(\"_child0\");",
|
|
|
|
"this->emitChild(0, &_child0, args);",
|
|
|
|
"SkString _child1(\"_child1\");",
|
|
|
|
"this->emitChild(1, &_child1, args);",
|
|
|
|
"this->registerChildProcessor(src.childProcessor(0).clone());",
|
|
|
|
"this->registerChildProcessor(src.childProcessor(1).clone());"
|
|
|
|
});
|
|
|
|
}
|
2018-08-30 20:08:18 +00:00
|
|
|
|
|
|
|
DEF_TEST(SkSLFPChildProcessorsWithInput, r) {
|
|
|
|
test(r,
|
|
|
|
"in fragmentProcessor child1;"
|
|
|
|
"in fragmentProcessor child2;"
|
|
|
|
"void main() {"
|
|
|
|
" half4 childIn = sk_InColor;"
|
|
|
|
" half4 childOut1 = process(child1, childIn);"
|
|
|
|
" half4 childOut2 = process(child2, childOut1);"
|
|
|
|
" sk_OutColor = childOut2;"
|
|
|
|
"}",
|
|
|
|
*SkSL::ShaderCapsFactory::Default(),
|
|
|
|
{
|
|
|
|
"this->registerChildProcessor(std::move(child1));",
|
|
|
|
"this->registerChildProcessor(std::move(child2));"
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"SkString _input0(\"childIn\");",
|
|
|
|
"SkString _child0(\"_child0\");",
|
|
|
|
"this->emitChild(0, _input0.c_str(), &_child0, args);",
|
|
|
|
"SkString _input1(\"childOut1\");",
|
|
|
|
"SkString _child1(\"_child1\");",
|
|
|
|
"this->emitChild(1, _input1.c_str(), &_child1, args);",
|
|
|
|
"this->registerChildProcessor(src.childProcessor(0).clone());",
|
|
|
|
"this->registerChildProcessor(src.childProcessor(1).clone());"
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
DEF_TEST(SkSLFPChildProcessorWithInputExpression, r) {
|
|
|
|
test(r,
|
|
|
|
"in fragmentProcessor child;"
|
|
|
|
"void main() {"
|
|
|
|
" sk_OutColor = process(child, sk_InColor * half4(0.5));"
|
|
|
|
"}",
|
|
|
|
*SkSL::ShaderCapsFactory::Default(),
|
|
|
|
{
|
|
|
|
"this->registerChildProcessor(std::move(child));",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"SkString _input0 = SkStringPrintf(\"%s * half4(0.5)\", args.fInputColor);",
|
|
|
|
"SkString _child0(\"_child0\");",
|
|
|
|
"this->emitChild(0, _input0.c_str(), &_child0, args);",
|
|
|
|
"this->registerChildProcessor(src.childProcessor(0).clone());",
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
DEF_TEST(SkSLFPNestedChildProcessors, r) {
|
|
|
|
test(r,
|
|
|
|
"in fragmentProcessor child1;"
|
|
|
|
"in fragmentProcessor child2;"
|
|
|
|
"void main() {"
|
|
|
|
" sk_OutColor = process(child2, sk_InColor * process(child1, sk_InColor * half4(0.5)));"
|
|
|
|
"}",
|
|
|
|
*SkSL::ShaderCapsFactory::Default(),
|
|
|
|
{
|
|
|
|
"this->registerChildProcessor(std::move(child1));",
|
|
|
|
"this->registerChildProcessor(std::move(child2));"
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"SkString _input0 = SkStringPrintf(\"%s * half4(0.5)\", args.fInputColor);",
|
|
|
|
"SkString _child0(\"_child0\");",
|
|
|
|
"this->emitChild(0, _input0.c_str(), &_child0, args);",
|
|
|
|
"SkString _input1 = SkStringPrintf(\"%s * %s\", args.fInputColor, _child0.c_str());",
|
|
|
|
"SkString _child1(\"_child1\");",
|
|
|
|
"this->emitChild(1, _input1.c_str(), &_child1, args);",
|
|
|
|
"this->registerChildProcessor(src.childProcessor(0).clone());",
|
|
|
|
"this->registerChildProcessor(src.childProcessor(1).clone());"
|
|
|
|
});
|
|
|
|
}
|
Reland "Redo how extra emit code flushing operates" with type fix.
This reverts commit d0440195d5cc049062238d02b8a962ae49c7f4ff.
Reason for revert: Fixes size_t -> int that was triggering ASAN failures.
Original change's description:
> Revert "Redo how extra emit code flushing operates"
>
> This reverts commit 9b8181b05a84e7dd24234c46c87d0bb2c73a7c08.
>
> Reason for revert: <INSERT REASONING HERE>
>
> Original change's description:
> > Redo how extra emit code flushing operates
> >
> > The previous implementation of flushEmittedCode(), that flushed on
> > demand when a process() was encountered, was brittle and susceptible to
> > mangling the expected sksl when fOut was modified outside of its
> > control. Given that writeFunction() and generateCode() in the parent
> > class all do this, it's possible to generate a simple SkSL snippet that
> > would generate a CPP file that builds invalid final SkSL:
> >
> > ```
> > in fragmentProcessor child;
> > bool someGlobalVar = ...;
> > void main() {
> > if (someGlobalVar) {
> > sk_OutColor = process(child, sk_InColor);
> > } else {
> > sk_OutColor = half4(1);
> > }
> > }
> > ```
> >
> > The CPP generated code *should* insert 'bool someGlobalVar' at the start
> > but because of the early flush from the child process and because of
> > how fOut was overwritten, someGlobalVar's declaration is put into a
> > stream that is not visible to the flush and ends up being inserted into
> > the output sksl in an incorrect location (namely after the if condition
> > that depends on it).
> >
> > This CL updates the extra emitted code logic to support multiple blocks
> > of extra CPP code. When a flush point occurs in SkSL writing, a special
> > token is inserted into the SkSL and a new CPP code buffer is associated
> > with that token. Then once all of the SkSL is accumulated into the root
> > output stream, it is processed into sections for each extra CPP block.
> > Special logic is done so that the SkSL that is emitted before the next
> > CPP block terminates at the end of the last valid statement before the
> > special token.
> >
> > A unit test demonstrating this failure condition is added to SkSLFPTest
> > and the CL properly passes. Since this bug did not trigger on existing
> > .fp files, the updated generator does not modify the generated FPs.
> >
> > Bug: skia:
> > Change-Id: Ib74911942080f1b964159807a06805bc52898789
> > Reviewed-on: https://skia-review.googlesource.com/152321
> > Commit-Queue: Michael Ludwig <michaelludwig@google.com>
> > Reviewed-by: Ethan Nicholas <ethannicholas@google.com>
>
> TBR=ethannicholas@google.com,michaelludwig@google.com
>
> Change-Id: Id0f908453b596873f43b86a1c14eed48b2474a76
> No-Presubmit: true
> No-Tree-Checks: true
> No-Try: true
> Bug: skia:
> Reviewed-on: https://skia-review.googlesource.com/152660
> Reviewed-by: Michael Ludwig <michaelludwig@google.com>
> Commit-Queue: Michael Ludwig <michaelludwig@google.com>
TBR=ethannicholas@google.com,michaelludwig@google.com
Change-Id: I3ccf2fee6ef96c6102dbe1c2c2ef6c14a701b8fd
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: skia:
Reviewed-on: https://skia-review.googlesource.com/152663
Commit-Queue: Michael Ludwig <michaelludwig@google.com>
Reviewed-by: Michael Ludwig <michaelludwig@google.com>
2018-09-07 17:13:06 +00:00
|
|
|
|
|
|
|
DEF_TEST(SkSLFPChildFPAndGlobal, r) {
|
|
|
|
test(r,
|
|
|
|
"in fragmentProcessor child;"
|
|
|
|
"bool hasCap = sk_Caps.externalTextureSupport;"
|
|
|
|
"void main() {"
|
|
|
|
" if (hasCap) {"
|
|
|
|
" sk_OutColor = process(child, sk_InColor);"
|
|
|
|
" } else {"
|
|
|
|
" sk_OutColor = half4(1);"
|
|
|
|
" }"
|
|
|
|
"}",
|
|
|
|
*SkSL::ShaderCapsFactory::Default(),
|
|
|
|
{
|
|
|
|
"this->registerChildProcessor(std::move(child));"
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"hasCap = sk_Caps.externalTextureSupport;",
|
|
|
|
"fragBuilder->codeAppendf(\"bool hasCap = %s;\\nif (hasCap) {\", "
|
|
|
|
"(hasCap ? \"true\" : \"false\"));",
|
|
|
|
"SkString _input0 = SkStringPrintf(\"%s\", args.fInputColor);",
|
|
|
|
"SkString _child0(\"_child0\");",
|
|
|
|
"this->emitChild(0, _input0.c_str(), &_child0, args);",
|
|
|
|
"fragBuilder->codeAppendf(\"\\n %s = %s;\\n} else {\\n %s = half4(1.0);\\n}"
|
|
|
|
"\\n\", args.fOutputColor, _child0.c_str(), args.fOutputColor);",
|
|
|
|
"this->registerChildProcessor(src.childProcessor(0).clone());"
|
|
|
|
});
|
|
|
|
}
|
2018-09-07 17:44:21 +00:00
|
|
|
|
|
|
|
DEF_TEST(SkSLFPChildProcessorInlineFieldAccess, r) {
|
|
|
|
test(r,
|
|
|
|
"in fragmentProcessor child;"
|
|
|
|
"void main() {"
|
|
|
|
" if (child.preservesOpaqueInput) {"
|
|
|
|
" sk_OutColor = process(child, sk_InColor);"
|
|
|
|
" } else {"
|
|
|
|
" sk_OutColor = half4(1);"
|
|
|
|
" }"
|
|
|
|
"}",
|
|
|
|
*SkSL::ShaderCapsFactory::Default(),
|
|
|
|
{
|
|
|
|
"this->registerChildProcessor(std::move(child));"
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"fragBuilder->codeAppendf(\"if (%s) {\", "
|
|
|
|
"(_outer.childProcessor(0).preservesOpaqueInput() ? \"true\" : \"false\"));",
|
|
|
|
"SkString _input0 = SkStringPrintf(\"%s\", args.fInputColor);",
|
|
|
|
"SkString _child0(\"_child0\");",
|
|
|
|
"this->emitChild(0, _input0.c_str(), &_child0, args);",
|
|
|
|
"fragBuilder->codeAppendf(\"\\n %s = %s;\\n} else {\\n %s = half4(1.0);\\n}\\n\""
|
|
|
|
", args.fOutputColor, _child0.c_str(), args.fOutputColor);",
|
|
|
|
"this->registerChildProcessor(src.childProcessor(0).clone());"
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
DEF_TEST(SkSLFPChildProcessorFieldAccess, r) {
|
|
|
|
test(r,
|
|
|
|
"in fragmentProcessor child;"
|
|
|
|
"bool opaque = child.preservesOpaqueInput;"
|
|
|
|
"void main() {"
|
|
|
|
" if (opaque) {"
|
|
|
|
" sk_OutColor = process(child);"
|
|
|
|
" } else {"
|
|
|
|
" sk_OutColor = half4(0.5);"
|
|
|
|
" }"
|
|
|
|
"}",
|
|
|
|
*SkSL::ShaderCapsFactory::Default(),
|
|
|
|
{
|
|
|
|
"this->registerChildProcessor(std::move(child));"
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"opaque = _outer.childProcessor(0).preservesOpaqueInput();",
|
|
|
|
"fragBuilder->codeAppendf(\"bool opaque = %s;\\nif (opaque) {\", "
|
|
|
|
"(opaque ? \"true\" : \"false\"));",
|
|
|
|
"SkString _child0(\"_child0\");",
|
|
|
|
"this->emitChild(0, &_child0, args);",
|
|
|
|
"fragBuilder->codeAppendf(\"\\n %s = %s;\\n} else {\\n %s = half4(0.5);\\n}\\n\""
|
|
|
|
", args.fOutputColor, _child0.c_str(), args.fOutputColor);",
|
|
|
|
"this->registerChildProcessor(src.childProcessor(0).clone());"
|
|
|
|
});
|
|
|
|
}
|