added support for sk_Dimensions to SkSL

Ethan Nicholas · Skia Commit-Bot · commit 9335c28e40d7 · 2018-08-21T17:17:16.000Z
Bug: skia: Change-Id: I5f6a9941822b7b4a3ad85b22b1bcd31d58320f90 Reviewed-on: https://skia-review.googlesource.com/146640 Reviewed-by: Brian Salomon <bsalomon@google.com> Commit-Queue: Ethan Nicholas <ethannicholas@google.com>
diff --git a/src/gpu/gl/GrGLProgram.cpp b/src/gpu/gl/GrGLProgram.cpp
@@ -127,10 +127,13 @@ void GrGLProgram::setFragmentData(const GrPipeline& pipeline, int* nextTexSample
 void GrGLProgram::setRenderTargetState(const GrPrimitiveProcessor& primProc,
                                        const GrRenderTargetProxy* proxy) {
     GrRenderTarget* rt = proxy->peekRenderTarget();
-    // Load the RT height uniform if it is needed to y-flip gl_FragCoord.
-    if (fBuiltinUniformHandles.fRTHeightUni.isValid() &&
-        fRenderTargetState.fRenderTargetSize.fHeight != rt->height()) {
-        fProgramDataManager.set1f(fBuiltinUniformHandles.fRTHeightUni, SkIntToScalar(rt->height()));
+    // Load the RT dimension uniform if it is needed
+    if (fBuiltinUniformHandles.fRTDimensionsUni.isValid() &&
+        (fRenderTargetState.fRenderTargetSize.fWidth != rt->width() ||
+         fRenderTargetState.fRenderTargetSize.fHeight != rt->height())) {
+        fProgramDataManager.set2f(fBuiltinUniformHandles.fRTDimensionsUni,
+                                  SkIntToScalar(rt->width()),
+                                  SkIntToScalar(rt->height()));
     }
 
     // set RT adjustment
diff --git a/src/gpu/gl/builders/GrGLProgramBuilder.cpp b/src/gpu/gl/builders/GrGLProgramBuilder.cpp
@@ -159,6 +159,12 @@ void GrGLProgramBuilder::computeCountsAndStrides(GrGLuint programID,
     SkASSERT(fInstanceStride == primProc.debugOnly_instanceStride());
 }
 
+void GrGLProgramBuilder::addInputVars(const SkSL::Program::Inputs& inputs) {
+    if (inputs.fRTDimensions) {
+        this->addRTDimensionsUniform(SKSL_RTDIMENSIONS_NAME);
+    }
+}
+
 GrGLProgram* GrGLProgramBuilder::finalize() {
     TRACE_EVENT0("skia", TRACE_FUNC);
 
@@ -204,9 +210,7 @@ GrGLProgram* GrGLProgramBuilder::finalize() {
         if (GR_GL_GET_ERROR(this->gpu()->glInterface()) == GR_GL_NO_ERROR) {
             cached = this->checkLinkStatus(programID);
             if (cached) {
-                if (inputs.fRTHeight) {
-                    this->addRTHeightUniform(SKSL_RTHEIGHT_NAME);
-                }
+                this->addInputVars(inputs);
                 this->computeCountsAndStrides(programID, primProc, false);
             }
         } else {
@@ -231,9 +235,7 @@ GrGLProgram* GrGLProgramBuilder::finalize() {
             return nullptr;
         }
         inputs = fs->fInputs;
-        if (inputs.fRTHeight) {
-            this->addRTHeightUniform(SKSL_RTHEIGHT_NAME);
-        }
+        this->addInputVars(inputs);
         if (!this->compileAndAttachShaders(glsl.c_str(), glsl.size(), programID,
                                            GR_GL_FRAGMENT_SHADER, &shadersToDelete, settings,
                                            inputs)) {
diff --git a/src/gpu/gl/builders/GrGLProgramBuilder.h b/src/gpu/gl/builders/GrGLProgramBuilder.h
@@ -48,6 +48,7 @@ class GrGLProgramBuilder : public GrGLSLProgramBuilder {
     GrGLProgramBuilder(GrGLGpu*, const GrPipeline&, const GrPrimitiveProcessor&,
                        GrProgramDesc*);
 
+    void addInputVars(const SkSL::Program::Inputs& inputs);
     bool compileAndAttachShaders(const char* glsl,
                                  int length,
                                  GrGLuint programId,
diff --git a/src/gpu/glsl/GrGLSLProgramBuilder.cpp b/src/gpu/glsl/GrGLSLProgramBuilder.cpp
@@ -371,12 +371,12 @@ void GrGLSLProgramBuilder::appendUniformDecls(GrShaderFlags visibility, SkString
     this->uniformHandler()->appendUniformDecls(visibility, out);
 }
 
-void GrGLSLProgramBuilder::addRTHeightUniform(const char* name) {
-        SkASSERT(!fUniformHandles.fRTHeightUni.isValid());
+void GrGLSLProgramBuilder::addRTDimensionsUniform(const char* name) {
+        SkASSERT(!fUniformHandles.fRTDimensionsUni.isValid());
         GrGLSLUniformHandler* uniformHandler = this->uniformHandler();
-        fUniformHandles.fRTHeightUni =
+        fUniformHandles.fRTDimensionsUni =
             uniformHandler->internalAddUniformArray(kFragment_GrShaderFlag,
-                                                    kHalf_GrSLType, kDefault_GrSLPrecision,
+                                                    kFloat2_GrSLType, kDefault_GrSLPrecision,
                                                     name, false, 0, nullptr);
 }
 
diff --git a/src/gpu/glsl/GrGLSLProgramBuilder.h b/src/gpu/glsl/GrGLSLProgramBuilder.h
@@ -49,9 +49,9 @@ class GrGLSLProgramBuilder {
         return this->uniformHandler()->samplerSwizzle(handle);
     }
 
-    // Used to add a uniform for the RenderTarget height (used for frag position) without mangling
-    // the name of the uniform inside of a stage.
-    void addRTHeightUniform(const char* name);
+    // Used to add a uniform for the RenderTarget height (used for sk_Dimensions and sk_FragCoord)
+    // without mangling the name of the uniform inside of a stage.
+    void addRTDimensionsUniform(const char* name);
 
     // Generates a name for a variable. The generated string will be name prefixed by the prefix
     // char (unless the prefix is '\0'). It also will mangle the name to be stage-specific unless
diff --git a/src/gpu/glsl/GrGLSLUniformHandler.h b/src/gpu/glsl/GrGLSLUniformHandler.h
@@ -20,9 +20,9 @@ class GrGLSLProgramBuilder;
 // Handles for program uniforms (other than per-effect uniforms)
 struct GrGLSLBuiltinUniformHandles {
     GrGLSLProgramDataManager::UniformHandle fRTAdjustmentUni;
-    // We use the render target height to provide a y-down frag coord when specifying
+    // Render target dimensions, used to implement sk_Dimensions and to calculate sk_FragCoord when
     // origin_upper_left is not supported.
-    GrGLSLProgramDataManager::UniformHandle fRTHeightUni;
+    GrGLSLProgramDataManager::UniformHandle fRTDimensionsUni;
 };
 
 class GrGLSLUniformHandler {
diff --git a/src/gpu/mtl/GrMtlPipelineState.mm b/src/gpu/mtl/GrMtlPipelineState.mm
@@ -145,9 +145,11 @@
     GrRenderTarget* rt = proxy->peekRenderTarget();
 
     // Load the RT height uniform if it is needed to y-flip gl_FragCoord.
-    if (fBuiltinUniformHandles.fRTHeightUni.isValid() &&
-        fRenderTargetState.fRenderTargetSize.fHeight != rt->height()) {
-        fDataManager.set1f(fBuiltinUniformHandles.fRTHeightUni, SkIntToScalar(rt->height()));
+    if (fBuiltinUniformHandles.fRTDimensionsUni.isValid() &&
+        (fRenderTargetState.fRenderTargetSize.fWidth != rt->width() ||
+         fRenderTargetState.fRenderTargetSize.fHeight != rt->height())) {
+        fDataManager.set2f(fBuiltinUniformHandles.fRTDimensionsUni, SkIntToScalar(rt->width()),
+                           SkIntToScalar(rt->height()));
     }
 
     // set RT adjustment
diff --git a/src/gpu/mtl/GrMtlPipelineStateBuilder.mm b/src/gpu/mtl/GrMtlPipelineStateBuilder.mm
@@ -70,8 +70,8 @@
     if (shaderLibrary == nil) {
         return nil;
     }
-    if (inputs.fRTHeight) {
-        this->addRTHeightUniform(SKSL_RTHEIGHT_NAME);
+    if (inputs.fRTDimensions) {
+        this->addRTDimensionsUniform(SKSL_RTDIMENSIONS_NAME);
     }
     if (inputs.fFlipY) {
         desc->setSurfaceOriginKey(GrGLSLFragmentShaderBuilder::KeyForSurfaceOrigin(
diff --git a/src/gpu/vk/GrVkPipelineState.cpp b/src/gpu/vk/GrVkPipelineState.cpp
@@ -350,9 +350,11 @@ void GrVkPipelineState::setRenderTargetState(const GrRenderTargetProxy* proxy) {
     GrRenderTarget* rt = proxy->peekRenderTarget();
 
     // Load the RT height uniform if it is needed to y-flip gl_FragCoord.
-    if (fBuiltinUniformHandles.fRTHeightUni.isValid() &&
-        fRenderTargetState.fRenderTargetSize.fHeight != rt->height()) {
-        fDataManager.set1f(fBuiltinUniformHandles.fRTHeightUni, SkIntToScalar(rt->height()));
+    if (fBuiltinUniformHandles.fRTDimensionsUni.isValid() &&
+        (fRenderTargetState.fRenderTargetSize.fWidth != rt->width() ||
+        fRenderTargetState.fRenderTargetSize.fHeight != rt->height())) {
+        fDataManager.set2f(fBuiltinUniformHandles.fRTDimensionsUni, SkIntToScalar(rt->height()),
+                           SkIntToScalar(rt->width()));
     }
 
     // set RT adjustment
diff --git a/src/gpu/vk/GrVkPipelineStateBuilder.cpp b/src/gpu/vk/GrVkPipelineStateBuilder.cpp
@@ -75,8 +75,8 @@ bool GrVkPipelineStateBuilder::createVkShaderModule(VkShaderStageFlagBits stage,
     if (!result) {
         return false;
     }
-    if (inputs.fRTHeight) {
-        this->addRTHeightUniform(SKSL_RTHEIGHT_NAME);
+    if (inputs.fRTDimensions) {
+        this->addRTDimensionsUniform(SKSL_RTDIMENSIONS_NAME);
     }
     if (inputs.fFlipY) {
         desc->setSurfaceOriginKey(GrGLSLFragmentShaderBuilder::KeyForSurfaceOrigin(
diff --git a/src/sksl/README b/src/sksl/README
@@ -57,6 +57,7 @@ Differences from GLSL
   Use swizzles instead.
 * Use texture() instead of textureProj(), e.g. texture(sampler2D, float3) is
   equivalent to GLSL's textureProj(sampler2D, float3)
+* Render target dimensions are available via sk_Dimensions
 * some built-in functions and one or two rarely-used language features are not
   yet supported (sorry!)
 
diff --git a/src/sksl/SkSLCPPCodeGenerator.cpp b/src/sksl/SkSLCPPCodeGenerator.cpp
@@ -246,6 +246,9 @@ void CPPCodeGenerator::writeVariableReference(const VariableReference& ref) {
             this->write("%s");
             fFormatArgs.push_back(String("args.fOutputColor"));
             break;
+        case SK_DIMENSIONS_BUILTIN:
+            this->write("sk_Dimensions");
+            break;
         default:
             if (ref.fVariable.fType.kind() == Type::kSampler_Kind) {
                 this->write("%s");
@@ -446,6 +449,9 @@ void CPPCodeGenerator::addUniform(const Variable& var) {
     }
 }
 
+void CPPCodeGenerator::writeInputVars() {
+}
+
 void CPPCodeGenerator::writePrivateVars() {
     for (const auto& p : fProgram) {
         if (ProgramElement::kVar_Kind == p.fKind) {
diff --git a/src/sksl/SkSLCPPCodeGenerator.h b/src/sksl/SkSLCPPCodeGenerator.h
@@ -68,6 +68,8 @@ class CPPCodeGenerator : public GLSLCodeGenerator {
 
     void writeVarInitializer(const Variable& var, const Expression& value) override;
 
+    void writeInputVars() override;
+
     void writePrivateVars();
 
     void writePrivateVarValues();
diff --git a/src/sksl/SkSLCompiler.h b/src/sksl/SkSLCompiler.h
@@ -28,6 +28,7 @@
 #define SK_LASTFRAGCOLOR_BUILTIN       10008
 #define SK_MAIN_X_BUILTIN              10009
 #define SK_MAIN_Y_BUILTIN              10010
+#define SK_DIMENSIONS_BUILTIN          10011
 #define SK_FRAGCOORD_BUILTIN              15
 #define SK_CLOCKWISE_BUILTIN              17
 #define SK_VERTEXID_BUILTIN               42
diff --git a/src/sksl/SkSLGLSLCodeGenerator.cpp b/src/sksl/SkSLGLSLCodeGenerator.cpp
@@ -693,7 +693,7 @@ void GLSLCodeGenerator::writeFragCoord() {
     if (!fProgram.fSettings.fFlipY) {
         this->write("gl_FragCoord");
     } else if (const char* extension =
-               fProgram.fSettings.fCaps->fragCoordConventionsExtensionString()) {
+                                  fProgram.fSettings.fCaps->fragCoordConventionsExtensionString()) {
         if (!fSetupFragPositionGlobal) {
             if (fProgram.fSettings.fCaps->generation() < k150_GrGLSLGeneration) {
                 this->writeExtension(extension);
@@ -703,25 +703,18 @@ void GLSLCodeGenerator::writeFragCoord() {
         }
         this->write("gl_FragCoord");
     } else {
-        if (!fSetupFragPositionGlobal) {
+        if (!fSetupFragPositionLocal) {
             // The Adreno compiler seems to be very touchy about access to "gl_FragCoord".
             // Accessing glFragCoord.zw can cause a program to fail to link. Additionally,
             // depending on the surrounding code, accessing .xy with a uniform involved can
             // do the same thing. Copying gl_FragCoord.xy into a temp float2 beforehand
             // (and only accessing .xy) seems to "fix" things.
-            const char* precision = usesPrecisionModifiers() ? "highp " : "";
-            fGlobals.writeText("uniform ");
-            fGlobals.writeText(precision);
-            fGlobals.writeText("float " SKSL_RTHEIGHT_NAME ";\n");
-            fSetupFragPositionGlobal = true;
-        }
-        if (!fSetupFragPositionLocal) {
             const char* precision = usesPrecisionModifiers() ? "highp " : "";
             fFunctionHeader += precision;
             fFunctionHeader += "    vec2 _sktmpCoord = gl_FragCoord.xy;\n";
             fFunctionHeader += precision;
-            fFunctionHeader += "    vec4 sk_FragCoord = vec4(_sktmpCoord.x, " SKSL_RTHEIGHT_NAME
-                               " - _sktmpCoord.y, 1.0, 1.0);\n";
+            fFunctionHeader += "    vec4 sk_FragCoord = vec4(_sktmpCoord.x, " SKSL_RTDIMENSIONS_NAME
+                               ".y - _sktmpCoord.y, 1.0, 1.0);\n";
             fSetupFragPositionLocal = true;
         }
         this->write("sk_FragCoord");
@@ -740,6 +733,9 @@ void GLSLCodeGenerator::writeVariableReference(const VariableReference& ref) {
         case SK_FRAGCOORD_BUILTIN:
             this->writeFragCoord();
             break;
+        case SK_DIMENSIONS_BUILTIN:
+            this->write("u_skRTDimensions");
+            break;
         case SK_CLOCKWISE_BUILTIN:
             this->write(fProgram.fSettings.fFlipY ? "(!gl_FrontFacing)" : "gl_FrontFacing");
             break;
@@ -1368,6 +1364,15 @@ void GLSLCodeGenerator::writeProgramElement(const ProgramElement& e) {
     }
 }
 
+void GLSLCodeGenerator::writeInputVars() {
+    if (fProgram.fInputs.fRTDimensions) {
+        const char* precision = usesPrecisionModifiers() ? "highp " : "";
+        fGlobals.writeText("uniform ");
+        fGlobals.writeText(precision);
+        fGlobals.writeText("vec2 " SKSL_RTDIMENSIONS_NAME ";\n");
+    }
+}
+
 bool GLSLCodeGenerator::generateCode() {
     fProgramKind = fProgram.fKind;
     if (fProgramKind != Program::kPipelineStage_Kind) {
@@ -1386,6 +1391,7 @@ bool GLSLCodeGenerator::generateCode() {
     fOut = rawOut;
 
     write_stringstream(fExtensions, *rawOut);
+    this->writeInputVars();
     write_stringstream(fGlobals, *rawOut);
 
     if (!fProgram.fSettings.fCaps->canUseFragCoord()) {
diff --git a/src/sksl/SkSLGLSLCodeGenerator.h b/src/sksl/SkSLGLSLCodeGenerator.h
@@ -118,7 +118,7 @@ class GLSLCodeGenerator : public CodeGenerator {
 
     void writeModifiers(const Modifiers& modifiers, bool globalContext);
 
-    void writeGlobalVars(const VarDeclaration& vs);
+    virtual void writeInputVars();
 
     virtual void writeVarInitializer(const Variable& var, const Expression& value);
 
diff --git a/src/sksl/SkSLIRGenerator.cpp b/src/sksl/SkSLIRGenerator.cpp
@@ -1025,16 +1025,22 @@ std::unique_ptr<Expression> IRGenerator::convertIdentifier(const ASTIdentifier&
         }
         case Symbol::kVariable_Kind: {
             const Variable* var = (const Variable*) result;
+            switch (var->fModifiers.fLayout.fBuiltin) {
+                case SK_DIMENSIONS_BUILTIN:
+                    fInputs.fRTDimensions = true;
+                    break;
 #ifndef SKSL_STANDALONE
-            if (var->fModifiers.fLayout.fBuiltin == SK_FRAGCOORD_BUILTIN) {
-                fInputs.fFlipY = true;
-                if (fSettings->fFlipY &&
-                    (!fSettings->fCaps ||
-                     !fSettings->fCaps->fragCoordConventionsExtensionString())) {
-                    fInputs.fRTHeight = true;
-                }
-            }
+                case SK_FRAGCOORD_BUILTIN:
+                    if (var->fModifiers.fLayout.fBuiltin == SK_FRAGCOORD_BUILTIN) {
+                        fInputs.fFlipY = true;
+                        if (fSettings->fFlipY &&
+                            (!fSettings->fCaps ||
+                             !fSettings->fCaps->fragCoordConventionsExtensionString())) {
+                            fInputs.fRTDimensions = true;
+                        }
+                    }
 #endif
+            }
             // default to kRead_RefKind; this will be corrected later if the variable is written to
             return std::unique_ptr<VariableReference>(new VariableReference(
                                                                  identifier.fOffset,
diff --git a/src/sksl/SkSLSPIRVCodeGenerator.cpp b/src/sksl/SkSLSPIRVCodeGenerator.cpp
diff --git a/src/sksl/SkSLSPIRVCodeGenerator.h b/src/sksl/SkSLSPIRVCodeGenerator.h
diff --git a/src/sksl/ir/SkSLProgram.h b/src/sksl/ir/SkSLProgram.h
diff --git a/src/sksl/sksl_fp.inc b/src/sksl/sksl_fp.inc
diff --git a/src/sksl/sksl_frag.inc b/src/sksl/sksl_frag.inc
diff --git a/tests/SkSLGLSLTest.cpp b/tests/SkSLGLSLTest.cpp

Original file line number	Diff line number	Diff line change
`@@ -70,8 +70,8 @@`
`70`	`70`	`if (shaderLibrary == nil) {`
`71`	`71`	`return nil;`
`72`	`72`	`}`
`73`		`- if (inputs.fRTHeight) {`
`74`		`- this->addRTHeightUniform(SKSL_RTHEIGHT_NAME);`
	`73`	`+ if (inputs.fRTDimensions) {`
	`74`	`+ this->addRTDimensionsUniform(SKSL_RTDIMENSIONS_NAME);`
`75`	`75`	`}`
`76`	`76`	`if (inputs.fFlipY) {`
`77`	`77`	`desc->setSurfaceOriginKey(GrGLSLFragmentShaderBuilder::KeyForSurfaceOrigin(`
Original file line number	Diff line number	Diff line change
`@@ -75,8 +75,8 @@ bool GrVkPipelineStateBuilder::createVkShaderModule(VkShaderStageFlagBits stage,`
`75`	`75`	`if (!result) {`
`76`	`76`	`return false;`
`77`	`77`	`}`
`78`		`- if (inputs.fRTHeight) {`
`79`		`- this->addRTHeightUniform(SKSL_RTHEIGHT_NAME);`
	`78`	`+ if (inputs.fRTDimensions) {`
	`79`	`+ this->addRTDimensionsUniform(SKSL_RTDIMENSIONS_NAME);`
`80`	`80`	`}`
`81`	`81`	`if (inputs.fFlipY) {`
`82`	`82`	`desc->setSurfaceOriginKey(GrGLSLFragmentShaderBuilder::KeyForSurfaceOrigin(`