57fb3bf3dc
This font is less complete than our bitmap font, Unifont: Unifont has essentially complete Unicode coverage and LibreCAD's font only has Latin, Cyrillic and Japanese, but it can be extended rather easily, so this should be fine for now. These embedded fonts fatten glhelper.o quite a bit: bitmapfont.table.h is about 8M in gzip-compressed bitmaps and vectorfont.table.h is about 2M in raw vector data. In spite of that it takes just around five seconds to build glhelper.c on my laptop, so it should be fine. The final executable grows from about 2M to about 8M, but this is a small price to pay for fairly extensive i18n support. The new font has somewhat different metrics, so the rendering code has been fudged to make it look good.
397 lines
12 KiB
C++
397 lines
12 KiB
C++
#define _USE_MATH_DEFINES
|
|
#include <zlib.h>
|
|
#include <cmath>
|
|
#include <cctype>
|
|
#include <algorithm>
|
|
#include <vector>
|
|
#include <string>
|
|
#include <map>
|
|
#include <iostream>
|
|
#include <fstream>
|
|
#include <sstream>
|
|
|
|
#define TOLERANCE 1e-6
|
|
|
|
double correctAngle(double a) {
|
|
return M_PI + remainder(a - M_PI, 2 * M_PI);
|
|
}
|
|
|
|
struct Point {
|
|
double x;
|
|
double y;
|
|
|
|
Point operator+(const Point &o) const { return { x + o.x, y + o.y }; }
|
|
Point operator-(const Point &o) const { return { x - o.x, y - o.y }; }
|
|
Point operator*(const Point &o) const { return { x * o.x, y * o.y }; }
|
|
Point operator/(const Point &o) const { return { x / o.x, y / o.y }; }
|
|
|
|
Point operator*(double k) const { return { x * k, y * k }; }
|
|
Point operator/(double k) const { return { x / k, y / k }; }
|
|
|
|
double length() const{
|
|
return sqrt(x * x + y * y);
|
|
}
|
|
|
|
double angle() const {
|
|
return correctAngle(atan2(y, x));
|
|
}
|
|
|
|
double distanceTo(const Point &v) const {
|
|
return (*this - v).length();
|
|
}
|
|
|
|
double angleTo(const Point &v) const {
|
|
return (v - *this).angle();
|
|
}
|
|
|
|
static Point polar(double radius, double angle) {
|
|
return { radius * cos(angle), radius * sin(angle) };
|
|
}
|
|
|
|
bool operator==(const Point &o) const { return x == o.x && y == o.y; }
|
|
bool operator!=(const Point &o) const { return x != o.x || y != o.y; }
|
|
|
|
};
|
|
|
|
struct Curve {
|
|
std::vector<Point> points;
|
|
};
|
|
|
|
struct Glyph {
|
|
char32_t character;
|
|
char32_t baseCharacter;
|
|
std::vector<Curve> curves;
|
|
|
|
void getBoundWidth(double *rminw, double *rmaxw) const {
|
|
if(curves.empty()) {
|
|
*rminw = 0.0;
|
|
*rmaxw = 0.0;
|
|
return;
|
|
}
|
|
double minw = curves[0].points[0].x;
|
|
double maxw = minw;
|
|
for(const Curve &c : curves) {
|
|
for(const Point &p : c.points) {
|
|
maxw = std::max(maxw, p.x);
|
|
minw = std::min(minw, p.x);
|
|
}
|
|
}
|
|
*rminw = minw;
|
|
*rmaxw = maxw;
|
|
}
|
|
|
|
void getBoundHeight(double *rminh, double *rmaxh) const {
|
|
if(curves.empty()) {
|
|
*rminh = 0.0;
|
|
*rmaxh = 0.0;
|
|
return;
|
|
}
|
|
double minh = curves[0].points[0].y;
|
|
double maxh = minh;
|
|
for(const Curve &c : curves) {
|
|
for(const Point &p : c.points) {
|
|
maxh = std::max(maxh, p.y);
|
|
minh = std::min(minh, p.y);
|
|
}
|
|
}
|
|
*rminh = minh;
|
|
*rmaxh = maxh;
|
|
}
|
|
|
|
double getWidth() const {
|
|
double maxw;
|
|
double minw;
|
|
getBoundWidth(&minw, &maxw);
|
|
return maxw - minw;
|
|
}
|
|
|
|
double getHeight() const {
|
|
double maxh;
|
|
double minh;
|
|
getBoundHeight(&minh, &maxh);
|
|
return maxh - minh;
|
|
}
|
|
|
|
bool operator<(const Glyph &o) const { return character < o.character; }
|
|
};
|
|
|
|
struct Font {
|
|
double letterSpacing;
|
|
double wordSpacing;
|
|
std::vector<Glyph> glyphs;
|
|
|
|
void getGlyphBound(double *rminw, double *rminh, double *rmaxw, double *rmaxh) {
|
|
if(glyphs.empty()) {
|
|
*rminw = 0.0;
|
|
*rmaxw = 0.0;
|
|
*rminh = 0.0;
|
|
*rmaxh = 0.0;
|
|
return;
|
|
}
|
|
|
|
glyphs[0].getBoundWidth(rminw, rmaxw);
|
|
glyphs[0].getBoundHeight(rminh, rmaxh);
|
|
for(const Glyph &g : glyphs) {
|
|
double minw, minh, maxw, maxh;
|
|
g.getBoundWidth(&minw, &maxw);
|
|
g.getBoundHeight(&minh, &maxh);
|
|
*rminw = std::min(*rminw, minw);
|
|
*rminh = std::min(*rminh, minh);
|
|
*rmaxw = std::max(*rmaxw, maxw);
|
|
*rmaxh = std::max(*rmaxh, maxh);
|
|
}
|
|
}
|
|
|
|
void createArc(Curve &curve, const Point &cp, double radius,
|
|
double a1, double a2, bool reversed) {
|
|
if (radius < 1e-6) return;
|
|
|
|
double aSign = 1.0;
|
|
if(reversed) {
|
|
if(a1 <= a2 + TOLERANCE) a1 += 2.0 * M_PI;
|
|
aSign = -1.0;
|
|
} else {
|
|
if(a2 <= a1 + TOLERANCE) a2 += 2.0 * M_PI;
|
|
}
|
|
|
|
// Angle Step (rad)
|
|
double da = fabs(a2 - a1);
|
|
int numPoints = 8;
|
|
double aStep = aSign * da / double(numPoints);
|
|
|
|
for(int i = 0; i <= numPoints; i++) {
|
|
curve.points.push_back(cp + Point::polar(radius, a1 + aStep * i));
|
|
}
|
|
}
|
|
|
|
void createBulge(const Point &v, double bulge, Curve &curve) {
|
|
bool reversed = bulge < 0.0;
|
|
double alpha = atan(bulge) * 4.0;
|
|
Point &point = curve.points.back();
|
|
|
|
Point middle = (point + v) / 2.0;
|
|
double dist = point.distanceTo(v) / 2.0;
|
|
double angle = point.angleTo(v);
|
|
|
|
// alpha can't be 0.0 at this point
|
|
double radius = fabs(dist / sin(alpha / 2.0));
|
|
double wu = fabs(radius*radius - dist*dist);
|
|
double h = sqrt(wu);
|
|
|
|
if(bulge > 0.0) {
|
|
angle += M_PI_2;
|
|
} else {
|
|
angle -= M_PI_2;
|
|
}
|
|
|
|
if (fabs(alpha) > M_PI) {
|
|
h *= -1.0;
|
|
}
|
|
|
|
Point center = Point::polar(h, angle);
|
|
center = center + middle;
|
|
|
|
double a1 = center.angleTo(point);
|
|
double a2 = center.angleTo(v);
|
|
createArc(curve, center, radius, a1, a2, reversed);
|
|
}
|
|
|
|
void readLff(const std::string &path) {
|
|
gzFile lfffont = gzopen(path.c_str(), "rb");
|
|
if(!lfffont) {
|
|
std::cerr << path << ": gzopen failed" << std::endl;
|
|
std::exit(1);
|
|
}
|
|
|
|
// Read line by line until we find a new letter:
|
|
Glyph *currentGlyph = NULL;
|
|
while(!gzeof(lfffont)) {
|
|
std::string line;
|
|
do {
|
|
char buf[128] = {0};
|
|
if(!gzgets(lfffont, buf, sizeof(buf)))
|
|
break;
|
|
line += buf;
|
|
} while(line.back() != '\n');
|
|
|
|
if(line.empty() || line[0] == '\n') {
|
|
continue;
|
|
} else if(line[0] == '#') {
|
|
// This is comment or metadata.
|
|
std::istringstream ss(line.substr(1));
|
|
|
|
std::vector<std::string> tokens;
|
|
while(!ss.eof()) {
|
|
std::string token;
|
|
std::getline(ss, token, ':');
|
|
std::istringstream(token) >> token; // trim
|
|
if(!token.empty())
|
|
tokens.push_back(token);
|
|
}
|
|
|
|
// If not in form of "a:b" then it's not metadata, just a comment.
|
|
if (tokens.size() != 2)
|
|
continue;
|
|
|
|
std::string &identifier = tokens[0];
|
|
std::string &value = tokens[1];
|
|
|
|
std::transform(identifier.begin(), identifier.end(), identifier.begin(),
|
|
::tolower);
|
|
if (identifier == "letterspacing") {
|
|
std::istringstream(value) >> letterSpacing;
|
|
} else if (identifier == "wordspacing") {
|
|
std::istringstream(value) >> wordSpacing;
|
|
} else if (identifier == "linespacingfactor") {
|
|
/* don't care */
|
|
} else if (identifier == "author") {
|
|
/* don't care */
|
|
} else if (identifier == "name") {
|
|
/* don't care */
|
|
} else if (identifier == "license") {
|
|
/* don't care */
|
|
} else if (identifier == "encoding") {
|
|
/* don't care */
|
|
} else if (identifier == "created") {
|
|
/* don't care */
|
|
}
|
|
} else if(line[0] == '[') {
|
|
// This is a glyph.
|
|
size_t closingPos;
|
|
char32_t chr = std::stoi(line.substr(1), &closingPos, 16);;
|
|
if(line[closingPos + 1] != ']') {
|
|
std::cerr << "unrecognized character number: " << line << std::endl;
|
|
currentGlyph = NULL;
|
|
continue;
|
|
}
|
|
|
|
glyphs.emplace_back();
|
|
currentGlyph = &glyphs.back();
|
|
currentGlyph->character = chr;
|
|
currentGlyph->baseCharacter = 0;
|
|
} else if(currentGlyph != NULL) {
|
|
if (line[0] == 'C') {
|
|
// This is a reference to another glyph.
|
|
currentGlyph->baseCharacter = std::stoi(line.substr(1), NULL, 16);
|
|
} else {
|
|
// This is a series of curves.
|
|
currentGlyph->curves.emplace_back();
|
|
Curve &curve = currentGlyph->curves.back();
|
|
|
|
std::stringstream ss(line);
|
|
while (!ss.eof()) {
|
|
std::string vertex;
|
|
std::getline(ss, vertex, ';');
|
|
|
|
std::stringstream ssv(vertex);
|
|
std::string coord;
|
|
Point p;
|
|
|
|
if(!std::getline(ssv, coord, ',')) continue;
|
|
p.x = std::stod(coord);
|
|
|
|
if(!std::getline(ssv, coord, ',')) continue;
|
|
p.y = std::stod(coord);
|
|
|
|
if(!std::getline(ssv, coord, ',') || coord[0] != 'A') {
|
|
// This is just a point.
|
|
curve.points.push_back(p);
|
|
} else {
|
|
// This is a point with a bulge.
|
|
double bulge = std::stod(coord.substr(1));
|
|
createBulge(p, bulge, curve);
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
std::cerr << "unrecognized line: " << line << std::endl;
|
|
}
|
|
}
|
|
gzclose(lfffont);
|
|
}
|
|
|
|
void writeCppHeader(const std::string &hName) {
|
|
std::sort(glyphs.begin(), glyphs.end());
|
|
|
|
std::ofstream ts(hName, std::ios::out);
|
|
|
|
double minX, minY, maxX, maxY;
|
|
getGlyphBound(&minX, &minY, &maxX, &maxY);
|
|
|
|
double size = 126.0;
|
|
double scale = size / std::max({ fabs(maxX), fabs(minX), fabs(maxY), fabs(minY) });
|
|
|
|
// We use tabs for indentation here to make compilation slightly faster
|
|
ts <<
|
|
"/**** This is a generated file - do not edit ****/\n\n"
|
|
"#ifndef __VECTORFONT_TABLE_H\n"
|
|
"#define __VECTORFONT_TABLE_H\n"
|
|
"\n"
|
|
"#define PEN_UP 127\n"
|
|
"#define UP PEN_UP\n"
|
|
"\n"
|
|
"struct VectorGlyph {\n"
|
|
"\tchar32_t character;\n"
|
|
"\tchar32_t baseCharacter;\n"
|
|
"\tint width;\n"
|
|
"\tconst int8_t *data;\n"
|
|
"};\n"
|
|
"\n"
|
|
"const int8_t VectorFontData[] = {\n"
|
|
"\tUP, UP,\n";
|
|
|
|
std::map<char32_t, size_t> glyphIndexes;
|
|
size_t index = 2;
|
|
for(const Glyph &g : glyphs) {
|
|
ts << "\t// U+" << std::hex << g.character << std::dec << "\n";
|
|
glyphIndexes[g.character] = index;
|
|
for(const Curve &c : g.curves) {
|
|
for(const Point &p : c.points) {
|
|
ts << "\t" << int(floor(p.x * scale)) << ", " <<
|
|
int(floor(p.y * scale)) << ",\n";
|
|
index += 2;
|
|
}
|
|
ts << "\tUP, UP,\n";
|
|
index += 2;
|
|
}
|
|
ts << "\tUP, UP,\n"; // end-of-glyph marker
|
|
index += 2;
|
|
}
|
|
|
|
ts <<
|
|
"};\n"
|
|
"\n"
|
|
"const VectorGlyph VectorFont[] = {\n"
|
|
"\t// U+20\n"
|
|
"\t{ 32, 0, " << int(floor(wordSpacing * scale)) << ", &VectorFontData[0] },\n";
|
|
|
|
for(const Glyph &g : glyphs) {
|
|
ts << "\t// U+" << std::hex << g.character << std::dec << "\n";
|
|
ts << "\t{ " << g.character << ", "
|
|
<< g.baseCharacter << ", "
|
|
<< int(floor((g.getWidth() + letterSpacing) * scale)) << ", ";
|
|
ts << "&VectorFontData[" << glyphIndexes[g.character] << "] },\n";
|
|
}
|
|
|
|
ts <<
|
|
"};\n"
|
|
"\n"
|
|
"#undef UP\n"
|
|
"\n"
|
|
"#endif\n";
|
|
}
|
|
};
|
|
|
|
int main(int argc, char** argv) {
|
|
if(argc != 3) {
|
|
std::cerr << "Usage: " << argv[0] << " <header out> <lff in>\n" << std::endl;
|
|
return 1;
|
|
}
|
|
|
|
Font font;
|
|
font.readLff(argv[2]);
|
|
font.writeCppHeader(argv[1]);
|
|
|
|
return 0;
|
|
}
|