Add conic support to Default and AAConvex path redender.

src/gpu/GrDefaultPathRenderer.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 "GrDefaultPathRenderer.h"
 
 #include "GrContext.h"
 #include "GrDefaultGeoProcFactory.h"
 #include "GrDrawState.h"
 #include "GrPathUtils.h"
+#include "SkGeometry.h"
 #include "SkString.h"
 #include "SkStrokeRec.h"
 #include "SkTLazy.h"
 #include "SkTraceEvent.h"
 
 
 GrDefaultPathRenderer::GrDefaultPathRenderer(bool separateStencilSupport,
                                              bool stencilWrapOpsSupport)
     : fSeparateStencil(separateStencilSupport)
     , fStencilWrapOps(stencilWrapOpsSupport) {
@@ skipping 225 matching lines @@
     SkPoint pts[4];
 
     bool first = true;
     int subpath = 0;
 
     SkPath::Iter iter(path, false);
 
     for (;;) {
         SkPath::Verb verb = iter.next(pts);
         switch (verb) {
-            case SkPath::kConic_Verb:
-                SkASSERT(0);
+            case SkPath::kConic_Verb: {
+                SkScalar weight = iter.conicWeight();
+                SkAutoConicToQuads converter;
+                const SkPoint* quadPts = converter.computeQuads(pts, weight, 0.25f);

[reed1, 2014/12/22 20:04:09]

// Converting in src-space, hence the finer tolerance (0.25)
// TODO: find a way to do this in dev-space so the tolerance means something

[egdaniel, 2014/12/22 21:37:13]

Done.

+                for (int i = 0; i < converter.countQuads(); ++i) {
+                    int baseIdx = i*2;
+                    uint16_t firstQPtIdx = (uint16_t)(vert - base) - 1;

[reed1, 2014/12/22 20:04:09]

Separate from this CL:
WHAT THE HECK IS UP WITH INT16 IN LOCALS AND LOOP VARIABLES?

[egdaniel, 2014/12/22 21:37:13]

Brian do you have any insight on this?

[bsalomon, 2014/12/22 22:10:31]

I dunno... the indices have to fit in shorts, but these should probably be ints.

+                    uint16_t numPts =  (uint16_t)
+                        GrPathUtils::generateQuadraticPoints(
+                            quadPts[baseIdx], quadPts[baseIdx + 1], quadPts[baseIdx + 2],
+                            srcSpaceTolSqd, &vert,
+                            GrPathUtils::quadraticPointCount(quadPts + baseIdx, srcSpaceTol));
+                    if (indexed) {
+                        for (uint16_t i = 0; i < numPts; ++i) {
+                            append_countour_edge_indices(isHairline, subpathIdxStart,
+                                                         firstQPtIdx + i, &idx);
+                        }
+                    }
+                }
                 break;
+            }
             case SkPath::kMove_Verb:
                 if (!first) {
                     uint16_t currIdx = (uint16_t) (vert - base);
                     subpathIdxStart = currIdx;
                     ++subpath;
                 }
                 *vert = pts[0];
                 vert++;
                 break;
             case SkPath::kLine_Verb:
                 if (indexed) {
                     uint16_t prevIdx = (uint16_t)(vert - base) - 1;
                     append_countour_edge_indices(isHairline, subpathIdxStart,
                                                  prevIdx, &idx);
                 }
                 *(vert++) = pts[1];
                 break;
             case SkPath::kQuad_Verb: {
                 // first pt of quad is the pt we ended on in previous step
                 uint16_t firstQPtIdx = (uint16_t)(vert - base) - 1;

[reed1, 2014/12/22 20:04:09]

can we capture this in a helper function, so we don't have to copy/paste to use
it above for conics?

[egdaniel, 2014/12/22 21:37:13]

Done.

                 uint16_t numPts =  (uint16_t)
                     GrPathUtils::generateQuadraticPoints(
                             pts[0], pts[1], pts[2],
                             srcSpaceTolSqd, &vert,
                             GrPathUtils::quadraticPointCount(pts, srcSpaceTol));
                 if (indexed) {
                     for (uint16_t i = 0; i < numPts; ++i) {
                         append_countour_edge_indices(isHairline, subpathIdxStart,
                                                      firstQPtIdx + i, &idx);
                     }
@@ skipping 227 matching lines @@
     }
     return true;
 }
 
 bool GrDefaultPathRenderer::canDrawPath(const GrDrawTarget* target,
                                         const GrDrawState* drawState,
                                         const SkPath& path,
                                         const SkStrokeRec& stroke,
                                         bool antiAlias) const {
     // this class can draw any path with any fill but doesn't do any anti-aliasing.
-
-    return !antiAlias && !(SkPath::kConic_SegmentMask & path.getSegmentMasks()) &&
-        (stroke.isFillStyle() ||
-         IsStrokeHairlineOrEquivalent(stroke, drawState->getViewMatrix(), NULL));
+    return !antiAlias && (stroke.isFillStyle() ||
+                          IsStrokeHairlineOrEquivalent(stroke, drawState->getViewMatrix(), NULL));
 }
 
 bool GrDefaultPathRenderer::onDrawPath(GrDrawTarget* target,
                                        GrDrawState* drawState,
                                        GrColor color,
                                        const SkPath& path,
                                        const SkStrokeRec& stroke,
                                        bool antiAlias) {
     return this->internalDrawPath(target,
                                   drawState,
                                   color,
                                   path,
                                   stroke,
                                   false);
 }
 
 void GrDefaultPathRenderer::onStencilPath(GrDrawTarget* target,
                                           GrDrawState* drawState,
                                           const SkPath& path,
                                           const SkStrokeRec& stroke) {
     SkASSERT(SkPath::kInverseEvenOdd_FillType != path.getFillType());
     SkASSERT(SkPath::kInverseWinding_FillType != path.getFillType());
     this->internalDrawPath(target, drawState, GrColor_WHITE, path, stroke, true);
 }