change hairline procs to take SkPoint by value, more efficient on SSE and NEON

src/core/SkScan_Hairline.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 "SkScan.h"
@@ skipping 22 matching lines @@
     } while (++y < stopy);
 }
 
 #ifdef SK_DEBUG
 static bool canConvertFDot6ToFixed(SkFDot6 x) {
     const int maxDot6 = SK_MaxS32 >> (16 - 6);
     return SkAbs32(x) <= maxDot6;
 }
 #endif
 
-void SkScan::HairLineRgn(const SkPoint& pt0, const SkPoint& pt1,
-                         const SkRegion* clip, SkBlitter* blitter) {
+void SkScan::HairLineRgn(SkPoint pt0, SkPoint pt1, const SkRegion* clip, SkBlitter* blitter) {
     SkBlitterClipper    clipper;
     SkRect  r;
     SkIRect clipR, ptsR;
     SkPoint pts[2] = { pt0, pt1 };
 
     // We have to pre-clip the line to fit in a SkFixed, so we just chop
     // the line. TODO find a way to actually draw beyond that range.
     {
         SkRect fixedBounds;
         const SkScalar max = SkIntToScalar(32767);
@@ skipping 148 matching lines @@
     int idx = SkScalarCeilToInt(dx);
     int idy = SkScalarCeilToInt(dy);
     // use the cheap approx for distance
     if (idx > idy) {
         return idx + (idy >> 1);
     } else {
         return idy + (idx >> 1);
     }
 }
 
-typedef void (*LineProc)(const SkPoint&, const SkPoint&, const SkRegion*,
-                         SkBlitter*);
+typedef void (*LineProc)(SkPoint, SkPoint, const SkRegion*, SkBlitter*);
 
 static void hairquad(const SkPoint pts[3], const SkRegion* clip,
                      SkBlitter* blitter, int level, LineProc lineproc) {
     if (level > 0) {
         SkPoint tmp[5];
 
         SkChopQuadAtHalf(pts, tmp);
         hairquad(tmp, clip, blitter, level - 1, lineproc);
         hairquad(&tmp[2], clip, blitter, level - 1, lineproc);
     } else {
@@ skipping 25 matching lines @@
      than a pixel.
      */
     int level = (33 - SkCLZ(d)) >> 1;
     // sanity check on level (from the previous version)
     if (level > kMaxQuadSubdivideLevel) {
         level = kMaxQuadSubdivideLevel;
     }
     return level;
 }
 
-static void hair_path(const SkPath& path, const SkRasterClip& rclip,
-                      SkBlitter* blitter, LineProc lineproc) {
+static void hair_path(const SkPath& path, const SkRasterClip& rclip, SkBlitter* blitter,
+                      LineProc lineproc) {
     if (path.isEmpty()) {
         return;
     }
 
     SkAAClipBlitterWrapper wrap;
     const SkRegion* clip = NULL;
 
     {
         const SkIRect ibounds = path.getBounds().roundOut().makeOutset(1, 1);
 
@@ skipping 42 matching lines @@
                 haircubic(pts, clip, blitter, kMaxCubicSubdivideLevel, lineproc);
                 break;
             case SkPath::kClose_Verb:
                 break;
             case SkPath::kDone_Verb:
                 break;
         }
     }
 }
 
-void SkScan::HairPath(const SkPath& path, const SkRasterClip& clip,
-                      SkBlitter* blitter) {
+void SkScan::HairPath(const SkPath& path, const SkRasterClip& clip, SkBlitter* blitter) {
     hair_path(path, clip, blitter, SkScan::HairLineRgn);
 }
 
-void SkScan::AntiHairPath(const SkPath& path, const SkRasterClip& clip,
-                          SkBlitter* blitter) {
+void SkScan::AntiHairPath(const SkPath& path, const SkRasterClip& clip, SkBlitter* blitter) {
     hair_path(path, clip, blitter, SkScan::AntiHairLineRgn);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkScan::FrameRect(const SkRect& r, const SkPoint& strokeSize,
                        const SkRasterClip& clip, SkBlitter* blitter) {
     SkASSERT(strokeSize.fX >= 0 && strokeSize.fY >= 0);
 
     if (strokeSize.fX < 0 || strokeSize.fY < 0) {
@@ skipping 20 matching lines @@
     tmp.fBottom = outer.fBottom;
     SkScan::FillRect(tmp, clip, blitter);
 
     tmp.set(outer.fLeft, outer.fTop + dy, outer.fLeft + dx, outer.fBottom - dy);
     SkScan::FillRect(tmp, clip, blitter);
     tmp.fLeft = outer.fRight - dx;
     tmp.fRight = outer.fRight;
     SkScan::FillRect(tmp, clip, blitter);
 }
 
-void SkScan::HairLine(const SkPoint& p0, const SkPoint& p1,
-                      const SkRasterClip& clip, SkBlitter* blitter) {
+void SkScan::HairLine(SkPoint p0, SkPoint p1, const SkRasterClip& clip, SkBlitter* blitter) {
     if (clip.isBW()) {
         HairLineRgn(p0, p1, &clip.bwRgn(), blitter);
     } else {
         const SkRegion* clipRgn = NULL;
         SkRect r;
         r.set(p0.fX, p0.fY, p1.fX, p1.fY);
         r.sort();
         r.outset(SK_ScalarHalf, SK_ScalarHalf);
 
         SkAAClipBlitterWrapper wrap;
         if (!clip.quickContains(r.roundOut())) {
             wrap.init(clip, blitter);
             blitter = wrap.getBlitter();
             clipRgn = &wrap.getRgn();
         }
         HairLineRgn(p0, p1, clipRgn, blitter);
     }
 }
 
-void SkScan::AntiHairLine(const SkPoint& p0, const SkPoint& p1,
-                          const SkRasterClip& clip, SkBlitter* blitter) {
+void SkScan::AntiHairLine(SkPoint p0, SkPoint p1, const SkRasterClip& clip, SkBlitter* blitter) {
     if (clip.isBW()) {
         AntiHairLineRgn(p0, p1, &clip.bwRgn(), blitter);
     } else {
         const SkRegion* clipRgn = NULL;
         SkRect r;
         r.set(p0.fX, p0.fY, p1.fX, p1.fY);
         r.sort();
 
         SkAAClipBlitterWrapper wrap;
         if (!clip.quickContains(r.roundOut().makeOutset(1, 1))) {
             wrap.init(clip, blitter);
             blitter = wrap.getBlitter();
             clipRgn = &wrap.getRgn();
         }
         AntiHairLineRgn(p0, p1, clipRgn, blitter);
     }
 }