Replace edge types with GrEdgeEffect

src/gpu/GrAAHairLinePathRenderer.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAAHairLinePathRenderer.h"
 
 #include "GrContext.h"
 #include "GrDrawState.h"
 #include "GrGpu.h"
 #include "GrIndexBuffer.h"
 #include "GrPathUtils.h"
 #include "SkGeometry.h"
 #include "SkStroke.h"
 #include "SkTemplates.h"
 
+#include "effects/GrEdgeEffect.h"
+
 namespace {
 // quadratics are rendered as 5-sided polys in order to bound the
 // AA stroke around the center-curve. See comments in push_quad_index_buffer and
 // bloat_quad.
 static const int kVertsPerQuad = 5;
 static const int kIdxsPerQuad = 9;
 
 static const int kVertsPerLineSeg = 4;
 static const int kIdxsPerLineSeg = 6;
 
@@ skipping 470 matching lines @@
 
     GrIRect devClipBounds;
     target->getClip()->getConservativeBounds(drawState->getRenderTarget(),
                                              &devClipBounds);
 
     // position + edge
     static const GrVertexAttrib kAttribs[] = {
         {kVec2f_GrVertexAttribType, 0},
         {kVec4f_GrVertexAttribType, sizeof(GrPoint)}
     };
-    static const GrAttribBindings kBindings = GrDrawState::kEdge_AttribBindingsBit;
     SkMatrix viewM = drawState->getViewMatrix();
 
     PREALLOC_PTARRAY(128) lines;
     PREALLOC_PTARRAY(128) quads;
     IntArray qSubdivs;
     *quadCnt = generate_lines_and_quads(path, viewM, devClipBounds,
                                         &lines, &quads, &qSubdivs);
 
     *lineCnt = lines.count() / 2;
     int vertCnt = kVertsPerLineSeg * *lineCnt + kVertsPerQuad * *quadCnt;
 
     target->drawState()->setVertexAttribs(kAttribs, SK_ARRAY_COUNT(kAttribs));
     target->drawState()->setAttribIndex(GrDrawState::kPosition_AttribIndex, 0);
-    target->drawState()->setAttribIndex(GrDrawState::kEdge_AttribIndex, 1);
-    target->drawState()->setAttribBindings(kBindings);
+    target->drawState()->setAttribBindings(GrDrawState::kDefault_AttribBindings);
     GrAssert(sizeof(Vertex) == target->getDrawState().getVertexSize());
 
     if (!arg->set(target, vertCnt, 0)) {
         return false;
     }
 
     Vertex* verts = reinterpret_cast<Vertex*>(arg->vertices());
 
     const SkMatrix* toDevice = NULL;
     const SkMatrix* toSrc = NULL;
@@ skipping 45 matching lines @@
     int quadCnt;
     GrDrawTarget::AutoReleaseGeometry arg;
     if (!this->createGeom(path,
                           target,
                           &lineCnt,
                           &quadCnt,
                           &arg)) {
         return false;
     }
 
+    GrDrawTarget::AutoStateRestore asr(target, GrDrawTarget::kPreserve_ASRInit);
+    GrDrawState* drawState = target->drawState();
+
     GrDrawState::AutoDeviceCoordDraw adcd;
-    GrDrawState* drawState = target->drawState();
     // createGeom transforms the geometry to device space when the matrix does not have
     // perspective.
     if (!drawState->getViewMatrix().hasPerspective()) {
         adcd.set(drawState);
         if (!adcd.succeeded()) {
             return false;
         }
     }
 
     // TODO: See whether rendering lines as degenerate quads improves perf
     // when we have a mix
 
-    GrDrawState::VertexEdgeType oldEdgeType = drawState->getVertexEdgeType();
+    enum {
+        // the edge effects share this stage with glyph rendering
+        // (kGlyphMaskStage in GrTextContext) && SW path rendering
+        // (kPathMaskStage in GrSWMaskHelper)
+        kEdgeEffectStage = GrPaint::kTotalStages,
+    };
+    static const int kEdgeAttrIndex = 1;
 
+    GrEffectRef* hairLineEffect = GrEdgeEffect::Create(GrEdgeEffect::kHairLine_EdgeType);
+    GrEffectRef* hairQuadEffect = GrEdgeEffect::Create(GrEdgeEffect::kHairQuad_EdgeType);
+ 
     target->setIndexSourceToBuffer(fLinesIndexBuffer);
     int lines = 0;
     int nBufLines = fLinesIndexBuffer->maxQuads();
-    drawState->setVertexEdgeType(GrDrawState::kHairLine_EdgeType);
+    drawState->setEffect(kEdgeEffectStage, hairLineEffect, kEdgeAttrIndex)->unref();
     while (lines < lineCnt) {
         int n = GrMin(lineCnt - lines, nBufLines);
         target->drawIndexed(kTriangles_GrPrimitiveType,
                             kVertsPerLineSeg*lines,    // startV
                             0,                         // startI
                             kVertsPerLineSeg*n,        // vCount
                             kIdxsPerLineSeg*n);        // iCount
         lines += n;
     }
 
     target->setIndexSourceToBuffer(fQuadsIndexBuffer);
     int quads = 0;
-    drawState->setVertexEdgeType(GrDrawState::kHairQuad_EdgeType);
+    drawState->setEffect(kEdgeEffectStage, hairQuadEffect, kEdgeAttrIndex)->unref();
     while (quads < quadCnt) {
         int n = GrMin(quadCnt - quads, kNumQuadsInIdxBuffer);
         target->drawIndexed(kTriangles_GrPrimitiveType,
                             4 * lineCnt + kVertsPerQuad*quads, // startV
                             0,                                 // startI
                             kVertsPerQuad*n,                   // vCount
                             kIdxsPerQuad*n);                   // iCount
         quads += n;
     }
-    drawState->setVertexEdgeType(oldEdgeType);
+
     return true;
 }