Move VertexBuilder to a GrGLFullShaderBuilder subclass

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"
 #include "gl/GrGLShaderBuilder.h"
+#include "gl/GrGLVertexEffect.h"
 #include "gl/GrGpuGL.h"
 
 typedef GrGLProgramEffects::EffectKey EffectKey;
 typedef GrGLProgramEffects::TransformedCoords TransformedCoords;
 typedef GrGLProgramEffects::TransformedCoordsArray TransformedCoordsArray;
 typedef GrGLProgramEffects::TextureSampler TextureSampler;
 typedef GrGLProgramEffects::TextureSamplerArray TextureSamplerArray;
 
 /**
  * We specialize the vertex code for each of these matrix types.
@@ skipping 128 matching lines @@
         SkTArray<Sampler, true>& samplers = fSamplers[e];
         int numSamplers = samplers.count();
         for (int s = 0; s < numSamplers; ++s) {
             SkASSERT(samplers[s].fUniform.isValid());
             uniformManager.setSampler(samplers[s].fUniform, *texUnitIdx);
             samplers[s].fTextureUnit = (*texUnitIdx)++;
         }
     }
 }
 
-void GrGLProgramEffects::setData(GrGpuGL* gpu,
-                                 const GrGLUniformManager& uniformManager,
-                                 const GrEffectStage* effectStages[]) {
+void GrGLVertexProgramEffects::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], fHasExplicitLocalCoords);
         fGLEffects[e]->setData(uniformManager, drawEffect);
         this->setTransformData(uniformManager, drawEffect, e);
         this->bindTextures(gpu, *drawEffect.effect(), e);
     }
 }
 
-void GrGLProgramEffects::setTransformData(const GrGLUniformManager& uniformManager,
-                                          const GrDrawEffect& drawEffect,
-                                          int effectIdx) {
+void GrGLVertexProgramEffects::setTransformData(const GrGLUniformManager& uniformManager,
+                                                const GrDrawEffect& drawEffect,
+                                                int effectIdx) {
     SkTArray<Transform, true>& transforms = fTransforms[effectIdx];
     int numTransforms = transforms.count();
     SkASSERT(numTransforms == (*drawEffect.effect())->numTransforms());
     for (int t = 0; t < numTransforms; ++t) {
         const GrCoordTransform& coordTransform = (*drawEffect.effect())->coordTransform(t);
         const SkMatrix& matrix = coordTransform.getMatrix();
         const SkMatrix& coordChangeMatrix = kLocal_GrCoordSet == coordTransform.sourceCoords() ?
                                                 drawEffect.getCoordChangeMatrix() :
                                                 SkMatrix::I();
         SkASSERT(transforms[t].fHandle.isValid() != (kVoid_GrSLType == transforms[t].fType));
@@ skipping 49 matching lines @@
         SkASSERT(samplers[s].fTextureUnit >= 0);
         const GrTextureAccess& textureAccess = effect->textureAccess(s);
         gpu->bindTexture(samplers[s].fTextureUnit,
                          textureAccess.getParams(),
                          static_cast<GrGLTexture*>(textureAccess.getTexture()));
     }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
-GrGLProgramEffectsBuilder::GrGLProgramEffectsBuilder(GrGLShaderBuilder* builder, int reserveCount)
-    : fBuilder(builder) {
-    GrGLShaderBuilder::VertexBuilder* vertexBuilder = fBuilder->getVertexBuilder();
-    SkASSERT(NULL != vertexBuilder);
-    fProgramEffects.reset(SkNEW_ARGS(GrGLProgramEffects,
-                                     (reserveCount, vertexBuilder->hasExplicitLocalCoords())));
+GrGLVertexProgramEffectsBuilder::GrGLVertexProgramEffectsBuilder(GrGLFullShaderBuilder* builder,
+                                                                 int reserveCount)
+    : fBuilder(builder)
+    , fProgramEffects(SkNEW_ARGS(GrGLVertexProgramEffects,
+                                 (reserveCount, fBuilder->hasExplicitLocalCoords()))) {
 }
 
-void GrGLProgramEffectsBuilder::emitEffect(const GrEffectStage& stage,
-                                           EffectKey key,
-                                           const char* outColor,
-                                           const char* inColor,
-                                           int stageIndex) {
-    GrGLShaderBuilder::VertexBuilder* vertexBuilder = fBuilder->getVertexBuilder();
-    SkASSERT(NULL != vertexBuilder);
+void GrGLVertexProgramEffectsBuilder::emitEffect(const GrEffectStage& stage,
+                                                 EffectKey key,
+                                                 const char* outColor,
+                                                 const char* inColor,
+                                                 int stageIndex) {
     SkASSERT(NULL != fProgramEffects.get());
 
     GrDrawEffect drawEffect(stage, fProgramEffects->fHasExplicitLocalCoords);
     const GrEffectRef& effect = *stage.getEffect();
     SkSTArray<2, TransformedCoords> coords(effect->numTransforms());
     SkSTArray<4, TextureSampler> samplers(effect->numTextures());
 
     this->emitAttributes(stage);
     this->emitTransforms(effect, key, &coords);
-    this->emitSamplers(effect, &samplers);
+    INHERITED::emitSamplers(fBuilder, fProgramEffects.get(), effect, &samplers);
 
     GrGLEffect* glEffect = effect->getFactory().createGLInstance(drawEffect);
     fProgramEffects->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());
-    vertexBuilder->vsCodeAppend(openBrace.c_str());
+    fBuilder->vsCodeAppend(openBrace.c_str());
     fBuilder->fsCodeAppend(openBrace.c_str());
 
-    glEffect->emitCode(fBuilder, drawEffect, key, outColor, inColor, coords, samplers);
+    if (glEffect->isVertexEffect()) {
+        GrGLVertexEffect* vertexEffect = static_cast<GrGLVertexEffect*>(glEffect);
+        vertexEffect->emitCode(fBuilder, drawEffect, key, outColor, inColor, coords, samplers);
+    } else {
+        glEffect->emitCode(fBuilder, drawEffect, key, outColor, inColor, coords, samplers);
+    }
 
-    vertexBuilder->vsCodeAppend("\t}\n");
+    fBuilder->vsCodeAppend("\t}\n");
     fBuilder->fsCodeAppend("\t}\n");
 }
 
-void GrGLProgramEffectsBuilder::emitAttributes(const GrEffectStage& stage) {
-    GrGLShaderBuilder::VertexBuilder* vertexBuilder = fBuilder->getVertexBuilder();
-    SkASSERT(NULL != vertexBuilder);
-
+void GrGLVertexProgramEffectsBuilder::emitAttributes(const GrEffectStage& stage) {
     int numAttributes = stage.getVertexAttribIndexCount();
     const int* attributeIndices = stage.getVertexAttribIndices();
     for (int a = 0; a < numAttributes; ++a) {
         // TODO: Make addAttribute mangle the name.
         SkString attributeName("aAttr");
         attributeName.appendS32(attributeIndices[a]);
-        vertexBuilder->addEffectAttribute(attributeIndices[a],
-                                          (*stage.getEffect())->vertexAttribType(a),
-                                          attributeName);
+        fBuilder->addEffectAttribute(attributeIndices[a],
+                                     (*stage.getEffect())->vertexAttribType(a),
+                                     attributeName);
     }
 }
 
-void GrGLProgramEffectsBuilder::emitTransforms(const GrEffectRef& effect,
-                                               EffectKey effectKey,
-                                               TransformedCoordsArray* outCoords) {
-    GrGLShaderBuilder::VertexBuilder* vertexBuilder = fBuilder->getVertexBuilder();
-    SkASSERT(NULL != vertexBuilder);
-
-    typedef GrGLProgramEffects::Transform Transform;
+void GrGLVertexProgramEffectsBuilder::emitTransforms(const GrEffectRef& effect,
+                                                     EffectKey effectKey,
+                                                     TransformedCoordsArray* outCoords) {
+    typedef GrGLVertexProgramEffects::Transform Transform;
     SkTArray<Transform, true>& transforms = fProgramEffects->fTransforms.push_back();
     EffectKey totalKey = GrBackendEffectFactory::GetTransformKey(effectKey);
     int numTransforms = effect->numTransforms();
     transforms.push_back_n(numTransforms);
     for (int t = 0; t < numTransforms; t++) {
         EffectKey key = (totalKey >> (kTransformKeyBits * t)) & kTransformKeyMask;
         GrSLType varyingType = kVoid_GrSLType;
         const char* uniName;
         switch (key & kMatrixTypeKeyMask) {
             case kIdentity_MatrixType:
@@ skipping 34 matching lines @@
 
         const char* varyingName = "MatrixCoord";
         SkString suffixedVaryingName;
         if (0 != t) {
             suffixedVaryingName.append(varyingName);
             suffixedVaryingName.appendf("_%i", t);
             varyingName = suffixedVaryingName.c_str();
         }
         const char* vsVaryingName;
         const char* fsVaryingName;
-        vertexBuilder->addVarying(varyingType, varyingName, &vsVaryingName, &fsVaryingName);
+        fBuilder->addVarying(varyingType, varyingName, &vsVaryingName, &fsVaryingName);
 
         const GrGLShaderVar& coords = (kPositionCoords_Flag & key) ?
-                                          vertexBuilder->positionAttribute() :
-                                          vertexBuilder->localCoordsAttribute();
+                                          fBuilder->positionAttribute() :
+                                          fBuilder->localCoordsAttribute();
         // varying = matrix * coords (logically)
         switch (transforms[t].fType) {
             case kVoid_GrSLType:
                 SkASSERT(kVec2f_GrSLType == varyingType);
-                vertexBuilder->vsCodeAppendf("\t%s = %s;\n", vsVaryingName, coords.c_str());
+                fBuilder->vsCodeAppendf("\t%s = %s;\n", vsVaryingName, coords.c_str());
                 break;
             case kVec2f_GrSLType:
                 SkASSERT(kVec2f_GrSLType == varyingType);
-                vertexBuilder->vsCodeAppendf("\t%s = %s + %s;\n",
-                                             vsVaryingName, uniName, coords.c_str());
+                fBuilder->vsCodeAppendf("\t%s = %s + %s;\n",
+                                        vsVaryingName, uniName, coords.c_str());
                 break;
             case kMat33f_GrSLType: {
                 SkASSERT(kVec2f_GrSLType == varyingType || kVec3f_GrSLType == varyingType);
                 if (kVec2f_GrSLType == varyingType) {
-                    vertexBuilder->vsCodeAppendf("\t%s = (%s * vec3(%s, 1)).xy;\n",
-                                                 vsVaryingName, uniName, coords.c_str());
+                    fBuilder->vsCodeAppendf("\t%s = (%s * vec3(%s, 1)).xy;\n",
+                                            vsVaryingName, uniName, coords.c_str());
                 } else {
-                    vertexBuilder->vsCodeAppendf("\t%s = %s * vec3(%s, 1);\n",
-                                                 vsVaryingName, uniName, coords.c_str());
+                    fBuilder->vsCodeAppendf("\t%s = %s * vec3(%s, 1);\n",
+                                            vsVaryingName, uniName, coords.c_str());
                 }
                 break;
             }
             default:
                 GrCrash("Unexpected uniform type.");
         }
         SkNEW_APPEND_TO_TARRAY(outCoords, TransformedCoords, (fsVaryingName, varyingType));
     }
 }
 
-void GrGLProgramEffectsBuilder::emitSamplers(const GrEffectRef& effect,
+void GrGLProgramEffectsBuilder::emitSamplers(GrGLShaderBuilder* builder,
+                                             GrGLProgramEffects* programEffects,
+                                             const GrEffectRef& effect,
                                              TextureSamplerArray* outSamplers) {
     typedef GrGLProgramEffects::Sampler Sampler;
-    SkTArray<Sampler, true>& samplers = fProgramEffects->fSamplers.push_back();
+    SkTArray<Sampler, true>& samplers = programEffects->fSamplers.push_back();
     int numTextures = effect->numTextures();
     samplers.push_back_n(numTextures);
     SkString name;
     for (int t = 0; t < numTextures; ++t) {
         name.printf("Sampler%d", t);
-        samplers[t].fUniform = fBuilder->addUniform(GrGLShaderBuilder::kFragment_Visibility,
-                                                    kSampler2D_GrSLType,
-                                                    name.c_str());
+        samplers[t].fUniform = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility,
+                                                   kSampler2D_GrSLType,
+                                                   name.c_str());
         SkNEW_APPEND_TO_TARRAY(outSamplers, TextureSampler,
                                (samplers[t].fUniform, effect->textureAccess(t)));
     }
 }