separate arrays for color and coverage effects.

src/gpu/gl/GrGLProgramDesc.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 "GrGLProgramDesc.h"
 #include "GrBackendEffectFactory.h"
 #include "GrDrawEffect.h"
 #include "GrEffect.h"
 #include "GrGLShaderBuilder.h"
 #include "GrGpuGL.h"
 
 #include "SkChecksum.h"
 
 void GrGLProgramDesc::Build(const GrDrawState& drawState,
                             bool isPoints,
                             GrDrawState::BlendOptFlags blendOpts,
                             GrBlendCoeff srcCoeff,
                             GrBlendCoeff dstCoeff,
                             const GrGpuGL* gpu,
                             const GrDeviceCoordTexture* dstCopy,
-                            const GrEffectStage* stages[],
+                            SkTArray<const GrEffectStage*, true>* colorStages,
+                            SkTArray<const GrEffectStage*, true>* coverageStages,
                             GrGLProgramDesc* desc) {
+    colorStages->reset();
+    coverageStages->reset();
+
     // This should already have been caught
     GrAssert(!(GrDrawState::kSkipDraw_BlendOptFlag & blendOpts));
 
     bool skipCoverage = SkToBool(blendOpts & GrDrawState::kEmitTransBlack_BlendOptFlag);
 
     bool skipColor = SkToBool(blendOpts & (GrDrawState::kEmitTransBlack_BlendOptFlag |
                                            GrDrawState::kEmitCoverage_BlendOptFlag));
 
     // The descriptor is used as a cache key. Thus when a field of the
     // descriptor will not affect program generation (because of the attribute
     // bindings in use or other descriptor field settings) it should be set
     // to a canonical value to avoid duplicate programs with different keys.
 
     bool requiresColorAttrib = !skipColor && drawState.hasColorVertexAttribute();
     bool requiresCoverageAttrib = !skipCoverage && drawState.hasCoverageVertexAttribute();
     // we only need the local coords if we're actually going to generate effect code
     bool requiresLocalCoordAttrib = !(skipCoverage  && skipColor) &&
                                     drawState.hasLocalCoordAttribute();
 
     bool colorIsTransBlack = SkToBool(blendOpts & GrDrawState::kEmitTransBlack_BlendOptFlag);
     bool colorIsSolidWhite = (blendOpts & GrDrawState::kEmitCoverage_BlendOptFlag) ||
                              (!requiresColorAttrib && 0xffffffff == drawState.getColor());
 
     // Do an initial loop over the stages to count them. We count the color and coverage effects
     // separately here. Later we may decide the distinction doesn't matter and will count all
     // effects as color in desc. Two things will allow simplication of this mess: GrDrawState will
     // have tight lists of color and coverage stages rather than a fixed size array with NULLS and
     // the xfermode-color filter will be removed.
-    int colorEffectCnt = 0;
-    int coverageEffectCnt = 0;
     if (!skipColor) {
         for (int s = 0; s < drawState.getFirstCoverageStage(); ++s) {
             if (drawState.isStageEnabled(s)) {
-                stages[colorEffectCnt] = &drawState.getStage(s);
-                ++colorEffectCnt;
+                colorStages->push_back(&drawState.getStage(s));
             }
         }
     }
     if (!skipCoverage) {
         for (int s = drawState.getFirstCoverageStage(); s < GrDrawState::kNumStages; ++s) {
             if (drawState.isStageEnabled(s)) {
-                stages[colorEffectCnt + coverageEffectCnt] = &drawState.getStage(s);
-                ++coverageEffectCnt;
+                coverageStages->push_back(&drawState.getStage(s));
             }
         }
     }
 
-    size_t newKeyLength = KeyLength(colorEffectCnt + coverageEffectCnt);
+    size_t newKeyLength = KeyLength(colorStages->count() + coverageStages->count());
     bool allocChanged;
     desc->fKey.reset(newKeyLength, SkAutoMalloc::kAlloc_OnShrink, &allocChanged);
     if (allocChanged || !desc->fInitialized) {
         // make sure any padding in the header is zero if we we haven't used this allocation before.
         memset(desc->header(), 0, kHeaderSize);
     }
     // write the key length
     *desc->atOffset<uint32_t, kLengthOffset>() = newKeyLength;
 
     KeyHeader* header = desc->header();
@@ skipping 98 matching lines @@
     }
 
     // Here we deal with whether/how we handle color and coverage separately.
 
     // Set these defaults and then possibly change our mind if there is coverage.
     header->fDiscardIfZeroCoverage = false;
     header->fCoverageOutput = kModulate_CoverageOutput;
 
     // If we do have coverage determine whether it matters.
     bool separateCoverageFromColor = false;
-    if (!drawState.isCoverageDrawing() && (coverageEffectCnt > 0 || requiresCoverageAttrib)) {
+    if (!drawState.isCoverageDrawing() && (coverageStages->count() > 0 || requiresCoverageAttrib)) {
         // color filter is applied between color/coverage computation
         if (SkXfermode::kDst_Mode != header->fColorFilterXfermode) {
             separateCoverageFromColor = true;
         }
 
         // If we're stenciling then we want to discard samples that have zero coverage
         if (drawState.getStencil().doesWrite()) {
             header->fDiscardIfZeroCoverage = true;
             separateCoverageFromColor = true;
         }
@@ skipping 15 matching lines @@
                 separateCoverageFromColor = true;
             }
         } else if (readsDst &&
                    kOne_GrBlendCoeff == srcCoeff &&
                    kZero_GrBlendCoeff == dstCoeff) {
             header->fCoverageOutput = kCombineWithDst_CoverageOutput;
             separateCoverageFromColor = true;
         }
     }
     if (separateCoverageFromColor) {
-        header->fColorEffectCnt = colorEffectCnt;
-        header->fCoverageEffectCnt = coverageEffectCnt;
+        header->fColorEffectCnt = colorStages->count();
+        header->fCoverageEffectCnt = coverageStages->count();
     } else {
-        header->fColorEffectCnt = colorEffectCnt + coverageEffectCnt;
+        header->fColorEffectCnt = colorStages->count() + coverageStages->count();
         header->fCoverageEffectCnt = 0;
+        colorStages->push_back_n(coverageStages->count(), coverageStages->begin());
+        coverageStages->reset();
     }
 
     *desc->checksum() = 0;
     *desc->checksum() = SkChecksum::Compute(reinterpret_cast<uint32_t*>(desc->fKey.get()),
                                             newKeyLength);
     desc->fInitialized = true;
 }
 
 GrGLProgramDesc& GrGLProgramDesc::operator= (const GrGLProgramDesc& other) {
     fInitialized = other.fInitialized;
     if (fInitialized) {
         size_t keyLength = other.keyLength();
         fKey.reset(keyLength);
         memcpy(fKey.get(), other.fKey.get(), keyLength);
     }
     return *this;
 }