SK_SUPPORT_LEGACY_GRTYPES to hide duplicate types from SkTypes.h

src/gpu/GrPathUtils.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrPathUtils.h"
 
 #include "GrPoint.h"
@@ skipping 18 matching lines @@
             stretch = SkMaxScalar(stretch, mat.mapRadius(SK_Scalar1));
         }
     }
     srcTol = SkScalarDiv(srcTol, stretch);
     return srcTol;
 }
 
 static const int MAX_POINTS_PER_CURVE = 1 << 10;
 static const SkScalar gMinCurveTol = 0.0001f;
 
-uint32_t GrPathUtils::quadraticPointCount(const GrPoint points[],
+uint32_t GrPathUtils::quadraticPointCount(const SkPoint points[],
                                           SkScalar tol) {
     if (tol < gMinCurveTol) {
         tol = gMinCurveTol;
     }
     SkASSERT(tol > 0);
 
     SkScalar d = points[1].distanceToLineSegmentBetween(points[0], points[2]);
     if (d <= tol) {
         return 1;
     } else {
         // Each time we subdivide, d should be cut in 4. So we need to
         // subdivide x = log4(d/tol) times. x subdivisions creates 2^(x)
         // points.
         // 2^(log4(x)) = sqrt(x);
         int temp = SkScalarCeilToInt(SkScalarSqrt(SkScalarDiv(d, tol)));
         int pow2 = GrNextPow2(temp);
         // Because of NaNs & INFs we can wind up with a degenerate temp
         // such that pow2 comes out negative. Also, our point generator
         // will always output at least one pt.
         if (pow2 < 1) {
             pow2 = 1;
         }
-        return GrMin(pow2, MAX_POINTS_PER_CURVE);
+        return SkTMin(pow2, MAX_POINTS_PER_CURVE);
     }
 }
 
-uint32_t GrPathUtils::generateQuadraticPoints(const GrPoint& p0,
-                                              const GrPoint& p1,
-                                              const GrPoint& p2,
+uint32_t GrPathUtils::generateQuadraticPoints(const SkPoint& p0,
+                                              const SkPoint& p1,
+                                              const SkPoint& p2,
                                               SkScalar tolSqd,
-                                              GrPoint** points,
+                                              SkPoint** points,
                                               uint32_t pointsLeft) {
     if (pointsLeft < 2 ||
         (p1.distanceToLineSegmentBetweenSqd(p0, p2)) < tolSqd) {
         (*points)[0] = p2;
         *points += 1;
         return 1;
     }
 
-    GrPoint q[] = {
+    SkPoint q[] = {
         { SkScalarAve(p0.fX, p1.fX), SkScalarAve(p0.fY, p1.fY) },
         { SkScalarAve(p1.fX, p2.fX), SkScalarAve(p1.fY, p2.fY) },
     };
-    GrPoint r = { SkScalarAve(q[0].fX, q[1].fX), SkScalarAve(q[0].fY, q[1].fY) };
+    SkPoint r = { SkScalarAve(q[0].fX, q[1].fX), SkScalarAve(q[0].fY, q[1].fY) };
 
     pointsLeft >>= 1;
     uint32_t a = generateQuadraticPoints(p0, q[0], r, tolSqd, points, pointsLeft);
     uint32_t b = generateQuadraticPoints(r, q[1], p2, tolSqd, points, pointsLeft);
     return a + b;
 }
 
-uint32_t GrPathUtils::cubicPointCount(const GrPoint points[],
+uint32_t GrPathUtils::cubicPointCount(const SkPoint points[],
                                            SkScalar tol) {
     if (tol < gMinCurveTol) {
         tol = gMinCurveTol;
     }
     SkASSERT(tol > 0);
 
-    SkScalar d = GrMax(
+    SkScalar d = SkTMax(
         points[1].distanceToLineSegmentBetweenSqd(points[0], points[3]),
         points[2].distanceToLineSegmentBetweenSqd(points[0], points[3]));
     d = SkScalarSqrt(d);
     if (d <= tol) {
         return 1;
     } else {
         int temp = SkScalarCeilToInt(SkScalarSqrt(SkScalarDiv(d, tol)));
         int pow2 = GrNextPow2(temp);
         // Because of NaNs & INFs we can wind up with a degenerate temp
         // such that pow2 comes out negative. Also, our point generator
         // will always output at least one pt.
         if (pow2 < 1) {
             pow2 = 1;
         }
-        return GrMin(pow2, MAX_POINTS_PER_CURVE);
+        return SkTMin(pow2, MAX_POINTS_PER_CURVE);
     }
 }
 
-uint32_t GrPathUtils::generateCubicPoints(const GrPoint& p0,
-                                          const GrPoint& p1,
-                                          const GrPoint& p2,
-                                          const GrPoint& p3,
+uint32_t GrPathUtils::generateCubicPoints(const SkPoint& p0,
+                                          const SkPoint& p1,
+                                          const SkPoint& p2,
+                                          const SkPoint& p3,
                                           SkScalar tolSqd,
-                                          GrPoint** points,
+                                          SkPoint** points,
                                           uint32_t pointsLeft) {
     if (pointsLeft < 2 ||
         (p1.distanceToLineSegmentBetweenSqd(p0, p3) < tolSqd &&
          p2.distanceToLineSegmentBetweenSqd(p0, p3) < tolSqd)) {
             (*points)[0] = p3;
             *points += 1;
             return 1;
         }
-    GrPoint q[] = {
+    SkPoint q[] = {
         { SkScalarAve(p0.fX, p1.fX), SkScalarAve(p0.fY, p1.fY) },
         { SkScalarAve(p1.fX, p2.fX), SkScalarAve(p1.fY, p2.fY) },
         { SkScalarAve(p2.fX, p3.fX), SkScalarAve(p2.fY, p3.fY) }
     };
-    GrPoint r[] = {
+    SkPoint r[] = {
         { SkScalarAve(q[0].fX, q[1].fX), SkScalarAve(q[0].fY, q[1].fY) },
         { SkScalarAve(q[1].fX, q[2].fX), SkScalarAve(q[1].fY, q[2].fY) }
     };
-    GrPoint s = { SkScalarAve(r[0].fX, r[1].fX), SkScalarAve(r[0].fY, r[1].fY) };
+    SkPoint s = { SkScalarAve(r[0].fX, r[1].fX), SkScalarAve(r[0].fY, r[1].fY) };
     pointsLeft >>= 1;
     uint32_t a = generateCubicPoints(p0, q[0], r[0], s, tolSqd, points, pointsLeft);
     uint32_t b = generateCubicPoints(s, r[1], q[2], p3, tolSqd, points, pointsLeft);
     return a + b;
 }
 
 int GrPathUtils::worstCasePointCount(const SkPath& path, int* subpaths,
                                      SkScalar tol) {
     if (tol < gMinCurveTol) {
         tol = gMinCurveTol;
     }
     SkASSERT(tol > 0);
 
     int pointCount = 0;
     *subpaths = 1;
 
     bool first = true;
 
     SkPath::Iter iter(path, false);
     SkPath::Verb verb;
 
-    GrPoint pts[4];
+    SkPoint pts[4];
     while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {
 
         switch (verb) {
             case SkPath::kLine_Verb:
                 pointCount += 1;
                 break;
             case SkPath::kQuad_Verb:
                 pointCount += quadraticPointCount(pts, tol);
                 break;
             case SkPath::kCubic_Verb:
                 pointCount += cubicPointCount(pts, tol);
                 break;
             case SkPath::kMove_Verb:
                 pointCount += 1;
                 if (!first) {
                     ++(*subpaths);
                 }
                 break;
             default:
                 break;
         }
         first = false;
     }
     return pointCount;
 }
 
-void GrPathUtils::QuadUVMatrix::set(const GrPoint qPts[3]) {
+void GrPathUtils::QuadUVMatrix::set(const SkPoint qPts[3]) {
     SkMatrix m;
     // We want M such that M * xy_pt = uv_pt
     // We know M * control_pts = [0  1/2 1]
     //                           [0  0   1]
     //                           [1  1   1]
     // And control_pts = [x0 x1 x2]
     //                   [y0 y1 y2]
     //                   [1  1  1 ]
     // We invert the control pt matrix and post concat to both sides to get M.
     // Using the known form of the control point matrix and the result, we can
@@ skipping 19 matching lines @@
             maxEdge = 1;
         }
         d = qPts[2].distanceToSqd(qPts[0]);
         if (d > maxD) {
             maxD = d;
             maxEdge = 2;
         }
         // We could have a tolerance here, not sure if it would improve anything
         if (maxD > 0) {
             // Set the matrix to give (u = 0, v = distance_to_line)
-            GrVec lineVec = qPts[(maxEdge + 1)%3] - qPts[maxEdge];
+            SkVector lineVec = qPts[(maxEdge + 1)%3] - qPts[maxEdge];
             // when looking from the point 0 down the line we want positive
             // distances to be to the left. This matches the non-degenerate
             // case.
-            lineVec.setOrthog(lineVec, GrPoint::kLeft_Side);
+            lineVec.setOrthog(lineVec, SkPoint::kLeft_Side);
             lineVec.dot(qPts[0]);
             // first row
             fM[0] = 0;
             fM[1] = 0;
             fM[2] = 0;
             // second row
             fM[3] = lineVec.fX;
             fM[4] = lineVec.fY;
             fM[5] = -lineVec.dot(qPts[maxEdge]);
         } else {
@@ skipping 268 matching lines @@
                                       sublevel + 1);
     convert_noninflect_cubic_to_quads(choppedPts + 3,
                                       toleranceSqd,
                                       constrainWithinTangents,
                                       dir,
                                       quads,
                                       sublevel + 1);
 }
 }
 
-void GrPathUtils::convertCubicToQuads(const GrPoint p[4],
+void GrPathUtils::convertCubicToQuads(const SkPoint p[4],
                                       SkScalar tolScale,
                                       bool constrainWithinTangents,
                                       SkPath::Direction dir,
                                       SkTArray<SkPoint, true>* quads) {
     SkPoint chopped[10];
     int count = SkChopCubicAtInflections(p, chopped);
 
     // base tolerance is 1 pixel.
     static const SkScalar kTolerance = SK_Scalar1;
     const SkScalar tolSqd = SkScalarSquare(SkScalarMul(tolScale, kTolerance));
@@ skipping 326 matching lines @@
         set_loop_klm(d, controlK, controlL, controlM);
     } else if (kCusp_CubicType == cType) {
         SkASSERT(0.f == d[0]);
         set_cusp_klm(d, controlK, controlL, controlM);
     } else if (kQuadratic_CubicType == cType) {
         set_quadratic_klm(d, controlK, controlL, controlM);
     }
 
     calc_cubic_klm(p, controlK, controlL, controlM, klm, &klm[3], &klm[6]);
 }