1 files changed, 125 insertions, 0 deletions
diff --git a/thirdparty/msdfgen/core/Scanline.cpp b/thirdparty/msdfgen/core/Scanline.cpp
new file mode 100644
index 0000000000..8e5352dbf6
--- /dev/null
+++ b/thirdparty/msdfgen/core/Scanline.cpp
@@ -0,0 +1,125 @@
+
+#include "Scanline.h"
+
+#include <algorithm>
+#include "arithmetics.hpp"
+
+namespace msdfgen {
+
+static int compareIntersections(const void *a, const void *b) {
+    return sign(reinterpret_cast<const Scanline::Intersection *>(a)->x-reinterpret_cast<const Scanline::Intersection *>(b)->x);
+}
+
+bool interpretFillRule(int intersections, FillRule fillRule) {
+    switch (fillRule) {
+        case FILL_NONZERO:
+            return intersections != 0;
+        case FILL_ODD:
+            return intersections&1;
+        case FILL_POSITIVE:
+            return intersections > 0;
+        case FILL_NEGATIVE:
+            return intersections < 0;
+    }
+    return false;
+}
+
+double Scanline::overlap(const Scanline &a, const Scanline &b, double xFrom, double xTo, FillRule fillRule) {
+    double total = 0;
+    bool aInside = false, bInside = false;
+    int ai = 0, bi = 0;
+    double ax = !a.intersections.empty() ? a.intersections[ai].x : xTo;
+    double bx = !b.intersections.empty() ? b.intersections[bi].x : xTo;
+    while (ax < xFrom || bx < xFrom) {
+        double xNext = min(ax, bx);
+        if (ax == xNext && ai < (int) a.intersections.size()) {
+            aInside = interpretFillRule(a.intersections[ai].direction, fillRule);
+            ax = ++ai < (int) a.intersections.size() ? a.intersections[ai].x : xTo;
+        }
+        if (bx == xNext && bi < (int) b.intersections.size()) {
+            bInside = interpretFillRule(b.intersections[bi].direction, fillRule);
+            bx = ++bi < (int) b.intersections.size() ? b.intersections[bi].x : xTo;
+        }
+    }
+    double x = xFrom;
+    while (ax < xTo || bx < xTo) {
+        double xNext = min(ax, bx);
+        if (aInside == bInside)
+            total += xNext-x;
+        if (ax == xNext && ai < (int) a.intersections.size()) {
+            aInside = interpretFillRule(a.intersections[ai].direction, fillRule);
+            ax = ++ai < (int) a.intersections.size() ? a.intersections[ai].x : xTo;
+        }
+        if (bx == xNext && bi < (int) b.intersections.size()) {
+            bInside = interpretFillRule(b.intersections[bi].direction, fillRule);
+            bx = ++bi < (int) b.intersections.size() ? b.intersections[bi].x : xTo;
+        }
+        x = xNext;
+    }
+    if (aInside == bInside)
+        total += xTo-x;
+    return total;
+}
+
+Scanline::Scanline() : lastIndex(0) { }
+
+void Scanline::preprocess() {
+    lastIndex = 0;
+    if (!intersections.empty()) {
+        qsort(&intersections[0], intersections.size(), sizeof(Intersection), compareIntersections);
+        int totalDirection = 0;
+        for (std::vector<Intersection>::iterator intersection = intersections.begin(); intersection != intersections.end(); ++intersection) {
+            totalDirection += intersection->direction;
+            intersection->direction = totalDirection;
+        }
+    }
+}
+
+void Scanline::setIntersections(const std::vector<Intersection> &intersections) {
+    this->intersections = intersections;
+    preprocess();
+}
+
+#ifdef MSDFGEN_USE_CPP11
+void Scanline::setIntersections(std::vector<Intersection> &&intersections) {
+    this->intersections = (std::vector<Intersection> &&) intersections;
+    preprocess();
+}
+#endif
+
+int Scanline::moveTo(double x) const {
+    if (intersections.empty())
+        return -1;
+    int index = lastIndex;
+    if (x < intersections[index].x) {
+        do {
+            if (index == 0) {
+                lastIndex = 0;
+                return -1;
+            }
+            --index;
+        } while (x < intersections[index].x);
+    } else {
+        while (index < (int) intersections.size()-1 && x >= intersections[index+1].x)
+            ++index;
+    }
+    lastIndex = index;
+    return index;
+}
+
+int Scanline::countIntersections(double x) const {
+    return moveTo(x)+1;
+}
+
+int Scanline::sumIntersections(double x) const {
+    int index = moveTo(x);
+    if (index >= 0)
+        return intersections[index].direction;
+    return 0;
+}
+
+bool Scanline::filled(double x, FillRule fillRule) const {
+    return interpretFillRule(sumIntersections(x), fillRule);
+}
+
+}