Port to real Sk2f.

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 99 matching lines @@
 static SkScalar eval_quad_derivative(const SkScalar src[], SkScalar t) {
     SkScalar A = src[4] - 2 * src[2] + src[0];
     SkScalar B = src[2] - src[0];
 
     return 2 * SkScalarMulAdd(A, t, B);
 }
 
 void SkEvalQuadAt(const SkPoint src[3], SkScalar t, SkPoint* pt, SkVector* tangent) {
     SkASSERT(src);
     SkASSERT(t >= 0 && t <= SK_Scalar1);
-    
+
     if (pt) {
         pt->set(eval_quad(&src[0].fX, t), eval_quad(&src[0].fY, t));
     }
     if (tangent) {
         tangent->set(eval_quad_derivative(&src[0].fX, t),
                      eval_quad_derivative(&src[0].fY, t));
     }
 }
 
-#include "Sk4x.h"
+#include "Sk2x.h"
 
 SkPoint SkEvalQuadAt(const SkPoint src[3], SkScalar t) {
     SkASSERT(src);
     SkASSERT(t >= 0 && t <= SK_Scalar1);
 
-    const Sk4f t2(t);
-    const Sk4f two(2);
-    
-    Sk4f P0 = Sk4f::Load2(&src[0].fX);
-    Sk4f P1 = Sk4f::Load2(&src[1].fX);
-    Sk4f P2 = Sk4f::Load2(&src[2].fX);
-    
-    Sk4f A = P2.subtract(P1.multiply(two)).add(P0);
-    Sk4f B = P1.subtract(P0).multiply(two);
-    
+    const Sk2f t2(t);
+
+    Sk2f P0 = Sk2f::Load(&src[0].fX);
+    Sk2f P1 = Sk2f::Load(&src[1].fX);
+    Sk2f P2 = Sk2f::Load(&src[2].fX);
+
+    Sk2f A = P2.subtract(P1.add(P1)).add(P0);
+    Sk2f B = P1.subtract(P0);
+    B = B.add(B);
+
     SkPoint result;
-    A.multiply(t2).add(B).multiply(t2).add(P0).store2(&result.fX);
+    A.multiply(t2).add(B).multiply(t2).add(P0).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);
@@ skipping 1224 matching lines @@
     return false;
 }
 
 SkScalar SkConic::TransformW(const SkPoint pts[], SkScalar w,
                              const SkMatrix& matrix) {
     if (!matrix.hasPerspective()) {
         return w;
     }
 
     SkP3D src[3], dst[3];
-    
+
     ratquad_mapTo3D(pts, w, src);
 
     matrix.mapHomogeneousPoints(&dst[0].fX, &src[0].fX, 3);
 
     // w' = sqrt(w1*w1/w0*w2)
     SkScalar w0 = dst[0].fZ;
     SkScalar w1 = dst[1].fZ;
     SkScalar w2 = dst[2].fZ;
     w = SkScalarSqrt((w1 * w1) / (w0 * w2));
     return w;
@@ skipping 77 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;
 }