Replace edge types with GrEdgeEffect.

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 58 matching lines @@
      * the interpolated vertex positions or explicit per-vertex coords, depending upon the
      * GrAttribBindings used to draw.
      *
      * The stages are divided into two sets, color-computing and coverage-computing. The final color
      * stage produces the final pixel color. The coverage-computing stages function exactly as the
      * color-computing but the output of the final coverage stage is treated as a fractional pixel
      * coverage rather than as input to the src/dst color blend step.
      *
      * The input color to the first enabled color-stage is either the constant color or interpolated
      * per-vertex colors, depending upon GrAttribBindings. The input to the first coverage stage is
-     * either a constant coverage (usually full-coverage), interpolated per-vertex coverage, or
-     * edge-AA computed coverage. (This latter is going away as soon as it can be rewritten as a
-     * GrEffect).
+     * 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.
      *
      * Stages 0 through GrPaint::kTotalStages-1 are reserved for stages copied from the client's
      * GrPaint. Stages GrPaint::kTotalStages through kNumStages-2 are earmarked for use by
      * GrTextContext and GrPathRenderer-derived classes. kNumStages-1 is earmarked for clipping
      * by GrClipMaskManager.
      */
     enum {
@@ skipping 26 matching lines @@
         fRenderTarget.reset(NULL);
 
         this->setDefaultVertexAttribs();
 
         fCommon.fColor = 0xffffffff;
         fCommon.fViewMatrix.reset();
         fCommon.fSrcBlend = kOne_GrBlendCoeff;
         fCommon.fDstBlend = kZero_GrBlendCoeff;
         fCommon.fBlendConstant = 0x0;
         fCommon.fFlagBits = 0x0;
-        fCommon.fVertexEdgeType = kHairLine_EdgeType;
         fCommon.fStencilSettings.setDisabled();
         fCommon.fFirstCoverageStage = kNumStages;
         fCommon.fCoverage = 0xffffffff;
         fCommon.fColorFilterMode = SkXfermode::kDst_Mode;
         fCommon.fColorFilterColor = 0x0;
         fCommon.fDrawFace = kBoth_DrawFace;
     }
 
     /**
      * Initializes the GrDrawState based on a GrPaint. Note that GrDrawState
@@ skipping 127 matching lines @@
      * Additional Bits that can be specified in GrAttribBindings.
      */
     enum AttribBindingsBits {
         /** explicit local coords are provided (instead of using pre-view-matrix positions) */
         kLocalCoords_AttribBindingsBit        = 0x1,
         /* program uses colors (GrColor) */
         kColor_AttribBindingsBit              = 0x2,
         /* program uses coverage (GrColor)
          */
         kCoverage_AttribBindingsBit           = 0x4,
-        /* program uses edge data. Distance to the edge is used to
-         * compute a coverage. See GrDrawState::setVertexEdgeType().
-         */
-        kEdge_AttribBindingsBit               = 0x8,
         // for below assert
         kDummyAttribBindingsBit,
         kHighAttribBindingsBit = kDummyAttribBindingsBit - 1
     };
     // make sure we haven't exceeded the number of bits in GrAttribBindings.
     GR_STATIC_ASSERT(kHighAttribBindingsBit < ((uint64_t)1 << 8*sizeof(GrAttribBindings)));
 
     enum AttribBindings {
         kDefault_AttribBindings = 0
     };
@@ skipping 35 matching lines @@
      * look up the vertex attribute data from the array, and potentially as the
      * attribute index if we're binding attributes in GL.
      *
      * Indices which do not have active attribute bindings will be ignored.
      */
 
     enum AttribIndex {
         kPosition_AttribIndex = 0,
         kColor_AttribIndex,
         kCoverage_AttribIndex,
-        kEdge_AttribIndex,
         kLocalCoords_AttribIndex,
 
         kLast_AttribIndex = kLocalCoords_AttribIndex
     };
     static const int kAttribIndexCount = kLast_AttribIndex + 1;
 
     // these are used when vertex color and coverage isn't set
     enum {
         kColorOverrideAttribIndexValue = GrDrawState::kVertexAttribCnt,
         kCoverageOverrideAttribIndexValue = GrDrawState::kVertexAttribCnt+1,
@@ skipping 594 matching lines @@
         fCommon.fStencilSettings.setDisabled();
     }
 
     const GrStencilSettings& getStencil() const { return fCommon.fStencilSettings; }
 
     GrStencilSettings* stencil() { return &fCommon.fStencilSettings; }
 
     /// @}
 
     ///////////////////////////////////////////////////////////////////////////
