Create GrGLSLVaryingHandler class for program building

src/gpu/GrDefaultGeoProcFactory.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrDefaultGeoProcFactory.h"
 
 #include "GrInvariantOutput.h"
 #include "glsl/GrGLSLFragmentShaderBuilder.h"
 #include "glsl/GrGLSLGeometryProcessor.h"
 #include "glsl/GrGLSLProgramBuilder.h"
 #include "glsl/GrGLSLVertexShaderBuilder.h"
+#include "glsl/GrGLSLVarying.h"
 #include "glsl/GrGLSLUtil.h"
 
 /*
  * The default Geometry Processor simply takes position and multiplies it by the uniform view
  * matrix. It also leaves coverage untouched.  Behind the scenes, we may add per vertex color or
  * local coords.
  */
 
 enum GPFlag {
     kColor_GPFlag =                 0x1,
@@ skipping 34 matching lines @@
     class GLSLProcessor : public GrGLSLGeometryProcessor {
     public:
         GLSLProcessor()
             : fViewMatrix(SkMatrix::InvalidMatrix()), fColor(GrColor_ILLEGAL), fCoverage(0xff) {}
 
         void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) override {
             const DefaultGeoProc& gp = args.fGP.cast<DefaultGeoProc>();
             GrGLSLGPBuilder* pb = args.fPB;
             GrGLSLVertexBuilder* vertBuilder = args.fVertBuilder;
             GrGLSLFragmentBuilder* fragBuilder = args.fFragBuilder;
+            GrGLSLVaryingHandler* varyingHandler = args.fVaryingHandler;
 
             // emit attributes
-            vertBuilder->emitAttributes(gp);
+            varyingHandler->emitAttributes(gp);
 
             // Setup pass through color
             if (!gp.colorIgnored()) {
                 if (gp.hasVertexColor()) {
-                    pb->addPassThroughAttribute(gp.inColor(), args.fOutputColor);
+                    varyingHandler->addPassThroughAttribute(gp.inColor(), args.fOutputColor);
                 } else {
                     this->setupUniformColor(pb, fragBuilder, args.fOutputColor, &fColorUniform);
                 }
             }
 
             // Setup position
             this->setupPosition(pb,
                                 vertBuilder,
                                 gpArgs,
                                 gp.inPosition()->fName,
                                 gp.viewMatrix(),
                                 &fViewMatrixUniform);
 
             if (gp.hasExplicitLocalCoords()) {
                 // emit transforms with explicit local coords
                 this->emitTransforms(pb,
                                      vertBuilder,
+                                     varyingHandler,
                                      gpArgs->fPositionVar,
                                      gp.inLocalCoords()->fName,
                                      gp.localMatrix(),
                                      args.fTransformsIn,
                                      args.fTransformsOut);
             } else if(gp.hasTransformedLocalCoords()) {
                 // transforms have already been applied to vertex attributes on the cpu
                 this->emitTransforms(pb,
                                      vertBuilder,
+                                     varyingHandler,
                                      gp.inLocalCoords()->fName,
                                      args.fTransformsIn,
                                      args.fTransformsOut);
             } else {
                 // emit transforms with position
                 this->emitTransforms(pb,
                                      vertBuilder,
+                                     varyingHandler,
                                      gpArgs->fPositionVar,
                                      gp.inPosition()->fName,
                                      gp.localMatrix(),
                                      args.fTransformsIn,
                                      args.fTransformsOut);
             }
 
             // Setup coverage as pass through
             if (!gp.coverageWillBeIgnored()) {
                 if (gp.hasVertexCoverage()) {
                     fragBuilder->codeAppendf("float alpha = 1.0;");
-                    args.fPB->addPassThroughAttribute(gp.inCoverage(), "alpha");
+                    varyingHandler->addPassThroughAttribute(gp.inCoverage(), "alpha");
                     fragBuilder->codeAppendf("%s = vec4(alpha);", args.fOutputCoverage);
                 } else if (gp.coverage() == 0xff) {
                     fragBuilder->codeAppendf("%s = vec4(1);", args.fOutputCoverage);
                 } else {
                     const char* fragCoverage;
                     fCoverageUniform = pb->addUniform(GrGLSLProgramBuilder::kFragment_Visibility,
                                                       kFloat_GrSLType,
                                                       kDefault_GrSLPrecision,
                                                       "Coverage",
                                                       &fragCoverage);
@@ skipping 197 matching lines @@
         }
 
         if (localCoords.hasLocalMatrix()) {
             invert.preConcat(*localCoords.fMatrix);
         }
     }
 
     LocalCoords inverted(LocalCoords::kUsePosition_Type, &invert);
     return Create(color, coverage, inverted, SkMatrix::I());
 }