Move bound and isFinite into pathref

src/core/SkPath.cpp

 
 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "SkBuffer.h"
@@ skipping 59 matching lines @@
 private:
     SkPath*              fPath;
     SkPath::Direction    fSaved;
 };
 
 /*  This guy's constructor/destructor bracket a path editing operation. It is
     used when we know the bounds of the amount we are going to add to the path
     (usually a new contour, but not required).
 
     It captures some state about the path up front (i.e. if it already has a
-    cached bounds), and the if it can, it updates the cache bounds explicitly,
+    cached bounds), and then if it can, it updates the cache bounds explicitly,
     avoiding the need to revisit all of the points in getBounds().
 
     It also notes if the path was originally degenerate, and if so, sets
     isConvex to true. Thus it can only be used if the contour being added is
-    convex.
+    convex (which is always true since we only allow the addition of rects).
  */
 class SkAutoPathBoundsUpdate {
 public:
     SkAutoPathBoundsUpdate(SkPath* path, const SkRect& r) : fRect(r) {
         this->init(path);
     }
 
     SkAutoPathBoundsUpdate(SkPath* path, SkScalar left, SkScalar top,
                            SkScalar right, SkScalar bottom) {
         fRect.set(left, top, right, bottom);
         this->init(path);
     }
 
     ~SkAutoPathBoundsUpdate() {
         fPath->setIsConvex(fDegenerate);
-        if (fEmpty) {
-            fPath->fBounds = fRect;
-            fPath->fBoundsIsDirty = false;
-            fPath->fIsFinite = fPath->fBounds.isFinite();
-        } else if (!fDirty) {
-            joinNoEmptyChecks(&fPath->fBounds, fRect);
-            fPath->fBoundsIsDirty = false;
-            fPath->fIsFinite = fPath->fBounds.isFinite();
+        if (fEmpty || fHasValidBounds) {
+            fPath->setBounds(fRect);
         }
     }
 
 private:
     SkPath* fPath;
     SkRect  fRect;
-    bool    fDirty;
+    bool    fHasValidBounds;
     bool    fDegenerate;
     bool    fEmpty;
 
-    // returns true if we should proceed
     void init(SkPath* path) {
+        // Cannot use fRect for our bounds unless we know it is sorted
+        fRect.sort();
         fPath = path;
         // Mark the path's bounds as dirty if (1) they are, or (2) the path
         // is non-finite, and therefore its bounds are not meaningful
-        fDirty = SkToBool(path->fBoundsIsDirty) || !path->fIsFinite;
+        fHasValidBounds = path->hasComputedBounds() && path->isFinite();
+        fEmpty = path->isEmpty();
+        if (fHasValidBounds && !fEmpty) {
+            joinNoEmptyChecks(&fRect, fPath->getBounds());
+        }
         fDegenerate = is_degenerate(*path);
-        fEmpty = path->isEmpty();
-        // Cannot use fRect for our bounds unless we know it is sorted
-        fRect.sort();
     }
 };
 
-// Return true if the computed bounds are finite.
-static bool compute_pt_bounds(SkRect* bounds, const SkPathRef& ref) {
-    int count = ref.countPoints();
-    if (count <= 1) {  // we ignore just 1 point (moveto)
-        bounds->setEmpty();
-        return count ? ref.points()->isFinite() : true;
-    } else {
-        return bounds->setBoundsCheck(ref.points(), count);
-    }
-}
-
 ////////////////////////////////////////////////////////////////////////////
 
 /*
     Stores the verbs and points as they are given to us, with exceptions:
     - we only record "Close" if it was immediately preceeded by Move | Line | Quad | Cubic
     - we insert a Move(0,0) if Line | Quad | Cubic is our first command
 
     The iterator does more cleanup, especially if forceClose == true
     1. If we encounter degenerate segments, remove them
     2. if we encounter Close, return a cons'd up Line() first (if the curr-pt != start-pt)
@@ skipping 13 matching lines @@
 #endif
 {
     this->resetFields();
 }
 
 void SkPath::resetFields() {
     //fPathRef is assumed to have been emptied by the caller.
     fLastMoveToIndex = INITIAL_LASTMOVETOINDEX_VALUE;
     fFillType = kWinding_FillType;
     fSegmentMask = 0;
-    fBoundsIsDirty = true;
     fConvexity = kUnknown_Convexity;
     fDirection = kUnknown_Direction;
-    fIsFinite = false;
     fIsOval = false;
 #ifdef SK_BUILD_FOR_ANDROID
     GEN_ID_INC;
     // We don't touch fSourcePath.  It's used to track texture garbage collection, so we don't
     // want to muck with it if it's been set to something non-NULL.
 #endif
 }
 
 SkPath::SkPath(const SkPath& that)
     : fPathRef(SkRef(that.fPathRef.get())) {
@@ skipping 19 matching lines @@
         GEN_ID_INC;  // Similar to swap, we can't just copy this or it could go back in time.
         fSourcePath = that.fSourcePath;
 #endif
     }
     SkDEBUGCODE(this->validate();)
     return *this;
 }
 
 void SkPath::copyFields(const SkPath& that) {
     //fPathRef is assumed to have been set by the caller.
-    fBounds          = that.fBounds;
     fLastMoveToIndex = that.fLastMoveToIndex;
     fFillType        = that.fFillType;
     fSegmentMask     = that.fSegmentMask;
-    fBoundsIsDirty   = that.fBoundsIsDirty;
     fConvexity       = that.fConvexity;
     fDirection       = that.fDirection;
-    fIsFinite        = that.fIsFinite;
     fIsOval          = that.fIsOval;
 }
 
 bool operator==(const SkPath& a, const SkPath& b) {
     // note: don't need to look at isConvex or bounds, since just comparing the
     // raw data is sufficient.
 
     // We explicitly check fSegmentMask as a quick-reject. We could skip it,
     // since it is only a cache of info in the fVerbs, but its a fast way to
     // notice a difference
 
     return &a == &b ||
         (a.fFillType == b.fFillType && a.fSegmentMask == b.fSegmentMask &&
          *a.fPathRef.get() == *b.fPathRef.get());
 }
 
 void SkPath::swap(SkPath& that) {
     SkASSERT(&that != NULL);
 
     if (this != &that) {
         fPathRef.swap(&that.fPathRef);
-        SkTSwap<SkRect>(fBounds, that.fBounds);
         SkTSwap<int>(fLastMoveToIndex, that.fLastMoveToIndex);
         SkTSwap<uint8_t>(fFillType, that.fFillType);
         SkTSwap<uint8_t>(fSegmentMask, that.fSegmentMask);
-        SkTSwap<uint8_t>(fBoundsIsDirty, that.fBoundsIsDirty);
         SkTSwap<uint8_t>(fConvexity, that.fConvexity);
         SkTSwap<uint8_t>(fDirection, that.fDirection);
-        SkTSwap<SkBool8>(fIsFinite, that.fIsFinite);
         SkTSwap<SkBool8>(fIsOval, that.fIsOval);
 #ifdef SK_BUILD_FOR_ANDROID
         // It doesn't really make sense to swap the generation IDs here, because they might go
         // backwards.  To be safe we increment both to mark them both as changed.
         GEN_ID_INC;
         GEN_ID_PTR_INC(&that);
         SkTSwap<const SkPath*>(fSourcePath, that.fSourcePath);
 #endif
     }
 }
 
+const SkRect& SkPath::getBounds() const {
+    return fPathRef->getBounds();
+}
+
+void SkPath::setBounds(const SkRect& rect) {
+    fPathRef->setBounds(rect);
+}
+
 static inline bool check_edge_against_rect(const SkPoint& p0,
                                            const SkPoint& p1,
                                            const SkRect& rect,
                                            SkPath::Direction dir) {
     const SkPoint* edgeBegin;
     SkVector v;
     if (SkPath::kCW_Direction == dir) {
         v = p1 - p0;
         edgeBegin = &p0;
     } else {
@@ skipping 100 matching lines @@
 
     SkPathRef::Rewind(&fPathRef);
     this->resetFields();
 }
 
 bool SkPath::isEmpty() const {
     SkDEBUGCODE(this->validate();)
     return 0 == fPathRef->countVerbs();
 }
 
+bool SkPath::isFinite() const {
+    SkDEBUGCODE(this->validate();)
+    return fPathRef->isFinite();
+}
+
+bool SkPath::hasComputedBounds() const {
+    SkDEBUGCODE(this->validate();)
+    return fPathRef->hasComputedBounds();
+}
+
 bool SkPath::isLine(SkPoint line[2]) const {
     int verbCount = fPathRef->countVerbs();
 
     if (2 == verbCount) {
         SkASSERT(kMove_Verb == fPathRef->atVerb(0));
         if (kLine_Verb == fPathRef->atVerb(1)) {
             SkASSERT(2 == fPathRef->countPoints());
             if (line) {
                 const SkPoint* pts = fPathRef->points();
                 line[0] = pts[0];
@@ skipping 261 matching lines @@
     if (count == 0) {
         this->moveTo(x, y);
     } else {
         fIsOval = false;
         SkPathRef::Editor ed(&fPathRef);
         ed.atPoint(count-1)->set(x, y);
         GEN_ID_INC;
     }
 }
 
-void SkPath::computeBounds() const {
-    SkDEBUGCODE(this->validate();)
-    SkASSERT(fBoundsIsDirty);
-
-    fIsFinite = compute_pt_bounds(&fBounds, *fPathRef.get());
-    fBoundsIsDirty = false;
-}
-
 void SkPath::setConvexity(Convexity c) {
     if (fConvexity != c) {
         fConvexity = c;
         GEN_ID_INC;
     }
 }
 
 //////////////////////////////////////////////////////////////////////////////
 //  Construction methods
 
 #define DIRTY_AFTER_EDIT                 \
     do {                                 \
-        fBoundsIsDirty = true;           \
         fConvexity = kUnknown_Convexity; \
         fDirection = kUnknown_Direction; \
         fIsOval = false;                 \
     } while (0)
 
-#define DIRTY_AFTER_EDIT_NO_CONVEXITY_OR_DIRECTION_CHANGE   \
-    do {                                                    \
-        fBoundsIsDirty = true;                              \
-    } while (0)
-
 void SkPath::incReserve(U16CPU inc) {
     SkDEBUGCODE(this->validate();)
     SkPathRef::Editor(&fPathRef, inc, inc);
     SkDEBUGCODE(this->validate();)
 }
 
 void SkPath::moveTo(SkScalar x, SkScalar y) {
     SkDEBUGCODE(this->validate();)
 
     SkPathRef::Editor ed(&fPathRef);
 
     // remember our index
     fLastMoveToIndex = ed.pathRef()->countPoints();
 
     ed.growForVerb(kMove_Verb)->set(x, y);
 
     GEN_ID_INC;
-    DIRTY_AFTER_EDIT_NO_CONVEXITY_OR_DIRECTION_CHANGE;
 }
 
 void SkPath::rMoveTo(SkScalar x, SkScalar y) {
     SkPoint pt;
     this->getLastPt(&pt);
     this->moveTo(pt.fX + x, pt.fY + y);
 }
 
 void SkPath::injectMoveToIfNeeded() {
     if (fLastMoveToIndex < 0) {
@@ skipping 948 matching lines @@
                     SkDEBUGFAIL("unknown verb");
                     break;
             }
         }
 
         dst->swap(tmp);
         SkPathRef::Editor ed(&dst->fPathRef);
         matrix.mapPoints(ed.points(), ed.pathRef()->countPoints());
         dst->fDirection = kUnknown_Direction;
     } else {
-        /*
-         *  If we're not in perspective, we can transform all of the points at
-         *  once.
-         *
-         *  Here we also want to optimize bounds, 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 (!fBoundsIsDirty && matrix.rectStaysRect() && fPathRef->countPoints() > 1) {
-            dst->fBoundsIsDirty = false;
-            if (fIsFinite) {
-                matrix.mapRect(&dst->fBounds, fBounds);
-                if (!(dst->fIsFinite = dst->fBounds.isFinite())) {
-                    dst->fBounds.setEmpty();
-                }
-            } else {
-                dst->fIsFinite = false;
-                dst->fBounds.setEmpty();
-            }
-        } else {
-            GEN_ID_PTR_INC(dst);
-            dst->fBoundsIsDirty = true;
-        }
-
         SkPathRef::CreateTransformedCopy(&dst->fPathRef, *fPathRef.get(), matrix);
 
         if (this != dst) {
             dst->fFillType = fFillType;
             dst->fSegmentMask = fSegmentMask;
             dst->fConvexity = fConvexity;
         }
 
 #ifdef SK_BUILD_FOR_ANDROID
-        if (!matrix.isIdentity()) {
+        if (!matrix.isIdentity() && !dst->hasComputedBounds()) {
             GEN_ID_PTR_INC(dst);
         }
 #endif
 
         if (kUnknown_Direction == fDirection) {
             dst->fDirection = kUnknown_Direction;
         } else {
             SkScalar det2x2 =
                 SkScalarMul(matrix.get(SkMatrix::kMScaleX), matrix.get(SkMatrix::kMScaleY)) -
                 SkScalarMul(matrix.get(SkMatrix::kMSkewX), matrix.get(SkMatrix::kMSkewY));
@@ skipping 348 matching lines @@
 ///////////////////////////////////////////////////////////////////////////////
 
 /*
     Format in compressed buffer: [ptCount, verbCount, pts[], verbs[]]
 */
 
 uint32_t SkPath::writeToMemory(void* storage) const {
     SkDEBUGCODE(this->validate();)
 
     if (NULL == storage) {
-        const int byteCount = sizeof(int32_t)
-                      + fPathRef->writeSize()
-                      + sizeof(SkRect);
+        const int byteCount = sizeof(int32_t) + fPathRef->writeSize();
         return SkAlign4(byteCount);
     }
 
     SkWBuffer   buffer(storage);
 
-    // Call getBounds() to ensure (as a side-effect) that fBounds
-    // and fIsFinite are computed.
-    const SkRect& bounds = this->getBounds();
-    SkASSERT(!fBoundsIsDirty);
-
-    int32_t packed = ((fIsFinite & 1) << kIsFinite_SerializationShift) |
-                     ((fIsOval & 1) << kIsOval_SerializationShift) |
+    int32_t packed = ((fIsOval & 1) << kIsOval_SerializationShift) |
                      (fConvexity << kConvexity_SerializationShift) |
                      (fFillType << kFillType_SerializationShift) |
                      (fSegmentMask << kSegmentMask_SerializationShift) |
-                     (fDirection << kDirection_SerializationShift);
+                     (fDirection << kDirection_SerializationShift)
+#ifndef DELETE_THIS_CODE_WHEN_SKPS_ARE_REBUILT_AT_V14_AND_ALL_OTHER_INSTANCES_TOO
+                     | (0x1 << kNewFormat_SerializationShift);
+#endif
 
     buffer.write32(packed);
 
     fPathRef->writeToBuffer(&buffer);
 
-    buffer.write(&bounds, sizeof(bounds));
-
     buffer.padToAlign4();
     return SkToU32(buffer.pos());
 }
 
 uint32_t SkPath::readFromMemory(const void* storage) {
     SkRBuffer   buffer(storage);
 
     uint32_t packed = buffer.readS32();
-    fIsFinite = (packed >> kIsFinite_SerializationShift) & 1;
     fIsOval = (packed >> kIsOval_SerializationShift) & 1;
     fConvexity = (packed >> kConvexity_SerializationShift) & 0xFF;
     fFillType = (packed >> kFillType_SerializationShift) & 0xFF;
     fSegmentMask = (packed >> kSegmentMask_SerializationShift) & 0xF;
     fDirection = (packed >> kDirection_SerializationShift) & 0x3;
+#ifndef DELETE_THIS_CODE_WHEN_SKPS_ARE_REBUILT_AT_V14_AND_ALL_OTHER_INSTANCES_TOO
+    bool newFormat = (packed >> kNewFormat_SerializationShift) & 1;
+#endif
 
-    fPathRef.reset(SkPathRef::CreateFromBuffer(&buffer));
-
-    buffer.read(&fBounds, sizeof(fBounds));
-    fBoundsIsDirty = false;
+    fPathRef.reset(SkPathRef::CreateFromBuffer(&buffer
+#ifndef DELETE_THIS_CODE_WHEN_SKPS_ARE_REBUILT_AT_V14_AND_ALL_OTHER_INSTANCES_TOO
+        , newFormat, packed)
+#endif
+        );
 
     buffer.skipToAlign4();
 
     GEN_ID_INC;
 
     SkDEBUGCODE(this->validate();)
     return SkToU32(buffer.pos());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ skipping 858 matching lines @@
     switch (this->getFillType()) {
         case SkPath::kEvenOdd_FillType:
         case SkPath::kInverseEvenOdd_FillType:
             w &= 1;
             break;
         default:
             break;
     }
     return SkToBool(w);
 }