Move more of SkPath into SkPathRef

include/core/SkPath.h

 
 /*
  * 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.
  */
 
 
 #ifndef SkPath_DEFINED
@@ skipping 75 matching lines @@
     /** Returns true if the filltype is one of the Inverse variants */
     bool isInverseFillType() const { return IsInverseFillType((FillType)fFillType); }
 
     /**
      *  Toggle between inverse and normal filltypes. This reverse the return
      *  value of isInverseFillType()
      */
     void toggleInverseFillType() {
         fFillType ^= 2;
         GEN_ID_INC;
-     }
+    }
 
     enum Convexity {
-        kUnknown_Convexity,
-        kConvex_Convexity,
-        kConcave_Convexity
+         kUnknown_Convexity = SkPathRef::kUnknown_Convexity,
+         kConvex_Convexity  = SkPathRef::kConvex_Convexity,
+         kConcave_Convexity = SkPathRef::kConcave_Convexity

[caryclark, 2013/10/03 20:36:15]

I don't agree with exposing the implementation in path ref unnecessarily here. I
would prefer to see compile time asserts in the implementation of path ref that
ensures that the two enums have identical values.

[bsalomon, 2013/10/03 20:40:23]

Would it make sense to promote Convexity to SkConvexity (that is, make it global
in some public header)? Then we wouldn't need two versions of the same enum.

Same for the other enums, though I'm less enthusiastic about promoting Verb out
of SkPath.

     };
 
     /**
      *  Return the path's convexity, as stored in the path. If it is currently unknown,
      *  then this function will attempt to compute the convexity (and cache the result).
      */
     Convexity getConvexity() const {
-        if (kUnknown_Convexity != fConvexity) {
-            return static_cast<Convexity>(fConvexity);
-        } else {
-            return this->internalGetConvexity();
-        }
+        return static_cast<Convexity>(fPathRef->getConvexity());
     }
 
     /**
      *  Return the currently cached value for convexity, even if that is set to
      *  kUnknown_Convexity. Note: getConvexity() will automatically call
      *  ComputeConvexity and cache its return value if the current setting is
      *  kUnknown.
      */
-    Convexity getConvexityOrUnknown() const { return (Convexity)fConvexity; }
+    Convexity getConvexityOrUnknown() const { 
+        return static_cast<Convexity>(fPathRef->getConvexityOrUnknown());
+    }
 
     /**
      *  Store a convexity setting in the path. There is no automatic check to
      *  see if this value actually agrees with the return value that would be
      *  computed by getConvexity().
      *
      *  Note: even if this is set to a "known" value, if the path is later
      *  changed (e.g. lineTo(), addRect(), etc.) then the cached value will be
      *  reset to kUnknown_Convexity.
      */
     void setConvexity(Convexity);
 
     /**
      *  DEPRECATED: use getConvexity()
      *  Returns true if the path is flagged as being convex. This is not a
      *  confirmed by any analysis, it is just the value set earlier.
      */
     bool isConvex() const {
-        return kConvex_Convexity == this->getConvexity();
+        return SkPathRef::kConvex_Convexity == this->getConvexity();

[caryclark, 2013/10/03 20:36:15]

why is this change needed? Isn't the contract that SkPath convexity enums must
equal SkPathRef convexity enums?

     }
 
     /**
      *  DEPRECATED: use setConvexity()
      *  Set the isConvex flag to true or false. Convex paths may draw faster if
      *  this flag is set, though setting this to true on a path that is in fact
      *  not convex can give undefined results when drawn. Paths default to
      *  isConvex == false
      */
     void setIsConvex(bool isConvex) {
         this->setConvexity(isConvex ? kConvex_Convexity : kConcave_Convexity);
     }
 
     /** 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.
      */
-    bool isOval(SkRect* rect) const;
+    bool isOval(SkRect* rect) const { return fPathRef->isOval(rect); }
 
     /** Clear any lines and curves from the path, making it empty. This frees up
         internal storage associated with those segments.
         On Android, does not change fSourcePath.
     */
     void reset();
 
     /** Similar to reset(), in that all lines and curves are removed from the
         path. However, any internal storage for those lines/curves is retained,
         making reuse of the path potentially faster.
@@ skipping 274 matching lines @@
                 this contour, to specify the 1st control point of a cubic curve
         @param dx2   The amount to add to the x-coordinate of the last point on
                 this contour, to specify the 2nd control point of a cubic curve
         @param dy2   The amount to add to the y-coordinate of the last point on
                 this contour, to specify the 2nd control point of a cubic curve
         @param dx3   The amount to add to the x-coordinate of the last point on
                      this contour, to specify the end point of a cubic curve
         @param dy3   The amount to add to the y-coordinate of the last point on
                      this contour, to specify the end point of a cubic curve
     */
