add interp path

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
 #define SkPath_DEFINED
 
@@ skipping 19 matching lines @@
     SkPath();
     SkPath(const SkPath&);
     ~SkPath();
 
     SkPath& operator=(const SkPath&);
     friend  SK_API bool operator==(const SkPath&, const SkPath&);
     friend bool operator!=(const SkPath& a, const SkPath& b) {
         return !(a == b);
     }
 
+    /** Return true if the paths contain an equal array of verbs and weights. Paths
+     *  with equal verb counts can be readily interpolated. If the paths contain one
+     *  or more conics, the conics' weights must also match.
+     *
+     *  @param compare  The path to compare.
+     *
+     *  @return true if the paths have the same verbs and weights.
+     */
+    bool isInterpolatable(const SkPath& compare) const;
+

[robertphillips, 2016/02/17 21:32:00]

identically ?

[caryclark, 2016/02/17 21:39:21]

If I can't spell it, I shouldn't use it (done)

+    /** Interpolate between two paths with indentically-sized point arrays.

[robertphillips, 2016/02/17 21:08:49]

conains ?

[caryclark, 2016/02/17 21:39:21]

Done.

+     *  The out path conains the verbs and weights of this path.
+     *  The out points are a weighted average of this path and the ending path. 
+     *
+     *  @param ending  The path to interpolate between.
+     *  @param weight  The weight, from 0 to 1. The output points are set to
+     *                 (this->points * weight) + ending->points * (1 - weight).
+     *  @return true if the paths could be interpolated.
+     */
+    bool interpolate(const SkPath& ending, SkScalar weight, SkPath* out) const;
+
 #ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
     /** Returns true if the caller is the only owner of the underlying path data */
     bool unique() const { return fPathRef->unique(); }
 #endif
 
     enum FillType {
         /** Specifies that "inside" is computed by a non-zero sum of signed
             edge crossings
         */
         kWinding_FillType,
@@ skipping 1093 matching lines @@
 
     friend class SkAutoPathBoundsUpdate;
     friend class SkAutoDisableOvalCheck;
     friend class SkAutoDisableDirectionCheck;
     friend class SkBench_AddPathTest; // perf test reversePathTo
     friend class PathTest_Private; // unit test reversePathTo
     friend class ForceIsRRect_Private; // unit test isRRect
 };
 
 #endif