GrFP can express distance vector field req., program builder declares variable for it

src/core/SkNormalSource.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkError.h"
 #include "SkErrorInternals.h"
 #include "SkLightingShader.h"
 #include "SkMatrix.h"
 #include "SkNormalSource.h"
 #include "SkPM4f.h"
 #include "SkReadBuffer.h"
 #include "SkWriteBuffer.h"
 
-// Genretating vtable
+#if SK_SUPPORT_GPU
+    #include "GrCoordTransform.h"
+    #include "GrInvariantOutput.h"
+    #include "GrTextureParams.h"
+    #include "glsl/GrGLSLFragmentProcessor.h"
+    #include "glsl/GrGLSLFragmentShaderBuilder.h"
+    #include "SkGr.h"
+#endif
+
+// Generating vtable
 SkNormalSource::~SkNormalSource() {}
 
+#if SK_SUPPORT_GPU
+
+// GLSLFragmentProcessors for NormalSourceImpls must sub-class this class and override onEmitCode.
+// This class exists to intercept emitCode calls and emit <0, 0, 1> if the FP requires a distance
+// vector but the GP doesn't provide it. onSetData calls need to be intercepted too because
+// uniform handlers will be invalid in subclasses where onEmitCode isn't called.
+// We don't need to adjust the key here since the use of a given GP (through its class ID already in
+// the key), will determine what code gets emitted here.
+class GLSLNormalFP : public GrGLSLFragmentProcessor {
+public:
+    GLSLNormalFP()
+        : fDidIntercept(false) {}
+
+    void emitCode(EmitArgs& args) override {

[egdaniel, 2016/07/14 02:47:46]

lets mark emitCode and onSetData here as final so that we don't accidentally
override them in a sub class.

[dvonbeck, 2016/07/14 13:40:34]

Done.

+        if (args.fFp.usesDistanceVectorField() && !args.fGpImplementsDistanceVector) {
+            GrGLSLFragmentBuilder* fragBuilder = args.fFragBuilder;
+            fragBuilder->codeAppendf("// GLSLNormalFP intercepted emitCode call, GP does not "
+                                     "implement required distance vector feature\n");
+            fragBuilder->codeAppendf("%s = vec4(0, 0, 1, 0);", args.fOutputColor);
+
+            fDidIntercept = true;
+        } else {
+            this->onEmitCode(args);
+        }
+    }
+
+    void onSetData(const GrGLSLProgramDataManager& pdman, const GrProcessor& proc) {
+        if (!fDidIntercept) {
+            this->onOnSetData(pdman, proc);
+        }
+    }
+
+protected:
+    virtual void onEmitCode(EmitArgs& args) = 0;
+    virtual void onOnSetData(const GrGLSLProgramDataManager& pdman, const GrProcessor& proc) = 0;

[egdaniel, 2016/07/14 02:47:46]

hmm this looks ugly. Maybe make it setNormalData?

[dvonbeck, 2016/07/14 13:40:34]

Done.

+
+private:
+    bool fDidIntercept;
+};
+
+#endif
+
 ///////////////////////////////////////////////////////////////////////////////
 
 class NormalMapSourceImpl : public SkNormalSource {
 public:
     NormalMapSourceImpl(sk_sp<SkShader> mapShader, const SkMatrix& invCTM)
         : fMapShader(std::move(mapShader))
         , fInvCTM(invCTM) {}
 
 #if SK_SUPPORT_GPU
     sk_sp<GrFragmentProcessor> asFragmentProcessor(GrContext*,
@@ skipping 38 matching lines @@
 
     friend class SkNormalSource;
 
     typedef SkNormalSource INHERITED;
 };
 
 ////////////////////////////////////////////////////////////////////////////
 
 #if SK_SUPPORT_GPU
 
-#include "GrCoordTransform.h"
-#include "GrInvariantOutput.h"
-#include "GrTextureParams.h"
-#include "glsl/GrGLSLFragmentProcessor.h"
-#include "glsl/GrGLSLFragmentShaderBuilder.h"
-#include "SkGr.h"
-
 class NormalMapFP : public GrFragmentProcessor {
 public:
     NormalMapFP(sk_sp<GrFragmentProcessor> mapFP, const SkMatrix& invCTM)
         : fInvCTM(invCTM) {
         this->registerChildProcessor(mapFP);
 
         this->initClassID<NormalMapFP>();
     }
 
-    class GLSLNormalMapFP : public GrGLSLFragmentProcessor {
+    class GLSLNormalMapFP : public GLSLNormalFP {
     public:
         GLSLNormalMapFP()
             : fColumnMajorInvCTM22{0.0f} {}
 
-        void emitCode(EmitArgs& args) override {
+        void onEmitCode(EmitArgs& args) override {
             GrGLSLFragmentBuilder* fragBuilder = args.fFragBuilder;
             GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
 
             // add uniform
             const char* xformUniName = nullptr;
             fXformUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kMat22f_GrSLType,
                                                    kDefault_GrSLPrecision, "Xform", &xformUniName);
 
             SkString dstNormalColorName("dstNormalColor");
             this->emitChild(0, nullptr, &dstNormalColorName, args);
@@ skipping 21 matching lines @@
                     args.fOutputColor);
             fragBuilder->codeAppend( "}");
         }
 
         static void GenKey(const GrProcessor& proc, const GrGLSLCaps&,
                            GrProcessorKeyBuilder* b) {
             b->add32(0x0);
         }
 
     protected:
-        void onSetData(const GrGLSLProgramDataManager& pdman, const GrProcessor& proc) override {
+        void onOnSetData(const GrGLSLProgramDataManager& pdman, const GrProcessor& proc) override {
             const NormalMapFP& normalMapFP = proc.cast<NormalMapFP>();
 
             const SkMatrix& invCTM = normalMapFP.invCTM();
             fColumnMajorInvCTM22[0] = invCTM.get(SkMatrix::kMScaleX);
             fColumnMajorInvCTM22[1] = invCTM.get(SkMatrix::kMSkewY);
             fColumnMajorInvCTM22[2] = invCTM.get(SkMatrix::kMSkewX);
             fColumnMajorInvCTM22[3] = invCTM.get(SkMatrix::kMScaleY);
             pdman.setMatrix2f(fXformUni, fColumnMajorInvCTM22);
         }
 
@@ skipping 223 matching lines @@
 ////////////////////////////////////////////////////////////////////////////
 
 #if SK_SUPPORT_GPU
 
 class NormalFlatFP : public GrFragmentProcessor {
 public:
     NormalFlatFP() {
         this->initClassID<NormalFlatFP>();
     }
 
-    class GLSLNormalFlatFP : public GrGLSLFragmentProcessor {
+    class GLSLNormalFlatFP : public GLSLNormalFP {
     public:
         GLSLNormalFlatFP() {}
 
-        void emitCode(EmitArgs& args) override {
+        void onEmitCode(EmitArgs& args) override {
             GrGLSLFragmentBuilder* fragBuilder = args.fFragBuilder;
-
             fragBuilder->codeAppendf("%s = vec4(0, 0, 1, 0);", args.fOutputColor);
         }
 
         static void GenKey(const GrProcessor& proc, const GrGLSLCaps&,
                            GrProcessorKeyBuilder* b) {
             b->add32(0x0);
         }
 
     protected:
-        void onSetData(const GrGLSLProgramDataManager& pdman, const GrProcessor& proc) override {}
+        void onOnSetData(const GrGLSLProgramDataManager& pdman, const GrProcessor& proc) override {}
     };
 
     void onGetGLSLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const override {
         GLSLNormalFlatFP::GenKey(*this, caps, b);
     }
 
     const char* name() const override { return "NormalFlatFP"; }
 
     void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
         inout->setToUnknown(GrInvariantOutput::ReadInput::kWillNot_ReadInput);
@@ skipping 111 matching lines @@
 ////////////////////////////////////////////////////////////////////////////
 
 #if SK_SUPPORT_GPU
 
 class NormalBevelFP : public GrFragmentProcessor {
 public:
     NormalBevelFP(SkNormalSource::BevelType type, SkScalar width, SkScalar height)
         : fType(type)
         , fWidth(width)
         , fHeight(height) {
+        fUsesDistanceVectorField = true;
+
         this->initClassID<NormalBevelFP>();
     }
 
-    class GLSLNormalBevelFP : public GrGLSLFragmentProcessor {
+    class GLSLNormalBevelFP : public GLSLNormalFP {
     public:
         GLSLNormalBevelFP() {
             fPrevType = SkNormalSource::BevelType::kLinear;
             fPrevWidth = SkFloatToScalar(0.0f);
             fPrevHeight = SkFloatToScalar(0.0f);
         }
 
-        void emitCode(EmitArgs& args) override {
+        void onEmitCode(EmitArgs& args) override {
             GrGLSLFragmentBuilder* fragBuilder = args.fFragBuilder;
-
-            fragBuilder->codeAppendf("%s = vec4(0, 0, 1, 0);", args.fOutputColor);
+            fragBuilder->codeAppendf("%s = normalize(vec4(0.0, 0.0, 1.0, 0.0));",
+                                     args.fOutputColor);
         }
 
         static void GenKey(const GrProcessor& proc, const GrGLSLCaps&,
                            GrProcessorKeyBuilder* b) {
             b->add32(0x0);
         }
 
     protected:
-        void onSetData(const GrGLSLProgramDataManager& pdman, const GrProcessor& proc) override {
+        void onOnSetData(const GrGLSLProgramDataManager& pdman, const GrProcessor& proc) override {
             const NormalBevelFP& normalBevelFP = proc.cast<NormalBevelFP>();
 
             fPrevType   = normalBevelFP.fType;
             fPrevWidth  = normalBevelFP.fWidth;
             fPrevHeight = normalBevelFP.fHeight;
         }
 
     private:
         SkNormalSource::BevelType fPrevType;
         SkScalar fPrevWidth;
@@ skipping 89 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////
 
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkNormalSource)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(NormalMapSourceImpl)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(NormalFlatSourceImpl)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(NormalBevelSourceImpl)
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END
 
 ////////////////////////////////////////////////////////////////////////////