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

src/gpu/glsl/GrGLSLProgramBuilder.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "glsl/GrGLSLProgramBuilder.h"
 
 #include "GrPipeline.h"
@@ skipping 69 matching lines @@
 }
 
 void GrGLSLProgramBuilder::emitAndInstallPrimProc(const GrPrimitiveProcessor& proc,
                                                   GrGLSLExpr4* outputColor,
                                                   GrGLSLExpr4* outputCoverage) {
     // Program builders have a bit of state we need to clear with each effect
     AutoStageAdvance adv(this);
     this->nameExpression(outputColor, "outputColor");
     this->nameExpression(outputCoverage, "outputCoverage");
 
+    const char* distanceVectorName = nullptr;
+    if (this->fPipeline.usesDistanceVectorField() && proc.implementsDistanceVector()) {
+        distanceVectorName = fFS.distanceVectorName();
+        fFS.codeAppend( "// Un-normalized vector to the closed geometric edge (in source space)\n");
+        fFS.codeAppendf("vec2 %s;", distanceVectorName);
+    }
+
     // Enclose custom code in a block to avoid namespace conflicts
     SkString openBrace;
     openBrace.printf("{ // Stage %d, %s\n", fStageIndex, proc.name());
     fFS.codeAppend(openBrace.c_str());
     fVS.codeAppendf("// Primitive Processor %s\n", proc.name());
 
     SkASSERT(!fGeometryProcessor);
     fGeometryProcessor = proc.createGLSLInstance(*this->glslCaps());
 
     SkSTArray<4, SamplerHandle> texSamplers(proc.numTextures());
     SkSTArray<2, SamplerHandle> bufferSamplers(proc.numBuffers());
     this->emitSamplers(proc, &texSamplers, &bufferSamplers);
 
     GrGLSLGeometryProcessor::EmitArgs args(&fVS,
                                            &fFS,
                                            this->varyingHandler(),
                                            this->uniformHandler(),
                                            this->glslCaps(),
                                            proc,
                                            outputColor->c_str(),
                                            outputCoverage->c_str(),
+                                           distanceVectorName,
                                            texSamplers.begin(),
                                            bufferSamplers.begin(),
                                            fCoordTransforms,
                                            &fOutCoords);
     fGeometryProcessor->emitCode(args);
 
     // We have to check that effects and the code they emit are consistent, ie if an effect
     // asks for dst color, then the emit code needs to follow suit
     SkDEBUGCODE(verify(proc);)
 
@@ skipping 33 matching lines @@
     this->emitSamplers(fp, &texSamplers, &bufferSamplers);
 
     GrGLSLFragmentProcessor::EmitArgs args(&fFS,
                                            this->uniformHandler(),
                                            this->glslCaps(),
                                            fp,
                                            output->c_str(),
                                            input.isOnes() ? nullptr : input.c_str(),
                                            fOutCoords[index],
                                            texSamplers.begin(),
-                                           bufferSamplers.begin());
+                                           bufferSamplers.begin(),
+                                           this->primitiveProcessor().implementsDistanceVector());
+
     fragProc->emitCode(args);
 
     // We have to check that effects and the code they emit are consistent, ie if an effect
     // asks for dst color, then the emit code needs to follow suit
     SkDEBUGCODE(verify(fp);)
     fFragmentProcessors.push_back(fragProc);
 
     fFS.codeAppend("}");
 }
 
@@ skipping 226 matching lines @@
         delete fFragmentProcessors[i];
     }
 }
 
 void GrGLSLProgramBuilder::finalizeShaders() {
     this->varyingHandler()->finalize();
     fVS.finalize(kVertex_GrShaderFlag);
     fFS.finalize(kFragment_GrShaderFlag);
 
 }