Make SkPath::isOval() and SkPath::isRRect return the orientation and starting index.

include/core/SkPathRef.h

 
 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkPathRef_DEFINED
 #define SkPathRef_DEFINED
@@ skipping 82 matching lines @@
          */
         void resetToSize(int newVerbCnt, int newPointCnt, int newConicCount) {
             fPathRef->resetToSize(newVerbCnt, newPointCnt, newConicCount);
         }
 
         /**
          * Gets the path ref that is wrapped in the Editor.
          */
         SkPathRef* pathRef() { return fPathRef; }
 
-        void setIsOval(bool isOval) { fPathRef->setIsOval(isOval); }
+        void setIsOval(bool isOval, bool isCCW, unsigned start) {
+            fPathRef->setIsOval(isOval, isCCW, start);
+        }
 
-        void setIsRRect(bool isRRect) { fPathRef->setIsRRect(isRRect); }
+        void setIsRRect(bool isRRect, bool isCCW, unsigned start) {
+            fPathRef->setIsRRect(isRRect, isCCW, start);
+        }
 
         void setBounds(const SkRect& rect) { fPathRef->setBounds(rect); }
 
     private:
         SkPathRef* fPathRef;
     };
 
     class SK_API Iter {
     public:
         Iter();
@@ skipping 41 matching lines @@
      *  Returns a mask, where each bit corresponding to a SegmentMask is
      *  set if the path contains 1 or more segments of that type.
      *  Returns 0 for an empty path (no segments).
      */
     uint32_t getSegmentMasks() const { return fSegmentMask; }
 
     /** Returns true if the path is an oval.
      *
      * @param rect      returns the bounding rect of this oval. It's a circle
      *                  if the height and width are the same.
+     * @param isCCW     is the oval CCW (or CW if false).
+     * @param start     indicates where the contour starts on the oval (see
+     *                  SkPath::addOval for intepretation of the index).
      *
      * @return true if this path is an oval.
      *              Tracking whether a path is an oval is considered an
      *              optimization for performance and so some paths that are in
      *              fact ovals can report false.
      */
-    bool isOval(SkRect* rect) const {
-        if (fIsOval && rect) {
-            *rect = this->getBounds();
+    bool isOval(SkRect* rect, bool* isCCW, unsigned* start) const {
+        if (fIsOval) {
+            if (rect) {
+                *rect = this->getBounds();
+            }
+            if (isCCW) {
+                *isCCW = SkToBool(fRRectOrOvalIsCCW);
+            }
+            if (start) {
+                *start = fRRectOrOvalStartIdx;
+            }
         }
 
         return SkToBool(fIsOval);
     }
 
-    bool isRRect(SkRRect* rrect) const {
-        if (fIsRRect && rrect) {
-            *rrect = this->getRRect();
+    bool isRRect(SkRRect* rrect, bool* isCCW, unsigned* start) const {
+        if (fIsRRect) {
+            if (rrect) {
+                *rrect = this->getRRect();
+            }
+            if (isCCW) {
+                *isCCW = SkToBool(fRRectOrOvalIsCCW);
+            }
+            if (start) {
+                *start = fRRectOrOvalStartIdx;
+            }
         }
         return SkToBool(fIsRRect);
     }
 
 
     bool hasComputedBounds() const {
         return !fBoundsIsDirty;
     }
 
     /** Returns the bounds of the path's points. If the path contains 0 or 1
@@ skipping 91 matching lines @@
         virtual ~GenIDChangeListener() {}
         virtual void onChange() = 0;
     };
 
     void addGenIDChangeListener(GenIDChangeListener* listener);
 
     SkDEBUGCODE(void validate() const;)
 
 private:
     enum SerializationOffsets {
-        kIsRRect_SerializationShift = 26,   // requires 1 bit
-        kIsFinite_SerializationShift = 25,  // requires 1 bit
-        kIsOval_SerializationShift = 24,    // requires 1 bit
-        kSegmentMask_SerializationShift = 0 // requires 4 bits
+        kRRectOrOvalStartIdx_SerializationShift = 28,  // requires 3 bits
+        kRRectOrOvalIsCCW_SerializationShift = 27,     // requires 1 bit
+        kIsRRect_SerializationShift = 26,              // requires 1 bit
+        kIsFinite_SerializationShift = 25,             // requires 1 bit
+        kIsOval_SerializationShift = 24,               // requires 1 bit
+        kSegmentMask_SerializationShift = 0            // requires 4 bits
     };
 
     SkPathRef() {
         fBoundsIsDirty = true;    // this also invalidates fIsFinite
         fPointCnt = 0;
         fVerbCnt = 0;
         fVerbs = NULL;
         fPoints = NULL;
         fFreeSpace = 0;
         fGenerationID = kEmptyGenID;
         fSegmentMask = 0;
         fIsOval = false;
         fIsRRect = false;
+        // The next two values don't matter unless fIsOval or fIsRRect are true.
+        SkDEBUGCODE(fRRectOrOvalIsCCW = false);
+        SkDEBUGCODE(fRRectOrOvalStartIdx = 0xAC);
         SkDEBUGCODE(fEditorsAttached = 0;)
         SkDEBUGCODE(this->validate();)
     }
 
     void copy(const SkPathRef& ref, int additionalReserveVerbs, int additionalReservePoints);
 
     // Return true if the computed bounds are finite.
     static bool ComputePtBounds(SkRect* bounds, const SkPathRef& ref) {
         return bounds->setBoundsCheck(ref.points(), ref.countPoints());
     }
@@ skipping 125 matching lines @@
      */
     size_t currSize() const {
         return reinterpret_cast<intptr_t>(fVerbs) - reinterpret_cast<intptr_t>(fPoints);
     }
 
     /**
      * Called the first time someone calls CreateEmpty to actually create the singleton.
      */
     friend SkPathRef* sk_create_empty_pathref();
 
-    void setIsOval(bool isOval) { fIsOval = isOval; }
+    void setIsOval(bool isOval, bool isCCW, unsigned start) {
+        fIsOval = isOval;
+        fRRectOrOvalIsCCW = isCCW;
+        fRRectOrOvalStartIdx = start;
+    }
 
-    void setIsRRect(bool isRRect) { fIsRRect = isRRect; }
+    void setIsRRect(bool isRRect, bool isCCW, unsigned start) {
+        fIsRRect = isRRect;
+        fRRectOrOvalIsCCW = isCCW;
+        fRRectOrOvalStartIdx = start;
+    }
 
     // called only by the editor. Note that this is not a const function.
     SkPoint* getPoints() {
         SkDEBUGCODE(this->validate();)
         fIsOval = false;
         fIsRRect = false;
         return fPoints;
     }
 
     const SkPoint* getPoints() const {
@@ skipping 22 matching lines @@
     mutable uint32_t    fGenerationID;
     SkDEBUGCODE(int32_t fEditorsAttached;) // assert that only one editor in use at any time.
 
     SkTDArray<GenIDChangeListener*> fGenIDChangeListeners;  // pointers are owned
 
     mutable uint8_t  fBoundsIsDirty;
     mutable SkBool8  fIsFinite;    // only meaningful if bounds are valid
 
     SkBool8  fIsOval;
     SkBool8  fIsRRect;
+    // Both the circle and rrect special cases have a notion of direction and starting point
+    // The next two variables store that information for either.
+    SkBool8  fRRectOrOvalIsCCW;
+    uint8_t  fRRectOrOvalStartIdx;
     uint8_t  fSegmentMask;
 
     friend class PathRefTest_Private;
     friend class ForceIsRRect_Private; // unit test isRRect
     typedef SkRefCnt INHERITED;
 };
 
 #endif