add SkPath::isRRect

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 "SkOncePtr.h"
 #include "SkPath.h"
@@ skipping 95 matching lines @@
             (*dst)->fIsFinite = false;
             (*dst)->fBounds.setEmpty();
         }
     } else {
         (*dst)->fBoundsIsDirty = true;
     }
 
     (*dst)->fSegmentMask = src.fSegmentMask;
 
     // It's an oval only if it stays a rect.
-    (*dst)->fIsOval = src.fIsOval && matrix.rectStaysRect();
+    bool rectStaysRect = matrix.rectStaysRect();
+    (*dst)->fIsOval = src.fIsOval && rectStaysRect;
+    (*dst)->fIsRRect = src.fIsRRect && rectStaysRect;
 
     SkDEBUGCODE((*dst)->validate();)
 }
 
 SkPathRef* SkPathRef::CreateFromBuffer(SkRBuffer* buffer) {
     SkPathRef* ref = new SkPathRef;
-    bool isOval;
-    uint8_t segmentMask;
 
     int32_t packed;
     if (!buffer->readS32(&packed)) {
         delete ref;
         return nullptr;
     }
 
     ref->fIsFinite = (packed >> kIsFinite_SerializationShift) & 1;
-    segmentMask = (packed >> kSegmentMask_SerializationShift) & 0xF;
-    isOval  = (packed >> kIsOval_SerializationShift) & 1;
+    uint8_t segmentMask = (packed >> kSegmentMask_SerializationShift) & 0xF;
+    bool isOval  = (packed >> kIsOval_SerializationShift) & 1;
+    bool isRRect  = (packed >> kIsRRect_SerializationShift) & 1;
 
     int32_t verbCount, pointCount, conicCount;
     if (!buffer->readU32(&(ref->fGenerationID)) ||
         !buffer->readS32(&verbCount) ||
         !buffer->readS32(&pointCount) ||
         !buffer->readS32(&conicCount)) {
         delete ref;
         return nullptr;
     }
 
     ref->resetToSize(verbCount, pointCount, conicCount);
     SkASSERT(verbCount == ref->countVerbs());
     SkASSERT(pointCount == ref->countPoints());
     SkASSERT(conicCount == ref->fConicWeights.count());
 
     if (!buffer->read(ref->verbsMemWritable(), verbCount * sizeof(uint8_t)) ||
         !buffer->read(ref->fPoints, pointCount * sizeof(SkPoint)) ||
         !buffer->read(ref->fConicWeights.begin(), conicCount * sizeof(SkScalar)) ||
         !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;
     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;
         (*pathRef)->fFreeSpace = (*pathRef)->currSize();
         (*pathRef)->fGenerationID = 0;
         (*pathRef)->fConicWeights.rewind();
         (*pathRef)->fSegmentMask = 0;
         (*pathRef)->fIsOval = false;
+        (*pathRef)->fIsRRect = false;
         SkDEBUGCODE((*pathRef)->validate();)
     } else {
         int oldVCnt = (*pathRef)->countVerbs();
         int oldPCnt = (*pathRef)->countPoints();
         pathRef->reset(new SkPathRef);
         (*pathRef)->resetToSize(0, 0, 0, oldVCnt, oldPCnt);
     }
 }
 
 bool SkPathRef::operator== (const SkPathRef& ref) const {
@@ skipping 46 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) |
                      ((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);
     buffer->write32(fConicWeights.count());
     buffer->write(verbsMemBegin(), fVerbCnt * sizeof(uint8_t));
@@ skipping 21 matching lines @@
     memcpy(this->verbsMemWritable(), ref.verbsMemBegin(), ref.fVerbCnt * sizeof(uint8_t));
     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;
     SkDEBUGCODE(this->validate();)
 }
 
 SkPoint* SkPathRef::growForRepeatedVerb(int /*SkPath::Verb*/ verb,
                                         int numVbs,
                                         SkScalar** weights) {
     // This value is just made-up for now. When count is 4, calling memset was much
     // slower than just writing the loop. This seems odd, and hopefully in the
     // future this will appear to have been a fluke...
     static const unsigned int kMIN_COUNT_FOR_MEMSET_TO_BE_FAST = 16;
@@ skipping 51 matching lines @@
             vb[~i] = verb;
         }
     }
 
     fVerbCnt += numVbs;
     fPointCnt += pCnt;
     fFreeSpace -= space;
     fBoundsIsDirty = true;  // this also invalidates fIsFinite
     if (dirtyAfterEdit) {
         fIsOval = false;
+        fIsRRect = false;
     }
 
     if (SkPath::kConic_Verb == verb) {
         SkASSERT(weights);
         *weights = fConicWeights.append(numVbs);
     }
 
     SkDEBUGCODE(this->validate();)
     return ret;
 }
@@ skipping 38 matching lines @@
     size_t space = sizeof(uint8_t) + pCnt * sizeof (SkPoint);
     this->makeSpace(space);
     this->fVerbs[~fVerbCnt] = verb;
     SkPoint* ret = fPoints + fPointCnt;
     fVerbCnt += 1;
     fPointCnt += pCnt;
     fFreeSpace -= space;
     fBoundsIsDirty = true;  // this also invalidates fIsFinite
     if (dirtyAfterEdit) {
         fIsOval = false;
+        fIsRRect = false;
     }
 
     if (SkPath::kConic_Verb == verb) {
         *fConicWeights.append() = weight;
     }
 
     SkDEBUGCODE(this->validate();)
     return ret;
 }
 
