Use fixed function pipeline only when drawing paths

src/gpu/gl/GrGLProgramEffects.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 "GrGLProgramEffects.h"
 #include "GrDrawEffect.h"
 #include "gl/GrGLEffect.h"
@@ skipping 451 matching lines @@
                                                  GrGLProgramEffects::EffectKey key,
                                                  const char* outColor,
                                                  const char* inColor,
                                                  int stageIndex) {
     SkASSERT(NULL != fProgramEffects.get());
     fProgramEffects->emitEffect(fBuilder, stage, key, outColor, inColor, stageIndex);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
-void GrGLTexGenProgramEffects::emitEffect(GrGLFragmentOnlyShaderBuilder* builder,
+void GrGLPathTexGenProgramEffects::emitEffect(GrGLFragmentOnlyShaderBuilder* builder,
                                           const GrEffectStage& stage,
                                           EffectKey key,
                                           const char* outColor,
                                           const char* inColor,
                                           int stageIndex) {
     GrDrawEffect drawEffect(stage, false);
     const GrEffectRef& effect = *stage.getEffect();
     SkSTArray<2, TransformedCoords> coords(effect->numTransforms());
     SkSTArray<4, TextureSampler> samplers(effect->numTextures());
 
     SkASSERT(0 == stage.getVertexAttribIndexCount());
-    this->setupTexGen(builder, effect, key, &coords);
+    this->setupPathTexGen(builder, effect, key, &coords);
     this->emitSamplers(builder, effect, &samplers);
 
     GrGLEffect* glEffect = effect->getFactory().createGLInstance(drawEffect);
     fGLEffects.push_back(glEffect);
 
     // Enclose custom code in a block to avoid namespace conflicts
     SkString openBrace;
     openBrace.printf("\t{ // Stage %d: %s\n", stageIndex, glEffect->name());
     builder->fsCodeAppend(openBrace.c_str());
 
     SkASSERT(!glEffect->isVertexEffect());
     glEffect->emitCode(builder, drawEffect, key, outColor, inColor, coords, samplers);
 
     builder->fsCodeAppend("\t}\n");
 }
 
-void GrGLTexGenProgramEffects::setupTexGen(GrGLFragmentOnlyShaderBuilder* builder,
+void GrGLPathTexGenProgramEffects::setupPathTexGen(GrGLFragmentOnlyShaderBuilder* builder,
                                            const GrEffectRef& effect,
                                            EffectKey effectKey,
                                            TransformedCoordsArray* outCoords) {
     int numTransforms = effect->numTransforms();
     EffectKey totalKey = GrBackendEffectFactory::GetTransformKey(effectKey);
     int texCoordIndex = builder->addTexCoordSets(numTransforms);
     SkNEW_APPEND_TO_TARRAY(&fTransforms, Transforms, (totalKey, texCoordIndex));
     SkString name;
     for (int t = 0; t < numTransforms; ++t) {
         GrSLType type = kGeneral_MatrixType == get_matrix_type(totalKey, t) ?
                             kVec3f_GrSLType :
                             kVec2f_GrSLType;
         name.printf("%s(gl_TexCoord[%i])", GrGLSLTypeString(type), texCoordIndex++);
         SkNEW_APPEND_TO_TARRAY(outCoords, TransformedCoords, (name, type));
     }
 }
 
-void GrGLTexGenProgramEffects::setData(GrGpuGL* gpu,
+void GrGLPathTexGenProgramEffects::setData(GrGpuGL* gpu,
                                        const GrGLUniformManager& uniformManager,
                                        const GrEffectStage* effectStages[]) {
     int numEffects = fGLEffects.count();
     SkASSERT(numEffects == fTransforms.count());
     SkASSERT(numEffects == fSamplers.count());
     for (int e = 0; e < numEffects; ++e) {
         GrDrawEffect drawEffect(*effectStages[e], false);
         fGLEffects[e]->setData(uniformManager, drawEffect);
-        this->setTexGenState(gpu, drawEffect, e);
+        this->setPathTexGenState(gpu, drawEffect, e);
         this->bindTextures(gpu, *drawEffect.effect(), e);
     }
 }
 
-void GrGLTexGenProgramEffects::setTexGenState(GrGpuGL* gpu,
+void GrGLPathTexGenProgramEffects::setPathTexGenState(GrGpuGL* gpu,
                                               const GrDrawEffect& drawEffect,
                                               int effectIdx) {
     EffectKey totalKey = fTransforms[effectIdx].fTransformKey;
     int texCoordIndex = fTransforms[effectIdx].fTexCoordIndex;
     int numTransforms = (*drawEffect.effect())->numTransforms();
     for (int t = 0; t < numTransforms; ++t) {
         switch (get_matrix_type(totalKey, t)) {
             case kIdentity_MatrixType: {
                 SkASSERT(get_transform_matrix(drawEffect, t).isIdentity());
                 GrGLfloat identity[] = {1, 0, 0,
                                         0, 1, 0};
-                gpu->enableTexGen(texCoordIndex++, GrGpuGL::kST_TexGenComponents, identity);
+                gpu->enablePathTexGen(texCoordIndex++,
+                                      GrGpuGL::kST_PathTexGenComponents,
+                                      identity);
                 break;
             }
             case kTrans_MatrixType: {
                 GrGLfloat tx, ty;
                 get_transform_translation(drawEffect, t, &tx, &ty);
                 GrGLfloat translate[] = {1, 0, tx,
                                          0, 1, ty};
-                gpu->enableTexGen(texCoordIndex++, GrGpuGL::kST_TexGenComponents, translate);
+                gpu->enablePathTexGen(texCoordIndex++,
+                                      GrGpuGL::kST_PathTexGenComponents,
+                                      translate);
                 break;
             }
             case kNoPersp_MatrixType: {
                 const SkMatrix& transform = get_transform_matrix(drawEffect, t);
-                gpu->enableTexGen(texCoordIndex++, GrGpuGL::kST_TexGenComponents, transform);
+                gpu->enablePathTexGen(texCoordIndex++,
+                                      GrGpuGL::kST_PathTexGenComponents,
+                                      transform);
                 break;
             }
             case kGeneral_MatrixType: {
                 const SkMatrix& transform = get_transform_matrix(drawEffect, t);
-                gpu->enableTexGen(texCoordIndex++, GrGpuGL::kSTR_TexGenComponents, transform);
+                gpu->enablePathTexGen(texCoordIndex++,
+                                      GrGpuGL::kSTR_PathTexGenComponents,
+                                      transform);
                 break;
             }
             default:
                 GrCrash("Unexpected matrixs type.");
         }
     }
 }
 
-GrGLTexGenProgramEffectsBuilder::GrGLTexGenProgramEffectsBuilder(
+GrGLPathTexGenProgramEffectsBuilder::GrGLPathTexGenProgramEffectsBuilder(
         GrGLFragmentOnlyShaderBuilder* builder,
         int reserveCount)
     : fBuilder(builder)
-    , fProgramEffects(SkNEW_ARGS(GrGLTexGenProgramEffects, (reserveCount))) {
+    , fProgramEffects(SkNEW_ARGS(GrGLPathTexGenProgramEffects, (reserveCount))) {
 }
 
-void GrGLTexGenProgramEffectsBuilder::emitEffect(const GrEffectStage& stage,
-                                                 GrGLProgramEffects::EffectKey key,
-                                                 const char* outColor,
-                                                 const char* inColor,
-                                                 int stageIndex) {
+void GrGLPathTexGenProgramEffectsBuilder::emitEffect(const GrEffectStage& stage,
+                                                     GrGLProgramEffects::EffectKey key,
+                                                     const char* outColor,
+                                                     const char* inColor,
+                                                     int stageIndex) {
     SkASSERT(NULL != fProgramEffects.get());
     fProgramEffects->emitEffect(fBuilder, stage, key, outColor, inColor, stageIndex);
 }