Remove legacy NVPR support

src/gpu/gl/GrGLPathProcessor.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrGLPathProcessor.h"
 
 #include "GrPathProcessor.h"
@@ skipping 41 matching lines @@
                                 const GrBatchTracker& bt) {
     const PathBatchTracker& local = bt.cast<PathBatchTracker>();
     if (kUniform_GrGPInput == local.fInputColorType && local.fColor != fColor) {
         GrGLfloat c[4];
         GrColorToRGBAFloat(local.fColor, c);
         pdman.set4fv(fColorUniform, 1, c);
         fColor = local.fColor;
     }
 }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-void GrGLLegacyPathProcessor::emitTransforms(GrGLGPBuilder*, const TransformsIn& tin,
-                                             TransformsOut* tout) {
+void GrGLPathProcessor::emitTransforms(GrGLGPBuilder* pb, const TransformsIn& tin,
+                                       TransformsOut* tout) {
     tout->push_back_n(tin.count());
     fInstalledTransforms.push_back_n(tin.count());
     for (int i = 0; i < tin.count(); i++) {
-        const ProcCoords& coordTransforms = tin[i];
-        int texCoordIndex = this->addTexCoordSets(coordTransforms.count());
-
-        // Use the first uniform location as the texcoord index.
-        fInstalledTransforms[i].push_back_n(1);
-        fInstalledTransforms[i][0].fHandle = ShaderVarHandle(texCoordIndex);
-
-        SkString name;
-        for (int t = 0; t < coordTransforms.count(); ++t) {
-            GrSLType type = coordTransforms[t]->getMatrix().hasPerspective() ? kVec3f_GrSLType :
-                                                                               kVec2f_GrSLType;
-
-            name.printf("%s(gl_TexCoord[%i])", GrGLSLTypeString(type), texCoordIndex++);
-            SkNEW_APPEND_TO_TARRAY(&(*tout)[i], GrGLProcessor::TransformedCoords, (name, type));
-        }
-    }
-}
-
-void GrGLLegacyPathProcessor::setTransformData(
-        const GrPrimitiveProcessor& primProc,
-        int index,
-        const SkTArray<const GrCoordTransform*, true>& transforms,
-        GrGLPathRendering* glpr,
-        GrGLuint) {
-    // We've hidden the texcoord index in the first entry of the transforms array for each
-    // effect
-    int texCoordIndex = fInstalledTransforms[index][0].fHandle.handle();
-    for (int t = 0; t < transforms.count(); ++t) {
-        const SkMatrix& transform = GetTransformMatrix(primProc.localMatrix(), *transforms[t]);
-        GrGLPathRendering::PathTexGenComponents components =
-                GrGLPathRendering::kST_PathTexGenComponents;
-        if (transform.hasPerspective()) {
-            components = GrGLPathRendering::kSTR_PathTexGenComponents;
-        }
-        glpr->enablePathTexGen(texCoordIndex++, components, transform);
-    }
-}
-
-void GrGLLegacyPathProcessor::didSetData(GrGLPathRendering* glpr) {
-    glpr->flushPathTexGenSettings(fTexCoordSetCnt);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-void GrGLNormalPathProcessor::emitTransforms(GrGLGPBuilder* pb, const TransformsIn& tin,
-                                             TransformsOut* tout) {
-    tout->push_back_n(tin.count());
-    fInstalledTransforms.push_back_n(tin.count());
-    for (int i = 0; i < tin.count(); i++) {
         const ProcCoords& coordTransforms = tin[i];
         fInstalledTransforms[i].push_back_n(coordTransforms.count());
         for (int t = 0; t < coordTransforms.count(); t++) {
             GrSLType varyingType =
                     coordTransforms[t]->getMatrix().hasPerspective() ? kVec3f_GrSLType :
                                                                        kVec2f_GrSLType;
 
 
             SkString strVaryingName("MatrixCoord");
             strVaryingName.appendf("_%i_%i", i, t);
             GrGLVertToFrag v(varyingType);
             pb->addVarying(strVaryingName.c_str(), &v);
             SeparableVaryingInfo& varyingInfo = fSeparableVaryingInfos.push_back();
             varyingInfo.fVariable = pb->getFragmentShaderBuilder()->fInputs.back();
             varyingInfo.fLocation = fSeparableVaryingInfos.count() - 1;
             varyingInfo.fType = varyingType;
             fInstalledTransforms[i][t].fHandle = ShaderVarHandle(varyingInfo.fLocation);
             fInstalledTransforms[i][t].fType = varyingType;
 
             SkNEW_APPEND_TO_TARRAY(&(*tout)[i], GrGLProcessor::TransformedCoords,
                                    (SkString(v.fsIn()), varyingType));
         }
     }
 }
 
-void GrGLNormalPathProcessor::resolveSeparableVaryings(GrGLGpu* gpu, GrGLuint programId) {
+void GrGLPathProcessor::resolveSeparableVaryings(GrGLGpu* gpu, GrGLuint programId) {
     int count = fSeparableVaryingInfos.count();
     for (int i = 0; i < count; ++i) {
         GrGLint location;
         GR_GL_CALL_RET(gpu->glInterface(),
                        location,
                        GetProgramResourceLocation(programId,
                                                   GR_GL_FRAGMENT_INPUT,
                                                   fSeparableVaryingInfos[i].fVariable.c_str()));
         fSeparableVaryingInfos[i].fLocation = location;
     }
 }
 
-void GrGLNormalPathProcessor::setTransformData(
+void GrGLPathProcessor::setTransformData(
         const GrPrimitiveProcessor& primProc,
         int index,
         const SkTArray<const GrCoordTransform*, true>& coordTransforms,
         GrGLPathRendering* glpr,
         GrGLuint programID) {
     SkSTArray<2, Transform, true>& transforms = fInstalledTransforms[index];
     int numTransforms = transforms.count();
     for (int t = 0; t < numTransforms; ++t) {
         SkASSERT(transforms[t].fHandle.isValid());
         const SkMatrix& transform = GetTransformMatrix(primProc.localMatrix(),
                                                        *coordTransforms[t]);
         if (transforms[t].fCurrentValue.cheapEqualTo(transform)) {
             continue;
         }
         transforms[t].fCurrentValue = transform;
         const SeparableVaryingInfo& fragmentInput =
                 fSeparableVaryingInfos[transforms[t].fHandle.handle()];
         SkASSERT(transforms[t].fType == kVec2f_GrSLType ||
                  transforms[t].fType == kVec3f_GrSLType);
         unsigned components = transforms[t].fType == kVec2f_GrSLType ? 2 : 3;
         glpr->setProgramPathFragmentInputTransform(programID,
                                                    fragmentInput.fLocation,
                                                    GR_GL_OBJECT_LINEAR,
                                                    components,
                                                    transform);
     }
 }