add asserts to point<-->verb helpers

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 395 matching lines @@
                 this contour, to specify the control point of a quadratic curve
         @param dy1   The amount to add to the y-coordinate of the last point on
                 this contour, to specify the control point of a quadratic curve
         @param dx2   The amount to add to the x-coordinate of the last point on
                      this contour, to specify the end point of a quadratic curve
         @param dy2   The amount to add to the y-coordinate of the last point on
                      this contour, to specify the end point of a quadratic curve
     */
     void rQuadTo(SkScalar dx1, SkScalar dy1, SkScalar dx2, SkScalar dy2);
 
+    void conicTo(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2,
+                 SkScalar w);
+    void conicTo(const SkPoint& p1, const SkPoint& p2, SkScalar w) {
+        this->conicTo(p1.fX, p1.fY, p2.fX, p2.fY, w);
+    }
+    void rConicTo(SkScalar dx1, SkScalar dy1, SkScalar dx2, SkScalar dy2,
+                  SkScalar w);
+    
     /** Add a cubic bezier from the last point, approaching control points
         (x1,y1) and (x2,y2), and ending at (x3,y3). If no moveTo() call has been
         made for this contour, the first point is automatically set to (0,0).
 
         @param x1   The x-coordinate of the 1st control point on a cubic curve
         @param y1   The y-coordinate of the 1st control point on a cubic curve
         @param x2   The x-coordinate of the 2nd control point on a cubic curve
         @param y2   The y-coordinate of the 2nd control point on a cubic curve
         @param x3   The x-coordinate of the end point on a cubic curve
         @param y3   The y-coordinate of the end point on a cubic curve
@@ skipping 346 matching lines @@
 
         @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,
-        kCubic_SegmentMask  = 1 << 2
+        kConic_SegmentMask  = 1 << 2,
+        kCubic_SegmentMask  = 1 << 3,
     };
 
     /**
      *  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; }
 
     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
+        kDone_Verb,     //!< iter.next returns 0 points
     };
 
     /** 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.
@@ skipping 13 matching lines @@
                    deemed degenerate (too short) and skip those.
             @return The verb for the current segment
         */
         Verb next(SkPoint pts[4], bool doConsumeDegerates = true) {
             if (doConsumeDegerates) {
                 this->consumeDegenerateSegments();
             }
             return this->doNext(pts);
         }
 
+        /**
+         *  Return the weight for the current conic. Only valid if the current
+         *  segment return by next() was a conic.
+         */
+        SkScalar conicWeight() const { return *fConicWeights; }
+
         /** If next() returns kLine_Verb, then this query returns true if the
             line was the result of a close() command (i.e. the end point is the
             initial moveto for this contour). If next() returned a different
             verb, this returns an undefined value.
 
             @return If the last call to next() returned kLine_Verb, return true
                     if it was the result of an explicit close command.
         */
         bool isCloseLine() const { return SkToBool(fCloseLine); }
 
         /** Returns true if the current contour is closed (has a kClose_Verb)
             @return true if the current contour is closed (has a kClose_Verb)
         */
         bool isClosedContour() const;
 
     private:
         const SkPoint*  fPts;
         const uint8_t*  fVerbs;
         const uint8_t*  fVerbStop;
+        const SkScalar* fConicWeights;
         SkPoint         fMoveTo;
         SkPoint         fLastPt;
         SkBool8         fForceClose;
         SkBool8         fNeedClose;
         SkBool8         fCloseLine;
         SkBool8         fSegmentState;
 
         inline const SkPoint& cons_moveTo();
         Verb autoClose(SkPoint pts[2]);
         void consumeDegenerateSegments();
@@ skipping 11 matching lines @@
 
         /** 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
                         This must not be NULL.
             @return The verb for the current segment
         */
         Verb next(SkPoint pts[4]);
 
+        SkScalar conicWeight() const { return *fConicWeights; }
+
     private:
         const SkPoint*  fPts;
         const uint8_t*  fVerbs;
         const uint8_t*  fVerbStop;
+        const SkScalar* fConicWeights;
         SkPoint         fMoveTo;
         SkPoint         fLastPt;
     };
 
     /**
      *  Returns true if the point { x, y } is contained by the path, taking into
      *  account the FillType.
      */
     bool contains(SkScalar x, SkScalar y) const;
 
@@ skipping 19 matching lines @@
 
     SkDEBUGCODE(void validate() const;)
 
 private:
     enum SerializationOffsets {
         kDirection_SerializationShift = 26, // requires 2 bits
         kIsFinite_SerializationShift = 25,  // requires 1 bit
         kIsOval_SerializationShift = 24,    // requires 1 bit
         kConvexity_SerializationShift = 16, // requires 2 bits
         kFillType_SerializationShift = 8,   // requires 2 bits
-        kSegmentMask_SerializationShift = 0 // requires 3 bits
+        kSegmentMask_SerializationShift = 0 // requires 4 bits
     };
 
 #if SK_DEBUG_PATH_REF
 public:
     /** Debugging wrapper for SkAutoTUnref<SkPathRef> used to track owners (SkPaths)
         of SkPathRefs */
     class PathRefDebugRef {
     public:
         PathRefDebugRef(SkPath* owner);
         PathRefDebugRef(SkPathRef* pr, SkPath* owner);
@@ skipping 61 matching lines @@
     bool isRectContour(bool allowPartial, int* currVerb, const SkPoint** pts,
                        bool* isClosed, Direction* direction) const;
 
     friend class SkAutoPathBoundsUpdate;
     friend class SkAutoDisableOvalCheck;
     friend class SkAutoDisableDirectionCheck;
     friend class SkBench_AddPathTest; // perf test pathTo/reversePathTo
 };
 
 #endif