Create GrGLSLVaryingHandler class for program building

src/gpu/effects/GrDashingEffect.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 "GrDashingEffect.h"
 
 #include "GrBatchFlushState.h"
 #include "GrBatchTest.h"
 #include "GrCaps.h"
 #include "GrGeometryProcessor.h"
 #include "GrContext.h"
 #include "GrCoordTransform.h"
 #include "GrDefaultGeoProcFactory.h"
 #include "GrDrawTarget.h"
 #include "GrInvariantOutput.h"
 #include "GrProcessor.h"
 #include "GrStrokeInfo.h"
 #include "GrVertexBuffer.h"
 #include "SkGr.h"
 #include "batches/GrVertexBatch.h"
 #include "glsl/GrGLSLFragmentShaderBuilder.h"
 #include "glsl/GrGLSLGeometryProcessor.h"
 #include "glsl/GrGLSLProgramBuilder.h"
 #include "glsl/GrGLSLProgramDataManager.h"
+#include "glsl/GrGLSLVarying.h"
 #include "glsl/GrGLSLVertexShaderBuilder.h"
 
 ///////////////////////////////////////////////////////////////////////////////
 
 // Returns whether or not the gpu can fast path the dash line effect.
 bool GrDashingEffect::CanDrawDashLine(const SkPoint pts[2], const GrStrokeInfo& strokeInfo,
                                       const SkMatrix& viewMatrix) {
     // Pts must be either horizontal or vertical in src space
     if (pts[0].fX != pts[1].fX && pts[0].fY != pts[1].fY) {
         return false;
@@ skipping 808 matching lines @@
     fColor = GrColor_ILLEGAL;
     fPrevRadius = SK_ScalarMin;
     fPrevCenterX = SK_ScalarMin;
     fPrevIntervalLength = SK_ScalarMax;
 }
 
 void GLDashingCircleEffect::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) {
     const DashingCircleEffect& dce = args.fGP.cast<DashingCircleEffect>();
     GrGLSLGPBuilder* pb = args.fPB;
     GrGLSLVertexBuilder* vertBuilder = args.fVertBuilder;
+    GrGLSLVaryingHandler* varyingHandler = args.fVaryingHandler;
 
     // emit attributes
-    vertBuilder->emitAttributes(dce);
+    varyingHandler->emitAttributes(dce);
 
     // XY are dashPos, Z is dashInterval
     GrGLSLVertToFrag dashParams(kVec3f_GrSLType);
-    args.fPB->addVarying("DashParam", &dashParams);
+    varyingHandler->addVarying("DashParam", &dashParams);
     vertBuilder->codeAppendf("%s = %s;", dashParams.vsOut(), dce.inDashParams()->fName);
 
     // x refers to circle radius - 0.5, y refers to cicle's center x coord
     GrGLSLVertToFrag circleParams(kVec2f_GrSLType);
-    args.fPB->addVarying("CircleParams", &circleParams);
+    varyingHandler->addVarying("CircleParams", &circleParams);
     vertBuilder->codeAppendf("%s = %s;", circleParams.vsOut(), dce.inCircleParams()->fName);
 
     GrGLSLFragmentBuilder* fragBuilder = args.fFragBuilder;
     // Setup pass through color
     if (!dce.colorIgnored()) {
         this->setupUniformColor(pb, fragBuilder, args.fOutputColor, &fColorUniform);
     }
 
     // Setup position
     this->setupPosition(pb, vertBuilder, gpArgs, dce.inPosition()->fName);
 
     // emit transforms
     this->emitTransforms(args.fPB,
                          vertBuilder,
+                         varyingHandler,
                          gpArgs->fPositionVar,
                          dce.inPosition()->fName,
                          dce.localMatrix(),
                          args.fTransformsIn,
                          args.fTransformsOut);
 
     // transforms all points so that we can compare them to our test circle
     fragBuilder->codeAppendf("float xShifted = %s.x - floor(%s.x / %s.z) * %s.z;",
                              dashParams.fsIn(), dashParams.fsIn(), dashParams.fsIn(),
                              dashParams.fsIn());
@@ skipping 165 matching lines @@
 
 GLDashingLineEffect::GLDashingLineEffect() {
     fColor = GrColor_ILLEGAL;
 }
 
 void GLDashingLineEffect::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) {
     const DashingLineEffect& de = args.fGP.cast<DashingLineEffect>();
     GrGLSLGPBuilder* pb = args.fPB;
 
     GrGLSLVertexBuilder* vertBuilder = args.fVertBuilder;
+    GrGLSLVaryingHandler* varyingHandler = args.fVaryingHandler;
 
     // emit attributes
-    vertBuilder->emitAttributes(de);
+    varyingHandler->emitAttributes(de);
 
     // XY refers to dashPos, Z is the dash interval length
     GrGLSLVertToFrag inDashParams(kVec3f_GrSLType);
-    args.fPB->addVarying("DashParams", &inDashParams, GrSLPrecision::kHigh_GrSLPrecision);
+    varyingHandler->addVarying("DashParams", &inDashParams, GrSLPrecision::kHigh_GrSLPrecision);
     vertBuilder->codeAppendf("%s = %s;", inDashParams.vsOut(), de.inDashParams()->fName);
 
     // The rect uniform's xyzw refer to (left + 0.5, top + 0.5, right - 0.5, bottom - 0.5),
     // respectively.
     GrGLSLVertToFrag inRectParams(kVec4f_GrSLType);
-    args.fPB->addVarying("RectParams", &inRectParams, GrSLPrecision::kHigh_GrSLPrecision);
+    varyingHandler->addVarying("RectParams", &inRectParams, GrSLPrecision::kHigh_GrSLPrecision);
     vertBuilder->codeAppendf("%s = %s;", inRectParams.vsOut(), de.inRectParams()->fName);
 
     GrGLSLFragmentBuilder* fragBuilder = args.fFragBuilder;
     // Setup pass through color
     if (!de.colorIgnored()) {
         this->setupUniformColor(pb, fragBuilder, args.fOutputColor, &fColorUniform);
     }
 
     // Setup position
     this->setupPosition(pb, vertBuilder, gpArgs, de.inPosition()->fName);
 
     // emit transforms
     this->emitTransforms(args.fPB,
                          vertBuilder,
+                         varyingHandler,
                          gpArgs->fPositionVar,
                          de.inPosition()->fName,
                          de.localMatrix(),
                          args.fTransformsIn,
                          args.fTransformsOut);
 
     // transforms all points so that we can compare them to our test rect
     fragBuilder->codeAppendf("float xShifted = %s.x - floor(%s.x / %s.z) * %s.z;",
                              inDashParams.fsIn(), inDashParams.fsIn(), inDashParams.fsIn(),
                              inDashParams.fsIn());
@@ skipping 187 matching lines @@
     info.fIntervals = intervals;
     info.fCount = 2;
     info.fPhase = phase;
     SkDEBUGCODE(bool success = ) strokeInfo.setDashInfo(info);
     SkASSERT(success);
 
     return create_batch(color, viewMatrix, pts, useAA, strokeInfo, msaaRT);
 }
 
 #endif