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

src/core/SkNormalMapSource.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 "SkNormalMapSource.h"
 
 #include "SkLightingShader.h"
 #include "SkMatrix.h"
 #include "SkNormalSource.h"
+#include "SkNormalSourcePriv.h"
 #include "SkPM4f.h"
 #include "SkReadBuffer.h"
 #include "SkWriteBuffer.h"
 
 #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 {
-            GrGLSLFragmentBuilder* fragBuilder = args.fFragBuilder;
+        void onEmitCode(EmitArgs& args) override {
+            GrGLSLFPFragmentBuilder* 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);
             fragBuilder->codeAppendf("vec3 normal = normalize(%s.rgb - vec3(0.5));",
@@ skipping 20 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 setNormalData(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 164 matching lines @@
 
 sk_sp<SkNormalSource> SkNormalSource::MakeFromNormalMap(sk_sp<SkShader> map, const SkMatrix& ctm) {
     SkMatrix invCTM;
 
     if (!ctm.invert(&invCTM) || !map) {
         return nullptr;
     }
 
     return sk_make_sp<SkNormalMapSourceImpl>(std::move(map), invCTM);
 }