Style bikeshed - remove extraneous whitespace

src/gpu/batches/GrAAConvexTessellator.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAAConvexTessellator.h"
 #include "SkCanvas.h"
 #include "SkPath.h"
@@ skipping 18 matching lines @@
 // dot product below which we use a round cap between curve segments
 static const SkScalar kRoundCapThreshold = 0.8f;
 
 static SkScalar intersect(const SkPoint& p0, const SkPoint& n0,
                           const SkPoint& p1, const SkPoint& n1) {
     const SkPoint v = p1 - p0;
     SkScalar perpDot = n0.fX * n1.fY - n0.fY * n1.fX;
     return (v.fX * n1.fY - v.fY * n1.fX) / perpDot;
 }
 
-// This is a special case version of intersect where we have the vector 
+// This is a special case version of intersect where we have the vector
 // perpendicular to the second line rather than the vector parallel to it.
 static SkScalar perp_intersect(const SkPoint& p0, const SkPoint& n0,
                                const SkPoint& p1, const SkPoint& perp) {
     const SkPoint v = p1 - p0;
     SkScalar perpDot = n0.dot(perp);
     return v.dot(perp) / perpDot;
 }
 
 static bool duplicate_pt(const SkPoint& p0, const SkPoint& p1) {
     SkScalar distSq = p0.distanceToSqd(p1);
@@ skipping 85 matching lines @@
 
     int prev = fBisectors.count() - 1;
     for (int cur = 0; cur < fBisectors.count(); prev = cur, ++cur) {
         fBisectors[cur] = fNorms[cur] + fNorms[prev];
         if (!fBisectors[cur].normalize()) {
             SkASSERT(SkPoint::kLeft_Side == fSide || SkPoint::kRight_Side == fSide);
             fBisectors[cur].setOrthog(fNorms[cur], (SkPoint::Side)-fSide);
             SkVector other;
             other.setOrthog(fNorms[prev], fSide);
             fBisectors[cur] += other;
-            SkAssertResult(fBisectors[cur].normalize());        
+            SkAssertResult(fBisectors[cur].normalize());
         } else {
             fBisectors[cur].negate();      // make the bisector face in
         }
 
         SkASSERT(SkScalarNearlyEqual(1.0f, fBisectors[cur].length()));
     }
 }
 
 // Create as many rings as we need to (up to a predefined limit) to reach the specified target
 // depth. If we are in fill mode, the final ring will automatically be fanned.
 bool GrAAConvexTessellator::createInsetRings(Ring& previousRing, SkScalar initialDepth,
-                                             SkScalar initialCoverage, SkScalar targetDepth, 
+                                             SkScalar initialCoverage, SkScalar targetDepth,
                                              SkScalar targetCoverage, Ring** finalRing) {
     static const int kMaxNumRings = 8;
 
     if (previousRing.numPts() < 3) {
         return false;
     }
     Ring* currentRing = &previousRing;
     int i;
     for (i = 0; i < kMaxNumRings; ++i) {
         Ring* nextRing = this->getNextRing(currentRing);
         SkASSERT(nextRing != currentRing);
 
-        bool done = this->createInsetRing(*currentRing, nextRing, initialDepth, initialCoverage, 
+        bool done = this->createInsetRing(*currentRing, nextRing, initialDepth, initialCoverage,
                                           targetDepth, targetCoverage, i == 0);
         currentRing = nextRing;
         if (done) {
             break;
         }
         currentRing->init(*this);
     }
 
     if (kMaxNumRings == i) {
         // Bail if we've exceeded the amount of time we want to throw at this.
@@ skipping 15 matching lines @@
 // controls the iteration. The CandidateVerts holds the formative points for the
 // next ring.
 bool GrAAConvexTessellator::tessellate(const SkMatrix& m, const SkPath& path) {
     if (!this->extractFromPath(m, path)) {
         return false;
     }
 
     SkScalar coverage = 1.0f;
     SkScalar scaleFactor = 0.0f;
     if (fStrokeWidth >= 0.0f) {
-        SkASSERT(m.isSimilarity()); 
+        SkASSERT(m.isSimilarity());
         scaleFactor = m.getMaxScale(); // x and y scale are the same
         SkScalar effectiveStrokeWidth = scaleFactor * fStrokeWidth;
         Ring outerStrokeRing;
-        this->createOuterRing(fInitialRing, effectiveStrokeWidth / 2 - kAntialiasingRadius, 
+        this->createOuterRing(fInitialRing, effectiveStrokeWidth / 2 - kAntialiasingRadius,
                               coverage, &outerStrokeRing);
         outerStrokeRing.init(*this);
         Ring outerAARing;
         this->createOuterRing(outerStrokeRing, kAntialiasingRadius * 2, 0.0f, &outerAARing);
     } else {
         Ring outerAARing;
         this->createOuterRing(fInitialRing, kAntialiasingRadius, 0.0f, &outerAARing);
     }
 
     // the bisectors are only needed for the computation of the outer ring
     fBisectors.rewind();
     if (fStrokeWidth >= 0.0f && fInitialRing.numPts() > 2) {
         SkScalar effectiveStrokeWidth = scaleFactor * fStrokeWidth;
         Ring* insetStrokeRing;
         SkScalar strokeDepth = effectiveStrokeWidth / 2 - kAntialiasingRadius;
-        if (this->createInsetRings(fInitialRing, 0.0f, coverage, strokeDepth, coverage, 
+        if (this->createInsetRings(fInitialRing, 0.0f, coverage, strokeDepth, coverage,
                              &insetStrokeRing)) {
             Ring* insetAARing;
-            this->createInsetRings(*insetStrokeRing, strokeDepth, coverage, strokeDepth + 
+            this->createInsetRings(*insetStrokeRing, strokeDepth, coverage, strokeDepth +
                              kAntialiasingRadius * 2, 0.0f, &insetAARing);
         }
     } else {
         Ring* insetAARing;
         this->createInsetRings(fInitialRing, 0.0f, 0.5f, kAntialiasingRadius, 1.0f, &insetAARing);
     }
 
     SkDEBUGCODE(this->validate();)
     return true;
 }
@@ skipping 126 matching lines @@
         }
 
         // Make all the normals face outwards rather than along the edge
         for (int cur = 0; cur < fNorms.count(); ++cur) {
             fNorms[cur].setOrthog(fNorms[cur], fSide);
             SkASSERT(SkScalarNearlyEqual(1.0f, fNorms[cur].length()));
         }
 
         this->computeBisectors();
     } else if (this->numPts() == 2) {
-        // We've got two points, so we're degenerate. 
+        // We've got two points, so we're degenerate.
         if (fStrokeWidth < 0.0f) {
             // it's a fill, so we don't need to worry about degenerate paths
             return false;
         }
         // For stroking, we still need to process the degenerate path, so fix it up
         fSide = SkPoint::kLeft_Side;
 
         // Make all the normals face outwards rather than along the edge
         for (int cur = 0; cur < fNorms.count(); ++cur) {
             fNorms[cur].setOrthog(fNorms[cur], fSide);
@@ skipping 35 matching lines @@
 }
 
 void GrAAConvexTessellator::fanRing(const Ring& ring) {
     // fan out from point 0
     int startIdx = ring.index(0);
     for (int cur = ring.numPts() - 2; cur >= 0; --cur) {
         this->addTri(startIdx, ring.index(cur), ring.index(cur + 1));
     }
 }
 
-void GrAAConvexTessellator::createOuterRing(const Ring& previousRing, SkScalar outset, 
+void GrAAConvexTessellator::createOuterRing(const Ring& previousRing, SkScalar outset,
                                             SkScalar coverage, Ring* nextRing) {
     const int numPts = previousRing.numPts();
     if (numPts == 0) {
         return;
     }
 
     int prev = numPts - 1;
     int lastPerpIdx = -1, firstPerpIdx = -1;
 
     const SkScalar outsetSq = SkScalarMul(outset, outset);
     SkScalar miterLimitSq = SkScalarMul(outset, fMiterLimit);
     miterLimitSq = SkScalarMul(miterLimitSq, miterLimitSq);
     for (int cur = 0; cur < numPts; ++cur) {
         int originalIdx = previousRing.index(cur);
-        // For each vertex of the original polygon we add at least two points to the 
+        // For each vertex of the original polygon we add at least two points to the
         // outset polygon - one extending perpendicular to each impinging edge. Connecting these
-        // two points yields a bevel join. We need one additional point for a mitered join, and 
+        // two points yields a bevel join. We need one additional point for a mitered join, and
         // a round join requires one or more points depending upon curvature.
 
         // The perpendicular point for the last edge
         SkPoint normal1 = previousRing.norm(prev);
         SkPoint perp1 = normal1;
         perp1.scale(outset);
         perp1 += this->point(originalIdx);
 
         // The perpendicular point for the next edge.
         SkPoint normal2 = previousRing.norm(cur);
@@ skipping 65 matching lines @@
                             // The two triangles for the corner
                             this->addTri(originalIdx, perp1Idx, miterIdx);
                             this->addTri(originalIdx, miterIdx, perp2Idx);
                         }
                         break;
                     }
                     case SkPaint::Join::kBevel_Join:
                         this->addTri(originalIdx, perp1Idx, perp2Idx);
                         break;
                     default:
-                        // kRound_Join is unsupported for now. GrAALinearizingConvexPathRenderer is 
+                        // kRound_Join is unsupported for now. GrAALinearizingConvexPathRenderer is
                         // only willing to draw mitered or beveled, so we should never get here.
                         SkASSERT(false);
                 }
             }
 
             nextRing->addIdx(perp2Idx, originalIdx);
         }
 
         if (0 == cur) {
             // Store the index of the first perpendicular point to finish up
@@ skipping 21 matching lines @@
 }
 
 // Something went wrong in the creation of the next ring. If we're filling the shape, just go ahead
 // and fan it.
 void GrAAConvexTessellator::terminate(const Ring& ring) {
     if (fStrokeWidth < 0.0f) {
         this->fanRing(ring);
     }
 }
 
-static SkScalar compute_coverage(SkScalar depth, SkScalar initialDepth, SkScalar initialCoverage, 
+static SkScalar compute_coverage(SkScalar depth, SkScalar initialDepth, SkScalar initialCoverage,
                                 SkScalar targetDepth, SkScalar targetCoverage) {
     if (SkScalarNearlyEqual(initialDepth, targetDepth)) {
         return targetCoverage;
     }
-    SkScalar result = (depth - initialDepth) / (targetDepth - initialDepth) * 
+    SkScalar result = (depth - initialDepth) / (targetDepth - initialDepth) *
             (targetCoverage - initialCoverage) + initialCoverage;
     return SkScalarClampMax(result, 1.0f);
 }
 
 // return true when processing is complete
-bool GrAAConvexTessellator::createInsetRing(const Ring& lastRing, Ring* nextRing, 
-                                            SkScalar initialDepth, SkScalar initialCoverage, 
-                                            SkScalar targetDepth, SkScalar targetCoverage, 
+bool GrAAConvexTessellator::createInsetRing(const Ring& lastRing, Ring* nextRing,
+                                            SkScalar initialDepth, SkScalar initialCoverage,
+                                            SkScalar targetDepth, SkScalar targetCoverage,
                                             bool forceNew) {
     bool done = false;
 
     fCandidateVerts.rewind();
 
     // Loop through all the points in the ring and find the intersection with the smallest depth
     SkScalar minDist = SK_ScalarMax, minT = 0.0f;
     int minEdgeIdx = -1;
 
     for (int cur = 0; cur < lastRing.numPts(); ++cur) {
@@ skipping 91 matching lines @@
             for (int i = cur - 1; i >= 0 && dst[i] == targetIdx; i--) {
                 dst[i] = fused;
             }
         }
     }
 
     // Fold the new ring's points into the global pool
     for (int i = 0; i < fCandidateVerts.numPts(); ++i) {
         int newIdx;
         if (fCandidateVerts.needsToBeNew(i) || forceNew) {
-            // if the originating index is still valid then this point wasn't 
+            // if the originating index is still valid then this point wasn't
             // fused (and is thus movable)
-            SkScalar coverage = compute_coverage(depth, initialDepth, initialCoverage, 
+            SkScalar coverage = compute_coverage(depth, initialDepth, initialCoverage,
                                                  targetDepth, targetCoverage);
             newIdx = this->addPt(fCandidateVerts.point(i), depth, coverage,
                                  fCandidateVerts.originatingIdx(i) != -1, false);
         } else {
             SkASSERT(fCandidateVerts.originatingIdx(i) != -1);
             this->updatePt(fCandidateVerts.originatingIdx(i), fCandidateVerts.point(i), depth,
                            targetCoverage);
             newIdx = fCandidateVerts.originatingIdx(i);
         }
 
@@ skipping 107 matching lines @@
 }
 
 #endif
 
 void GrAAConvexTessellator::lineTo(SkPoint p, bool isCurve) {
     if (this->numPts() > 0 && duplicate_pt(p, this->lastPoint())) {
         return;
     }
 
     SkASSERT(fPts.count() <= 1 || fPts.count() == fNorms.count()+1);
-    if (this->numPts() >= 2 && 
+    if (this->numPts() >= 2 &&
         abs_dist_from_line(fPts.top(), fNorms.top(), p) < kClose) {
         // The old last point is on the line from the second to last to the new point
         this->popLastPt();
         fNorms.pop();
         fIsCurve.pop();
         // double-check that the new last point is not a duplicate of the new point. In an ideal
         // world this wouldn't be necessary (since it's only possible for non-convex paths), but
         // floating point precision issues mean it can actually happen on paths that were determined
         // to be convex.
         if (duplicate_pt(p, this->lastPoint())) {
@@ skipping 12 matching lines @@
 
 void GrAAConvexTessellator::lineTo(const SkMatrix& m, SkPoint p, bool isCurve) {
     m.mapPoints(&p, 1);
     this->lineTo(p, isCurve);
 }
 
 void GrAAConvexTessellator::quadTo(SkPoint pts[3]) {
     int maxCount = GrPathUtils::quadraticPointCount(pts, kQuadTolerance);
     fPointBuffer.setReserve(maxCount);
     SkPoint* target = fPointBuffer.begin();
-    int count = GrPathUtils::generateQuadraticPoints(pts[0], pts[1], pts[2], 
+    int count = GrPathUtils::generateQuadraticPoints(pts[0], pts[1], pts[2],
             kQuadTolerance, &target, maxCount);
     fPointBuffer.setCount(count);
     for (int i = 0; i < count; i++) {
         lineTo(fPointBuffer[i], true);
     }
 }
 
 void GrAAConvexTessellator::quadTo(const SkMatrix& m, SkPoint pts[3]) {
     SkPoint transformed[3];
     transformed[0] = pts[0];
     transformed[1] = pts[1];
     transformed[2] = pts[2];
     m.mapPoints(transformed, 3);
     quadTo(transformed);
 }
 
 void GrAAConvexTessellator::cubicTo(const SkMatrix& m, SkPoint pts[4]) {
     m.mapPoints(pts, 4);
     int maxCount = GrPathUtils::cubicPointCount(pts, kCubicTolerance);
     fPointBuffer.setReserve(maxCount);
     SkPoint* target = fPointBuffer.begin();
-    int count = GrPathUtils::generateCubicPoints(pts[0], pts[1], pts[2], pts[3], 
+    int count = GrPathUtils::generateCubicPoints(pts[0], pts[1], pts[2], pts[3],
             kCubicTolerance, &target, maxCount);
     fPointBuffer.setCount(count);
     for (int i = 0; i < count; i++) {
         lineTo(fPointBuffer[i], true);
     }
 }
 
 // include down here to avoid compilation errors caused by "-" overload in SkGeometry.h
 #include "SkGeometry.h"
 
@@ skipping 28 matching lines @@
     int gs = int(255*paramValue);
     paint.setARGB(255, gs, gs, gs);
 
     canvas->drawCircle(p.fX, p.fY, kPointRadius, paint);
 
     if (stroke) {
         SkPaint stroke;
         stroke.setColor(SK_ColorYELLOW);
         stroke.setStyle(SkPaint::kStroke_Style);
         stroke.setStrokeWidth(kPointRadius/3.0f);
-        canvas->drawCircle(p.fX, p.fY, kPointRadius, stroke); 
+        canvas->drawCircle(p.fX, p.fY, kPointRadius, stroke);
     }
 }
 
 static void draw_line(SkCanvas* canvas, const SkPoint& p0, const SkPoint& p1, SkColor color) {
     SkPaint p;
     p.setColor(color);
 
     canvas->drawLine(p0.fX, p0.fY, p1.fX, p1.fY, p);
 }
 
@@ skipping 31 matching lines @@
         }
 
         SkString num;
         num.printf("%d", this->origEdgeID(cur));
         canvas->drawText(num.c_str(), num.size(), mid.fX, mid.fY, paint);
 
         if (fPts.count()) {
             draw_arrow(canvas, tess.point(fPts[cur].fIndex), fPts[cur].fBisector,
                        kArrowLength, SK_ColorBLUE);
         }
-    }    
+    }
 }
 
 void GrAAConvexTessellator::draw(SkCanvas* canvas) const {
     for (int i = 0; i < fIndices.count(); i += 3) {
         SkASSERT(fIndices[i] < this->numPts()) ;
         SkASSERT(fIndices[i+1] < this->numPts()) ;
         SkASSERT(fIndices[i+2] < this->numPts()) ;
 
         draw_line(canvas,
                   this->point(this->fIndices[i]), this->point(this->fIndices[i+1]),
                   SK_ColorBLACK);
         draw_line(canvas,
                   this->point(this->fIndices[i+1]), this->point(this->fIndices[i+2]),
                   SK_ColorBLACK);
         draw_line(canvas,
                   this->point(this->fIndices[i+2]), this->point(this->fIndices[i]),
                   SK_ColorBLACK);
     }
 
     fInitialRing.draw(canvas, *this);
     for (int i = 0; i < fRings.count(); ++i) {
         fRings[i]->draw(canvas, *this);
     }
 
     for (int i = 0; i < this->numPts(); ++i) {
         draw_point(canvas,
-                   this->point(i), 0.5f + (this->depth(i)/(2 * kAntialiasingRadius)), 
+                   this->point(i), 0.5f + (this->depth(i)/(2 * kAntialiasingRadius)),
                    !this->movable(i));
 
         SkPaint paint;
         paint.setTextSize(kPointTextSize);
         paint.setTextAlign(SkPaint::kCenter_Align);
         if (this->depth(i) <= -kAntialiasingRadius) {
             paint.setColor(SK_ColorWHITE);
         }
 
         SkString num;
         num.printf("%d", i);
-        canvas->drawText(num.c_str(), num.size(), 
-                         this->point(i).fX, this->point(i).fY+(kPointRadius/2.0f), 
+        canvas->drawText(num.c_str(), num.size(),
+                         this->point(i).fX, this->point(i).fY+(kPointRadius/2.0f),
                          paint);
     }
 }
 
 #endif
-