Move segment mask from SkPath to SkPathRef

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 53 matching lines @@
          * return value is a pointer to where the points for the verb should be written.
          */
         SkPoint* growForVerb(int /*SkPath::Verb*/ verb) {
             SkDEBUGCODE(fPathRef->validate();)
             return fPathRef->growForVerb(verb);
         }
 
         SkPoint* growForConic(SkScalar w);
 
         /**
-         * Allocates space for additional verbs and points and returns pointers to the new verbs and
-         * points. verbs will point one beyond the first new verb (index it using [~<i>]). pts points
-         * at the first new point (indexed normally [<i>]).
+         * Allocates space for additional lines and returns a pointer to the new
+         * points. The return pointer points at the first new point (indexed normally [<i>]).
          */
-        void grow(int newVerbs, int newPts, uint8_t** verbs, SkPoint** pts) {
-            SkASSERT(NULL != verbs);
-            SkASSERT(NULL != pts);
-            SkDEBUGCODE(fPathRef->validate();)
-            int oldVerbCnt = fPathRef->fVerbCnt;
-            int oldPointCnt = fPathRef->fPointCnt;
-            SkASSERT(verbs && pts);
-            fPathRef->grow(newVerbs, newPts);
-            *verbs = fPathRef->fVerbs - oldVerbCnt;
-            *pts = fPathRef->fPoints + oldPointCnt;
-            SkDEBUGCODE(fPathRef->validate();)
-        }
+        SkPoint* growForLines(int numLines) { return fPathRef->growForLines(numLines); }

[bsalomon, 2013/12/09 16:16:04]

This feels a little weirdly specialized in SkPathRef's interface. Is it hard to
preserve addPoly performance if it was growForRepeatedVerb(Verb, n)? (perhaps
with a better name).

[robertphillips, 2013/12/09 19:01:52]

Done.

 
         /**
          * Resets the path ref to a new verb and point count. The new verbs and points are
          * uninitialized.
          */
         void resetToSize(int newVerbCnt, int newPointCnt, int newConicCount) {
             fPathRef->resetToSize(newVerbCnt, newPointCnt, newConicCount);
         }
         /**
          * Gets the path ref that is wrapped in the Editor.
@@ skipping 16 matching lines @@
      *  Returns true if all of the points in this path are finite, meaning there
      *  are no infinities and no NaNs.
      */
     bool isFinite() const {
         if (fBoundsIsDirty) {
             this->computeBounds();
         }
         return SkToBool(fIsFinite);
     }
 
+    /**
+     *  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.
      *
      * @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.
      */
@@ skipping 83 matching lines @@
      * Shortcut for this->points() + this->countPoints()
      */
     const SkPoint* pointsEnd() const { return this->points() + this->countPoints(); }
 
     const SkScalar* conicWeights() const { SkDEBUGCODE(this->validate();) return fConicWeights.begin(); }
     const SkScalar* conicWeightsEnd() const { SkDEBUGCODE(this->validate();) return fConicWeights.end(); }
 
     /**
      * Convenience methods for getting to a verb or point by index.
      */
