path ops : fix empty-diff bug, op-in-place

src/pathops/SkOpEdgeBuilder.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "SkOpEdgeBuilder.h"
 #include "SkReduceOrder.h"
 
 void SkOpEdgeBuilder::init() {
@@ skipping 35 matching lines @@
             ++cIndex;
             continue;
         }
         fCurrentContour = &fContours[cIndex];
         rIndex += fCurrentContour->updateSegment(offset - 1,
                 &fReducePts[rIndex]);
     }
     fExtra.reset();  // we're done with this
 }
 
-// FIXME:remove once we can access path pts directly
+// Note that copying the points here avoids copying the resulting path later.
+// To allow Op() to take one of the input paths as an output parameter, either the source data
+// must be copied (as implemented below) or the result must be copied.
+// OPTIMIZATION: This copies both sets of input points every time. If the input data was read
+// directly, the output path would only need to be copied if it was also one of the input paths.
 int SkOpEdgeBuilder::preFetch() {
-    SkPath::RawIter iter(*fPath);  // FIXME: access path directly when allowed
+    SkPath::RawIter iter(*fPath);
     SkPoint pts[4];
     SkPath::Verb verb;
     do {
         verb = iter.next(pts);
         *fPathVerbs.append() = verb;
         if (verb == SkPath::kMove_Verb) {
             *fPathPts.append() = pts[0];
         } else if (verb >= SkPath::kLine_Verb && verb <= SkPath::kCubic_Verb) {
             fPathPts.append(verb, &pts[1]);
         }
     } while (verb != SkPath::kDone_Verb);
     return fPathVerbs.count() - 1;
 }
 
 void SkOpEdgeBuilder::walk() {
     SkPath::Verb reducedVerb;
     uint8_t* verbPtr = fPathVerbs.begin();
     uint8_t* endOfFirstHalf = &verbPtr[fSecondHalf];
     const SkPoint* pointsPtr = fPathPts.begin();
     const SkPoint* finalCurveStart = NULL;
     const SkPoint* finalCurveEnd = NULL;
     SkPath::Verb verb;
-    while ((verb = (SkPath::Verb) *verbPtr++) != SkPath::kDone_Verb) {
+    while ((verb = (SkPath::Verb) *verbPtr) != SkPath::kDone_Verb) {
+        if (verbPtr == endOfFirstHalf) {
+            fOperand = true;
+        }
+        verbPtr++;
         switch (verb) {
             case SkPath::kMove_Verb:
                 complete();
                 if (!fCurrentContour) {
                     fCurrentContour = fContours.push_back_n(1);
                     fCurrentContour->setOperand(fOperand);
                     fCurrentContour->setXor(fXorMask[fOperand] == kEvenOdd_PathOpsMask);
                     *fExtra.append() = -1;  // start new contour
                 }
                 finalCurveEnd = pointsPtr++;
-                goto nextVerb;
+                continue;
             case SkPath::kLine_Verb:
                 // skip degenerate points
                 if (pointsPtr[-1].fX != pointsPtr[0].fX || pointsPtr[-1].fY != pointsPtr[0].fY) {
                     fCurrentContour->addLine(&pointsPtr[-1]);
                 }
                 break;
             case SkPath::kQuad_Verb:
                 reducedVerb = SkReduceOrder::Quad(&pointsPtr[-1], &fReducePts);
                 if (reducedVerb == 0) {
                     break;  // skip degenerate points
@@ skipping 22 matching lines @@
                 break;
             case SkPath::kClose_Verb:
                 SkASSERT(fCurrentContour);
                 if (finalCurveStart && finalCurveEnd
                         && *finalCurveStart != *finalCurveEnd) {
                     *fReducePts.append() = *finalCurveStart;
                     *fReducePts.append() = *finalCurveEnd;
                     *fExtra.append() = fCurrentContour->addLine(fReducePts.end() - 2);
                 }
                 complete();
-                goto nextVerb;
+                continue;
             default:
                 SkDEBUGFAIL("bad verb");
                 return;
         }
         finalCurveStart = &pointsPtr[verb - 1];
         pointsPtr += verb;
         SkASSERT(fCurrentContour);
-    nextVerb:
-        if (verbPtr == endOfFirstHalf) {
-            fOperand = true;
-        }
     }
 }