remove slower scalar code in favor of vectors

src/core/SkGeometry.cpp

 /*
  * 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.
  */
 
 #include "SkGeometry.h"
 #include "SkMatrix.h"
 #include "Sk2x.h"
@@ skipping 161 matching lines @@
     Sk2s P1 = from_point(src[1]);
     Sk2s P2 = from_point(src[2]);
 
     Sk2s B = P1 - P0;
     Sk2s A = P2 - P1 - B;
     Sk2s T = A * Sk2s(t) + B;
 
     return to_vector(T + T);
 }
 
-static void interp_quad_coords(const SkScalar* src, SkScalar* dst, SkScalar t) {
-    SkScalar    ab = SkScalarInterp(src[0], src[2], t);
-    SkScalar    bc = SkScalarInterp(src[2], src[4], t);
-
-    dst[0] = src[0];
-    dst[2] = ab;
-    dst[4] = SkScalarInterp(ab, bc, t);
-    dst[6] = bc;
-    dst[8] = src[4];
-}
-
-void SkChopQuadAt(const SkPoint src[3], SkPoint dst[5], SkScalar t) {
-    SkASSERT(t > 0 && t < SK_Scalar1);
-
-    interp_quad_coords(&src[0].fX, &dst[0].fX, t);
-    interp_quad_coords(&src[0].fY, &dst[0].fY, t);
-}
-
 static inline Sk2s interp(const Sk2s& v0, const Sk2s& v1, const Sk2s& t) {
     return v0 + (v1 - v0) * t;
 }
 
