Fix for bisector computation bug in GrAAConvexTessellator

src/gpu/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 107 matching lines @@
     fRings[1].rewind();
 #endif
 }
 
 void GrAAConvexTessellator::computeBisectors() {
     fBisectors.setCount(fNorms.count());
 
     int prev = fBisectors.count() - 1;
     for (int cur = 0; cur < fBisectors.count(); prev = cur, ++cur) {
         fBisectors[cur] = fNorms[cur] + fNorms[prev];
-        fBisectors[cur].normalize();
-        fBisectors[cur].negate();      // make the bisector face in
+        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());        
+        } else {
+            fBisectors[cur].negate();      // make the bisector face in
+        }
 
         SkASSERT(SkScalarNearlyEqual(1.0f, fBisectors[cur].length()));
     }
 }
 
 // The general idea here is to, conceptually, start with the original polygon and slide
 // the vertices along the bisectors until the first intersection. At that
 // point two of the edges collapse and the process repeats on the new polygon.
 // The polygon state is captured in the Ring class while the GrAAConvexTessellator
 // controls the iteration. The CandidateVerts holds the formative points for the
@@ skipping 480 matching lines @@
 
 void GrAAConvexTessellator::validate() const {
     SkASSERT(fPts.count() == fDepths.count());
     SkASSERT(fPts.count() == fMovable.count());
     SkASSERT(0 == (fIndices.count() % 3));
 }
 
 //////////////////////////////////////////////////////////////////////////////
 void GrAAConvexTessellator::Ring::init(const GrAAConvexTessellator& tess) {
     this->computeNormals(tess);
-    this->computeBisectors();
+    this->computeBisectors(tess);
     SkASSERT(this->isConvex(tess));
 }
 
 void GrAAConvexTessellator::Ring::init(const SkTDArray<SkVector>& norms,
                                        const SkTDArray<SkVector>& bisectors) {
     for (int i = 0; i < fPts.count(); ++i) {
         fPts[i].fNorm = norms[i];
         fPts[i].fBisector = bisectors[i];
     }
 }
 
 // Compute the outward facing normal at each vertex.
 void GrAAConvexTessellator::Ring::computeNormals(const GrAAConvexTessellator& tess) {
     for (int cur = 0; cur < fPts.count(); ++cur) {
         int next = (cur + 1) % fPts.count();
 
         fPts[cur].fNorm = tess.point(fPts[next].fIndex) - tess.point(fPts[cur].fIndex);
         SkDEBUGCODE(SkScalar len =) SkPoint::Normalize(&fPts[cur].fNorm);
         SkASSERT(len > 0.0f);
         fPts[cur].fNorm.setOrthog(fPts[cur].fNorm, tess.side());
 
         SkASSERT(SkScalarNearlyEqual(1.0f, fPts[cur].fNorm.length()));
     }
 }
 
-void GrAAConvexTessellator::Ring::computeBisectors() {
+void GrAAConvexTessellator::Ring::computeBisectors(const GrAAConvexTessellator& tess) {
     int prev = fPts.count() - 1;
     for (int cur = 0; cur < fPts.count(); prev = cur, ++cur) {
         fPts[cur].fBisector = fPts[cur].fNorm + fPts[prev].fNorm;
-        fPts[cur].fBisector.normalize();
-        fPts[cur].fBisector.negate();      // make the bisector face in
+        if (!fPts[cur].fBisector.normalize()) {
+            SkASSERT(SkPoint::kLeft_Side == tess.side() || SkPoint::kRight_Side == tess.side());
+            fPts[cur].fBisector.setOrthog(fPts[cur].fNorm, (SkPoint::Side)-tess.side());
+            SkVector other;
+            other.setOrthog(fPts[prev].fNorm, tess.side());
+            fPts[cur].fBisector += other;
+            SkAssertResult(fPts[cur].fBisector.normalize());
+        } else {
+            fPts[cur].fBisector.negate();      // make the bisector face in
+        }
 
         SkASSERT(SkScalarNearlyEqual(1.0f, fPts[cur].fBisector.length()));
     }    
 }
 
 //////////////////////////////////////////////////////////////////////////////
 #ifdef SK_DEBUG
 // Is this ring convex?
 bool GrAAConvexTessellator::Ring::isConvex(const GrAAConvexTessellator& tess) const {
     if (fPts.count() < 3) {
@@ skipping 193 matching lines @@
         SkString num;
         num.printf("%d", i);
         canvas->drawText(num.c_str(), num.size(), 
                          this->point(i).fX, this->point(i).fY+(kPointRadius/2.0f), 
                          paint);
     }
 }
 
 #endif