Make GrGLProgram no longer depend on kNumStages

src/gpu/gl/GrGLProgram.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrGLProgram.h"
 
 #include "GrAllocator.h"
@@ skipping 40 matching lines @@
                          const GrGLProgramDesc& desc,
                          const GrEffectStage* stages[])
 : fContext(gl)
 , fUniformManager(gl) {
     fDesc = desc;
     fVShaderID = 0;
     fGShaderID = 0;
     fFShaderID = 0;
     fProgramID = 0;
 
+    fDstCopyTexUnit = -1;
+
     fColor = GrColor_ILLEGAL;
     fColorFilterColor = GrColor_ILLEGAL;
 
-    for (int s = 0; s < GrDrawState::kNumStages; ++s) {
-        fEffects[s] = NULL;
-    }
+    fEffectStates.reset(desc.numTotalEffects());
 
     this->genProgram(stages);
 }
 
 GrGLProgram::~GrGLProgram() {
     if (fVShaderID) {
         GL_CALL(DeleteShader(fVShaderID));
     }
     if (fGShaderID) {
         GL_CALL(DeleteShader(fGShaderID));
     }
     if (fFShaderID) {
         GL_CALL(DeleteShader(fFShaderID));
     }
     if (fProgramID) {
         GL_CALL(DeleteProgram(fProgramID));
     }
-
-    for (int i = 0; i < GrDrawState::kNumStages; ++i) {
-        delete fEffects[i];
-    }
 }
 
 void GrGLProgram::abandon() {
     fVShaderID = 0;
     fGShaderID = 0;
     fFShaderID = 0;
     fProgramID = 0;
 }
 
 void GrGLProgram::overrideBlend(GrBlendCoeff* srcCoeff,
@@ skipping 383 matching lines @@
     SkXfermode::Coeff colorCoeff;
     SkXfermode::Coeff filterColorCoeff;
     SkAssertResult(
         SkXfermode::ModeAsCoeff(static_cast<SkXfermode::Mode>(header.fColorFilterXfermode),
                                 &filterColorCoeff,
                                 &colorCoeff));
     bool needColor, needFilterColor;
     need_blend_inputs(filterColorCoeff, colorCoeff, &needFilterColor, &needColor);
 
     // used in order for builder to return the per-stage uniform handles.
-    SkTArray<GrGLUniformManager::UniformHandle, true>* stageUniformArrays[GrDrawState::kNumStages];
+    typedef SkTArray<GrGLUniformManager::UniformHandle, true>* UniHandleArrayPtr;
+    int maxColorOrCovEffectCnt = GrMax(fDesc.numColorEffects(), fDesc.numCoverageEffects());
+    SkAutoTArray<UniHandleArrayPtr> effectUniformArrays(maxColorOrCovEffectCnt);
+    SkAutoTArray<GrGLEffect*> glEffects(maxColorOrCovEffectCnt);
 
     if (needColor) {
-        for (int s = 0; s < fDesc.numColorEffects(); ++s) {
-            stageUniformArrays[s] = &fUniformHandles.fEffectSamplerUnis[s];
+        for (int e = 0; e < fDesc.numColorEffects(); ++e) {
+            effectUniformArrays[e] = &fEffectStates[e].fSamplerUnis;
         }
 
         builder.emitEffects(stages,
                             fDesc.effectKeys(),
                             fDesc.numColorEffects(),
                             &inColor,
                             &knownColorValue,
-                            stageUniformArrays,
-                            fEffects);
+                            effectUniformArrays.get(),
+                            glEffects.get());
+
+        for (int e = 0; e < fDesc.numColorEffects(); ++e) {
+            fEffectStates[e].fGLEffect = glEffects[e];
+        }
     }
 
     // Insert the color filter. This will soon be replaced by a color effect.
     if (SkXfermode::kDst_Mode != header.fColorFilterXfermode) {
         const char* colorFilterColorUniName = NULL;
         fUniformHandles.fColorFilterUni = builder.addUniform(GrGLShaderBuilder::kFragment_ShaderType,
                                                              kVec4f_GrSLType, "FilterColor",
                                                              &colorFilterColorUniName);
 
         builder.fsCodeAppend("\tvec4 filteredColor;\n");
         const char* color;
         // add_color_filter requires a real input string.
         if (knownColorValue == kOnes_GrSLConstantVec) {
             color = GrGLSLOnesVecf(4);
         } else if (knownColorValue == kZeros_GrSLConstantVec) {
             color = GrGLSLZerosVecf(4);
         } else {
             color = inColor.c_str();
         }
         add_color_filter(&builder, "filteredColor", filterColorCoeff,
                          colorCoeff, colorFilterColorUniName, color);
         inColor = "filteredColor";
     }
 
     ///////////////////////////////////////////////////////////////////////////
     // compute the partial coverage
     SkString inCoverage;
     GrSLConstantVec knownCoverageValue = this->genInputCoverage(&builder, &inCoverage);
 
-    for (int s = 0; s < fDesc.numCoverageEffects(); ++s) {
-        stageUniformArrays[s] = &fUniformHandles.fEffectSamplerUnis[s + fDesc.numColorEffects()];
+    for (int e = 0; e < fDesc.numCoverageEffects(); ++e) {
+        effectUniformArrays[e] = &fEffectStates[e + fDesc.numColorEffects()].fSamplerUnis;
     }
 
     builder.emitEffects(stages + fDesc.numColorEffects(),
                         fDesc.getEffectKeys() + fDesc.numColorEffects(),
                         fDesc.numCoverageEffects(),
                         &inCoverage,
                         &knownCoverageValue,
-                        stageUniformArrays,
-                        fEffects + fDesc.numColorEffects());
+                        effectUniformArrays.get(),
+                        glEffects.get());
+    for (int e = 0; e < fDesc.numCoverageEffects(); ++e) {
+        fEffectStates[e + fDesc.numColorEffects()].fGLEffect = glEffects[e];
+    }
 
     // discard if coverage is zero
     if (header.fDiscardIfZeroCoverage && kOnes_GrSLConstantVec != knownCoverageValue) {
         if (kZeros_GrSLConstantVec == knownCoverageValue) {
             // This is unfortunate.
             builder.fsCodeAppend("\tdiscard;\n");
         } else {
             builder.fsCodeAppendf("\tif (all(lessThanEqual(%s, vec4(0.0)))) {\n\t\tdiscard;\n\t}\n",
                                   inCoverage.c_str());
         }
@@ skipping 180 matching lines @@
         GrAssert(!"Error linking program");
         GL_CALL(DeleteProgram(fProgramID));
         fProgramID = 0;
         return false;
     }
     return true;
 }
 
 void GrGLProgram::initSamplerUniforms() {
     GL_CALL(UseProgram(fProgramID));
-    // We simply bind the uniforms to successive texture units beginning at 0. setData() assumes
-    // this behavior.
     GrGLint texUnitIdx = 0;
     if (GrGLUniformManager::kInvalidUniformHandle != fUniformHandles.fDstCopySamplerUni) {
         fUniformManager.setSampler(fUniformHandles.fDstCopySamplerUni, texUnitIdx);
-        ++texUnitIdx;
+        fDstCopyTexUnit = texUnitIdx++;
     }
 
-    for (int s = 0; s < GrDrawState::kNumStages; ++s) {
-        int numSamplers = fUniformHandles.fEffectSamplerUnis[s].count();
-        for (int u = 0; u < numSamplers; ++u) {
-            UniformHandle handle = fUniformHandles.fEffectSamplerUnis[s][u];
+    for (int e = 0; e < fEffectStates.count(); ++e) {
+        int numSamplers = fEffectStates[e].fSamplerUnis.count();
+        fEffectStates[e].fTextureUnits.reset(numSamplers);
+        for (int s = 0; s < numSamplers; ++s) {
+            UniformHandle handle = fEffectStates[e].fSamplerUnis[s];
             if (GrGLUniformManager::kInvalidUniformHandle != handle) {
                 fUniformManager.setSampler(handle, texUnitIdx);
-                ++texUnitIdx;
+                fEffectStates[e].fTextureUnits[s] = texUnitIdx++;
             }
         }
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void GrGLProgram::setData(GrGpuGL* gpu,
                           GrDrawState::BlendOptFlags blendOpts,
                           const GrEffectStage* stages[],
@@ skipping 20 matching lines @@
 
     // Setup the SkXfermode::Mode-based colorfilter uniform if necessary
     if (GrGLUniformManager::kInvalidUniformHandle != fUniformHandles.fColorFilterUni &&
         fColorFilterColor != drawState.getColorFilterColor()) {
         GrGLfloat c[4];
         GrColorToRGBAFloat(drawState.getColorFilterColor(), c);
         fUniformManager.set4fv(fUniformHandles.fColorFilterUni, 0, 1, c);
         fColorFilterColor = drawState.getColorFilterColor();
     }
 
-    GrGLint texUnitIdx = 0;
     if (NULL != dstCopy) {
         if (GrGLUniformManager::kInvalidUniformHandle != fUniformHandles.fDstCopyTopLeftUni) {
             GrAssert(GrGLUniformManager::kInvalidUniformHandle != fUniformHandles.fDstCopyScaleUni);
             GrAssert(GrGLUniformManager::kInvalidUniformHandle !=
                      fUniformHandles.fDstCopySamplerUni);
             fUniformManager.set2f(fUniformHandles.fDstCopyTopLeftUni,
                                   static_cast<GrGLfloat>(dstCopy->offset().fX),
                                   static_cast<GrGLfloat>(dstCopy->offset().fY));
             fUniformManager.set2f(fUniformHandles.fDstCopyScaleUni,
                                   1.f / dstCopy->texture()->width(),
                                   1.f / dstCopy->texture()->height());
             GrGLTexture* texture = static_cast<GrGLTexture*>(dstCopy->texture());
             static GrTextureParams kParams; // the default is clamp, nearest filtering.
-            gpu->bindTexture(texUnitIdx, kParams, texture);
-            ++texUnitIdx;
+            gpu->bindTexture(fDstCopyTexUnit, kParams, texture);
         } else {
             GrAssert(GrGLUniformManager::kInvalidUniformHandle ==
                     fUniformHandles.fDstCopyScaleUni);
             GrAssert(GrGLUniformManager::kInvalidUniformHandle ==
                     fUniformHandles.fDstCopySamplerUni);
         }
     } else {
         GrAssert(GrGLUniformManager::kInvalidUniformHandle == fUniformHandles.fDstCopyTopLeftUni);
         GrAssert(GrGLUniformManager::kInvalidUniformHandle == fUniformHandles.fDstCopyScaleUni);
         GrAssert(GrGLUniformManager::kInvalidUniformHandle == fUniformHandles.fDstCopySamplerUni);
     }
 
     int numEffects = fDesc.numTotalEffects();
     for (int e = 0; e < numEffects; ++e) {
         GrAssert(NULL != stages[e]);
         // We may have omitted the GrGLEffect because of the color filter logic in genProgram.
         // This can be removed when the color filter is an effect.
-        if (NULL != fEffects[e]) {
+        if (NULL != fEffectStates[e].fGLEffect) {
             bool explicitLocalCoords = -1 != fDesc.getHeader().fLocalCoordAttributeIndex;
             GrDrawEffect drawEffect(*stages[e], explicitLocalCoords);
-            fEffects[e]->setData(fUniformManager, drawEffect);
-            int numSamplers = fUniformHandles.fEffectSamplerUnis[e].count();
-            for (int u = 0; u < numSamplers; ++u) {
-                UniformHandle handle = fUniformHandles.fEffectSamplerUnis[e][u];
+            fEffectStates[e].fGLEffect->setData(fUniformManager, drawEffect);
+            int numSamplers = fEffectStates[e].fSamplerUnis.count();
+            GrAssert((*stages[e]->getEffect())->numTextures() == numSamplers);
+            for (int s = 0; s < numSamplers; ++s) {
+                UniformHandle handle = fEffectStates[e].fSamplerUnis[s];
                 if (GrGLUniformManager::kInvalidUniformHandle != handle) {
-                    const GrTextureAccess& access = (*stages[e]->getEffect())->textureAccess(u);
+                    const GrTextureAccess& access = (*stages[e]->getEffect())->textureAccess(s);
                     GrGLTexture* texture = static_cast<GrGLTexture*>(access.getTexture());
-                    gpu->bindTexture(texUnitIdx, access.getParams(), texture);
-                    ++texUnitIdx;
+                    int unit = fEffectStates[e].fTextureUnits[s];
+                    gpu->bindTexture(unit, access.getParams(), texture);
                 }
             }
         }
     }
 }
 
 void GrGLProgram::setColor(const GrDrawState& drawState,
                            GrColor color,
                            SharedGLState* sharedState) {
     const GrGLProgramDesc::KeyHeader& header = fDesc.getHeader();
@@ skipping 115 matching lines @@
             SkScalarToFloat(m[SkMatrix::kMTransX]),
             SkScalarToFloat(m[SkMatrix::kMTransY]),
             SkScalarToFloat(m[SkMatrix::kMPersp2])
         };
         fUniformManager.setMatrix3f(fUniformHandles.fViewMatrixUni, mt);
         fMatrixState.fViewMatrix = drawState.getViewMatrix();
         fMatrixState.fRenderTargetSize = size;
         fMatrixState.fRenderTargetOrigin = rt->origin();
     }
 }