Replace fixed-size array of effect stages in GrDrawState with two appendable arrays, one for color,…

include/gpu/GrEffectStage.h

 
 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 
 #ifndef GrEffectStage_DEFINED
 #define GrEffectStage_DEFINED
 
 #include "GrBackendEffectFactory.h"
 #include "GrEffect.h"
 #include "SkMatrix.h"
 #include "GrTypes.h"
 
 #include "SkShader.h"
 
 class GrEffectStage {
 public:
-    GrEffectStage()
-    : fEffectRef (NULL) {
-        GR_DEBUGCODE(fSavedCoordChangeCnt = 0;)
+    GrEffectStage() {
+        fCoordChangeMatrixSet = false;
+        fVertexAttribIndices[0] = -1;
+        fVertexAttribIndices[1] = -1;
     }
 
-    ~GrEffectStage() {
-        GrSafeUnref(fEffectRef);
-        GrAssert(0 == fSavedCoordChangeCnt);
+    explicit GrEffectStage(const GrEffectRef* effectRef, int attrIndex0 = -1, int attrIndex1 = -1)
+    : fEffectRef(SkSafeRef(effectRef)) {
+        fCoordChangeMatrixSet = false;
+        fVertexAttribIndices[0] = attrIndex0;
+        fVertexAttribIndices[1] = attrIndex1;
     }
 
-    bool operator ==(const GrEffectStage& other) const {
+    GrEffectStage(const GrEffectStage& other) {
+        *this = other;
+    }
+
+    GrEffectStage& operator= (const GrEffectStage& other) {
+        fCoordChangeMatrixSet = other.fCoordChangeMatrixSet;
+        if (other.fCoordChangeMatrixSet) {
+            fCoordChangeMatrix = other.fCoordChangeMatrix;
+        }
+        fEffectRef.reset(SkSafeRef(other.fEffectRef.get()));
+        memcpy(fVertexAttribIndices, other.fVertexAttribIndices, sizeof(fVertexAttribIndices));
+        return *this;
+    }
+
+    bool operator== (const GrEffectStage& other) const {
         // first handle cases where one or the other has no effect
-        if (NULL == fEffectRef) {
-            return NULL == other.fEffectRef;
-        } else if (NULL == other.fEffectRef) {
+        if (NULL == fEffectRef.get()) {
+            return NULL == other.fEffectRef.get();
+        } else if (NULL == other.fEffectRef.get()) {
             return false;
         }
 
         if (!(*this->getEffect())->isEqual(*other.getEffect())) {
             return false;
         }
 
         if (fCoordChangeMatrixSet != other.fCoordChangeMatrixSet) {
             return false;
         }
 
         if (!fCoordChangeMatrixSet) {
             return true;
         }
 
         return fCoordChangeMatrix == other.fCoordChangeMatrix;
     }
 
     bool operator!= (const GrEffectStage& s) const { return !(*this == s); }
 
-    GrEffectStage& operator= (const GrEffectStage& other) {
-        GrSafeAssign(fEffectRef, other.fEffectRef);
-        fCoordChangeMatrixSet = other.fCoordChangeMatrixSet;
-        if (NULL != fEffectRef && fCoordChangeMatrixSet) {
-            fCoordChangeMatrix = other.fCoordChangeMatrix;
-        }
-        return *this;
-    }
-
     /**
      * This is called when the coordinate system in which the geometry is specified will change.
      *
      * @param matrix    The transformation from the old coord system in which geometry is specified
      *                  to the new one from which it will actually be drawn.
      */
     void localCoordChange(const SkMatrix& matrix) {
         if (fCoordChangeMatrixSet) {
             fCoordChangeMatrix.preConcat(matrix);
         } else {
@@ skipping 16 matching lines @@
      * localCoordChange calls since the effect was installed. It is used when then caller
      * wants to temporarily change the source geometry coord system, draw something, and then
      * restore the previous coord system (e.g. temporarily draw in device coords).
      */
     void saveCoordChange(SavedCoordChange* savedCoordChange) const {
         savedCoordChange->fCoordChangeMatrixSet = fCoordChangeMatrixSet;
         if (fCoordChangeMatrixSet) {
             savedCoordChange->fCoordChangeMatrix = fCoordChangeMatrix;
         }
         GrAssert(NULL == savedCoordChange->fEffectRef.get());
-        GR_DEBUGCODE(GrSafeRef(fEffectRef);)
-        GR_DEBUGCODE(savedCoordChange->fEffectRef.reset(fEffectRef);)
-        GR_DEBUGCODE(++fSavedCoordChangeCnt);
+        GR_DEBUGCODE(GrSafeRef(fEffectRef.get());)
+        GR_DEBUGCODE(savedCoordChange->fEffectRef.reset(fEffectRef.get());)
     }
 
     /**
      * This balances the saveCoordChange call.
      */
     void restoreCoordChange(const SavedCoordChange& savedCoordChange) {
         fCoordChangeMatrixSet = savedCoordChange.fCoordChangeMatrixSet;
         if (fCoordChangeMatrixSet) {
             fCoordChangeMatrix = savedCoordChange.fCoordChangeMatrix;
         }
         GrAssert(savedCoordChange.fEffectRef.get() == fEffectRef);
-        GR_DEBUGCODE(--fSavedCoordChangeCnt);
         GR_DEBUGCODE(savedCoordChange.fEffectRef.reset(NULL);)
     }
 
     /**
      * Used when storing a deferred GrDrawState. The DeferredStage allows resources owned by its
      * GrEffect to be recycled through the cache.
      */
     class DeferredStage {
     public:
         DeferredStage() : fEffect(NULL) {
             SkDEBUGCODE(fInitialized = false;)
         }
 
         ~DeferredStage() {
             if (NULL != fEffect) {
                 fEffect->decDeferredRefCounts();
             }
         }
 
         void saveFrom(const GrEffectStage& stage) {
             GrAssert(!fInitialized);
-            if (NULL != stage.fEffectRef) {
+            if (NULL != stage.fEffectRef.get()) {
                 stage.fEffectRef->get()->incDeferredRefCounts();
                 fEffect = stage.fEffectRef->get();
                 fCoordChangeMatrixSet = stage.fCoordChangeMatrixSet;
                 if (fCoordChangeMatrixSet) {
                     fCoordChangeMatrix = stage.fCoordChangeMatrix;
                 }
                 fVertexAttribIndices[0] = stage.fVertexAttribIndices[0];
                 fVertexAttribIndices[1] = stage.fVertexAttribIndices[1];
             }
             SkDEBUGCODE(fInitialized = true;)
         }
 
         void restoreTo(GrEffectStage* stage) {
             GrAssert(fInitialized);
-            const GrEffectRef* oldEffectRef = stage->fEffectRef;
             if (NULL != fEffect) {
-                stage->fEffectRef = GrEffect::CreateEffectRef(fEffect);
+                stage->fEffectRef.reset(GrEffect::CreateEffectRef(fEffect));
                 stage->fCoordChangeMatrixSet = fCoordChangeMatrixSet;
                 if (fCoordChangeMatrixSet) {
                     stage->fCoordChangeMatrix = fCoordChangeMatrix;
                 }
                 stage->fVertexAttribIndices[0] = fVertexAttribIndices[0];
                 stage->fVertexAttribIndices[1] = fVertexAttribIndices[1];
             } else {
-                stage->fEffectRef = NULL;
+                stage->fEffectRef.reset(NULL);
             }
-            SkSafeUnref(oldEffectRef);
         }
 
         bool isEqual(const GrEffectStage& stage, bool ignoreCoordChange) const {
-            if (NULL == stage.fEffectRef) {
+            if (NULL == stage.fEffectRef.get()) {
                 return NULL == fEffect;
             } else if (NULL == fEffect) {
                 return false;
             }
 
             if (fVertexAttribIndices[0] != stage.fVertexAttribIndices[0]
                 || fVertexAttribIndices[1] != stage.fVertexAttribIndices[1]) {
                 return false;
             }
 
@@ skipping 31 matching lines @@
      * installed in the stage.
      */
     const SkMatrix& getCoordChangeMatrix() const {
         if (fCoordChangeMatrixSet) {
             return fCoordChangeMatrix;
         } else {
             return SkMatrix::I();
         }
     }
 
-    void reset() {
-        GrSafeSetNull(fEffectRef);
-    }
+    void reset() { fEffectRef.reset(NULL); }
 
-    const GrEffectRef* setEffect(const GrEffectRef* EffectRef) {
-        GrAssert(0 == fSavedCoordChangeCnt);
-        GrSafeAssign(fEffectRef, EffectRef);
-        fCoordChangeMatrixSet = false;
-
-        fVertexAttribIndices[0] = -1;
-        fVertexAttribIndices[1] = -1;
-
-        return EffectRef;
-    }
-
-    const GrEffectRef* setEffect(const GrEffectRef* EffectRef, int attr0, int attr1 = -1) {
-        GrAssert(0 == fSavedCoordChangeCnt);
-        GrSafeAssign(fEffectRef, EffectRef);
+    const GrEffectRef* setEffect(const GrEffectRef* effect, int attr0 = -1, int attr1 = -1) {
+        fEffectRef.reset(SkSafeRef(effect));
         fCoordChangeMatrixSet = false;
 
         fVertexAttribIndices[0] = attr0;
         fVertexAttribIndices[1] = attr1;
 
-        return EffectRef;
+        return effect;
     }
 
-    const GrEffectRef* getEffect() const { return fEffectRef; }
+    const GrEffectRef* getEffect() const { return fEffectRef.get(); }
 
     const int* getVertexAttribIndices() const { return fVertexAttribIndices; }
     int getVertexAttribIndexCount() const { return fEffectRef->get()->numVertexAttribs(); }
 
 private:
-    bool                    fCoordChangeMatrixSet;
-    SkMatrix                fCoordChangeMatrix;
-    const GrEffectRef*      fEffectRef;
-    int                     fVertexAttribIndices[2];
-
-    GR_DEBUGCODE(mutable int fSavedCoordChangeCnt;)
+    bool                                fCoordChangeMatrixSet;
+    SkMatrix                            fCoordChangeMatrix;
+    SkAutoTUnref<const GrEffectRef>     fEffectRef;
+    int                                 fVertexAttribIndices[2];
 };
 
 #endif