-    uint8_t atVerb(int index) {
+    uint8_t atVerb(int index) const {
         SkASSERT((unsigned) index < (unsigned) fVerbCnt);
         return this->verbs()[~index];
     }
     const SkPoint& atPoint(int index) const {
         SkASSERT((unsigned) index < (unsigned) fPointCnt);
         return this->points()[index];
     }
 
     bool operator== (const SkPathRef& ref) const;
 
     /**
      * Writes the path points and verbs to a buffer.
      */
-    void writeToBuffer(SkWBuffer* buffer);
+    void writeToBuffer(SkWBuffer* buffer) const;
 
     /**
      * Gets the number of bytes that would be written in writeBuffer()
      */
-    uint32_t writeSize();
+    uint32_t writeSize() const;
 
     /**
      * Gets an ID that uniquely identifies the contents of the path ref. If two path refs have the
      * same ID then they have the same verbs and points. However, two path refs may have the same
      * contents but different genIDs.
      */
     uint32_t genID() const;
 
 private:
     enum SerializationOffsets {
         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;
         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) {
         int count = ref.countPoints();
@@ skipping 23 matching lines @@
     }
 
     /** Resets the path ref with verbCount verbs and pointCount points, all uninitialized. Also
      *  allocates space for reserveVerb additional verbs and reservePoints additional points.*/
     void resetToSize(int verbCount, int pointCount, int conicCount,
                      int reserveVerbs = 0, int reservePoints = 0) {
         SkDEBUGCODE(this->validate();)
         fBoundsIsDirty = true;      // this also invalidates fIsFinite
         fGenerationID = 0;
 
+        fSegmentMask = 0;
         fIsOval = false;
 
         size_t newSize = sizeof(uint8_t) * verbCount + sizeof(SkPoint) * pointCount;
         size_t newReserve = sizeof(uint8_t) * reserveVerbs + sizeof(SkPoint) * reservePoints;
         size_t minSize = newSize + newReserve;
 
         ptrdiff_t sizeDelta = this->currSize() - minSize;
 
         if (sizeDelta < 0 || static_cast<size_t>(sizeDelta) >= 3 * minSize) {
             sk_free(fPoints);
             fPoints = NULL;
             fVerbs = NULL;
             fFreeSpace = 0;
             fVerbCnt = 0;
             fPointCnt = 0;
             this->makeSpace(minSize);
             fVerbCnt = verbCount;
             fPointCnt = pointCount;
             fFreeSpace -= newSize;
         } else {
             fPointCnt = pointCount;
             fVerbCnt = verbCount;
             fFreeSpace = this->currSize() - minSize;
         }
         fConicWeights.setCount(conicCount);
         SkDEBUGCODE(this->validate();)
     }
 
     /**
-     * Increases the verb count by newVerbs and the point count be newPoints. New verbs and points
-     * are uninitialized.
+     * Increases the verb and point count by numLines. The new points
+     * are uninitialized. All the new verbs are set to kLine_Verb.
      */
-    void grow(int newVerbs, int newPoints) {
-        SkDEBUGCODE(this->validate();)
-        size_t space = newVerbs * sizeof(uint8_t) + newPoints * sizeof (SkPoint);
-        this->makeSpace(space);
-        fVerbCnt += newVerbs;
-        fPointCnt += newPoints;
-        fFreeSpace -= space;
-        fBoundsIsDirty = true;  // this also invalidates fIsFinite
-        SkDEBUGCODE(this->validate();)
-    }
+    SkPoint* growForLines(int numLines);
 
     /**
      * Increases the verb count 1, records the new verb, and creates room for the requisite number
      * of additional points. A pointer to the first point is returned. Any new points are
      * uninitialized.
      */
     SkPoint* growForVerb(int /*SkPath::Verb*/ verb);
 
     /**
      * Ensures that the free space available in the path ref is >= size. The verb and point counts
@@ skipping 52 matching lines @@
      */
     static void CreateEmptyImpl(SkPathRef** empty);
 
     void setIsOval(bool isOval) { fIsOval = isOval; }
 
     enum {
         kMinSize = 256,
     };
 
     mutable SkRect      fBounds;
+    uint8_t             fSegmentMask;
     mutable uint8_t     fBoundsIsDirty;
     mutable SkBool8     fIsFinite;    // only meaningful if bounds are valid
     mutable SkBool8     fIsOval;
 
     SkPoint*            fPoints; // points to begining of the allocation
     uint8_t*            fVerbs; // points just past the end of the allocation (verbs grow backwards)
     int                 fVerbCnt;
     int                 fPointCnt;
     size_t              fFreeSpace; // redundant but saves computation
     SkTDArray<SkScalar> fConicWeights;
 
     enum {
         kEmptyGenID = 1, // GenID reserved for path ref with zero points and zero verbs.
     };
     mutable uint32_t    fGenerationID;
     SkDEBUGCODE(int32_t fEditorsAttached;) // assert that only one editor in use at any time.
 
     typedef SkRefCnt INHERITED;
 };
 
 #endif