WIP: GPU-accelerated trapezoidal path renderer.

src/core/SkStroke.cpp

 /*
  * Copyright 2008 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 "SkStrokerPriv.h"
 #include "SkGeometry.h"
 #include "SkPathPriv.h"
@@ skipping 101 matching lines @@
         fTangentEnd = parent->fTangentEnd;
         fEndSet = true;
         return true;
    }
 };
 
 class SkPathStroker {
 public:
     SkPathStroker(const SkPath& src,
                   SkScalar radius, SkScalar miterLimit, SkPaint::Cap,
-                  SkPaint::Join, SkScalar resScale);
+                  SkPaint::Join, SkScalar resScale, bool autoClose, bool reverseInner);
 
     bool hasOnlyMoveTo() const { return 0 == fSegmentCount; }
     SkPoint moveToPt() const { return fFirstPt; }
 
     void moveTo(const SkPoint&);
     void lineTo(const SkPoint&);
     void quadTo(const SkPoint&, const SkPoint&);
     void conicTo(const SkPoint&, const SkPoint&, SkScalar weight);
     void cubicTo(const SkPoint&, const SkPoint&, const SkPoint&);
     void close(bool isLine) { this->finishContour(true, isLine); }
 
     void done(SkPath* dst, bool isLine) {
-        this->finishContour(false, isLine);
+        this->finishContour(fAutoClose, isLine);
         fOuter.addPath(fExtra);
         dst->swap(fOuter);
     }
 
     SkScalar getResScale() const { return fResScale; }
 
 private:
     SkScalar    fRadius;
     SkScalar    fInvMiterLimit;
     SkScalar    fResScale;
     SkScalar    fInvResScale;
     SkScalar    fInvResScaleSquared;
 
     SkVector    fFirstNormal, fPrevNormal, fFirstUnitNormal, fPrevUnitNormal;
     SkPoint     fFirstPt, fPrevPt;  // on original path
     SkPoint     fFirstOuterPt;
     int         fSegmentCount;
     bool        fPrevIsLine;
+    bool        fAutoClose;
+    bool        fReverseInner;
 
     SkStrokerPriv::CapProc  fCapper;
     SkStrokerPriv::JoinProc fJoiner;
 
     SkPath  fInner, fOuter; // outer is our working answer, inner is temp
     SkPath  fExtra;         // added as extra complete contours
 
     enum StrokeType {
         kOuter_StrokeType = 1,      // use sign-opposite values later to flip perpendicular axis
         kInner_StrokeType = -1
@@ skipping 116 matching lines @@
 
 void SkPathStroker::finishContour(bool close, bool currIsLine) {
     if (fSegmentCount > 0) {
         SkPoint pt;
 
         if (close) {
             fJoiner(&fOuter, &fInner, fPrevUnitNormal, fPrevPt,
                     fFirstUnitNormal, fRadius, fInvMiterLimit,
                     fPrevIsLine, currIsLine);
             fOuter.close();
-            // now add fInner as its own contour
-            fInner.getLastPt(&pt);
-            fOuter.moveTo(pt.fX, pt.fY);
-            fOuter.reversePathTo(fInner);
+            if (fReverseInner) {
+                // now add fInner as its own contour
+                fInner.getLastPt(&pt);
+                fOuter.moveTo(pt.fX, pt.fY);
+                fOuter.reversePathTo(fInner);
+            } else {
+                fOuter.addPath(fInner);
+            }
             fOuter.close();
         } else {    // add caps to start and end
-            // cap the end
-            fInner.getLastPt(&pt);
-            fCapper(&fOuter, fPrevPt, fPrevNormal, pt,
-                    currIsLine ? &fInner : nullptr);
-            fOuter.reversePathTo(fInner);
-            // cap the start
-            fCapper(&fOuter, fFirstPt, -fFirstNormal, fFirstOuterPt,
-                    fPrevIsLine ? &fInner : nullptr);
-            fOuter.close();
+            if (fReverseInner) {
+                // cap the end
+                fInner.getLastPt(&pt);
+                fCapper(&fOuter, fPrevPt, fPrevNormal, pt,
+                        currIsLine ? &fInner : nullptr);
+                fOuter.reversePathTo(fInner);
+                // cap the start
+                fCapper(&fOuter, fFirstPt, -fFirstNormal, fFirstOuterPt,
+                        fPrevIsLine ? &fInner : nullptr);
+                fOuter.close();
+            } else {
+                fOuter.addPath(fInner);
+            }
         }
     }
     // since we may re-use fInner, we rewind instead of reset, to save on
     // reallocating its internal storage.
     fInner.rewind();
     fSegmentCount = -1;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkPathStroker::SkPathStroker(const SkPath& src,
                              SkScalar radius, SkScalar miterLimit,
-                             SkPaint::Cap cap, SkPaint::Join join, SkScalar resScale)
+                             SkPaint::Cap cap, SkPaint::Join join, SkScalar resScale,
+                             bool autoClose, bool reverseInner)
         : fRadius(radius)
-        , fResScale(resScale) {
+        , fResScale(resScale)
+        , fAutoClose(autoClose)
+        , fReverseInner(reverseInner) {
 
     /*  This is only used when join is miter_join, but we initialize it here
         so that it is always defined, to fis valgrind warnings.
     */
     fInvMiterLimit = 0;
 
     if (join == SkPaint::kMiter_Join) {
         if (miterLimit <= SK_Scalar1) {
             join = SkPaint::kBevel_Join;
         } else {
@@ skipping 17 matching lines @@
     fInner.setIsVolatile(true);
     // TODO : write a common error function used by stroking and filling
     // The '4' below matches the fill scan converter's error term
     fInvResScale = SkScalarInvert(resScale * 4);
     fInvResScaleSquared = fInvResScale * fInvResScale;
     fRecursionDepth = 0;
 }
 
 void SkPathStroker::moveTo(const SkPoint& pt) {
     if (fSegmentCount > 0) {
-        this->finishContour(false, false);
+        this->finishContour(fAutoClose, false);
     }
     fSegmentCount = 0;
     fFirstPt = fPrevPt = pt;
 }
 
 void SkPathStroker::line_to(const SkPoint& currPt, const SkVector& normal) {
     fOuter.lineTo(currPt.fX + normal.fX, currPt.fY + normal.fY);
     fInner.lineTo(currPt.fX - normal.fX, currPt.fY - normal.fY);
 }
 
@@ skipping 849 matching lines @@
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "SkPaintDefaults.h"
 
 SkStroke::SkStroke() {
     fWidth      = SK_Scalar1;
     fMiterLimit = SkPaintDefaults_MiterLimit;
     fCap        = SkPaint::kDefault_Cap;
     fJoin       = SkPaint::kDefault_Join;
     fDoFill     = false;
+    fAutoClose  = false;
+    fReverseInner  = true;
 }
 
 SkStroke::SkStroke(const SkPaint& p) {
     fWidth      = p.getStrokeWidth();
     fMiterLimit = p.getStrokeMiter();
     fCap        = (uint8_t)p.getStrokeCap();
     fJoin       = (uint8_t)p.getStrokeJoin();
     fDoFill     = SkToU8(p.getStyle() == SkPaint::kStrokeAndFill_Style);
+    fAutoClose  = false;
+    fReverseInner  = true;
 }
 
 SkStroke::SkStroke(const SkPaint& p, SkScalar width) {
     fWidth      = width;
     fMiterLimit = p.getStrokeMiter();
     fCap        = (uint8_t)p.getStrokeCap();
     fJoin       = (uint8_t)p.getStrokeJoin();
     fDoFill     = SkToU8(p.getStyle() == SkPaint::kStrokeAndFill_Style);
+    fAutoClose  = false;
+    fReverseInner  = true;
 }
 
 void SkStroke::setWidth(SkScalar width) {
     SkASSERT(width >= 0);
     fWidth = width;
 }
 
 void SkStroke::setMiterLimit(SkScalar miterLimit) {
     SkASSERT(miterLimit >= 0);
     fMiterLimit = miterLimit;
@@ skipping 57 matching lines @@
             this->strokeRect(rect, dst, dir);
             // our answer should preserve the inverseness of the src
             if (src.isInverseFillType()) {
                 SkASSERT(!dst->isInverseFillType());
                 dst->toggleInverseFillType();
             }
             return;
         }
     }
 
-    SkPathStroker   stroker(src, radius, fMiterLimit, this->getCap(), this->getJoin(), fResScale);
+    SkPathStroker   stroker(src, radius, fMiterLimit, this->getCap(), this->getJoin(), fResScale, this->getAutoClose(), this->getReverseInner());
     SkPath::Iter    iter(src, false);
     SkPath::Verb    lastSegment = SkPath::kMove_Verb;
 
     for (;;) {
         SkPoint  pts[4];
         switch (iter.next(pts, false)) {
             case SkPath::kMove_Verb:
                 stroker.moveTo(pts[0]);
                 break;
             case SkPath::kLine_Verb:
@@ skipping 135 matching lines @@
         case SkPaint::kRound_Join:
             dst->addRoundRect(r, radius, radius, dir);
             break;
         default:
             break;
     }
 
     if (fWidth < SkMinScalar(rw, rh) && !fDoFill) {
         r = rect;
         r.inset(radius, radius);
-        dst->addRect(r, reverse_direction(dir));
+        dst->addRect(r, this->getReverseInner() ? reverse_direction(dir) : dir);
     }
 }