First step to moving vertex attributes to the geometryProcessor

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"
@@ skipping 624 matching lines @@
         }
     }
 
     *vert += kLineSegNumVertices;
 }
 
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-namespace {
-// position + edge
-extern const GrVertexAttrib gHairlineBezierAttribs[] = {
-    {kVec2f_GrVertexAttribType, 0,                  kPosition_GrVertexAttribBinding},
-    {kVec4f_GrVertexAttribType, sizeof(SkPoint),    kGeometryProcessor_GrVertexAttribBinding}
-};
-};
-
 bool GrAAHairLinePathRenderer::createLineGeom(GrDrawTarget* target,
                                               GrDrawState* drawState,
                                               GrDrawTarget::AutoReleaseGeometry* arg,
                                               SkRect* devBounds,
                                               const SkPath& path,
                                               const PtArray& lines,
                                               int lineCnt) {
     const SkMatrix& viewM = drawState->getViewMatrix();
 
     int vertCnt = kLineSegNumVertices * lineCnt;
 
-    GrDefaultGeoProcFactory::SetAttribs(drawState, GrDefaultGeoProcFactory::kPosition_GPType |
-                                                   GrDefaultGeoProcFactory::kCoverage_GPType);
-
-    if (!arg->set(target, vertCnt, drawState->getVertexStride(),  0)) {
+    size_t vstride = drawState->getGeometryProcessor()->getVertexStride();
+    SkASSERT(vstride == sizeof(LineVertex));
+    if (!arg->set(target, vertCnt, vstride,  0)) {
         return false;
     }
 
     LineVertex* verts = reinterpret_cast<LineVertex*>(arg->vertices());
 
     const SkMatrix* toSrc = NULL;
     SkMatrix ivm;
 
     if (viewM.hasPerspective()) {
         if (viewM.invert(&ivm)) {
@@ skipping 16 matching lines @@
 bool GrAAHairLinePathRenderer::createBezierGeom(GrDrawTarget* target,
                                                 GrDrawState* drawState,
                                                 GrDrawTarget::AutoReleaseGeometry* arg,
                                                 SkRect* devBounds,
                                                 const SkPath& path,
                                                 const PtArray& quads,
                                                 int quadCnt,
                                                 const PtArray& conics,
                                                 int conicCnt,
                                                 const IntArray& qSubdivs,
-                                                const FloatArray& cWeights) {
+                                                const FloatArray& cWeights,
+                                                size_t vertexStride) {
     const SkMatrix& viewM = drawState->getViewMatrix();
 
     int vertCnt = kQuadNumVertices * quadCnt + kQuadNumVertices * conicCnt;
 
-    int vAttribCnt = SK_ARRAY_COUNT(gHairlineBezierAttribs);
-    drawState->setVertexAttribs<gHairlineBezierAttribs>(vAttribCnt, sizeof(BezierVertex));
-
-    if (!arg->set(target, vertCnt, drawState->getVertexStride(), 0)) {
+    if (!arg->set(target, vertCnt, vertexStride, 0)) {
         return false;
     }
 
     BezierVertex* verts = reinterpret_cast<BezierVertex*>(arg->vertices());
 
     const SkMatrix* toDevice = NULL;
     const SkMatrix* toSrc = NULL;
     SkMatrix ivm;
 
     if (viewM.hasPerspective()) {
@@ skipping 116 matching lines @@
     quadCnt = generate_lines_and_quads(path, drawState->getViewMatrix(), devClipBounds,
                                        &lines, &quads, &conics, &qSubdivs, &cWeights);
     lineCnt = lines.count() / 2;
     conicCnt = conics.count() / 3;
 
     // do lines first
     if (lineCnt) {
         GrDrawTarget::AutoReleaseGeometry arg;
         SkRect devBounds;
 
+        uint32_t gpFlags = GrDefaultGeoProcFactory::kPosition_GPType |
+                           GrDefaultGeoProcFactory::kCoverage_GPType;
+        GrDrawState::AutoRestoreEffects are(drawState);
+        drawState->setGeometryProcessor(GrDefaultGeoProcFactory::Create(gpFlags))->unref();
+
         if (!this->createLineGeom(target,
                                   drawState,
                                   &arg,
                                   &devBounds,
                                   path,
                                   lines,
                                   lineCnt)) {
             return false;
         }
 
         // createLineGeom transforms the geometry to device space when the matrix does not have
         // perspective.
         GrDrawState::AutoViewMatrixRestore avmr;
         if (!drawState->getViewMatrix().hasPerspective() && !avmr.setIdentity(drawState)) {
             return false;
         }
 
         // Check devBounds
         SkASSERT(check_bounds<LineVertex>(drawState, devBounds, arg.vertices(),
                                           kLineSegNumVertices * lineCnt));
 
         {
-            GrDrawState::AutoRestoreEffects are(drawState);
-            drawState->setGeometryProcessor(GrDefaultGeoProcFactory::Create(false))->unref();
             target->setIndexSourceToBuffer(fLinesIndexBuffer);
             int lines = 0;
             while (lines < lineCnt) {
                 int n = SkTMin(lineCnt - lines, kLineSegsNumInIdxBuffer);
                 target->drawIndexed(drawState,
                                     kTriangles_GrPrimitiveType,
                                     kLineSegNumVertices*lines,     // startV
                                     0,                             // startI
                                     kLineSegNumVertices*n,         // vCount
                                     kIdxsPerLineSeg*n,             // iCount
@@ skipping 11 matching lines @@
         if (!this->createBezierGeom(target,
                                     drawState,
                                     &arg,
                                     &devBounds,
                                     path,
                                     quads,
                                     quadCnt,
                                     conics,
                                     conicCnt,
                                     qSubdivs,
-                                    cWeights)) {
+                                    cWeights,
+                                    sizeof(BezierVertex))) {
             return false;
         }
 
         // createGeom transforms the geometry to device space when the matrix does not have
         // perspective.
         GrDrawState::AutoViewMatrixRestore avmr;
         if (!drawState->getViewMatrix().hasPerspective() && !avmr.setIdentity(drawState)) {
             return false;
         }
 
 
         // Check devBounds
         SkASSERT(check_bounds<BezierVertex>(drawState, devBounds, arg.vertices(),
                                             kQuadNumVertices * quadCnt + kQuadNumVertices * conicCnt));
 
         if (quadCnt > 0) {
             GrGeometryProcessor* hairQuadProcessor =
                     GrQuadEffect::Create(kHairlineAA_GrProcessorEdgeType, *target->caps());
             SkASSERT(hairQuadProcessor);
             GrDrawState::AutoRestoreEffects are(drawState);
             target->setIndexSourceToBuffer(fQuadsIndexBuffer);
+
             drawState->setGeometryProcessor(hairQuadProcessor)->unref();
             int quads = 0;
             while (quads < quadCnt) {
                 int n = SkTMin(quadCnt - quads, kQuadsNumInIdxBuffer);
                 target->drawIndexed(drawState,
                                     kTriangles_GrPrimitiveType,
                                     kQuadNumVertices*quads,               // startV
                                     0,                                    // startI
                                     kQuadNumVertices*n,                   // vCount
                                     kIdxsPerQuad*n,                       // iCount
                                     &devBounds);
                 quads += n;
             }
         }
 
         if (conicCnt > 0) {
             GrDrawState::AutoRestoreEffects are(drawState);
             GrGeometryProcessor* hairConicProcessor = GrConicEffect::Create(
                     kHairlineAA_GrProcessorEdgeType, *target->caps());
             SkASSERT(hairConicProcessor);
+
             drawState->setGeometryProcessor(hairConicProcessor)->unref();
             int conics = 0;
             while (conics < conicCnt) {
                 int n = SkTMin(conicCnt - conics, kQuadsNumInIdxBuffer);
                 target->drawIndexed(drawState,
                                     kTriangles_GrPrimitiveType,
                                     kQuadNumVertices*(quadCnt + conics),  // startV
                                     0,                                    // startI
                                     kQuadNumVertices*n,                   // vCount
                                     kIdxsPerQuad*n,                       // iCount
                                     &devBounds);
                 conics += n;
             }
         }
     }
 
     target->resetIndexSource();
 
     return true;
 }