add support for capped hairlines

src/core/SkScan_Hairline.cpp

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkScan.h"
 #include "SkBlitter.h"
 #include "SkRasterClip.h"
@@ skipping 330 matching lines @@
      than a pixel.
      */
     int level = (33 - SkCLZ(d)) >> 1;
     // sanity check on level (from the previous version)
     if (level > kMaxQuadSubdivideLevel) {
         level = kMaxQuadSubdivideLevel;
     }
     return level;
 }
 
+static void hairconic(SkPoint pts[4], const SkRegion* clip, SkBlitter* blitter,
+                      SkScalar weight, SkScan::HairRgnProc lineproc) {             
+    SkAutoConicToQuads converter;
+    // how close should the quads be to the original conic?
+    const SkScalar tol = SK_Scalar1 / 4;
+    const SkPoint* quadPts = converter.computeQuads(pts, weight, tol);
+    for (int i = 0; i < converter.countQuads(); ++i) {
+        int level = compute_quad_level(quadPts);
+        hairquad(quadPts, clip, blitter, level, lineproc);
+        quadPts += 2;
+    }
+}
+
+/* Extend the points in the direction of the starting or ending tangent by 1/2 unit to
+   account for a round or square cap. If there's no distance between the end point and
+   the control point, use the next control point to create a tangent. If the curve
+   is degenerate, move the cap out 1/2 unit horizontally. */
+static void extend_pts(SkPath::Verb prevVerb, SkPath::Verb nextVerb, SkPoint* pts, int ptCount) {
+    if (SkPath::kMove_Verb == prevVerb) {
+        SkPoint* first = pts;
+        SkPoint* ctrl = first;
+        int controls = ptCount - 1;
+        SkVector tangent;
+        do {
+            tangent = *first - *++ctrl;
+        } while (tangent.isZero() && --controls > 0);
+        if (tangent.isZero()) {
+            tangent.set(1, 0);
+        } else {
+            tangent.normalize();
+        }
+        first->fX += tangent.fX * 0.5f;
+        first->fY += tangent.fY * 0.5f;
+    }
+    if (SkPath::kMove_Verb == nextVerb || SkPath::kDone_Verb == nextVerb) {
+        SkPoint* last = &pts[ptCount - 1];
+        SkPoint* ctrl = last;
+        int controls = ptCount - 1;
+        SkVector tangent;
+        do {
+            tangent = *last - *--ctrl;
+        } while (tangent.isZero() && --controls > 0);
+        if (tangent.isZero()) {
+            tangent.set(-1, 0);
+        } else {
+            tangent.normalize();
+        }
+        last->fX += tangent.fX * 0.5f;
+        last->fY += tangent.fY * 0.5f;
+    }
+}
+
+enum ExtendEnds {
+    kNo_ExtendEnds,
+    kCaps_ExtendEnds,
+};
+
 static void hair_path(const SkPath& path, const SkRasterClip& rclip, SkBlitter* blitter,
-                      SkScan::HairRgnProc lineproc) {
+                      SkScan::HairRgnProc lineproc, ExtendEnds extendForCaps) {
     if (path.isEmpty()) {
         return;
     }
 
     SkAAClipBlitterWrapper wrap;
     const SkRegion* clip = nullptr;
 
     {
         const SkIRect ibounds = path.getBounds().roundOut().makeOutset(1, 1);
 
         if (rclip.quickReject(ibounds)) {
             return;
         }
         if (!rclip.quickContains(ibounds)) {
             if (rclip.isBW()) {
                 clip = &rclip.bwRgn();
             } else {
                 wrap.init(rclip, blitter);
                 blitter = wrap.getBlitter();
                 clip = &wrap.getRgn();
             }
         }
     }
 
     SkPath::Iter    iter(path, false);
     SkPoint         pts[4];
     SkPath::Verb    verb;
-    SkAutoConicToQuads converter;
 
-    while ((verb = iter.next(pts, false)) != SkPath::kDone_Verb) {
-        switch (verb) {
-            case SkPath::kMove_Verb:
+    if (kNo_ExtendEnds == extendForCaps) {
+        while ((verb = iter.next(pts, false)) != SkPath::kDone_Verb) {
+            switch (verb) {
+                case SkPath::kMove_Verb:
+                    break;
+                case SkPath::kLine_Verb:
+                    lineproc(pts, 2, clip, blitter);
+                    break;
+                case SkPath::kQuad_Verb:
+                    hairquad(pts, clip, blitter, compute_quad_level(pts), lineproc);
+                    break;
+                case SkPath::kConic_Verb:
+                    hairconic(pts, clip, blitter, iter.conicWeight(), lineproc);
+                    break;
+                case SkPath::kCubic_Verb:
+                    haircubic(pts, clip, blitter, kMaxCubicSubdivideLevel, lineproc);
                 break;
-            case SkPath::kLine_Verb:
-                lineproc(pts, 2, clip, blitter);
+                case SkPath::kClose_Verb:
+                    break;
+                case SkPath::kDone_Verb:
+                    break;
+            }
+        }
+    } else {
+        /* If the caps require extending the haircurve, use the previous and following verbs
+           to determine if the curve is at the start or end of the contour. If the curve is
+           preceeded by a move verb, or followed by a move verb or a done verb, extend the curve. */
+        SkASSERT(kCaps_ExtendEnds == extendForCaps);
+        SkPath::Verb prevVerb;
+        verb = SkPath::kDone_Verb;
+        SkScalar weight SK_INIT_TO_AVOID_WARNING;
+        do {
+            SkPoint nextPts[4];
+            SkPath::Verb nextVerb = iter.next(nextPts, false);
+            switch (verb) {
+                case SkPath::kMove_Verb:
+                    break;
+                case SkPath::kLine_Verb:
+                    extend_pts(prevVerb, nextVerb, pts, 2);
+                    lineproc(pts, 2, clip, blitter);
+                    break;
+                case SkPath::kQuad_Verb:
+                    extend_pts(prevVerb, nextVerb, pts, 3);
+                    hairquad(pts, clip, blitter, compute_quad_level(pts), lineproc);
+                    break;
+                case SkPath::kConic_Verb:
+                    extend_pts(prevVerb, nextVerb, pts, 3);
+                    hairconic(pts, clip, blitter, weight, lineproc);
+                    break;
+                case SkPath::kCubic_Verb:
+                    extend_pts(prevVerb, nextVerb, pts, 4);
+                    haircubic(pts, clip, blitter, kMaxCubicSubdivideLevel, lineproc);
                 break;
-            case SkPath::kQuad_Verb:
-                hairquad(pts, clip, blitter, compute_quad_level(pts), lineproc);
-                break;
-            case SkPath::kConic_Verb: {
-                // how close should the quads be to the original conic?
-                const SkScalar tol = SK_Scalar1 / 4;
-                const SkPoint* quadPts = converter.computeQuads(pts,
-                                                       iter.conicWeight(), tol);
-                for (int i = 0; i < converter.countQuads(); ++i) {
-                    int level = compute_quad_level(quadPts);
-                    hairquad(quadPts, clip, blitter, level, lineproc);
-                    quadPts += 2;
-                }
+                case SkPath::kClose_Verb:
+                    break;
+                case SkPath::kDone_Verb:
+                    break;
+            }
+            if (SkPath::kDone_Verb == nextVerb) {
                 break;
             }
-            case SkPath::kCubic_Verb: {
-                haircubic(pts, clip, blitter, kMaxCubicSubdivideLevel, lineproc);
-            } break;
-            case SkPath::kClose_Verb:
-                break;
-            case SkPath::kDone_Verb:
-                break;
-        }
+            if (SkPath::kConic_Verb == nextVerb) {
+                weight = iter.conicWeight();
+            }
+            memcpy(pts, nextPts, sizeof(pts));
+            prevVerb = verb;
+            verb = nextVerb;
+        } while (true);
     }
 }
 
 void SkScan::HairPath(const SkPath& path, const SkRasterClip& clip, SkBlitter* blitter) {
-    hair_path(path, clip, blitter, SkScan::HairLineRgn);
+    hair_path(path, clip, blitter, SkScan::HairLineRgn, kNo_ExtendEnds);
 }
 
 void SkScan::AntiHairPath(const SkPath& path, const SkRasterClip& clip, SkBlitter* blitter) {
-    hair_path(path, clip, blitter, SkScan::AntiHairLineRgn);
+    hair_path(path, clip, blitter, SkScan::AntiHairLineRgn, kNo_ExtendEnds);
+}
+
+void SkScan::HairCapPath(const SkPath& path, const SkRasterClip& clip, SkBlitter* blitter) {
+    hair_path(path, clip, blitter, SkScan::HairLineRgn, kCaps_ExtendEnds);
+}
+
+void SkScan::AntiHairCapPath(const SkPath& path, const SkRasterClip& clip, SkBlitter* blitter) {
+    hair_path(path, clip, blitter, SkScan::AntiHairLineRgn, kCaps_ExtendEnds);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkScan::FrameRect(const SkRect& r, const SkPoint& strokeSize,
                        const SkRasterClip& clip, SkBlitter* blitter) {
     SkASSERT(strokeSize.fX >= 0 && strokeSize.fY >= 0);
 
     if (strokeSize.fX < 0 || strokeSize.fY < 0) {
         return;
@@ skipping 59 matching lines @@
 
         SkAAClipBlitterWrapper wrap;
         if (!clip.quickContains(r.roundOut().makeOutset(1, 1))) {
             wrap.init(clip, blitter);
             blitter = wrap.getBlitter();
             clipRgn = &wrap.getRgn();
         }
         AntiHairLineRgn(pts, count, clipRgn, blitter);
     }
 }