Add GrEllipseEdgeEffect

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 163 matching lines @@
 
     size_t getVertexSize() const;
 
     /**
      *  Sets default vertex attributes for next draw.
      *
      *  This will also set default vertex attribute indices and bindings
      */
     void setDefaultVertexAttribs();
 
+    bool validateVertexAttribs() const;
+
     ////////////////////////////////////////////////////////////////////////////
     // Helpers for picking apart vertex attributes
 
     // helper array to let us check the expected so we know what bound attrib indices
     // we care about
     static const size_t kVertexAttribSizes[kGrVertexAttribTypeCount];
 
     /**
      * Accessing positions, texture coords, or colors, of a vertex within an
      * array is a hassle involving casts and simple math. These helpers exist
@@ skipping 131 matching lines @@
      * Determines whether src alpha is guaranteed to be one for all src pixels
      */
     bool srcAlphaWillBeOne(GrAttribBindings) const;
 
     /**
      * Determines whether the output coverage is guaranteed to be one for all pixels hit by a draw.
      */
     bool hasSolidCoverage(GrAttribBindings) const;
 
     static void VertexAttributesUnitTest();
-
+   
     /// @}
 
     ///////////////////////////////////////////////////////////////////////////
     /// @name Vertex Attribute Indices
     ////
 
     /**
      * Vertex attribute indices map the data set in the vertex attribute array
      * to the bindings specified in the attribute bindings. Each binding type
      * has an associated index in the attribute array. This index is used to
@@ skipping 130 matching lines @@
     GrColor getCoverage() const {
         return fCommon.fCoverage;
     }
 
     /// @}
 
     ///////////////////////////////////////////////////////////////////////////
     /// @name Effect Stages
     ////
 
-    const GrEffectRef* setEffect(int stageIdx, const GrEffectRef* effect) {
-        fStages[stageIdx].setEffect(effect);
+    const GrEffectRef* setEffect(int stageIdx, const GrEffectRef* effect, 
+                                 const int* indices = NULL) {
+        fStages[stageIdx].setEffect(effect, indices);
         return effect;
     }
 
     /**
      * Creates a GrSimpleTextureEffect.
      */
     void createTextureEffect(int stageIdx, GrTexture* texture, const SkMatrix& matrix) {
         GrAssert(!this->getStage(stageIdx).getEffect());
         GrEffectRef* effect = GrSimpleTextureEffect::Create(texture, matrix);
         this->setEffect(stageIdx, effect)->unref();
     }
     void createTextureEffect(int stageIdx,
                              GrTexture* texture,
                              const SkMatrix& matrix,
                              const GrTextureParams& params) {
         GrAssert(!this->getStage(stageIdx).getEffect());
         GrEffectRef* effect = GrSimpleTextureEffect::Create(texture, matrix, params);
         this->setEffect(stageIdx, effect)->unref();
     }
 
     bool stagesDisabled() {
         for (int i = 0; i < kNumStages; ++i) {
             if (NULL != fStages[i].getEffect()) {
                 return false;
             }
         }
         return true;
     }
 
-    void disableStage(int stageIdx) { this->setEffect(stageIdx, NULL); }
+    void disableStage(int stageIdx) { 
+        this->setEffect(stageIdx, NULL, NULL); 
+    }
 
     /**
      * Release all the GrEffects referred to by this draw state.
      */
     void disableStages() {
         for (int i = 0; i < kNumStages; ++i) {
             this->disableStage(i);
         }
     }
 
@@ skipping 486 matching lines @@
            components used). Coverage based on signed distance with negative
            being inside, positive outside. Edge specified in window space
            (y-down) */
         kQuad_EdgeType,
         /* Same as above but for hairline quadratics. Uses unsigned distance.
            Coverage is min(0, 1-distance). */
         kHairQuad_EdgeType,
         /* Circle specified as center_x, center_y, outer_radius, inner_radius
            all in window space (y-down). */
         kCircle_EdgeType,
-        /* Axis-aligned ellipse specified as center_x, center_y, x_radius, x_radius/y_radius
-           all in window space (y-down). */
-        kEllipse_EdgeType,
 
         kVertexEdgeTypeCnt
     };
 
     /**
      * Determines the interpretation per-vertex edge data when the
      * kEdge_AttribBindingsBit is set (see GrDrawTarget). When per-vertex edges
      * are not specified the value of this setting has no effect.
      */
     void setVertexEdgeType(VertexEdgeType type) {
@@ skipping 145 matching lines @@
 
     bool isStageEnabled(int s) const {
         GrAssert((unsigned)s < kNumStages);
         return (NULL != fStages[s].getEffect());
     }
 
     bool operator ==(const GrDrawState& s) const {
         if (fRenderTarget.get() != s.fRenderTarget.get() || fCommon != s.fCommon) {
             return false;
         }
-        if (fVertexAttribs.count() != s.fVertexAttribs.count()) {
+        if (fVertexAttribs != s.fVertexAttribs) {
             return false;
         }
-        for (int i = 0; i < fVertexAttribs.count(); ++i) {
-            if (fVertexAttribs[i] != s.fVertexAttribs[i]) {
-                return false;
-            }
-        }
         for (int i = 0; i < kAttribIndexCount; ++i) {
             if ((i == kPosition_AttribIndex ||
                     s.fCommon.fAttribBindings & kAttribIndexMasks[i]) &&
                 fAttribIndices[i] != s.fAttribIndices[i]) {
                 return false;
             }
         }
         for (int i = 0; i < kNumStages; i++) {
             bool enabled = this->isStageEnabled(i);
             if (enabled != s.isStageEnabled(i)) {
@@ skipping 118 matching lines @@
             if (fRenderTarget != state.fRenderTarget.get() || fCommon != state.fCommon) {
                 return false;
             }
             for (int i = 0; i < kAttribIndexCount; ++i) {
                 if ((i == kPosition_AttribIndex ||
                      state.fCommon.fAttribBindings & kAttribIndexMasks[i]) &&
                     fAttribIndices[i] != state.fAttribIndices[i]) {
                     return false;
                 }
             }
-            if (fVertexAttribs.count() != state.fVertexAttribs.count()) {
+            if (fVertexAttribs != state.fVertexAttribs) {
                 return false;
             }
-            for (int i = 0; i < fVertexAttribs.count(); ++i)
-                if (fVertexAttribs[i] != state.fVertexAttribs[i]) {
-                    return false;
-            }
             for (int i = 0; i < kNumStages; ++i) {
                 if (!fStages[i].isEqual(state.fStages[i])) {
                     return false;
                 }
             }
             return true;
         }
 
     private:
         GrRenderTarget*                       fRenderTarget;
@@ skipping 15 matching lines @@
     int                                    fAttribIndices[kAttribIndexCount];
     GrVertexAttribArray<kVertexAttribCnt>  fVertexAttribs;
     GrEffectStage                          fStages[kNumStages];
 
     typedef GrRefCnt INHERITED;
 };
 
 GR_MAKE_BITFIELD_OPS(GrDrawState::BlendOptFlags);
 
 #endif