The Tor Browser / file revision

 /*

  * Copyright 2013 Google Inc.

  *

  * Use of this source code is governed by a BSD-style license that can be

  * found in the LICENSE file.

  */

 #ifndef SkOpContour_DEFINED

 #define SkOpContour_DEFINED

 #include "SkOpSegment.h"

 #include "SkTArray.h"

 class SkIntersections;

 class SkOpContour;

 class SkPathWriter;

 struct SkCoincidence {

     SkOpContour* fOther;

     int fSegments[2];

     double fTs[2][2];

     SkPoint fPts[2];

 };

 class SkOpContour {

 public:

     SkOpContour() {

         reset();

 #ifdef SK_DEBUG

         fID = ++SkPathOpsDebug::gContourID;

 #endif

     }

     bool operator<(const SkOpContour& rh) const {

         return fBounds.fTop == rh.fBounds.fTop

                 ? fBounds.fLeft < rh.fBounds.fLeft

                 : fBounds.fTop < rh.fBounds.fTop;

     }

     bool addCoincident(int index, SkOpContour* other, int otherIndex,

                        const SkIntersections& ts, bool swap);

     void addCoincidentPoints();

     void addCross(const SkOpContour* crosser) {

 #ifdef DEBUG_CROSS

         for (int index = 0; index < fCrosses.count(); ++index) {

             SkASSERT(fCrosses[index] != crosser);

         }

 #endif

         fCrosses.push_back(crosser);

     }

     void addCubic(const SkPoint pts[4]) {

         fSegments.push_back().addCubic(pts, fOperand, fXor);

         fContainsCurves = fContainsCubics = true;

     }

     int addLine(const SkPoint pts[2]) {

         fSegments.push_back().addLine(pts, fOperand, fXor);

         return fSegments.count();

     }

     void addOtherT(int segIndex, int tIndex, double otherT, int otherIndex) {

         fSegments[segIndex].addOtherT(tIndex, otherT, otherIndex);

     }

     bool addPartialCoincident(int index, SkOpContour* other, int otherIndex,

                        const SkIntersections& ts, int ptIndex, bool swap);

     int addQuad(const SkPoint pts[3]) {

         fSegments.push_back().addQuad(pts, fOperand, fXor);

         fContainsCurves = true;

         return fSegments.count();

     }

     int addT(int segIndex, SkOpContour* other, int otherIndex, const SkPoint& pt, double newT) {

         setContainsIntercepts();

         return fSegments[segIndex].addT(&other->fSegments[otherIndex], pt, newT);

     }

     int addSelfT(int segIndex, SkOpContour* other, int otherIndex, const SkPoint& pt, double newT) {

         setContainsIntercepts();

         return fSegments[segIndex].addSelfT(&other->fSegments[otherIndex], pt, newT);

     }

     const SkPathOpsBounds& bounds() const {

         return fBounds;

     }

     void calcCoincidentWinding();

     void calcPartialCoincidentWinding();

     void checkEnds() {

         if (!fContainsCurves) {

             return;

         }

         int segmentCount = fSegments.count();

         for (int sIndex = 0; sIndex < segmentCount; ++sIndex) {

             SkOpSegment* segment = &fSegments[sIndex];

             if (segment->verb() == SkPath::kLine_Verb) {

                 continue;

             }

             if (segment->done()) {

                 continue;   // likely coincident, nothing to do

             }

             segment->checkEnds();

         }

     }

     // if same point has different T values, choose a common T

     void checkTiny() {

         int segmentCount = fSegments.count();

         if (segmentCount <= 2) {

             return;

         }

         for (int sIndex = 0; sIndex < segmentCount; ++sIndex) {

             fSegments[sIndex].checkTiny();

         }

     }

     void complete() {

         setBounds();

         fContainsIntercepts = false;

     }

     bool containsCubics() const {

         return fContainsCubics;

     }

     bool crosses(const SkOpContour* crosser) const {

         for (int index = 0; index < fCrosses.count(); ++index) {

             if (fCrosses[index] == crosser) {

                 return true;

             }

         }

         return false;

     }

     bool done() const {

         return fDone;

     }

     const SkPoint& end() const {

         const SkOpSegment& segment = fSegments.back();

         return segment.pts()[SkPathOpsVerbToPoints(segment.verb())];

     }

     void fixOtherTIndex() {

         int segmentCount = fSegments.count();

         for (int sIndex = 0; sIndex < segmentCount; ++sIndex) {

             fSegments[sIndex].fixOtherTIndex();

         }

     }

     void joinCoincidence() {

         joinCoincidence(fCoincidences, false);

         joinCoincidence(fPartialCoincidences, true);

     }

     SkOpSegment* nonVerticalSegment(int* start, int* end);

     bool operand() const {

         return fOperand;

     }

     void reset() {

         fSegments.reset();

         fBounds.set(SK_ScalarMax, SK_ScalarMax, SK_ScalarMax, SK_ScalarMax);

         fContainsCurves = fContainsCubics = fContainsIntercepts = fDone = false;

     }

     SkTArray<SkOpSegment>& segments() {

         return fSegments;

     }

     void setContainsIntercepts() {

         fContainsIntercepts = true;

     }

     void setOperand(bool isOp) {

         fOperand = isOp;

     }

     void setOppXor(bool isOppXor) {

         fOppXor = isOppXor;

         int segmentCount = fSegments.count();

         for (int test = 0; test < segmentCount; ++test) {

             fSegments[test].setOppXor(isOppXor);

         }

     }

     void setXor(bool isXor) {

         fXor = isXor;

     }

     void sortSegments();

     const SkPoint& start() const {

         return fSegments.front().pts()[0];

     }

     void toPath(SkPathWriter* path) const;

     void toPartialBackward(SkPathWriter* path) const {

         int segmentCount = fSegments.count();

         for (int test = segmentCount - 1; test >= 0; --test) {

             fSegments[test].addCurveTo(1, 0, path, true);

         }

     }

     void toPartialForward(SkPathWriter* path) const {

         int segmentCount = fSegments.count();

         for (int test = 0; test < segmentCount; ++test) {

             fSegments[test].addCurveTo(0, 1, path, true);

         }

     }

     void topSortableSegment(const SkPoint& topLeft, SkPoint* bestXY, SkOpSegment** topStart);

     SkOpSegment* undoneSegment(int* start, int* end);

     int updateSegment(int index, const SkPoint* pts) {

         SkOpSegment& segment = fSegments[index];

         segment.updatePts(pts);

         return SkPathOpsVerbToPoints(segment.verb()) + 1;

     }

 #if DEBUG_TEST

     SkTArray<SkOpSegment>& debugSegments() {

         return fSegments;

     }

 #endif

 #if DEBUG_ACTIVE_SPANS || DEBUG_ACTIVE_SPANS_FIRST_ONLY

     void debugShowActiveSpans() {

         for (int index = 0; index < fSegments.count(); ++index) {

             fSegments[index].debugShowActiveSpans();

         }

     }

 #endif

 #if DEBUG_SHOW_WINDING

     int debugShowWindingValues(int totalSegments, int ofInterest);

     static void debugShowWindingValues(const SkTArray<SkOpContour*, true>& contourList);

 #endif

 private:

     void calcCommonCoincidentWinding(const SkCoincidence& );

     void joinCoincidence(const SkTArray<SkCoincidence, true>& , bool partial);

     void setBounds();

     SkTArray<SkOpSegment> fSegments;

     SkTArray<SkOpSegment*, true> fSortedSegments;

     int fFirstSorted;

     SkTArray<SkCoincidence, true> fCoincidences;

     SkTArray<SkCoincidence, true> fPartialCoincidences;

     SkTArray<const SkOpContour*, true> fCrosses;

     SkPathOpsBounds fBounds;

     bool fContainsIntercepts;  // FIXME: is this used by anybody?

     bool fContainsCubics;

     bool fContainsCurves;

     bool fDone;

     bool fOperand;  // true for the second argument to a binary operator

     bool fXor;

     bool fOppXor;

 #ifdef SK_DEBUG

     int fID;

 #endif

 };

 #endif