Revert of Analytic AntiAlias for Convex Shapes

src/core/SkEdgeBuilder.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "SkEdgeBuilder.h"
 #include "SkPath.h"
 #include "SkEdge.h"
-#include "SkAnalyticEdge.h"
 #include "SkEdgeClipper.h"
 #include "SkLineClipper.h"
 #include "SkGeometry.h"
 
 template <typename T> static T* typedAllocThrow(SkChunkAlloc& alloc) {
     return static_cast<T*>(alloc.allocThrow(sizeof(T)));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ skipping 35 matching lines @@
             return kPartial_Combine;
         }
         last->fLastY = last->fFirstY - 1;
         last->fFirstY = edge->fFirstY;
         last->fWinding = edge->fWinding;
         return kPartial_Combine;
     }
     return kNo_Combine;
 }
 
-SkEdgeBuilder::Combine SkEdgeBuilder::CombineVertical(
-        const SkAnalyticEdge* edge, SkAnalyticEdge* last) {
-    SkASSERT(fAnalyticAA);
-    if (last->fCurveCount || last->fDX || edge->fX != last->fX) {
-        return kNo_Combine;
-    }
-    if (edge->fWinding == last->fWinding) {
-        if (edge->fLowerY == last->fUpperY) {
-            last->fUpperY = edge->fUpperY;
-            last->fY = last->fUpperY;
-            return kPartial_Combine;
-        }
-        if (edge->fUpperY == last->fLowerY) {
-            last->fLowerY = edge->fLowerY;
-            return kPartial_Combine;
-        }
-        return kNo_Combine;
-    }
-    if (edge->fUpperY == last->fUpperY) {
-        if (edge->fLowerY == last->fLowerY) {
-            return kTotal_Combine;
-        }
-        if (edge->fLowerY < last->fLowerY) {
-            last->fUpperY = edge->fLowerY;
-            last->fY = last->fUpperY;
-            return kPartial_Combine;
-        }
-        last->fUpperY = last->fLowerY;
-        last->fY = last->fUpperY;
-        last->fLowerY = edge->fLowerY;
-        last->fWinding = edge->fWinding;
-        return kPartial_Combine;
-    }
-    if (edge->fLowerY == last->fLowerY) {
-        if (edge->fUpperY > last->fUpperY) {
-            last->fLowerY = edge->fUpperY;
-            return kPartial_Combine;
-        }
-        last->fLowerY = last->fUpperY;
-        last->fUpperY = edge->fUpperY;
-        last->fY = last->fUpperY;
-        last->fWinding = edge->fWinding;
-        return kPartial_Combine;
-    }
-    return kNo_Combine;
-}
-
-bool SkEdgeBuilder::vertical_line(const SkEdge* edge) {
-    return !edge->fDX && !edge->fCurveCount;
-}
-
-bool SkEdgeBuilder::vertical_line(const SkAnalyticEdge* edge) {
-    SkASSERT(fAnalyticAA);
+static bool vertical_line(const SkEdge* edge) {
     return !edge->fDX && !edge->fCurveCount;
 }
 
 void SkEdgeBuilder::addLine(const SkPoint pts[]) {
-    if (fAnalyticAA) {
-        SkAnalyticEdge* edge = typedAllocThrow<SkAnalyticEdge>(fAlloc);
-        if (edge->setLine(pts[0], pts[1])) {
-            if (vertical_line(edge) && fList.count()) {
-                Combine combine = CombineVertical(edge, (SkAnalyticEdge*)*(fList.end() - 1));
-                if (kNo_Combine != combine) {
-                    if (kTotal_Combine == combine) {
-                        fList.pop();
-                    }
-                    goto unallocate_analytic_edge;
+    SkEdge* edge = typedAllocThrow<SkEdge>(fAlloc);
+    if (edge->setLine(pts[0], pts[1], fShiftUp)) {
+        if (vertical_line(edge) && fList.count()) {
+            Combine combine = CombineVertical(edge, *(fList.end() - 1));
+            if (kNo_Combine != combine) {
+                if (kTotal_Combine == combine) {
+                    fList.pop();
                 }
+                goto unallocate_edge;
             }
-            fList.push(edge);
-        } else {
-unallocate_analytic_edge:
-            ;
-            // TODO: unallocate edge from storage...
         }
+        fList.push(edge);
     } else {
-        SkEdge* edge = typedAllocThrow<SkEdge>(fAlloc);
-        if (edge->setLine(pts[0], pts[1], fShiftUp)) {
-            if (vertical_line(edge) && fList.count()) {
-                Combine combine = CombineVertical(edge, (SkEdge*)*(fList.end() - 1));
-                if (kNo_Combine != combine) {
-                    if (kTotal_Combine == combine) {
-                        fList.pop();
-                    }
-                    goto unallocate_edge;
-                }
-            }
-            fList.push(edge);
-        } else {
 unallocate_edge:
-            ;
-            // TODO: unallocate edge from storage...
-        }
+        ;
+        // TODO: unallocate edge from storage...
     }
 }
 
 void SkEdgeBuilder::addQuad(const SkPoint pts[]) {
-    if (fAnalyticAA) {
-        SkAnalyticQuadraticEdge* edge = typedAllocThrow<SkAnalyticQuadraticEdge>(fAlloc);
-        if (edge->setQuadratic(pts)) {
-            fList.push(edge);
-        } else {
-            // TODO: unallocate edge from storage...
-        }
+    SkQuadraticEdge* edge = typedAllocThrow<SkQuadraticEdge>(fAlloc);
+    if (edge->setQuadratic(pts, fShiftUp)) {
+        fList.push(edge);
     } else {
-        SkQuadraticEdge* edge = typedAllocThrow<SkQuadraticEdge>(fAlloc);
-        if (edge->setQuadratic(pts, fShiftUp)) {
-            fList.push(edge);
-        } else {
-            // TODO: unallocate edge from storage...
-        }
+        // TODO: unallocate edge from storage...
     }
 }
 
 void SkEdgeBuilder::addCubic(const SkPoint pts[]) {
-    if (fAnalyticAA) {
-        SkAnalyticCubicEdge* edge = typedAllocThrow<SkAnalyticCubicEdge>(fAlloc);
-        if (edge->setCubic(pts)) {
-            fList.push(edge);
-        } else {
-            // TODO: unallocate edge from storage...
-        }
+    SkCubicEdge* edge = typedAllocThrow<SkCubicEdge>(fAlloc);
+    if (edge->setCubic(pts, fShiftUp)) {
+        fList.push(edge);
     } else {
-        SkCubicEdge* edge = typedAllocThrow<SkCubicEdge>(fAlloc);
-        if (edge->setCubic(pts, fShiftUp)) {
-            fList.push(edge);
-        } else {
-            // TODO: unallocate edge from storage...
-        }
+        // TODO: unallocate edge from storage...
     }
 }
 
 void SkEdgeBuilder::addClipper(SkEdgeClipper* clipper) {
     SkPoint      pts[4];
     SkPath::Verb verb;
 
     while ((verb = clipper->next(pts)) != SkPath::kDone_Verb) {
         switch (verb) {
             case SkPath::kLine_Verb:
@@ skipping 14 matching lines @@
 ///////////////////////////////////////////////////////////////////////////////
 
 static void setShiftedClip(SkRect* dst, const SkIRect& src, int shift) {
     dst->set(SkIntToScalar(src.fLeft >> shift),
              SkIntToScalar(src.fTop >> shift),
              SkIntToScalar(src.fRight >> shift),
              SkIntToScalar(src.fBottom >> shift));
 }
 
 SkEdgeBuilder::Combine SkEdgeBuilder::checkVertical(const SkEdge* edge, SkEdge** edgePtr) {
-    return !vertical_line(edge) || edgePtr <= (SkEdge**)fEdgeList ? kNo_Combine :
+    return !vertical_line(edge) || edgePtr <= fEdgeList ? kNo_Combine :
             CombineVertical(edge, edgePtr[-1]);
 }
 
-SkEdgeBuilder::Combine SkEdgeBuilder::checkVertical(const SkAnalyticEdge* edge,
-        SkAnalyticEdge** edgePtr) {
-    SkASSERT(fAnalyticAA);
-    return !vertical_line(edge) || edgePtr <= (SkAnalyticEdge**)fEdgeList ? kNo_Combine :
-            CombineVertical(edge, edgePtr[-1]);
-}
-
 int SkEdgeBuilder::buildPoly(const SkPath& path, const SkIRect* iclip, int shiftUp,
                              bool canCullToTheRight) {
     SkPath::Iter    iter(path, true);
     SkPoint         pts[4];
     SkPath::Verb    verb;
 
     int maxEdgeCount = path.countPoints();
     if (iclip) {
         // clipping can turn 1 line into (up to) kMaxClippedLineSegments, since
         // we turn portions that are clipped out on the left/right into vertical
         // segments.
         maxEdgeCount *= SkLineClipper::kMaxClippedLineSegments;
     }
-    size_t edgeSize = fAnalyticAA ? sizeof(SkAnalyticEdge) : sizeof(SkEdge);
-    size_t maxEdgeSize = maxEdgeCount * edgeSize;
-    size_t maxEdgePtrSize = maxEdgeCount * sizeof(char*);
+    size_t maxEdgeSize = maxEdgeCount * sizeof(SkEdge);
+    size_t maxEdgePtrSize = maxEdgeCount * sizeof(SkEdge*);
 
     // lets store the edges and their pointers in the same block
     char* storage = (char*)fAlloc.allocThrow(maxEdgeSize + maxEdgePtrSize);
-    char* edge = (char*)storage;
-    char** edgePtr = (char**)(storage + maxEdgeSize);
+    SkEdge* edge = reinterpret_cast<SkEdge*>(storage);
+    SkEdge** edgePtr = reinterpret_cast<SkEdge**>(storage + maxEdgeSize);
     // Record the beginning of our pointers, so we can return them to the caller
-    fEdgeList = (void**)edgePtr;
+    fEdgeList = edgePtr;
 
     if (iclip) {
         SkRect clip;
         setShiftedClip(&clip, *iclip, shiftUp);
 
         while ((verb = iter.next(pts, false)) != SkPath::kDone_Verb) {
             switch (verb) {
                 case SkPath::kMove_Verb:
                 case SkPath::kClose_Verb:
                     // we ignore these, and just get the whole segment from
                     // the corresponding line/quad/cubic verbs
                     break;
                 case SkPath::kLine_Verb: {
                     SkPoint lines[SkLineClipper::kMaxPoints];
                     int lineCount = SkLineClipper::ClipLine(pts, clip, lines, canCullToTheRight);
                     SkASSERT(lineCount <= SkLineClipper::kMaxClippedLineSegments);
                     for (int i = 0; i < lineCount; i++) {
-                        bool setLineResult = fAnalyticAA ?
-                                ((SkAnalyticEdge*)edge)->setLine(lines[i], lines[i + 1]) :
-                                ((SkEdge*)edge)->setLine(lines[i], lines[i + 1], shiftUp);
-                        if (setLineResult) {
-                            Combine combine = fAnalyticAA ?
-                                    checkVertical((SkAnalyticEdge*)edge, (SkAnalyticEdge**)edgePtr) :
-                                    checkVertical((SkEdge*)edge, (SkEdge**)edgePtr);
+                        if (edge->setLine(lines[i], lines[i + 1], shiftUp)) {
+                            Combine combine = checkVertical(edge, edgePtr);
                             if (kNo_Combine == combine) {
-                                *edgePtr++ = edge;
-                                edge += edgeSize;
+                                *edgePtr++ = edge++;
                             } else if (kTotal_Combine == combine) {
                                 --edgePtr;
                             }
                         }
                     }
                     break;
                 }
                 default:
                     SkDEBUGFAIL("unexpected verb");
                     break;
             }
         }
     } else {
         while ((verb = iter.next(pts, false)) != SkPath::kDone_Verb) {
             switch (verb) {
                 case SkPath::kMove_Verb:
                 case SkPath::kClose_Verb:
                     // we ignore these, and just get the whole segment from
                     // the corresponding line/quad/cubic verbs
                     break;
-                case SkPath::kLine_Verb: {
-                    bool setLineResult = fAnalyticAA ?
-                            ((SkAnalyticEdge*)edge)->setLine(pts[0], pts[1]) :
-                            ((SkEdge*)edge)->setLine(pts[0], pts[1], shiftUp);
-                    if (setLineResult) {
-                        Combine combine = fAnalyticAA ?
-                                checkVertical((SkAnalyticEdge*)edge, (SkAnalyticEdge**)edgePtr) :
-                                checkVertical((SkEdge*)edge, (SkEdge**)edgePtr);
+                case SkPath::kLine_Verb:
+                    if (edge->setLine(pts[0], pts[1], shiftUp)) {
+                        Combine combine = checkVertical(edge, edgePtr);
                         if (kNo_Combine == combine) {
-                            *edgePtr++ = edge;
-                            edge += edgeSize;
+                            *edgePtr++ = edge++;
                         } else if (kTotal_Combine == combine) {
                             --edgePtr;
                         }
                     }
                     break;
-                }
                 default:
                     SkDEBUGFAIL("unexpected verb");
                     break;
             }
         }
     }
     SkASSERT((char*)edge <= (char*)fEdgeList);
-    SkASSERT(edgePtr - (char**)fEdgeList <= maxEdgeCount);
-    return SkToInt(edgePtr - (char**)fEdgeList);
+    SkASSERT(edgePtr - fEdgeList <= maxEdgeCount);
+    return SkToInt(edgePtr - fEdgeList);
 }
 
 static void handle_quad(SkEdgeBuilder* builder, const SkPoint pts[3]) {
     SkPoint monoX[5];
     int n = SkChopQuadAtYExtrema(pts, monoX);
     for (int i = 0; i <= n; i++) {
         builder->addQuad(&monoX[i * 2]);
     }
 }
 
 int SkEdgeBuilder::build(const SkPath& path, const SkIRect* iclip, int shiftUp,
-                         bool canCullToTheRight, bool analyticAA) {
+                         bool canCullToTheRight) {
     fAlloc.reset();
     fList.reset();
     fShiftUp = shiftUp;
-    fAnalyticAA = analyticAA;
 
     if (SkPath::kLine_SegmentMask == path.getSegmentMasks()) {
         return this->buildPoly(path, iclip, shiftUp, canCullToTheRight);
     }
 
     SkAutoConicToQuads quadder;
     const SkScalar conicTol = SK_Scalar1 / 4;
 
     SkPath::Iter    iter(path, true);
     SkPoint         pts[4];
@@ skipping 77 matching lines @@
                 }
                 default:
                     SkDEBUGFAIL("unexpected verb");
                     break;
             }
         }
     }
     fEdgeList = fList.begin();
     return fList.count();
 }