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.

[egdaniel, 2016/07/13 19:27:26]

Add to this comment that 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.

[dvonbeck, 2016/07/13 21:28:14]

Done.

+class GLSLNormalFP : public GrGLSLFragmentProcessor {
+public:
+    void emitCode(EmitArgs& args) override {
+        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);
+        } else {
+            this->onEmitCode(args);
+        }
+    }
+protected:
+    virtual void onEmitCode(EmitArgs& args) = 0;
+};
+
+#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 265 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 {}
@@ skipping 121 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 {
             const NormalBevelFP& normalBevelFP = proc.cast<NormalBevelFP>();
@@ skipping 98 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
 
 ////////////////////////////////////////////////////////////////////////////