Replace edge types with GrEdgeEffect.

src/gpu/GrDrawState.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrDrawState.h"
 #include "GrPaint.h"
 
@@ skipping 41 matching lines @@
     3*sizeof(float),        // kVec3_GrVertexAttribType
     4*sizeof(float),        // kVec4_GrVertexAttribType
     4*sizeof(char)          // kCVec4_GrVertexAttribType
 };
 
 static size_t vertex_size(const GrVertexAttrib* attribs, int count) {
     // this works as long as we're 4 byte-aligned
 #if GR_DEBUG
     uint32_t overlapCheck = 0;
 #endif
-    GrAssert(count <= GrDrawState::kAttribIndexCount);
+    GrAssert(count <= GrDrawState::kVertexAttribCnt);
     size_t size = 0;
     for (int index = 0; index < count; ++index) {
         size_t attribSize = GrDrawState::kVertexAttribSizes[attribs[index].fType];
         size += attribSize;
 #if GR_DEBUG
         size_t dwordCount = attribSize >> 2;
         uint32_t mask = (1 << dwordCount)-1;
         size_t offsetShift = attribs[index].fOffset >> 2;
         GrAssert(!(overlapCheck & (mask << offsetShift)));
         overlapCheck |= (mask << offsetShift);
 #endif
     }
     return size;
 }
 
 size_t GrDrawState::getVertexSize() const {
     return vertex_size(fVertexAttribs.begin(), fVertexAttribs.count());
 }
 
 const GrAttribBindings GrDrawState::kAttribIndexMasks[kAttribIndexCount] = {
     0,                            // position is not reflected in the bindings
     kColor_AttribBindingsBit,
     kCoverage_AttribBindingsBit,
-    kEdge_AttribBindingsBit,
     kLocalCoords_AttribBindingsBit,
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 
 void GrDrawState::setVertexAttribs(const GrVertexAttrib* attribs, int count) {
-    GrAssert(count <= GrDrawState::kAttribIndexCount);
+    GrAssert(count <= GrDrawState::kVertexAttribCnt);
     fVertexAttribs.reset();
     for (int index = 0; index < count; ++index) {
         fVertexAttribs.push_back(attribs[index]);
     }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 void GrDrawState::setDefaultVertexAttribs() {
     static const GrVertexAttrib kPositionAttrib = {kVec2f_GrVertexAttribType, 0};
@@ skipping 29 matching lines @@
             if (attributeIndex >= kMaxValidAttribIndex) {
                 return false;
             }
             // they should not be shared at all
             if (attributeTypes[attributeIndex] != -1) {
                 return false;
             }
             attributeTypes[attributeIndex] = kBuiltInAttributeType;
         }
     }
-    for (int j = kEdge_AttribIndex; j < kAttribIndexCount; ++j) {
-        if (fCommon.fAttribBindings & kAttribIndexMasks[j]) {
-            int attributeIndex = fAttribIndices[j];
-            if (attributeIndex >= kVertexAttribCnt) {
-                return false;
-            }
-            // they should not be shared at all
-            if (attributeTypes[attributeIndex] != -1) {
-                return false;
-            }
-            attributeTypes[attributeIndex] = kBuiltInAttributeType;
+    if (fCommon.fAttribBindings & kAttribIndexMasks[kLocalCoords_AttribIndex]) {
+        int attributeIndex = fAttribIndices[kLocalCoords_AttribIndex];
+        if (attributeIndex >= kVertexAttribCnt) {
+            return false;
         }
+        // they should not be shared at all
+        if (attributeTypes[attributeIndex] != -1) {
+            return false;
+        }
+        attributeTypes[attributeIndex] = kBuiltInAttributeType;
     }
 
     // now those set by effects
     for (int s = 0; s < kNumStages; ++s) {
         const GrEffectStage& stage = fStages[s];
         const GrEffectRef* effect = stage.getEffect();
         if (effect == NULL) {
             continue;
         }
 
@@ skipping 199 matching lines @@
     // (0,1). The same applies when coverage is known to be 0.
     if ((kZero_GrBlendCoeff == *srcCoeff && dstCoeffIsOne) || covIsZero) {
         if (this->getStencil().doesWrite()) {
             return kDisableBlend_BlendOptFlag |
                    kEmitTransBlack_BlendOptFlag;
         } else {
             return kSkipDraw_BlendOptFlag;
         }
     }
 
-    // check for coverage due to constant coverage, per-vertex coverage,
-    // edge aa or coverage stage
+    // check for coverage due to constant coverage, per-vertex coverage, or coverage stage
     bool hasCoverage = forceCoverage ||
                        0xffffffff != this->getCoverage() ||
-                       (bindings & GrDrawState::kCoverage_AttribBindingsBit) ||
-                       (bindings & GrDrawState::kEdge_AttribBindingsBit);
+                       (bindings & GrDrawState::kCoverage_AttribBindingsBit);
     for (int s = this->getFirstCoverageStage();
          !hasCoverage && s < GrDrawState::kNumStages;
          ++s) {
         if (this->isStageEnabled(s)) {
             hasCoverage = true;
         }
     }
 
     // if we don't have coverage we can check whether the dst
     // has to read at all. If not, we'll disable blending.
@@ skipping 120 matching lines @@
             }
             fRestoreMask |= (1 << s);
             GrEffectStage* stage = drawState->fStages + s;
             stage->saveCoordChange(&fSavedCoordChanges[s]);
             stage->localCoordChange(invVM);
         }
     }
     drawState->viewMatrix()->reset();
     return true;
 }