cleanup using constructors

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"
 
 static Sk2s from_point(const SkPoint& point) {
     return Sk2s::Load(&point.fX);
 }
 
 static SkPoint to_point(const Sk2s& x) {
     SkPoint point;
     x.store(&point.fX);
     return point;
 }
 
 static SkVector to_vector(const Sk2s& x) {
     SkVector vector;
     x.store(&vector.fX);
     return vector;
 }
 
-#if 0
-static Sk2s divide(const Sk2s& numer, const Sk2s& denom) {
-    SkScalar numerStorage[2], denomStorage[2];
-    numer.store(numerStorage);
-    denom.store(denomStorage);
-    numerStorage[0] /= denomStorage[0];
-    numerStorage[1] /= denomStorage[1];
-    return Sk2s::Load(numerStorage);
-}
-#endif
-
 /** If defined, this makes eval_quad and eval_cubic do more setup (sometimes
     involving integer multiplies by 2 or 3, but fewer calls to SkScalarMul.
     May also introduce overflow of fixed when we compute our setup.
 */
 //    #define DIRECT_EVAL_OF_POLYNOMIALS
 
 ////////////////////////////////////////////////////////////////////////
 
 static int is_not_monotonic(SkScalar a, SkScalar b, SkScalar c) {
     SkScalar ab = a - b;
@@ skipping 162 matching lines @@
 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) {
     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 = Sk2s(t);
+    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);
 }
@@ skipping 1047 matching lines @@
 }
 
 static Sk2s times_2(const Sk2s& value) {
     return value + value;
 }
 
 SkPoint SkConic::evalAt(SkScalar t) const {
     Sk2s p0 = from_point(fPts[0]);
     Sk2s p1 = from_point(fPts[1]);
     Sk2s p2 = from_point(fPts[2]);
-    Sk2s tt = Sk2s(t);
-    Sk2s ww = Sk2s(fW);
-    Sk2s one = Sk2s(1);
+    Sk2s tt(t);
+    Sk2s ww(fW);
+    Sk2s one(1);
 
     Sk2s p1w = p1 * ww;
     Sk2s C = p0;
     Sk2s A = p2 - times_2(p1w) + p0;
     Sk2s B = times_2(p1w - C);
     Sk2s numer = quad_poly_eval(A, B, C, tt);
 
     B = times_2(ww - one);
     A = -B;
     Sk2s denom = quad_poly_eval(A, B, one, tt);
 
     return to_point(numer / denom);
 }
 
 SkVector SkConic::evalTangentAt(SkScalar t) const {
     Sk2s p0 = from_point(fPts[0]);
     Sk2s p1 = from_point(fPts[1]);
     Sk2s p2 = from_point(fPts[2]);
-    Sk2s ww = Sk2s(fW);
+    Sk2s ww(fW);
 
     Sk2s p20 = p2 - p0;
     Sk2s p10 = p1 - p0;
 
     Sk2s C = ww * p10;
     Sk2s A = ww * p20 - p20;
     Sk2s B = p20 - C - C;
 
     return to_vector(quad_poly_eval(A, B, C, Sk2s(t)));
 #if 0
@@ skipping 34 matching lines @@
 
     dst[1].fPts[0].set(mx, my);
     dst[1].fPts[1].set((p1x + fPts[2].fX) * scale,
                        (p1y + fPts[2].fY) * scale);
     dst[1].fPts[2] = fPts[2];
 
     dst[0].fW = dst[1].fW = subdivide_w_value(fW);
 }
 
 void SkConic::chop2(SkConic * SK_RESTRICT dst) const {
-    Sk2s scale(SkScalarInvert(SK_Scalar1 + fW));
-//    Sk2s scale = Sk2s(SK_Scalar1 + fW).invert();
+    Sk2s scale = Sk2s(SK_Scalar1 + fW).invert();    // approxInvert is wicked faster!!!
     SkScalar newW = subdivide_w_value(fW);
 
     Sk2s p0 = from_point(fPts[0]);
     Sk2s p1 = from_point(fPts[1]);
     Sk2s p2 = from_point(fPts[2]);
-    Sk2s ww = Sk2s(fW);
-    Sk2s half = Sk2s(0.5f);
+    Sk2s ww(fW);
+    Sk2s half(0.5f);
 
     Sk2s wp1 = ww * p1;
     Sk2s m = ((p0 + wp1 + wp1 + p2) * half) * scale;
 
     dst[0].fPts[0] = fPts[0];
     dst[0].fPts[1] = to_point((p0 + wp1) * scale);
     dst[0].fPts[2] = dst[1].fPts[0] = to_point(m);
     dst[1].fPts[1] = to_point((wp1 + p2) * scale);
     dst[1].fPts[2] = fPts[2];
 
@@ skipping 242 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;
 }