-    // @name Edge AA
-    // Edge equations can be specified to perform anti-aliasing. Because the
-    // edges are specified as per-vertex data, vertices that are shared by
-    // multiple edges must be split.
-    //
-    ////
-
-    /**
-     * When specifying edges as vertex data this enum specifies what type of
-     * edges are in use. The edges are always 4 SkScalars in memory, even when
-     * the edge type requires fewer than 4.
-     *
-     * TODO: Fix the fact that HairLine and Circle edge types use y-down coords.
-     *       (either adjust in VS or use origin_upper_left in GLSL)
-     */
-    enum VertexEdgeType {
-        /* 1-pixel wide line
-           2D implicit line eq (a*x + b*y +c = 0). 4th component unused */
-        kHairLine_EdgeType,
-        /* Quadratic specified by u^2-v canonical coords (only 2
-           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,
-
-        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) {
-        GrAssert(type >=0 && type < kVertexEdgeTypeCnt);
-        fCommon.fVertexEdgeType = type;
-    }
-
-    VertexEdgeType getVertexEdgeType() const { return fCommon.fVertexEdgeType; }
-
-    /// @}
-
-    ///////////////////////////////////////////////////////////////////////////
     /// @name State Flags
     ////
 
     /**
      *  Flags that affect rendering. Controlled using enable/disableState(). All
      *  default to disabled.
      */
     enum StateBits {
         /**
          * Perform dithering. TODO: Re-evaluate whether we need this bit
@@ skipping 175 matching lines @@
     /** 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;
         GrAttribBindings                fAttribBindings;
         SkMatrix                        fViewMatrix;
         GrBlendCoeff                    fSrcBlend;
         GrBlendCoeff                    fDstBlend;
         GrColor                         fBlendConstant;
         uint32_t                        fFlagBits;
-        VertexEdgeType                  fVertexEdgeType;
         GrStencilSettings               fStencilSettings;
         int                             fFirstCoverageStage;
         GrColor                         fCoverage;
         SkXfermode::Mode                fColorFilterMode;
         GrColor                         fColorFilterColor;
         DrawFace                        fDrawFace;
         bool operator== (const CommonState& other) const {
             return fColor == other.fColor &&
                    fAttribBindings == other.fAttribBindings &&
                    fViewMatrix.cheapEqualTo(other.fViewMatrix) &&
                    fSrcBlend == other.fSrcBlend &&
                    fDstBlend == other.fDstBlend &&
                    fBlendConstant == other.fBlendConstant &&
                    fFlagBits == other.fFlagBits &&
-                   fVertexEdgeType == other.fVertexEdgeType &&
                    fStencilSettings == other.fStencilSettings &&
                    fFirstCoverageStage == other.fFirstCoverageStage &&
                    fCoverage == other.fCoverage &&
                    fColorFilterMode == other.fColorFilterMode &&
                    fColorFilterColor == other.fColorFilterColor &&
                    fDrawFace == other.fDrawFace;
         }
         bool operator!= (const CommonState& other) const { return !(*this == other); }
     };
 
@@ skipping 93 matching lines @@
     int                                    fAttribIndices[kAttribIndexCount];
     GrVertexAttribArray<kVertexAttribCnt>  fVertexAttribs;
     GrEffectStage                          fStages[kNumStages];
 
     typedef GrRefCnt INHERITED;
 };
 
 GR_MAKE_BITFIELD_OPS(GrDrawState::BlendOptFlags);
 
 #endif