-void SkChopQuadAt2(const SkPoint src[3], SkPoint dst[5], SkScalar t) {
+void SkChopQuadAt(const SkPoint src[3], SkPoint dst[5], SkScalar t) {
     SkASSERT(t > 0 && t < SK_Scalar1);
 
     Sk2s p0 = from_point(src[0]);
     Sk2s p1 = from_point(src[1]);
     Sk2s p2 = from_point(src[2]);
     Sk2s tt(t);
     
     Sk2s p01 = interp(p0, p1, tt);
     Sk2s p12 = interp(p1, p2, tt);
 
     dst[0] = to_point(p0);
     dst[1] = to_point(p01);
     dst[2] = to_point(interp(p01, p12, tt));
     dst[3] = to_point(p12);
     dst[4] = to_point(p2);
 }
 
 void SkChopQuadAtHalf(const SkPoint src[3], SkPoint dst[5]) {
-    SkScalar x01 = SkScalarAve(src[0].fX, src[1].fX);
-    SkScalar y01 = SkScalarAve(src[0].fY, src[1].fY);
-    SkScalar x12 = SkScalarAve(src[1].fX, src[2].fX);
-    SkScalar y12 = SkScalarAve(src[1].fY, src[2].fY);
-
-    dst[0] = src[0];
-    dst[1].set(x01, y01);
-    dst[2].set(SkScalarAve(x01, x12), SkScalarAve(y01, y12));
-    dst[3].set(x12, y12);
-    dst[4] = src[2];
+    SkChopQuadAt(src, dst, 0.5f); return;

[mtklein, 2015/03/26 14:24:30]

No need for return?

 }
 
 /** Quad'(t) = At + B, where
     A = 2(a - 2b + c)
     B = 2(b - a)
     Solve for t, only if it fits between 0 < t < 1
 */
 int SkFindQuadExtrema(SkScalar a, SkScalar b, SkScalar c, SkScalar tValue[1]) {
     /*  At + B == 0
         t = -B / A
@@ skipping 204 matching lines @@
 int SkFindCubicExtrema(SkScalar a, SkScalar b, SkScalar c, SkScalar d,
                        SkScalar tValues[2]) {
     // we divide A,B,C by 3 to simplify
     SkScalar A = d - a + 3*(b - c);
     SkScalar B = 2*(a - b - b + c);
     SkScalar C = b - a;
 
     return SkFindUnitQuadRoots(A, B, C, tValues);
 }
 
-static void interp_cubic_coords(const SkScalar* src, SkScalar* dst,
-                                SkScalar t) {
-    SkScalar    ab = SkScalarInterp(src[0], src[2], t);
-    SkScalar    bc = SkScalarInterp(src[2], src[4], t);
-    SkScalar    cd = SkScalarInterp(src[4], src[6], t);
-    SkScalar    abc = SkScalarInterp(ab, bc, t);
-    SkScalar    bcd = SkScalarInterp(bc, cd, t);
-    SkScalar    abcd = SkScalarInterp(abc, bcd, t);
-
-    dst[0] = src[0];
-    dst[2] = ab;
-    dst[4] = abc;
-    dst[6] = abcd;
-    dst[8] = bcd;
-    dst[10] = cd;
-    dst[12] = src[6];
-}
-
 void SkChopCubicAt(const SkPoint src[4], SkPoint dst[7], SkScalar t) {
     SkASSERT(t > 0 && t < SK_Scalar1);
 
-    interp_cubic_coords(&src[0].fX, &dst[0].fX, t);
-    interp_cubic_coords(&src[0].fY, &dst[0].fY, t);
-}
-
-void SkChopCubicAt2(const SkPoint src[4], SkPoint dst[7], SkScalar t) {
-    SkASSERT(t > 0 && t < SK_Scalar1);
-
     Sk2s    p0 = from_point(src[0]);
     Sk2s    p1 = from_point(src[1]);
     Sk2s    p2 = from_point(src[2]);
     Sk2s    p3 = from_point(src[3]);
     Sk2s    tt(t);
 
     Sk2s    ab = interp(p0, p1, tt);
     Sk2s    bc = interp(p1, p2, tt);
     Sk2s    cd = interp(p2, p3, tt);
     Sk2s    abc = interp(ab, bc, tt);
@@ skipping 69 matching lines @@
                     // if we can't, just create a degenerate cubic
                     dst[4] = dst[5] = dst[6] = src[3];
                     break;
                 }
             }
         }
     }
 }
 
 void SkChopCubicAtHalf(const SkPoint src[4], SkPoint dst[7]) {
-    SkScalar x01 = SkScalarAve(src[0].fX, src[1].fX);
-    SkScalar y01 = SkScalarAve(src[0].fY, src[1].fY);
-    SkScalar x12 = SkScalarAve(src[1].fX, src[2].fX);
-    SkScalar y12 = SkScalarAve(src[1].fY, src[2].fY);
-    SkScalar x23 = SkScalarAve(src[2].fX, src[3].fX);
-    SkScalar y23 = SkScalarAve(src[2].fY, src[3].fY);
-
-    SkScalar x012 = SkScalarAve(x01, x12);
-    SkScalar y012 = SkScalarAve(y01, y12);
-    SkScalar x123 = SkScalarAve(x12, x23);
-    SkScalar y123 = SkScalarAve(y12, y23);
-
-    dst[0] = src[0];
-    dst[1].set(x01, y01);
-    dst[2].set(x012, y012);
-    dst[3].set(SkScalarAve(x012, x123), SkScalarAve(y012, y123));
-    dst[4].set(x123, y123);
-    dst[5].set(x23, y23);
-    dst[6] = src[3];
+    SkChopCubicAt(src, dst, 0.5f);
 }
 
 static void flatten_double_cubic_extrema(SkScalar coords[14]) {
     coords[4] = coords[8] = coords[6];
 }
 
 /** Given 4 points on a cubic bezier, chop it into 1, 2, 3 beziers such that
     the resulting beziers are monotonic in Y. This is called by the scan
     converter.  Depending on what is returned, dst[] is treated as follows:
     0   dst[0..3] is the original cubic
@@ skipping 1036 matching lines @@
         matrix.preScale(SK_Scalar1, -SK_Scalar1);
     }
     if (userMatrix) {
         matrix.postConcat(*userMatrix);
     }
     for (int i = 0; i < conicCount; ++i) {
         matrix.mapPoints(dst[i].fPts, 3);
     }
     return conicCount;
 }