move parts of SkPoint to SkPointPriv

Move specialized SkPoint methods to SkPointPriv.
Use constexpr and inline initialization where possible.

R=reed@google.com,bsalomon@google.com
Bug: skia: 6898
Change-Id: I01ec5186f010f2dc80c068c70d9cc352f3221338
Reviewed-on: https://skia-review.googlesource.com/68700
Reviewed-by: Mike Reed <reed@google.com>
Commit-Queue: Ravi Mistry <rmistry@google.com>

1 files changed, 95 insertions, 0 deletions

diff --git a/src/core/SkPointPriv.h b/src/core/SkPointPriv.h
index 6685b15176..6c8fd480a7 100644
--- a/src/core/SkPointPriv.h
+++ b/src/core/SkPointPriv.h
@@ -12,6 +12,100 @@
 
 class SkPointPriv {
 public:
+    enum Side {
+        kLeft_Side  = -1,
+        kOn_Side    =  0,
+        kRight_Side =  1,
+    };
+
+    static bool AreFinite(const SkPoint array[], int count) {
+        return SkScalarsAreFinite(&array[0].fX, count << 1);
+    }
+
+    static const SkScalar* AsScalars(const SkPoint& pt) { return &pt.fX; }
+
+    static bool CanNormalize(SkScalar dx, SkScalar dy) {
+        // Simple enough (and performance critical sometimes) so we inline it.
+        return (dx*dx + dy*dy) > (SK_ScalarNearlyZero * SK_ScalarNearlyZero);
+    }
+
+    static SkScalar DistanceToLineBetweenSqd(const SkPoint& pt, const SkPoint& a,
+                                             const SkPoint& b, Side* side = nullptr);
+
+    static SkScalar DistanceToLineBetween(const SkPoint& pt, const SkPoint& a,
+                                          const SkPoint& b, Side* side = nullptr) {
+        return SkScalarSqrt(DistanceToLineBetweenSqd(pt, a, b, side));
+    }
+
+    static SkScalar DistanceToLineSegmentBetweenSqd(const SkPoint& pt, const SkPoint& a,
+                                                   const SkPoint& b);
+
+    static SkScalar DistanceToLineSegmentBetween(const SkPoint& pt, const SkPoint& a,
+                                                 const SkPoint& b) {
+        return SkScalarSqrt(DistanceToLineSegmentBetweenSqd(pt, a, b));
+    }
+
+    static SkScalar DistanceToSqd(const SkPoint& pt, const SkPoint& a) {
+        SkScalar dx = pt.fX - a.fX;
+        SkScalar dy = pt.fY - a.fY;
+        return dx * dx + dy * dy;
+    }
+
+    static bool EqualsWithinTolerance(const SkPoint& p1, const SkPoint& p2) {
+        return !CanNormalize(p1.fX - p2.fX, p1.fY - p2.fY);
+    }
+
+    static bool EqualsWithinTolerance(const SkPoint& pt, const SkPoint& p, SkScalar tol) {
+        return SkScalarNearlyZero(pt.fX - p.fX, tol)
+               && SkScalarNearlyZero(pt.fY - p.fY, tol);
+    }
+
+    static SkScalar LengthSqd(const SkPoint& pt) {
+        return SkPoint::DotProduct(pt, pt);
+    }
+
+    static void Negate(SkIPoint& pt) {
+        pt.fX = -pt.fX;
+        pt.fY = -pt.fY;
+    }
+
+    static void RotateCCW(const SkPoint& src, SkPoint* dst) {
+        // use a tmp in case src == dst
+        SkScalar tmp = src.fX;
+        dst->fX = src.fY;
+        dst->fY = -tmp;
+    }
+
+    static void RotateCCW(SkPoint* pt) {
+        RotateCCW(*pt, pt);
+    }
+
+    static void RotateCW(const SkPoint& src, SkPoint* dst) {
+        // use a tmp in case src == dst
+        SkScalar tmp = src.fX;
+        dst->fX = -src.fY;
+        dst->fY = tmp;
+    }
+
+    static void RotateCW(SkPoint* pt) {
+        RotateCW(*pt, pt);
+    }
+
+    static bool SetLengthFast(SkPoint* pt, float length);
+
+    static void SetOrthog(SkPoint* pt, const SkPoint& vec, Side side = kLeft_Side) {
+        // vec could be this
+        SkScalar tmp = vec.fX;
+        if (kRight_Side == side) {
+            pt->fX = -vec.fY;
+            pt->fY = tmp;
+        } else {
+            SkASSERT(kLeft_Side == side);
+            pt->fX = vec.fY;
+            pt->fY = -tmp;
+        }
+    }
+
     // counter-clockwise fan
     static void SetRectFan(SkPoint v[], SkScalar l, SkScalar t, SkScalar r, SkScalar b,
             size_t stride) {
@@ -33,6 +127,7 @@ public:
         ((SkPoint*)((intptr_t)v + 2 * stride))->set(r, t);
         ((SkPoint*)((intptr_t)v + 3 * stride))->set(r, b);
     }
+
 };
 
 #endif