Create GrGLSLVaryingHandler class for program building

src/gpu/batches/GrAAConvexPathRenderer.cpp

 
 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAAConvexPathRenderer.h"
 
@@ skipping 10 matching lines @@
 #include "GrPipelineBuilder.h"
 #include "GrStrokeInfo.h"
 #include "SkGeometry.h"
 #include "SkPathPriv.h"
 #include "SkString.h"
 #include "SkTraceEvent.h"
 #include "batches/GrVertexBatch.h"
 #include "glsl/GrGLSLGeometryProcessor.h"
 #include "glsl/GrGLSLProgramBuilder.h"
 #include "glsl/GrGLSLProgramDataManager.h"
+#include "glsl/GrGLSLVarying.h"
 
 GrAAConvexPathRenderer::GrAAConvexPathRenderer() {
 }
 
 struct Segment {
     enum {
         // These enum values are assumed in member functions below.
         kLine = 0,
         kQuad = 1,
     } fType;
@@ skipping 502 matching lines @@
 
     class GLSLProcessor : public GrGLSLGeometryProcessor {
     public:
         GLSLProcessor()
             : fColor(GrColor_ILLEGAL) {}
 
         void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) override {
             const QuadEdgeEffect& qe = args.fGP.cast<QuadEdgeEffect>();
             GrGLSLGPBuilder* pb = args.fPB;
             GrGLSLVertexBuilder* vertBuilder = args.fVertBuilder;
+            GrGLSLVaryingHandler* varyingHandler = args.fVaryingHandler;
 
             // emit attributes
-            vertBuilder->emitAttributes(qe);
+            varyingHandler->emitAttributes(qe);
 
             GrGLSLVertToFrag v(kVec4f_GrSLType);
-            args.fPB->addVarying("QuadEdge", &v);
+            varyingHandler->addVarying("QuadEdge", &v);
             vertBuilder->codeAppendf("%s = %s;", v.vsOut(), qe.inQuadEdge()->fName);
 
             GrGLSLFragmentBuilder* fragBuilder = args.fFragBuilder;
             // Setup pass through color
             if (!qe.colorIgnored()) {
                 this->setupUniformColor(pb, fragBuilder, args.fOutputColor, &fColorUniform);
             }
 
             // Setup position
             this->setupPosition(pb, vertBuilder, gpArgs, qe.inPosition()->fName);
 
             // emit transforms
             this->emitTransforms(args.fPB,
                                  vertBuilder,
+                                 varyingHandler,
                                  gpArgs->fPositionVar,
                                  qe.inPosition()->fName,
                                  qe.localMatrix(),
                                  args.fTransformsIn,
                                  args.fTransformsOut);
 
             SkAssertResult(fragBuilder->enableFeature(
                     GrGLSLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature));
             fragBuilder->codeAppendf("float edgeAlpha;");
 
@@ skipping 428 matching lines @@
 DRAW_BATCH_TEST_DEFINE(AAConvexPathBatch) {
     AAConvexPathBatch::Geometry geometry;
     geometry.fColor = GrRandomColor(random);
     geometry.fViewMatrix = GrTest::TestMatrixInvertible(random);
     geometry.fPath = GrTest::TestPathConvex(random);
 
     return AAConvexPathBatch::Create(geometry);
 }
 
 #endif