Fix conics for gpu GrAAHairLinePathRender

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 19 matching lines @@
 //      |\ -_______   /|
 //      | \        \ / |
 //      |  *--------*  |
 //      | /  ______/ \ |
 //      */_-__________\*
 // For: 6 vertices and 18 indices (for 6 triangles)
 
 // Each quadratic is rendered as a five sided polygon. This poly bounds
 // the quadratic's bounding triangle but has been expanded so that the
 // 1-pixel wide area around the curve is inside the poly.
-// If a,b,c are the original control points then the poly a0,b0,c0,c1,a1
+// If a,b,c are the original control points then the poly a0,a1,b0,c0,c1

[bsalomon, 2014/12/22 16:40:46]

really? a1 connects to b0? otherwise, lgtm

[egdaniel, 2014/12/22 16:52:17]

yeah we draw the two "skinny" triangles on the side and then the "large" center
one (a1, b0, c1). Basically a triangle fan with b0 as the base.

[bsalomon, 2014/12/22 17:04:46]

ok, i think the comment is describing the bounding polygon before it is turned
into a tri-whatever.

 // that is rendered would look like this:
 //              b0
 //              b
 //
 //     a0              c0
 //      a            c
 //       a1       c1
 // Each is drawn as three triangles specified by these 9 indices:
 static const uint16_t kQuadIdxBufPattern[] = {
     0, 1, 2,
@@ skipping 885 matching lines @@
                                     kQuadNumVertices*quads,               // startV
                                     0,                                    // startI
                                     kQuadNumVertices*n,                   // vCount
                                     kIdxsPerQuad*n,                       // iCount
                                     &devBounds);
                 quads += n;
             }
         }
 
         if (conicCnt > 0) {
-            GrDrawState::AutoRestoreEffects are(drawState);
             SkAutoTUnref<GrGeometryProcessor> hairConicProcessor(
                     GrConicEffect::Create(color, kHairlineAA_GrProcessorEdgeType, *target->caps(),
                                           newCoverage));
             SkASSERT(hairConicProcessor);
+            GrDrawState::AutoRestoreEffects are(drawState);
+            target->setIndexSourceToBuffer(fQuadsIndexBuffer);
 
             int conics = 0;
             while (conics < conicCnt) {
                 int n = SkTMin(conicCnt - conics, kQuadsNumInIdxBuffer);
                 target->drawIndexed(drawState,
                                     hairConicProcessor,
                                     kTriangles_GrPrimitiveType,
                                     kQuadNumVertices*(quadCnt + conics),  // startV
                                     0,                                    // startI
                                     kQuadNumVertices*n,                   // vCount
                                     kIdxsPerQuad*n,                       // iCount
                                     &devBounds);
                 conics += n;
             }
         }
     }
 
     target->resetIndexSource();
 
     return true;
 }