-    void    rCubicTo(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2,
-                     SkScalar x3, SkScalar y3);
+    void rCubicTo(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2,
+                  SkScalar x3, SkScalar y3);
 
     /** Append the specified arc to the path as a new contour. If the start of
         the path is different from the path's current last point, then an
         automatic lineTo() is added to connect the current contour to the start
         of the arc. However, if the path is empty, then we call moveTo() with
         the first point of the arc. The sweep angle is treated mod 360.
 
         @param oval The bounding oval defining the shape and size of the arc
         @param startAngle Starting angle (in degrees) where the arc begins
         @param sweepAngle Sweep angle (in degrees) measured clockwise. This is
                           treated mod 360.
         @param forceMoveTo If true, always begin a new contour with the arc
     */
-    void    arcTo(const SkRect& oval, SkScalar startAngle, SkScalar sweepAngle,
-                  bool forceMoveTo);
+    void arcTo(const SkRect& oval, SkScalar startAngle, SkScalar sweepAngle,
+               bool forceMoveTo);
 
     /** Append a line and arc to the current path. This is the same as the
         PostScript call "arct".
     */
     void arcTo(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2,
                SkScalar radius);
 
     /** Append a line and arc to the current path. This is the same as the
         PostScript call "arct".
     */
     void arcTo(const SkPoint p1, const SkPoint p2, SkScalar radius) {
         this->arcTo(p1.fX, p1.fY, p2.fX, p2.fY, radius);
     }
 
     /** Close the current contour. If the current point is not equal to the
         first point of the contour, a line segment is automatically added.
     */
     void close();
 
     enum Direction {
         /** Direction either has not been or could not be computed */
-        kUnknown_Direction,
+        kUnknown_Direction = SkPathRef::kUnknown_Direction,
         /** clockwise direction for adding closed contours */
-        kCW_Direction,
+        kCW_Direction      = SkPathRef::kCW_Direction,
         /** counter-clockwise direction for adding closed contours */
-        kCCW_Direction,
+        kCCW_Direction     = SkPathRef::kCCW_Direction,

[caryclark, 2013/10/03 20:36:15]

same feedback as convexity change above; would prefer to see compile time
asserts verifying equality

     };
 
     /**
      *  Return the opposite of the specified direction. kUnknown is its own
      *  opposite.
      */
     static Direction OppositeDirection(Direction dir) {
-        static const Direction gOppositeDir[] = {
-            kUnknown_Direction, kCCW_Direction, kCW_Direction
-        };
-        return gOppositeDir[dir];
+        return (Direction) SkPathRef::OppositeDirection((SkPathRef::Direction)dir);

[caryclark, 2013/10/03 20:36:15]

you have static casts in similar changes above

     }
 
     /**
      *  Returns whether or not a fill type is inverted
      *
      *  kWinding_FillType        -> false
      *  kEvenOdd_FillType        -> false
      *  kInverseWinding_FillType -> true
      *  kInverseEvenOdd_FillType -> true
      */
@@ skipping 21 matching lines @@
         return (FillType)(fill & 1);
     }
 
     /**
      *  Tries to quickly compute the direction of the first non-degenerate
      *  contour. If it can be computed, return true and set dir to that
      *  direction. If it cannot be (quickly) determined, return false and ignore
      *  the dir parameter. If the direction was determined, it is cached to make
      *  subsequent calls return quickly.
      */
