4c3f7d1290
Adds multi-channel SDF font texture generation and rendering support. Adds per-font oversampling support. Adds FontData import plugins (for dynamic fonts, BMFonts and monospaced image fonts), font texture cache pre-generation and loading. Adds BMFont binary format and outline support.
126 lines
3.9 KiB
C++
126 lines
3.9 KiB
C++
|
|
#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);
|
|
}
|
|
|
|
}
|