use Sk2s for EvalQuadTangent and ChopQuadAt

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"
 
@@ skipping 129 matching lines @@
     Sk2f P2 = Sk2f::Load(&src[2].fX);
 
     Sk2f B = P1 - P0;
     Sk2f A = P2 - P1 - B;
 
     SkPoint result;
     ((A * t2 + B+B) * t2 + P0).store(&result.fX);
     return result;
 }
 
+SkVector SkEvalQuadTangentAt(const SkPoint src[3], SkScalar t) {
+    SkASSERT(src);
+    SkASSERT(t >= 0 && t <= SK_Scalar1);
+
+    Sk2f P0 = Sk2f::Load(&src[0].fX);
+    Sk2f P1 = Sk2f::Load(&src[1].fX);
+    Sk2f P2 = Sk2f::Load(&src[2].fX);
+
+    Sk2f B = P1 - P0;
+    Sk2f A = P2 - P1 - B;
+    Sk2f T = A * Sk2f(t) + B;
+
+    SkVector result;
+    (T + T).store(&result.fX);
+    return result;
+}
+
 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 Sk2s interp(Sk2s A, Sk2s B, Sk2s T) {

[mtklein, 2015/03/20 11:39:48]

Interesting.

The x86 Windows warnings are telling us it has no way to guarantee these
parameters will be passed with 16-byte alignment.  The x86-64 calling convention
requires these to pass by xmm registers, which is perfect, and other 32-bit
platforms probably 16-byte align the stack, which is fine, but here MSVC is
throwing up its hands and saying it can do neither.

Annoyingly, I think we have to write

static Sk2s interp(const Sk2s& A, const Sk2s& B, const Sk2s& T) {
   return A + (B - A) * T;
}

+    return A + (B - A) * T;
+}
+
+void SkChopQuadAt2(const SkPoint src[3], SkPoint dst[5], SkScalar t) {
+    SkASSERT(t > 0 && t < SK_Scalar1);
+
+    Sk2s P0 = Sk2f::Load(&src[0].fX);

[mtklein, 2015/03/20 11:39:48]

You might call these A,B,C to match AB and BC.

+    Sk2s P1 = Sk2f::Load(&src[1].fX);
+    Sk2s P2 = Sk2f::Load(&src[2].fX);
+    Sk2s tt = Sk2s(t);
+    
+    Sk2s AB = interp(P0, P1, tt);
+    Sk2s BC = interp(P1, P2, tt);
+
+    P0.store(&dst[0].fX);
+    AB.store(&dst[1].fX);
+    interp(AB, BC, tt).store(&dst[2].fX);
+    BC.store(&dst[3].fX);
+    P2.store(&dst[4].fX);
+}
+
 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);
@@ skipping 1301 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;
 }