-    bool cheapComputeDirection(Direction* dir) const;
+    bool cheapComputeDirection(Direction* dir) const {
+        return fPathRef->cheapComputeDirection((SkPathRef::Direction*) dir);

[caryclark, 2013/10/03 20:36:15]

static cast

+    }
 
     /**
      *  Returns true if the path's direction can be computed via
      *  cheapComputDirection() and if that computed direction matches the
      *  specified direction. If dir is kUnknown, returns true if the direction
      *  cannot be computed.
      */
     bool cheapIsDirection(Direction dir) const {
         Direction computedDir = kUnknown_Direction;
         (void)this->cheapComputeDirection(&computedDir);
@@ skipping 205 matching lines @@
     /** Set the last point on the path. If no points have been added, moveTo(p)
         is automatically called.
 
         @param p    The new location for the last point
     */
     void setLastPt(const SkPoint& p) {
         this->setLastPt(p.fX, p.fY);
     }
 
     enum SegmentMask {
-        kLine_SegmentMask   = 1 << 0,
-        kQuad_SegmentMask   = 1 << 1,
-        kConic_SegmentMask  = 1 << 2,
-        kCubic_SegmentMask  = 1 << 3,
+        kLine_SegmentMask   = SkPathRef::kLine_SegmentMask,
+        kQuad_SegmentMask   = SkPathRef::kQuad_SegmentMask,
+        kConic_SegmentMask  = SkPathRef::kConic_SegmentMask,
+        kCubic_SegmentMask  = SkPathRef::kCubic_SegmentMask,

[caryclark, 2013/10/03 20:36:15]

Additionally, this change makes Skia harder to use. I have to look in two places
to associate debugging values with what they do.

     };
 
     /**
      *  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; }
+    uint32_t getSegmentMasks() const { return fPathRef->getSegmentMasks(); }
 
     enum Verb {
-        kMove_Verb,     //!< iter.next returns 1 point
-        kLine_Verb,     //!< iter.next returns 2 points
-        kQuad_Verb,     //!< iter.next returns 3 points
-        kConic_Verb,    //!< iter.next returns 3 points + iter.conicWeight()
-        kCubic_Verb,    //!< iter.next returns 4 points
-        kClose_Verb,    //!< iter.next returns 1 point (contour's moveTo pt)
-        kDone_Verb,     //!< iter.next returns 0 points
+        kMove_Verb  = SkPathRef::kMove_Verb,  //!< iter.next returns 1 point
+        kLine_Verb  = SkPathRef::kLine_Verb,  //!< iter.next returns 2 points
+        kQuad_Verb  = SkPathRef::kQuad_Verb,  //!< iter.next returns 3 points
+        kConic_Verb = SkPathRef::kConic_Verb, //!< iter.next returns 3 points + iter.conicWeight()
+        kCubic_Verb = SkPathRef::kCubic_Verb, //!< iter.next returns 4 points
+        kClose_Verb = SkPathRef::kClose_Verb, //!< iter.next returns 1 point (contour's moveTo pt)
+        kDone_Verb  = SkPathRef::kDone_Verb,  //!< iter.next returns 0 points

[caryclark, 2013/10/03 20:36:15]

another place to have compile time asserts

     };
 
     /** Iterate through all of the segments (lines, quadratics, cubics) of
         each contours in a path.
 
         The iterator cleans up the segments along the way, removing degenerate
         segments and adding close verbs where necessary. When the forceClose
         argument is provided, each contour (as defined by a new starting
         move command) will be completed with a close verb regardless of the
         contour's contents.
     */
     class SK_API Iter {
     public:
         Iter();
         Iter(const SkPath&, bool forceClose);
+        Iter(const SkPathRef*, bool forceClose);
 
         void setPath(const SkPath&, bool forceClose);
+        void setPathRef(const SkPathRef*, bool forceClose);
 
         /** Return the next verb in this iteration of the path. When all
             segments have been visited, return kDone_Verb.
 
             @param  pts The points representing the current verb and/or segment
             @param doConsumeDegerates If true, first scan for segments that are
                    deemed degenerate (too short) and skip those.
             @return The verb for the current segment
         */
         Verb next(SkPoint pts[4], bool doConsumeDegerates = true) {
@@ skipping 96 matching lines @@
     const SkPath* getSourcePath() const;
     void setSourcePath(const SkPath* path);
 #endif
 
     SkDEBUGCODE(void validate() const;)
 
 private:
     enum SerializationOffsets {
 #ifndef DELETE_THIS_CODE_WHEN_SKPS_ARE_REBUILT_AT_V14_AND_ALL_OTHER_INSTANCES_TOO
         kNewFormat_SerializationShift = 28, // requires 1 bit
+        kOldDirection_SerializationShift = 26, // requires 2 bits
+        kOldIsFinite_SerializationShift = 25,    // 1 bit
+        kOldIsOval_SerializationShift = 24,    // requires 1 bit
+        kOldConvexity_SerializationShift = 16, // requires 8 bits
+#endif  
+        // TODO: make this shift be 0
+        kFillType_SerializationShift = 8,   // requires 8 bits
+#ifndef DELETE_THIS_CODE_WHEN_SKPS_ARE_REBUILT_AT_V14_AND_ALL_OTHER_INSTANCES_TOO
+        kOldSegmentMask_SerializationShift = 0 // requires 4 bits
 #endif
-        kDirection_SerializationShift = 26, // requires 2 bits
-#ifndef DELETE_THIS_CODE_WHEN_SKPS_ARE_REBUILT_AT_V14_AND_ALL_OTHER_INSTANCES_TOO
-        // rename to kUnused_SerializationShift
-        kOldIsFinite_SerializationShift = 25,    // 1 bit
-#endif
-        kIsOval_SerializationShift = 24,    // requires 1 bit
-        kConvexity_SerializationShift = 16, // requires 8 bits
-        kFillType_SerializationShift = 8,   // requires 8 bits
-        kSegmentMask_SerializationShift = 0 // requires 4 bits
     };
 
     SkAutoTUnref<SkPathRef> fPathRef;
 
-    int                 fLastMoveToIndex;
     uint8_t             fFillType;
-    uint8_t             fSegmentMask;
-    mutable uint8_t     fConvexity;
-    mutable uint8_t     fDirection;
-    mutable SkBool8     fIsOval;
 #ifdef SK_BUILD_FOR_ANDROID
     uint32_t            fGenerationID;
     const SkPath*       fSourcePath;
 #endif
 
     /** Resets all fields other than fPathRef to their initial 'empty' values.
      *  Assumes the caller has already emptied fPathRef.
      *  On Android increments fGenerationID without reseting it.
      */
     void resetFields();
@@ skipping 12 matching lines @@
         automatically set to (0,0).
     */
     void pathTo(const SkPath& path);
 
     /*  Append, in reverse order, the first contour of path, ignoring path's
         last point. If no moveTo() call has been made for this contour, the
         first point is automatically set to (0,0).
     */
     void reversePathTo(const SkPath&);
 
-    // called before we add points for lineTo, quadTo, cubicTo, checking to see
-    // if we need to inject a leading moveTo first
-    //
-    //  SkPath path; path.lineTo(...);   <--- need a leading moveTo(0, 0)
-    // SkPath path; ... path.close(); path.lineTo(...) <-- need a moveTo(previous moveTo)
-    //
-    inline void injectMoveToIfNeeded();
-
     inline bool hasOnlyMoveTos() const;
 
-    Convexity internalGetConvexity() const;
-
     bool isRectContour(bool allowPartial, int* currVerb, const SkPoint** pts,
                        bool* isClosed, Direction* direction) const;
 
     /** Returns if the path can return a bound at no cost (true) or will have to
         perform some computation (false).
      */
     bool hasComputedBounds() const {
         SkDEBUGCODE(this->validate();)
         return fPathRef->hasComputedBounds();
     }
 
 
     // 'rect' needs to be sorted
     void setBounds(const SkRect& rect) {
         fPathRef->setBounds(rect);
     }
 
+    Direction getDirection() const {
+        return static_cast<Direction>(fPathRef->getDirection());
+    }
+    void setDirection(Direction dir) {
+        fPathRef->setDirection(static_cast<SkPathRef::Direction>(dir));
+    }
+
+    void setIsOval(bool isOval) { fPathRef->setIsOval(isOval); }
+
 #ifndef DELETE_THIS_CODE_WHEN_SKPS_ARE_REBUILT_AT_V14_AND_ALL_OTHER_INSTANCES_TOO
     friend class SkPathRef;     // just for SerializationOffsets
 #endif
     friend class SkAutoPathBoundsUpdate;
-    friend class SkAutoDisableOvalCheck;
-    friend class SkAutoDisableDirectionCheck;
     friend class SkBench_AddPathTest; // perf test pathTo/reversePathTo
 };
 
 #endif