Add GrEllipseEdgeEffect

include/gpu/GrEffect.h

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrEffect_DEFINED
 #define GrEffect_DEFINED
 
 #include "GrColor.h"
 #include "GrEffectUnitTest.h"
 #include "GrNoncopyable.h"
 #include "GrRefCnt.h"
 #include "GrTexture.h"
 #include "GrTextureAccess.h"
+#include "GrTypesPriv.h"
 
 class GrBackendEffectFactory;
 class GrContext;
 class GrEffect;
 class SkString;
 
 /**
  * A Wrapper class for GrEffect. Its ref-count will track owners that may use effects to enqueue
  * new draw operations separately from ownership within a deferred drawing queue. When the
  * GrEffectRef ref count reaches zero the scratch GrResources owned by the effect can be recycled
@@ skipping 102 matching lines @@
 
     int numTextures() const { return fTextureAccesses.count(); }
 
     /** Returns the access pattern for the texture at index. index must be valid according to
         numTextures(). */
     const GrTextureAccess& textureAccess(int index) const { return *fTextureAccesses[index]; }
 
     /** Shortcut for textureAccess(index).texture(); */
     GrTexture* texture(int index) const { return this->textureAccess(index).getTexture(); }
 
+
+    int numVertexAttribs() const { return fVertexAttribTypes.count(); }
+
+    GrSLType vertexAttribType(int index) const { return fVertexAttribTypes[index]; }
+
+    static const int kMaxVertexAttribs = 2;
+
+
     /** Useful for effects that want to insert a texture matrix that is implied by the texture
         dimensions */
     static inline SkMatrix MakeDivByTextureWHMatrix(const GrTexture* texture) {
         GrAssert(NULL != texture);
         SkMatrix mat;
         mat.setIDiv(texture->width(), texture->height());
         return mat;
     }
 
     void* operator new(size_t size);
@@ skipping 12 matching lines @@
     void decDeferredRefCounts() const {
         int count = fTextureAccesses.count();
         for (int t = 0; t < count; ++t) {
             fTextureAccesses[t]->getTexture()->decDeferredRefCount();
         }
         this->unref();
     }
 
 protected:
     /**
-     * Subclasses call this from their constructor to register GrTextureAcceses. The effect subclass
-     * manages the lifetime of the accesses (this function only stores a pointer). This must only be
-     * called from the constructor because GrEffects are supposed to be immutable.
+     * Subclasses call this from their constructor to register GrTextureAccesses. The effect 
+     * subclass manages the lifetime of the accesses (this function only stores a pointer). This 
+     * must only be called from the constructor because GrEffects are immutable.
      */
     void addTextureAccess(const GrTextureAccess* textureAccess);
 
+    /**
+     * Subclasses call this from their constructor to register vertex attributes (at most 
+     * kMaxVertexAttribs). This must only be called from the constructor because GrEffects are 
+     * immutable.
+     */
+    void addVertexAttrib(GrSLType type);
+
     GrEffect() : fEffectRef(NULL) {};
 
     /** This should be called by GrEffect subclass factories. See the comment on AutoEffectUnref for
         an example factory function. */
     static GrEffectRef* CreateEffectRef(GrEffect* effect) {
         if (NULL == effect->fEffectRef) {
             effect->fEffectRef = SkNEW_ARGS(GrEffectRef, (effect));
         } else {
             effect->fEffectRef->ref();
         }
@@ skipping 52 matching lines @@
         getFactory()).*/
     virtual bool onIsEqual(const GrEffect& other) const = 0;
 
     void EffectRefDestroyed() { fEffectRef = NULL; }
 
     friend class GrEffectRef;   // to call EffectRefDestroyed()
     friend class GrEffectStage; // to rewrap GrEffect in GrEffectRef when restoring an effect-stage
                                 // from deferred state, to call isEqual on naked GrEffects, and
                                 // to inc/dec deferred ref counts.
 
-    SkSTArray<4, const GrTextureAccess*, true>  fTextureAccesses;
-    GrEffectRef*                                fEffectRef;
+    SkSTArray<4, const GrTextureAccess*, true>   fTextureAccesses;
+    SkSTArray<kMaxVertexAttribs, GrSLType, true> fVertexAttribTypes;
+    GrEffectRef*                                 fEffectRef;
 
     typedef GrRefCnt INHERITED;
 };
 
 inline GrEffectRef::GrEffectRef(GrEffect* effect) {
     GrAssert(NULL != effect);
     effect->ref();
     fEffect = effect;
 }
 
 #endif