Add GrEllipseEdgeEffect

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.
  */
 
 
 
@@ skipping 98 matching lines @@
                 fEffect->decDeferredRefCounts();
             }
         }
 
         void saveFrom(const GrEffectStage& stage) {
             GrAssert(!fInitialized);
             if (NULL != stage.fEffectRef) {
                 stage.fEffectRef->get()->incDeferredRefCounts();
                 fEffect = stage.fEffectRef->get();
                 fCoordChangeMatrix = stage.fCoordChangeMatrix;
+                fVertexAttribIndices = stage.fVertexAttribIndices;
             }
             SkDEBUGCODE(fInitialized = true;)
         }
 
         void restoreTo(GrEffectStage* stage) {
             GrAssert(fInitialized);
             const GrEffectRef* oldEffectRef = stage->fEffectRef;
             if (NULL != fEffect) {
                 stage->fEffectRef = GrEffect::CreateEffectRef(fEffect);
                 stage->fCoordChangeMatrix = fCoordChangeMatrix;
+                stage->fVertexAttribIndices = fVertexAttribIndices;
             } else {
                 stage->fEffectRef = NULL;
             }
             SkSafeUnref(oldEffectRef);
         }
 
         bool isEqual(const GrEffectStage& stage) const {
             if (NULL == stage.fEffectRef) {
                 return NULL == fEffect;
             } else if (NULL == fEffect) {
                 return false;
             }
 
+            int vertexAttribCount = fVertexAttribIndices.count();
+            if (vertexAttribCount != stage.fVertexAttribIndices.count()) {
+                return false;
+            }
+            for (int i = 0; i < vertexAttribCount; ++i) {
+                if (fVertexAttribIndices[i] != stage.fVertexAttribIndices[i]) {
+                    return false;
+                }
+            }
+
             if (!(*stage.getEffect())->isEqual(*fEffect)) {
                 return false;
             }
 
             return fCoordChangeMatrix == stage.fCoordChangeMatrix;
         }
 
     private:
         const GrEffect*               fEffect;
         SkMatrix                      fCoordChangeMatrix;
+        SkSTArray<2, int, true>       fVertexAttribIndices;
         SkDEBUGCODE(bool fInitialized;)
     };
 
     /**
      * Gets the matrix representing all changes of coordinate system since the GrEffect was
      * installed in the stage.
      */
     const SkMatrix& getCoordChangeMatrix() const { return fCoordChangeMatrix; }
 
     void reset() {
         GrSafeSetNull(fEffectRef);
     }
 
     const GrEffectRef* setEffect(const GrEffectRef* EffectRef) {
         GrAssert(0 == fSavedCoordChangeCnt);
         GrSafeAssign(fEffectRef, EffectRef);
         fCoordChangeMatrix.reset();
         return EffectRef;
     }
 
     const GrEffectRef* getEffect() const { return fEffectRef; }
 
+    void setVertexAttribIndices(const int indices[], int count) { 

[robertphillips, 2013/03/05 20:30:13]

Is there a reserve we can use here?

[jvanverth1, 2013/03/07 15:21:54]

Done.

+        fVertexAttribIndices.reset();
+        for (int index = 0; index < count; ++index) {
+            fVertexAttribIndices.push_back(indices[index]);
+        }
+    }
+
+    const int* getVertexAttribIndices() const { return fVertexAttribIndices.begin(); }
+    int getVertexAttribIndexCount() const { return fVertexAttribIndices.count(); }
+
 private:
-    SkMatrix            fCoordChangeMatrix;
-    const GrEffectRef*  fEffectRef;
+    SkMatrix                fCoordChangeMatrix;
+    const GrEffectRef*      fEffectRef;
+    SkSTArray<2, int, true> fVertexAttribIndices;
 
     GR_DEBUGCODE(mutable int fSavedCoordChangeCnt;)
 };
 
 #endif