@@ skipping 26 matching lines @@
 // we need to be called *before* the genID gets changed or zerod
 void SkPathRef::callGenIDChangeListeners() {
     for (int i = 0; i < fGenIDChangeListeners.count(); i++) {
         fGenIDChangeListeners[i]->onChange();
     }
 
     // Listeners get at most one shot, so whether these triggered or not, blow them away.
     fGenIDChangeListeners.deleteAll();
 }
 
+SkRRect SkPathRef::getRRect() const {
+    const SkRect& bounds = this->getBounds();
+    SkVector radii[4] = {{0, 0}, {0, 0}, {0, 0}, {0, 0}};
+    Iter iter(*this);
+    SkPoint pts[4];
+    uint8_t verb = iter.next(pts);
+    SkASSERT(SkPath::kMove_Verb == verb);
+    while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {
+        if (SkPath::kConic_Verb == verb) {
+            SkVector v1_0 = pts[1] - pts[0];
+            SkVector v2_1 = pts[2] - pts[1];
+            SkVector dxdy;
+            if (v1_0.fX) {
+                SkASSERT(!v2_1.fX && !v1_0.fY);
+                dxdy.set(SkScalarAbs(v1_0.fX), SkScalarAbs(v2_1.fY));
+            } else if (!v1_0.fY) {
+                SkASSERT(!v2_1.fX || !v2_1.fY);
+                dxdy.set(SkScalarAbs(v2_1.fX), SkScalarAbs(v2_1.fY));
+            } else {
+                SkASSERT(!v2_1.fY);
+                dxdy.set(SkScalarAbs(v2_1.fX), SkScalarAbs(v1_0.fY));
+            }
+            SkRRect::Corner corner =
+                    pts[1].fX == bounds.fLeft ?
+                        pts[1].fY == bounds.fTop ?
+                            SkRRect::kUpperLeft_Corner : SkRRect::kLowerLeft_Corner :
+                    pts[1].fY == bounds.fTop ?
+                            SkRRect::kUpperRight_Corner : SkRRect::kLowerRight_Corner;
+            SkASSERT(!radii[corner].fX && !radii[corner].fY);
+            radii[corner] = dxdy;
+        } else {
+            SkASSERT((verb == SkPath::kLine_Verb
+                    && (!(pts[1].fX - pts[0].fX) || !(pts[1].fY - pts[0].fY)))
+                    || verb == SkPath::kClose_Verb);
+        }
+    }
+    SkRRect rrect;
+    rrect.setRectRadii(bounds, radii);
+    return rrect;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+SkPathRef::Iter::Iter() {
+#ifdef SK_DEBUG
+    fPts = nullptr;
+    fConicWeights = nullptr;
+#endif
+    // need to init enough to make next() harmlessly return kDone_Verb
+    fVerbs = nullptr;
+    fVerbStop = nullptr;
+}
+
+SkPathRef::Iter::Iter(const SkPathRef& path) {
+    this->setPathRef(path);
+}
+
+void SkPathRef::Iter::setPathRef(const SkPathRef& path) {
+    fPts = path.points();
+    fVerbs = path.verbs();
+    fVerbStop = path.verbsMemBegin();
+    fConicWeights = path.conicWeights() - 1; // begin one behind
+}
+
+uint8_t SkPathRef::Iter::next(SkPoint pts[4]) {
+    SkASSERT(pts);
+    if (fVerbs == fVerbStop) {
+        return (uint8_t) SkPath::kDone_Verb;
+    }
+
+    // fVerbs points one beyond next verb so decrement first.
+    unsigned verb = *(--fVerbs);
+    const SkPoint* srcPts = fPts;
+
+    switch (verb) {
+        case SkPath::kMove_Verb:
+            pts[0] = srcPts[0];
+            srcPts += 1;
+            break;
+        case SkPath::kLine_Verb:
+            pts[0] = srcPts[-1];
+            pts[1] = srcPts[0];
+            srcPts += 1;
+            break;
+        case SkPath::kConic_Verb:
+            fConicWeights += 1;
+            // fall-through
+        case SkPath::kQuad_Verb:
+            pts[0] = srcPts[-1];
+            pts[1] = srcPts[0];
+            pts[2] = srcPts[1];
+            srcPts += 2;
+            break;
+        case SkPath::kCubic_Verb:
+            pts[0] = srcPts[-1];
+            pts[1] = srcPts[0];
+            pts[2] = srcPts[1];
+            pts[3] = srcPts[2];
+            srcPts += 3;
+            break;
+        case SkPath::kClose_Verb:
+            break;
+        case SkPath::kDone_Verb:
+            SkASSERT(fVerbs == fVerbStop);
+            break;
+    }
+    fPts = srcPts;
+    return (uint8_t) verb;
+}
+
 #ifdef SK_DEBUG
 void SkPathRef::validate() const {
     this->INHERITED::validate();
     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));
@@ skipping 53 matching lines @@
                 break;
             default:
                 SkDEBUGFAIL("Unknown Verb");
                 break;
         }
     }
     SkASSERT(mask == fSegmentMask);
 #endif // SK_DEBUG_PATH
 }
 #endif