Add support for #pragma settings comments in SkSL.

This will allow us to write skslc-based golden tests that deviate from
the standalone skslc settings.

This CL provides six options; more will be added as necessary.
- Default (caps)
- UsesPrecisionModifiers (caps)
- Version110 (caps)
- Version450Core (caps)
- ForceHighPrecision (settings flag bit)
- Sharpen (settings flag bit)

Change-Id: I9b779e039b2f0c0ccf43dca226fb4844aff3526b
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/317237
Commit-Queue: John Stiles <[email protected]>
Auto-Submit: John Stiles <[email protected]>
Reviewed-by: Brian Osman <[email protected]>

Author: johnstiles-google

gn/sksl_tests.gni

@@ -31,6 +31,7 @@ sksl_glsl_tests_sources = [
   "$_tests/sksl/glsl/DependentInitializers.sksl",
   "$_tests/sksl/glsl/Discard.sksl",
   "$_tests/sksl/glsl/FloatFolding.sksl",
+  "$_tests/sksl/glsl/ForceHighPrecision.sksl",
   "$_tests/sksl/glsl/FrExp.sksl",
   "$_tests/sksl/glsl/Functions.sksl",
   "$_tests/sksl/glsl/Height.sksl",
@@ -72,9 +73,18 @@ sksl_glsl_tests_sources = [
   "$_tests/sksl/glsl/TernaryAsLValueEntirelyFoldable.sksl",
   "$_tests/sksl/glsl/TernaryAsLValueFoldableTest.sksl",
   "$_tests/sksl/glsl/TernaryAsLValueUnfoldable.sksl",
+  "$_tests/sksl/glsl/Texture.sksl",
+  "$_tests/sksl/glsl/TextureSharpen.sksl",
+  "$_tests/sksl/glsl/TextureSharpenVersion110.sksl",
+  "$_tests/sksl/glsl/TextureVersion110.sksl",
+  "$_tests/sksl/glsl/TypePrecisionDisabled.sksl",
+  "$_tests/sksl/glsl/TypePrecisionEnabled.sksl",
   "$_tests/sksl/glsl/UnusedVariables.sksl",
+  "$_tests/sksl/glsl/UsesPrecisionModifiers.sksl",
   "$_tests/sksl/glsl/VectorConstructors.sksl",
   "$_tests/sksl/glsl/VectorFolding.sksl",
+  "$_tests/sksl/glsl/Version110.sksl",
+  "$_tests/sksl/glsl/Version450Core.sksl",
   "$_tests/sksl/glsl/VertexID.vert",
   "$_tests/sksl/glsl/Width.sksl",
   "$_tests/sksl/inliner/DoWhileBodyMustBeInlinedIntoAScope.sksl",

src/gpu/glsl/GrGLSLFragmentShaderBuilder.cpp

@@ -263,7 +263,7 @@ void GrGLSLFragmentShaderBuilder::enableSecondaryOutput() {
 
     // If the primary output is declared, we must declare also the secondary output
     // and vice versa, since it is not allowed to use a built-in gl_FragColor and a custom
-    // output. The condition also co-incides with the condition in whici GLES SL 2.0
+    // output. The condition also co-incides with the condition in which GLES SL 2.0
     // requires the built-in gl_SecondaryFragColorEXT, where as 3.0 requires a custom output.
     if (caps.mustDeclareFragmentShaderOutput()) {
         fOutputs.emplace_back(DeclaredSecondaryColorOutputName(), kHalf4_GrSLType,

src/sksl/SkSLMain.cpp

@@ -33,6 +33,62 @@ static SkSL::String base_name(const char* fpPath, const char* prefix, const char
     return result;
 }
 
+// Given a string containing an SkSL program, searches for a #pragma settings comment, like so:
+//    /*#pragma settings Default Sharpen*/
+// The passed-in Settings object will be updated accordingly. Any number of options can be provided.
+static void detect_shader_settings(const SkSL::String& text, SkSL::Program::Settings* settings) {
+    // Find a matching comment and isolate the name portion.
+    static constexpr char kPragmaSettings[] = "/*#pragma settings ";
+    const char* settingsPtr = strstr(text.c_str(), kPragmaSettings);
+    if (settingsPtr != nullptr) {
+        // Subtract one here in order to preserve the leading space, which is necessary to allow
+        // consumeSuffix to find the first item.
+        settingsPtr += strlen(kPragmaSettings) - 1;
+
+        const char* settingsEnd = strstr(settingsPtr, "*/");
+        if (settingsEnd != nullptr) {
+            SkSL::String settingsText{settingsPtr, size_t(settingsEnd - settingsPtr)};
+
+            // Apply settings as requested. Since they can come in any order, repeat until we've
+            // consumed them all.
+            for (;;) {
+                const size_t startingLength = settingsText.length();
+
+                if (settingsText.consumeSuffix(" Default")) {
+                    static auto s_defaultCaps = SkSL::ShaderCapsFactory::Default();
+                    settings->fCaps = s_defaultCaps.get();
+                }
+                if (settingsText.consumeSuffix(" UsesPrecisionModifiers")) {
+                    static auto s_precisionCaps = SkSL::ShaderCapsFactory::UsesPrecisionModifiers();
+                    settings->fCaps = s_precisionCaps.get();
+                }
+                if (settingsText.consumeSuffix(" Version110")) {
+                    static auto s_version110Caps = SkSL::ShaderCapsFactory::Version110();
+                    settings->fCaps = s_version110Caps.get();
+                }
+                if (settingsText.consumeSuffix(" Version450Core")) {
+                    static auto s_version450CoreCaps = SkSL::ShaderCapsFactory::Version450Core();
+                    settings->fCaps = s_version450CoreCaps.get();
+                }
+                if (settingsText.consumeSuffix(" ForceHighPrecision")) {
+                    settings->fForceHighPrecision = true;
+                }
+                if (settingsText.consumeSuffix(" Sharpen")) {
+                    settings->fSharpenTextures = true;
+                }
+
+                if (settingsText.empty()) {
+                    break;
+                }
+                if (settingsText.length() == startingLength) {
+                    printf("Unrecognized #pragma settings: %s\n", settingsText.c_str());
+                    exit(3);
+                }
+            }
+        }
+    }
+}
+
 /**
  * Very simple standalone executable to facilitate testing.
  */
@@ -60,17 +116,15 @@ int main(int argc, const char** argv) {
     }
 
     std::ifstream in(argv[1]);
-    std::string stdText((std::istreambuf_iterator<char>(in)),
-                        std::istreambuf_iterator<char>());
-    SkSL::String text(stdText.c_str());
+    SkSL::String text((std::istreambuf_iterator<char>(in)),
+                       std::istreambuf_iterator<char>());
     if (in.rdstate()) {
         printf("error reading '%s'\n", argv[1]);
         exit(2);
     }
 
-    SkSL::ShaderCapsPointer caps = SkSL::ShaderCapsFactory::Standalone();
     SkSL::Program::Settings settings;
-    settings.fCaps = caps.get();
+    detect_shader_settings(text, &settings);
     SkSL::String name(argv[2]);
     if (name.endsWith(".spirv")) {
         SkSL::FileOutputStream out(argv[2]);

src/sksl/SkSLString.cpp

@@ -61,6 +61,18 @@ bool String::endsWith(const char suffix[]) const {
     return !strncmp(this->data() + this->size() - suffixLength, suffix, suffixLength);
 }
 
+bool String::consumeSuffix(const char suffix[]) {
+    size_t suffixLength = strlen(suffix);
+    if (this->length() < suffixLength) {
+        return false;
+    }
+    if (0 != strncmp(this->data() + this->size() - suffixLength, suffix, suffixLength)) {
+        return false;
+    }
+    this->resize(this->length() - suffixLength);
+    return true;
+}
+
 String String::operator+(const char* s) const {
     String result(*this);
     result.append(s);

src/sksl/SkSLString.h

@@ -65,8 +65,9 @@ class SK_API String : public std::string {
     void appendf(const char* fmt, ...);
     void vappendf(const char* fmt, va_list va);
 
-    bool startsWith(const char* prefix) const;
-    bool endsWith(const char* suffix) const;
+    bool startsWith(const char prefix[]) const;
+    bool endsWith(const char suffix[]) const;
+    bool consumeSuffix(const char suffix[]);
 
     String operator+(const char* s) const;
     String operator+(const String& s) const;

src/sksl/SkSLUtil.h

@@ -85,9 +85,8 @@ class StandaloneShaderCaps {
         return fUsesPrecisionModifiers;
     }
 
-    bool fMustDeclareFragmentShaderOutput = true;
     bool mustDeclareFragmentShaderOutput() const {
-        return fMustDeclareFragmentShaderOutput;
+        return fGLSLGeneration > k110_GrGLSLGeneration;
     }
 
     bool fFBFetchSupport = true;