Implement color filter as GrGLEffect

src/gpu/GrDrawState.h

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrDrawState_DEFINED
 #define GrDrawState_DEFINED
 
@@ skipping 248 matching lines @@
      *  Sets the color to be used for the next draw to be
      *  (r,g,b,a) = (alpha, alpha, alpha, alpha).
      *
      *  @param alpha The alpha value to set as the color.
      */
     void setAlpha(uint8_t a) {
         this->setColor((a << 24) | (a << 16) | (a << 8) | a);
     }
 
     /**
-     * Add a color filter that can be represented by a color and a mode. Applied
-     * after color-computing effect stages.
-     */
-    void setColorFilter(GrColor c, SkXfermode::Mode mode) {
-        fCommon.fColorFilterColor = c;
-        fCommon.fColorFilterMode = mode;
-    }
-
-    GrColor getColorFilterColor() const { return fCommon.fColorFilterColor; }
-    SkXfermode::Mode getColorFilterMode() const { return fCommon.fColorFilterMode; }
-
-    /**
      * Constructor sets the color to be 'color' which is undone by the destructor.
      */
     class AutoColorRestore : public ::SkNoncopyable {
     public:
         AutoColorRestore() : fDrawState(NULL), fOldColor(0) {}
 
         AutoColorRestore(GrDrawState* drawState, GrColor color) {
             fDrawState = NULL;
             this->set(drawState, color);
         }
@@ skipping 62 matching lines @@
     /// The input color to the first color-stage is either the constant color or interpolated
     /// per-vertex colors. The input to the first coverage stage is either a constant coverage
     /// (usually full-coverage) or interpolated per-vertex coverage.
     ///
     /// See the documentation of kCoverageDrawing_StateBit for information about disabling the
     /// the color / coverage distinction.
     ////
 
     const GrEffectRef* addColorEffect(const GrEffectRef* effect, int attr0 = -1, int attr1 = -1) {
         SkASSERT(NULL != effect);
-        SkNEW_APPEND_TO_TARRAY(&fColorStages, GrEffectStage, (effect, attr0, attr1));
+        fColorStages.appendStage(effect, attr0, attr1);
         return effect;
     }
 
     const GrEffectRef* addCoverageEffect(const GrEffectRef* effect, int attr0 = -1, int attr1 = -1) {
         SkASSERT(NULL != effect);
-        SkNEW_APPEND_TO_TARRAY(&fCoverageStages, GrEffectStage, (effect, attr0, attr1));
+        fCoverageStages.appendStage(effect, attr0, attr1);
         return effect;
     }
 
     /**
      * Creates a GrSimpleTextureEffect that uses local coords as texture coordinates.
      */
     void addColorTextureEffect(GrTexture* texture, const SkMatrix& matrix) {
         GrEffectRef* effect = GrSimpleTextureEffect::Create(texture, matrix);
         this->addColorEffect(effect)->unref();
     }
@@ skipping 16 matching lines @@
         GrEffectRef* effect = GrSimpleTextureEffect::Create(texture, matrix, params);
         this->addCoverageEffect(effect)->unref();
     }
 
     /**
      * When this object is destroyed it will remove any effects from the draw state that were added
      * after its constructor.
      */
     class AutoRestoreEffects : public ::SkNoncopyable {
     public:
-        AutoRestoreEffects() : fDrawState(NULL), fColorEffectCnt(0), fCoverageEffectCnt(0) {}
+        AutoRestoreEffects()
+            : fDrawState(NULL),
+              fFirstEffectiveColorEffect(0),
+              fColorEffectCnt(0),
+              fFirstEffectiveCoverageEffect(0),
+              fCoverageEffectCnt(0) {
+        }
 
-        AutoRestoreEffects(GrDrawState* ds) : fDrawState(NULL), fColorEffectCnt(0), fCoverageEffectCnt(0) {
+        AutoRestoreEffects(GrDrawState* ds)
+            : fDrawState(NULL),
+              fFirstEffectiveColorEffect(0),
+              fColorEffectCnt(0),
+              fFirstEffectiveCoverageEffect(0),
+              fCoverageEffectCnt(0) {
             this->set(ds);
         }
 
         ~AutoRestoreEffects() { this->set(NULL); }
 
         void set(GrDrawState* ds) {
             if (NULL != fDrawState) {
                 int n = fDrawState->fColorStages.count() - fColorEffectCnt;
                 SkASSERT(n >= 0);
-                fDrawState->fColorStages.pop_back_n(n);
+                fDrawState->fColorStages.removeLastStages(n, fFirstEffectiveColorEffect);
                 n = fDrawState->fCoverageStages.count() - fCoverageEffectCnt;
                 SkASSERT(n >= 0);
-                fDrawState->fCoverageStages.pop_back_n(n);
+                fDrawState->fCoverageStages.removeLastStages(n, fFirstEffectiveCoverageEffect);
                 SkDEBUGCODE(--fDrawState->fBlockEffectRemovalCnt;)
             }
             fDrawState = ds;
             if (NULL != ds) {
+                fFirstEffectiveColorEffect = ds->fColorStages.getFirstEffectiveStageIndex();
                 fColorEffectCnt = ds->fColorStages.count();
+                fFirstEffectiveCoverageEffect = ds->fCoverageStages.getFirstEffectiveStageIndex();
                 fCoverageEffectCnt = ds->fCoverageStages.count();
                 SkDEBUGCODE(++ds->fBlockEffectRemovalCnt;)
             }
         }
 
     private:
         GrDrawState* fDrawState;
+        int fFirstEffectiveColorEffect;
         int fColorEffectCnt;
+        int fFirstEffectiveCoverageEffect;
         int fCoverageEffectCnt;
     };
 
-    int numColorStages() const { return fColorStages.count(); }
-    int numCoverageStages() const { return fCoverageStages.count(); }
-    int numTotalStages() const { return this->numColorStages() + this->numCoverageStages(); }
+    int totalStageCount() const { return fColorStages.count() + fCoverageStages.count(); }
 
-    const GrEffectStage& getColorStage(int stageIdx) const { return fColorStages[stageIdx]; }
-    const GrEffectStage& getCoverageStage(int stageIdx) const { return fCoverageStages[stageIdx]; }
+    int effectiveColorStageCount() const { return fColorStages.effectiveStageCount(); }
+    int effectiveCoverageStageCount() const { return fCoverageStages.effectiveStageCount(); }
+    int totalEffectiveStageCount() const { return this->effectiveColorStageCount() + this->effectiveCoverageStageCount(); }
+
+    const GrEffectStage& getEffectiveColorStage(int stageIdx) const { return fColorStages.getEffectiveStage(stageIdx); }
+    const GrEffectStage& getEffectiveCoverageStage(int stageIdx) const { return fCoverageStages.getEffectiveStage(stageIdx); }
 
     /**
      * Checks whether any of the effects will read the dst pixel color.
      */
     bool willEffectReadDstColor() const;
 
     /// @}
 
     ///////////////////////////////////////////////////////////////////////////
     /// @name Blending
@@ skipping 423 matching lines @@
         for (int i = 0; i < fCoverageStages.count(); i++) {
             if (fCoverageStages[i] != s.fCoverageStages[i]) {
                 return false;
             }
         }
         return true;
     }
     bool operator !=(const GrDrawState& s) const { return !(*this == s); }
 
     GrDrawState& operator= (const GrDrawState& s) {
-        SkASSERT(0 == fBlockEffectRemovalCnt || 0 == this->numTotalStages());
+        SkASSERT(0 == fBlockEffectRemovalCnt || 0 == this->totalStageCount());
         this->setRenderTarget(s.fRenderTarget.get());
         fCommon = s.fCommon;
         fColorStages = s.fColorStages;
         fCoverageStages = s.fCoverageStages;
+
         return *this;
     }
 
 private:
 
     void onReset(const SkMatrix* initialViewMatrix) {
-        SkASSERT(0 == fBlockEffectRemovalCnt || 0 == this->numTotalStages());
+        SkASSERT(0 == fBlockEffectRemovalCnt || 0 == this->totalStageCount());
         fColorStages.reset();
         fCoverageStages.reset();
 
         fRenderTarget.reset(NULL);
 
         this->setDefaultVertexAttribs();
 
         fCommon.fColor = 0xffffffff;
         if (NULL == initialViewMatrix) {
             fCommon.fViewMatrix.reset();
         } else {
             fCommon.fViewMatrix = *initialViewMatrix;
         }
         fCommon.fSrcBlend = kOne_GrBlendCoeff;
         fCommon.fDstBlend = kZero_GrBlendCoeff;
         fCommon.fBlendConstant = 0x0;
         fCommon.fFlagBits = 0x0;
         fCommon.fStencilSettings.setDisabled();
         fCommon.fCoverage = 0xffffffff;
-        fCommon.fColorFilterMode = SkXfermode::kDst_Mode;
-        fCommon.fColorFilterColor = 0x0;
         fCommon.fDrawFace = kBoth_DrawFace;
     }
 
     /** Fields that are identical in GrDrawState and GrDrawState::DeferredState. */
     struct CommonState {
         // These fields are roughly sorted by decreasing likelihood of being different in op==
         GrColor               fColor;
         SkMatrix              fViewMatrix;
         GrBlendCoeff          fSrcBlend;
         GrBlendCoeff          fDstBlend;
         GrColor               fBlendConstant;
         uint32_t              fFlagBits;
         const GrVertexAttrib* fVAPtr;
         int                   fVACount;
         GrStencilSettings     fStencilSettings;
         GrColor               fCoverage;
-        SkXfermode::Mode      fColorFilterMode;
-        GrColor               fColorFilterColor;
         DrawFace              fDrawFace;
 
         // This is simply a different representation of info in fVertexAttribs and thus does
         // not need to be compared in op==.
         int fFixedFunctionVertexAttribIndices[kGrFixedFunctionVertexAttribBindingCnt];
 
         bool operator== (const CommonState& other) const {
             bool result = fColor == other.fColor &&
                           fViewMatrix.cheapEqualTo(other.fViewMatrix) &&
                           fSrcBlend == other.fSrcBlend &&
                           fDstBlend == other.fDstBlend &&
                           fBlendConstant == other.fBlendConstant &&
                           fFlagBits == other.fFlagBits &&
                           fVACount == other.fVACount &&
                           !memcmp(fVAPtr, other.fVAPtr, fVACount * sizeof(GrVertexAttrib)) &&
                           fStencilSettings == other.fStencilSettings &&
                           fCoverage == other.fCoverage &&
-                          fColorFilterMode == other.fColorFilterMode &&
-                          fColorFilterColor == other.fColorFilterColor &&
                           fDrawFace == other.fDrawFace;
             SkASSERT(!result || 0 == memcmp(fFixedFunctionVertexAttribIndices,
                                             other.fFixedFunctionVertexAttribIndices,
                                             sizeof(fFixedFunctionVertexAttribIndices)));
             return result;
         }
         bool operator!= (const CommonState& other) const { return !(*this == other); }
     };
 
     /** GrDrawState uses GrEffectStages to hold stage state which holds a ref on GrEffectRef.
@@ skipping 38 matching lines @@
             SkDEBUGCODE(fInitialized = true;)
         }
 
         void restoreTo(GrDrawState* drawState) {
             SkASSERT(fInitialized);
             drawState->fCommon = fCommon;
             drawState->setRenderTarget(fRenderTarget);
             // reinflate color/cov stage arrays.
             drawState->fColorStages.reset();
             for (int i = 0; i < fColorStageCnt; ++i) {
-                SkNEW_APPEND_TO_TARRAY(&drawState->fColorStages, GrEffectStage, (fStages[i]));
+                drawState->fColorStages.appendStage(fStages[i]);
             }
             int coverageStageCnt = fStages.count() - fColorStageCnt;
             drawState->fCoverageStages.reset();
             for (int i = 0; i < coverageStageCnt; ++i) {
-                SkNEW_APPEND_TO_TARRAY(&drawState->fCoverageStages,
-                                        GrEffectStage, (fStages[i + fColorStageCnt]));
+                drawState->fCoverageStages.appendStage(fStages[i + fColorStageCnt]);
             }
         }
 
         bool isEqual(const GrDrawState& state) const {
             int numCoverageStages = fStages.count() - fColorStageCnt;
             if (fRenderTarget != state.fRenderTarget.get() ||
                 fColorStageCnt != state.fColorStages.count() ||
                 numCoverageStages != state.fCoverageStages.count() ||
                 fCommon != state.fCommon) {
                 return false;
@@ skipping 22 matching lines @@
         DeferredStageArray                    fStages;
 
         SkDEBUGCODE(bool fInitialized;)
     };
 
 private:
 
     SkAutoTUnref<GrRenderTarget>        fRenderTarget;
     CommonState                         fCommon;
 
-    typedef SkSTArray<4, GrEffectStage> EffectStageArray;
+    class EffectStageArray {

[bsalomon, 2013/10/07 14:05:00]

It seems like we'd be adding a fair amount of complexity to keep the live effect
set minimal. Unless there is a downside, it seems like it'd be a lot simpler to
leave it as it was and just toss some of the effects when we go to build the
program descriptor. We have to walk them all anyway. Maybe I'm missing
something.

[Kimmo Kinnunen, 2013/10/10 08:12:29]

Done.

+    public:
+        EffectStageArray()
+            : fFirstEffectiveStage(0) {
+        }
+
+        int getFirstEffectiveStageIndex() const { return fFirstEffectiveStage; }
+
+        const GrEffectStage& getEffectiveStage(int i) const { return fArray[i + fFirstEffectiveStage]; }
+
+        int effectiveStageCount() const { return fArray.count() - fFirstEffectiveStage; }
+
+        void appendStage(const GrEffectRef* effect, int attr0, int attr1) {
+            GrEffectStage* newStage = SkNEW_APPEND_TO_TARRAY(&fArray, GrEffectStage, (effect, attr0, attr1));
+            if (!(*newStage->getEffect())->willUseInputColor()) {
+                fFirstEffectiveStage = fArray.count() - 1;
+            }
+        }
+
+        void appendStage(const GrEffectStage::DeferredStage& effect) {
+            GrEffectStage* newStage = SkNEW_APPEND_TO_TARRAY(&fArray, GrEffectStage, (effect));
+            if (!(*newStage->getEffect())->willUseInputColor()) {
+                fFirstEffectiveStage = fArray.count() - 1;
+            }
+        }
+
+        void appendStage(const GrEffectStage& effect) {
+            GrEffectStage& newStage = fArray.push_back(effect);
+            if (!(*newStage.getEffect())->willUseInputColor()) {
+                fFirstEffectiveStage = fArray.count() - 1;
+            }
+        }
+
+        void removeLastStages(int n, int newFirstEffectiveStage) {
+            fArray.pop_back_n(n);
+            fFirstEffectiveStage = newFirstEffectiveStage;
+        }
+
+        const GrEffectStage& operator[](int i) const { return fArray[i]; }
+        GrEffectStage& operator[](int i) { return fArray[i]; }
+
+        void reset() {
+            fArray.reset();
+            fFirstEffectiveStage = 0;
+        }
+
+        int count() const { return fArray.count(); }
+
+    private:
+        SkSTArray<4, GrEffectStage> fArray;
+        int fFirstEffectiveStage;
+    };
+
     EffectStageArray                    fColorStages;
     EffectStageArray                    fCoverageStages;
 
     // Some of the auto restore objects assume that no effects are removed during their lifetime.
     // This is used to assert that this condition holds.
     SkDEBUGCODE(int fBlockEffectRemovalCnt;)
 
     /**
      *  Sets vertex attributes for next draw.
      *
      *  @param attribs    the array of vertex attributes to set.
      *  @param count      the number of attributes being set, limited to kMaxVertexAttribCnt.
      */
     void setVertexAttribs(const GrVertexAttrib attribs[], int count);
 
     typedef SkRefCnt INHERITED;
 };
 
 GR_MAKE_BITFIELD_OPS(GrDrawState::BlendOptFlags);
 
 #endif