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

src/core/SkPathRef.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBuffer.h"
 #include "SkOnce.h"
 #include "SkPath.h"
@@ skipping 38 matching lines @@
 
 SkPathRef* SkPathRef::CreateEmpty() {
     static SkOnce once;
     once([]{
         gEmpty = new SkPathRef;
         gEmpty->computeBounds();   // Avoids races later to be the first to do this.
     });
     return SkRef(gEmpty);
 }
 
+static void transform_dir_and_start(const SkMatrix& matrix, bool isRRect, bool* isCCW,
+                                    unsigned* start) {
+    int inStart = *start;
+    int rm = 0;
+    if (isRRect) {
+        // Degenerate rrect indices to oval indices and remember the remainder.
+        // Ovals have one index per side whereas rrects have two.
+        rm = inStart & 0b1;
+        inStart /= 2;
+    }
+    // Is the antidiagonal non-zero (otherwise the diagonal is zero)
+    int antiDiag;
+    // Is the non-zero value in the top row (either kMScaleX or kMSkewX) negative
+    int topNeg;
+    // Are the two non-zero diagonal or antidiagonal values the same sign.
+    int sameSign;
+    if (matrix.get(SkMatrix::kMScaleX) != 0) {
+        antiDiag = 0b00;
+        if (matrix.get(SkMatrix::kMScaleX) > 0) {
+            topNeg = 0b00;
+            sameSign = matrix.get(SkMatrix::kMScaleY) > 0 ? 0b01 : 0b00;
+        } else {
+            topNeg = 0b10;
+            sameSign = matrix.get(SkMatrix::kMScaleY) > 0 ? 0b00 : 0b01;
+        }
+    } else {
+        antiDiag = 0b01;
+        if (matrix.get(SkMatrix::kMSkewX) > 0) {
+            topNeg = 0b00;
+            sameSign = matrix.get(SkMatrix::kMSkewY) > 0 ? 0b01 : 0b00;
+        } else {
+            topNeg = 0b10;
+            sameSign = matrix.get(SkMatrix::kMSkewY) > 0 ? 0b00 : 0b01;
+        }
+    }
+    if (sameSign != antiDiag) {
+        // This is a rotation (and maybe scale). The direction is unchanged.
+        // Trust me on the start computation (or draw yourself some pictures)
+        *start = (inStart + 4 - (topNeg | antiDiag)) % 4;
+        SkASSERT(*start < 4);
+        if (isRRect) {
+            *start = 2 * *start + rm;
+        }
+    } else {
+        // This is a mirror (and maybe scale). The direction is reversed.
+        *isCCW = !*isCCW;
+        // Trust me on the start computation (or draw yourself some pictures)
+        *start = (6 + (topNeg | antiDiag) - inStart) % 4;
+        SkASSERT(*start < 4);
+        if (isRRect) {
+            *start = 2 * *start + (rm ? 0 : 1);
+        }
+    }
+}
+
 void SkPathRef::CreateTransformedCopy(SkAutoTUnref<SkPathRef>* dst,
                                       const SkPathRef& src,
                                       const SkMatrix& matrix) {
     SkDEBUGCODE(src.validate();)
     if (matrix.isIdentity()) {
         if (*dst != &src) {
             src.ref();
             dst->reset(const_cast<SkPathRef*>(&src));
             SkDEBUGCODE((*dst)->validate();)
         }
@@ skipping 14 matching lines @@
     SkASSERT((*dst)->countPoints() == src.countPoints());
     SkASSERT((*dst)->countVerbs() == src.countVerbs());
     SkASSERT((*dst)->fConicWeights.count() == src.fConicWeights.count());
 
     // Need to check this here in case (&src == dst)
     bool canXformBounds = !src.fBoundsIsDirty && matrix.rectStaysRect() && src.countPoints() > 1;
 
     matrix.mapPoints((*dst)->fPoints, src.points(), src.fPointCnt);
 
     /*
-        *  Here we optimize the bounds computation, by noting if the bounds are
-        *  already known, and if so, we just transform those as well and mark
-        *  them as "known", rather than force the transformed path to have to
-        *  recompute them.
-        *
-        *  Special gotchas if the path is effectively empty (<= 1 point) or
-        *  if it is non-finite. In those cases bounds need to stay empty,
-        *  regardless of the matrix.
-        */
+     *  Here we optimize the bounds computation, by noting if the bounds are
+     *  already known, and if so, we just transform those as well and mark
+     *  them as "known", rather than force the transformed path to have to
+     *  recompute them.
+     *
+     *  Special gotchas if the path is effectively empty (<= 1 point) or
+     *  if it is non-finite. In those cases bounds need to stay empty,
+     *  regardless of the matrix.
+     */
     if (canXformBounds) {
         (*dst)->fBoundsIsDirty = false;
         if (src.fIsFinite) {
             matrix.mapRect(&(*dst)->fBounds, src.fBounds);
             if (!((*dst)->fIsFinite = (*dst)->fBounds.isFinite())) {
                 (*dst)->fBounds.setEmpty();
             }
         } else {
             (*dst)->fIsFinite = false;
             (*dst)->fBounds.setEmpty();
         }
     } else {
         (*dst)->fBoundsIsDirty = true;
     }
 
     (*dst)->fSegmentMask = src.fSegmentMask;
 
     // It's an oval only if it stays a rect.
     bool rectStaysRect = matrix.rectStaysRect();
     (*dst)->fIsOval = src.fIsOval && rectStaysRect;
     (*dst)->fIsRRect = src.fIsRRect && rectStaysRect;
+    if ((*dst)->fIsOval || (*dst)->fIsRRect) {
+        unsigned start = src.fRRectOrOvalStartIdx;
+        bool isCCW = SkToBool(src.fRRectOrOvalIsCCW);
+        transform_dir_and_start(matrix, (*dst)->fIsRRect, &isCCW, &start);
+        (*dst)->fRRectOrOvalIsCCW = isCCW;
+        (*dst)->fRRectOrOvalStartIdx = start;
+    }
 
     SkDEBUGCODE((*dst)->validate();)
 }
 
 SkPathRef* SkPathRef::CreateFromBuffer(SkRBuffer* buffer) {
     SkPathRef* ref = new SkPathRef;
 
     int32_t packed;
     if (!buffer->readS32(&packed)) {
         delete ref;
         return nullptr;
     }
 
     ref->fIsFinite = (packed >> kIsFinite_SerializationShift) & 1;
     uint8_t segmentMask = (packed >> kSegmentMask_SerializationShift) & 0xF;
     bool isOval  = (packed >> kIsOval_SerializationShift) & 1;
     bool isRRect  = (packed >> kIsRRect_SerializationShift) & 1;
+    bool rrectOrOvalIsCCW = (packed >> kRRectOrOvalIsCCW_SerializationShift) & 1;
+    unsigned rrectOrOvalStartIdx = (packed >> kRRectOrOvalStartIdx_SerializationShift) & 0x7;
 
     int32_t verbCount, pointCount, conicCount;
     ptrdiff_t maxPtrDiff = std::numeric_limits<ptrdiff_t>::max();
     if (!buffer->readU32(&(ref->fGenerationID)) ||
         !buffer->readS32(&verbCount) ||
         verbCount < 0 ||
         static_cast<uint32_t>(verbCount) > maxPtrDiff/sizeof(uint8_t) ||
         !buffer->readS32(&pointCount) ||
         pointCount < 0 ||
         static_cast<uint32_t>(pointCount) > maxPtrDiff/sizeof(SkPoint) ||
@@ skipping 16 matching lines @@
         !buffer->read(&ref->fBounds, sizeof(SkRect))) {
         delete ref;
         return nullptr;
     }
     ref->fBoundsIsDirty = false;
 
     // resetToSize clears fSegmentMask and fIsOval
     ref->fSegmentMask = segmentMask;
     ref->fIsOval = isOval;
     ref->fIsRRect = isRRect;
+    ref->fRRectOrOvalIsCCW = rrectOrOvalIsCCW;
+    ref->fRRectOrOvalStartIdx = rrectOrOvalStartIdx;
     return ref;
 }
 
 void SkPathRef::Rewind(SkAutoTUnref<SkPathRef>* pathRef) {
     if ((*pathRef)->unique()) {
         SkDEBUGCODE((*pathRef)->validate();)
         (*pathRef)->callGenIDChangeListeners();
         (*pathRef)->fBoundsIsDirty = true;  // this also invalidates fIsFinite
         (*pathRef)->fVerbCnt = 0;
         (*pathRef)->fPointCnt = 0;
@@ skipping 60 matching lines @@
 }
 
 void SkPathRef::writeToBuffer(SkWBuffer* buffer) const {
     SkDEBUGCODE(this->validate();)
     SkDEBUGCODE(size_t beforePos = buffer->pos();)
 
     // Call getBounds() to ensure (as a side-effect) that fBounds
     // and fIsFinite are computed.
     const SkRect& bounds = this->getBounds();
 
-    int32_t packed = ((fIsFinite & 1) << kIsFinite_SerializationShift) |
+    int32_t packed = ((fRRectOrOvalStartIdx & 7) << kRRectOrOvalStartIdx_SerializationShift) |
+                     ((fRRectOrOvalIsCCW & 1) << kRRectOrOvalIsCCW_SerializationShift) |
+                     ((fIsFinite & 1) << kIsFinite_SerializationShift) |
                      ((fIsOval & 1) << kIsOval_SerializationShift) |
                      ((fIsRRect & 1) << kIsRRect_SerializationShift) |
                      (fSegmentMask << kSegmentMask_SerializationShift);
     buffer->write32(packed);
 
     // TODO: write gen ID here. Problem: We don't know if we're cross process or not from
     // SkWBuffer. Until this is fixed we write 0.
     buffer->write32(0);
     buffer->write32(fVerbCnt);
     buffer->write32(fPointCnt);
@@ skipping 24 matching lines @@
     sk_careful_memcpy(this->fPoints, ref.fPoints, ref.fPointCnt * sizeof(SkPoint));
     fConicWeights = ref.fConicWeights;
     fBoundsIsDirty = ref.fBoundsIsDirty;
     if (!fBoundsIsDirty) {
         fBounds = ref.fBounds;
         fIsFinite = ref.fIsFinite;
     }
     fSegmentMask = ref.fSegmentMask;
     fIsOval = ref.fIsOval;
     fIsRRect = ref.fIsRRect;
+    fRRectOrOvalIsCCW = ref.fRRectOrOvalIsCCW;
+    fRRectOrOvalStartIdx = ref.fRRectOrOvalStartIdx;
     SkDEBUGCODE(this->validate();)
 }
 
 
 void SkPathRef::interpolate(const SkPathRef& ending, SkScalar weight, SkPathRef* out) const {
     const SkScalar* inValues = &ending.getPoints()->fX;
     SkScalar* outValues = &out->getPoints()->fX;
     int count = out->countPoints() * 2;
     for (int index = 0; index < count; ++index) {
         outValues[index] = outValues[index] * weight + inValues[index] * (1 - weight);
@@ skipping 298 matching lines @@
     SkASSERT(static_cast<ptrdiff_t>(fFreeSpace) >= 0);
     SkASSERT(reinterpret_cast<intptr_t>(fVerbs) - reinterpret_cast<intptr_t>(fPoints) >= 0);
     SkASSERT((nullptr == fPoints) == (nullptr == fVerbs));
     SkASSERT(!(nullptr == fPoints && 0 != fFreeSpace));
     SkASSERT(!(nullptr == fPoints && 0 != fFreeSpace));
     SkASSERT(!(nullptr == fPoints && fPointCnt));
     SkASSERT(!(nullptr == fVerbs && fVerbCnt));
     SkASSERT(this->currSize() ==
                 fFreeSpace + sizeof(SkPoint) * fPointCnt + sizeof(uint8_t) * fVerbCnt);
 
+    if (fIsOval || fIsRRect) {
+        // Currently we don't allow both of these to be set, even though ovals are round rects.
+        SkASSERT(fIsOval != fIsRRect);
+        if (fIsOval) {
+            SkASSERT(fRRectOrOvalStartIdx < 4);
+        } else {
+            SkASSERT(fRRectOrOvalStartIdx < 8);
+        }
+    }
+
     if (!fBoundsIsDirty && !fBounds.isEmpty()) {
         bool isFinite = true;
         for (int i = 0; i < fPointCnt; ++i) {
 #ifdef SK_DEBUG
             if (fPoints[i].isFinite() &&
                 (fPoints[i].fX < fBounds.fLeft || fPoints[i].fX > fBounds.fRight ||
                  fPoints[i].fY < fBounds.fTop || fPoints[i].fY > fBounds.fBottom)) {
                 SkDebugf("bounds: %f %f %f %f\n",
                          fBounds.fLeft, fBounds.fTop, fBounds.fRight, fBounds.fBottom);
                 for (int j = 0; j < fPointCnt; ++j) {
@@ skipping 40 matching lines @@
                 break;
             default:
                 SkDEBUGFAIL("Unknown Verb");
                 break;
         }
     }
     SkASSERT(mask == fSegmentMask);
 #endif // SK_DEBUG_PATH
 }
 #endif