Implement color filter as GrGLEffect

src/gpu/GrDrawState.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrDrawState.h"
 #include "GrPaint.h"
 
 bool GrDrawState::setIdentityViewMatrix()  {
     if (fColorStages.count() || fCoverageStages.count()) {
         SkMatrix invVM;
         if (!fCommon.fViewMatrix.invert(&invVM)) {
             // sad trombone sound
             return false;
         }
         for (int s = 0; s < fColorStages.count(); ++s) {
             fColorStages[s].localCoordChange(invVM);
         }
         for (int s = 0; s < fCoverageStages.count(); ++s) {
             fCoverageStages[s].localCoordChange(invVM);
         }
     }
     fCommon.fViewMatrix.reset();
     return true;
 }
 
 void GrDrawState::setFromPaint(const GrPaint& paint, const SkMatrix& vm, GrRenderTarget* rt) {
-    SkASSERT(0 == fBlockEffectRemovalCnt || 0 == this->numTotalStages());
+    SkASSERT(0 == fBlockEffectRemovalCnt || 0 == this->totalStageCount());
 
     fColorStages.reset();
     fCoverageStages.reset();
 
     for (int i = 0; i < paint.numColorStages(); ++i) {
-        fColorStages.push_back(paint.getColorStage(i));
+        fColorStages.appendStage(paint.getColorStage(i));
     }
 
     for (int i = 0; i < paint.numCoverageStages(); ++i) {
-        fCoverageStages.push_back(paint.getCoverageStage(i));
+        fCoverageStages.appendStage(paint.getCoverageStage(i));
     }
 
     this->setRenderTarget(rt);
 
     fCommon.fViewMatrix = vm;
 
     // These have no equivalent in GrPaint, set them to defaults
     fCommon.fBlendConstant = 0x0;
     fCommon.fDrawFace = kBoth_DrawFace;
     fCommon.fStencilSettings.setDisabled();
     this->resetStateFlags();
 
     // Enable the clip bit
     this->enableState(GrDrawState::kClip_StateBit);
 
     this->setColor(paint.getColor());
     this->setCoverage4(paint.getCoverage());
     this->setState(GrDrawState::kDither_StateBit, paint.isDither());
     this->setState(GrDrawState::kHWAntialias_StateBit, paint.isAntiAlias());
 
     this->setBlendFunc(paint.getSrcBlendCoeff(), paint.getDstBlendCoeff());
-    this->setColorFilter(paint.getColorFilterColor(), paint.getColorFilterMode());
     this->setCoverage(paint.getCoverage());
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 static size_t vertex_size(const GrVertexAttrib* attribs, int count) {
     // this works as long as we're 4 byte-aligned
 #ifdef SK_DEBUG
     uint32_t overlapCheck = 0;
 #endif
@@ skipping 139 matching lines @@
         validComponentFlags = kRGBA_GrColorComponentFlags;
         color = this->getColor();
     }
 
     // Run through the color stages
     for (int s = 0; s < fColorStages.count(); ++s) {
         const GrEffectRef* effect = fColorStages[s].getEffect();
         (*effect)->getConstantColorComponents(&color, &validComponentFlags);
     }
 
-    // Check if the color filter could introduce an alpha.
-    // We could skip the above work when this is true, but it is rare and the right fix is to make
-    // the color filter a GrEffect and implement getConstantColorComponents() for it.
-    if (SkXfermode::kDst_Mode != this->getColorFilterMode()) {
-        validComponentFlags = 0;
-    }
-
     // Check whether coverage is treated as color. If so we run through the coverage computation.
     if (this->isCoverageDrawing()) {
         GrColor coverageColor = this->getCoverage();
         GrColor oldColor = color;
         color = 0;
         for (int c = 0; c < 4; ++c) {
             if (validComponentFlags & (1 << c)) {
                 U8CPU a = (oldColor >> (c * 8)) & 0xff;
                 U8CPU b = (coverageColor >> (c * 8)) & 0xff;
                 color |= (SkMulDiv255Round(a, b) << (c * 8));
@@ skipping 156 matching lines @@
     }
     return kNone_BlendOpt;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 void GrDrawState::AutoViewMatrixRestore::restore() {
     if (NULL != fDrawState) {
         SkDEBUGCODE(--fDrawState->fBlockEffectRemovalCnt;)
         fDrawState->fCommon.fViewMatrix = fViewMatrix;
-        SkASSERT(fDrawState->numColorStages() >= fNumColorStages);
+        SkASSERT(fDrawState->fColorStages.count() >= fNumColorStages);
         int numCoverageStages = fSavedCoordChanges.count() - fNumColorStages;
-        SkASSERT(fDrawState->numCoverageStages() >= numCoverageStages);
+        SkASSERT(fDrawState->fCoverageStages.count() >= numCoverageStages);
 
         int i = 0;
         for (int s = 0; s < fNumColorStages; ++s, ++i) {
             fDrawState->fColorStages[s].restoreCoordChange(fSavedCoordChanges[i]);
         }
         for (int s = 0; s < numCoverageStages; ++s, ++i) {
             fDrawState->fCoverageStages[s].restoreCoordChange(fSavedCoordChanges[i]);
         }
         fDrawState = NULL;
     }
@@ skipping 21 matching lines @@
 
     if (NULL == drawState) {
         return false;
     }
 
     if (drawState->getViewMatrix().isIdentity()) {
         return true;
     }
 
     fViewMatrix = drawState->getViewMatrix();
-    if (0 == drawState->numTotalStages()) {
+    if (0 == drawState->totalStageCount()) {
         drawState->fCommon.fViewMatrix.reset();
         fDrawState = drawState;
         fNumColorStages = 0;
         fSavedCoordChanges.reset(0);
         SkDEBUGCODE(++fDrawState->fBlockEffectRemovalCnt;)
         return true;
     } else {
         SkMatrix inv;
         if (!fViewMatrix.invert(&inv)) {
             return false;
         }
         drawState->fCommon.fViewMatrix.reset();
         fDrawState = drawState;
         this->doEffectCoordChanges(inv);
         SkDEBUGCODE(++fDrawState->fBlockEffectRemovalCnt;)
         return true;
     }
 }
 
 void GrDrawState::AutoViewMatrixRestore::doEffectCoordChanges(const SkMatrix& coordChangeMatrix) {
-    fSavedCoordChanges.reset(fDrawState->numTotalStages());
+    fSavedCoordChanges.reset(fDrawState->totalStageCount());
     int i = 0;
 
-    fNumColorStages = fDrawState->numColorStages();
+    fNumColorStages = fDrawState->fColorStages.count();
     for (int s = 0; s < fNumColorStages; ++s, ++i) {
         fDrawState->fColorStages[s].saveCoordChange(&fSavedCoordChanges[i]);
         fDrawState->fColorStages[s].localCoordChange(coordChangeMatrix);
     }
 
-    int numCoverageStages = fDrawState->numCoverageStages();
+    int numCoverageStages = fDrawState->fCoverageStages.count();
     for (int s = 0; s < numCoverageStages; ++s, ++i) {
         fDrawState->fCoverageStages[s].saveCoordChange(&fSavedCoordChanges[i]);
         fDrawState->fCoverageStages[s].localCoordChange(coordChangeMatrix);
     }
 }