Skip to content
Navigation Menu
{{ message }}
forked from realthunder/solvespace
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathttf.cpp
More file actions
330 lines (289 loc) · 11.4 KB
/
Copy pathttf.cpp
File metadata and controls
330 lines (289 loc) · 11.4 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
//-----------------------------------------------------------------------------
// Routines to read a TrueType font as vector outlines, and generate them
// as entities, since they're always representable as either lines or
// quadratic Bezier curves.
//
// Copyright 2016 whitequark, Peter Barfuss.
//-----------------------------------------------------------------------------
#include <ft2build.h>
#include FT_FREETYPE_H
#include FT_OUTLINE_H
#include FT_ADVANCES_H
/* Yecch. Irritatingly, you need to do this nonsense to get the error string table,
since nobody thought to put this exact function into FreeType itsself. */
#undef __FTERRORS_H__
#define FT_ERRORDEF(e, v, s) { (e), (s) },
#define FT_ERROR_START_LIST
#define FT_ERROR_END_LIST { 0, NULL }
struct ft_error {
int err;
const char *str;
};
static const struct ft_error ft_errors[] = {
#include FT_ERRORS_H
};
extern "C" const char *ft_error_string(int err) {
const struct ft_error *e;
for(e = ft_errors; e->str; e++)
if(e->err == err)
return e->str;
return "Unknown error";
}
/* Okay, we're done with that. */
#undef FT_ERRORDEF
#undef FT_ERROR_START_LIST
#undef FT_ERROR_END_LIST
#include "solvespace.h"
//-----------------------------------------------------------------------------
// Get the list of available font filenames, and load the name for each of
// them. Only that, though, not the glyphs too.
//-----------------------------------------------------------------------------
TtfFontList::TtfFontList() {
FT_Init_FreeType(&fontLibrary);
}
TtfFontList::~TtfFontList() {
FT_Done_FreeType(fontLibrary);
}
void TtfFontList::LoadAll() {
if(loaded) return;
for(const std::string &font : GetFontFiles()) {
TtfFont tf = {};
tf.fontFile = font;
if(tf.LoadFromFile(fontLibrary))
l.Add(&tf);
}
// Sort fonts according to their actual name, not filename.
std::sort(&l.elem[0], &l.elem[l.n],
[](const TtfFont &a, const TtfFont &b) { return a.name < b.name; });
// Filter out fonts with the same family and style name. This is not
// strictly necessarily the exact same font, but it will almost always be.
TtfFont *it = std::unique(&l.elem[0], &l.elem[l.n],
[](const TtfFont &a, const TtfFont &b) { return a.name == b.name; });
l.RemoveLast(&l.elem[l.n] - it);
// TODO: identify fonts by their name and not filename, which may change
// between OSes.
loaded = true;
}
void TtfFontList::PlotString(const std::string &font, const std::string &str,
SBezierList *sbl, Vector origin, Vector u, Vector v)
{
LoadAll();
TtfFont *tf = std::find_if(&l.elem[0], &l.elem[l.n],
[&](const TtfFont &tf) { return tf.FontFileBaseName() == font; });
if(!str.empty() && tf != &l.elem[l.n]) {
if(tf->fontFace == NULL) {
tf->LoadFromFile(fontLibrary, /*nameOnly=*/false);
}
tf->PlotString(str, sbl, origin, u, v);
} else {
// No text or no font; so draw a big X for an error marker.
SBezier sb;
sb = SBezier::From(origin, origin.Plus(u).Plus(v));
sbl->l.Add(&sb);
sb = SBezier::From(origin.Plus(v), origin.Plus(u));
sbl->l.Add(&sb);
}
}
//-----------------------------------------------------------------------------
// Return the basename of our font filename; that's how the requests and
// entities that reference us will store it.
//-----------------------------------------------------------------------------
std::string TtfFont::FontFileBaseName() const {
std::string baseName = fontFile;
size_t pos = baseName.rfind(PATH_SEP);
if(pos != std::string::npos)
return baseName.erase(0, pos + 1);
return "";
}
//-----------------------------------------------------------------------------
// Load a TrueType font into memory. We care about the curves that define
// the letter shapes, and about the mappings that determine which glyph goes
// with which character.
//-----------------------------------------------------------------------------
bool TtfFont::LoadFromFile(FT_Library fontLibrary, bool nameOnly) {
FT_Open_Args args = {};
args.flags = FT_OPEN_PATHNAME;
args.pathname = &fontFile[0]; // FT_String is char* for historical reasons
// We don't use ssfopen() here to let freetype do its own memory management.
// This is OK because on Linux/OS X we just delegate to fopen and on Windows
// we only look into C:\Windows\Fonts, which has a known short path.
if(int fterr = FT_Open_Face(fontLibrary, &args, 0, &fontFace)) {
dbp("freetype: loading font from file '%s' failed: %s",
fontFile.c_str(), ft_error_string(fterr));
return false;
}
if(int fterr = FT_Select_Charmap(fontFace, FT_ENCODING_UNICODE)) {
dbp("freetype: loading unicode CMap for file '%s' failed: %s",
fontFile.c_str(), ft_error_string(fterr));
FT_Done_Face(fontFace);
fontFace = NULL;
return false;
}
name = std::string(fontFace->family_name) +
" (" + std::string(fontFace->style_name) + ")";
if(nameOnly) {
FT_Done_Face(fontFace);
fontFace = NULL;
return true;
}
// We always ask Freetype to give us a unit size character.
// It uses fixed point; put the unit size somewhere in the middle of the dynamic
// range of its 26.6 fixed point type, and adjust the factors so that the unit
// matches cap height.
FT_Size_RequestRec sizeRequest;
sizeRequest.type = FT_SIZE_REQUEST_TYPE_REAL_DIM;
sizeRequest.width = 1 << 16;
sizeRequest.height = 1 << 16;
sizeRequest.horiResolution = 128;
sizeRequest.vertResolution = 128;
if(int fterr = FT_Request_Size(fontFace, &sizeRequest)) {
dbp("freetype: cannot set character size: %s",
ft_error_string(fterr));
FT_Done_Face(fontFace);
fontFace = NULL;
return false;
}
char chr = 'A';
uint32_t gid = FT_Get_Char_Index(fontFace, 'A');
if (gid == 0) {
dbp("freetype: CID-to-GID mapping for CID 0x%04x failed: %s; using CID as GID",
chr, ft_error_string(gid));
gid = chr;
}
if(gid) {
if(int fterr = FT_Load_Glyph(fontFace, gid, FT_LOAD_NO_BITMAP | FT_LOAD_NO_HINTING)) {
dbp("freetype: cannot load glyph for GID 0x%04x: %s",
gid, ft_error_string(fterr));
FT_Done_Face(fontFace);
fontFace = NULL;
return false;
}
FT_BBox bbox;
FT_Outline_Get_CBox(&fontFace->glyph->outline, &bbox);
capHeight = (double)bbox.yMax;
}
return true;
}
typedef struct OutlineData {
Vector origin, u, v; // input parameters
SBezierList *beziers; // output bezier list
float factor; // ratio between freetype and solvespace coordinates
FT_Pos bx; // x offset of the current glyph
FT_Pos px, py; // current point
} OutlineData;
static Vector Transform(OutlineData *data, FT_Pos x, FT_Pos y) {
Vector r = data->origin;
r = r.Plus(data->u.ScaledBy((float)(data->bx + x) * data->factor));
r = r.Plus(data->v.ScaledBy((float)y * data->factor));
return r;
}
static int MoveTo(const FT_Vector *p, void *cc)
{
OutlineData *data = (OutlineData *) cc;
data->px = p->x;
data->py = p->y;
return 0;
}
static int LineTo(const FT_Vector *p, void *cc)
{
OutlineData *data = (OutlineData *) cc;
SBezier sb = SBezier::From(
Transform(data, data->px, data->py),
Transform(data, p->x, p->y));
data->beziers->l.Add(&sb);
data->px = p->x;
data->py = p->y;
return 0;
}
static int ConicTo(const FT_Vector *c, const FT_Vector *p, void *cc)
{
OutlineData *data = (OutlineData *) cc;
SBezier sb = SBezier::From(
Transform(data, data->px, data->py),
Transform(data, c->x, c->y),
Transform(data, p->x, p->y));
data->beziers->l.Add(&sb);
data->px = p->x;
data->py = p->y;
return 0;
}
static int CubicTo(const FT_Vector *c1, const FT_Vector *c2, const FT_Vector *p, void *cc)
{
OutlineData *data = (OutlineData *) cc;
SBezier sb = SBezier::From(
Transform(data, data->px, data->py),
Transform(data, c1->x, c1->y),
Transform(data, c2->x, c2->y),
Transform(data, p->x, p->y));
data->beziers->l.Add(&sb);
data->px = p->x;
data->py = p->y;
return 0;
}
void TtfFont::PlotString(const std::string &str,
SBezierList *sbl, Vector origin, Vector u, Vector v)
{
if(fontFace == NULL) oops();
FT_Outline_Funcs outlineFuncs;
outlineFuncs.move_to = MoveTo;
outlineFuncs.line_to = LineTo;
outlineFuncs.conic_to = ConicTo;
outlineFuncs.cubic_to = CubicTo;
outlineFuncs.shift = 0;
outlineFuncs.delta = 0;
FT_Pos dx = 0;
for(char32_t cid : ReadUTF8(str)) {
uint32_t gid = FT_Get_Char_Index(fontFace, cid);
if (gid == 0) {
dbp("freetype: CID-to-GID mapping for CID 0x%04x failed: %s; using CID as GID",
cid, ft_error_string(gid));
gid = cid;
}
/*
* Stupid hacks:
* - if we want fake-bold, use FT_Outline_Embolden(). This actually looks
* quite good.
* - if we want fake-italic, apply a shear transform [1 s s 1 0 0] here using
* FT_Set_Transform. This looks decent at small font sizes and bad at larger
* ones, antialiasing mitigates this considerably though.
*/
if(int fterr = FT_Load_Glyph(fontFace, gid, FT_LOAD_NO_BITMAP | FT_LOAD_NO_HINTING)) {
dbp("freetype: cannot load glyph for GID 0x%04x: %s",
gid, ft_error_string(fterr));
return;
}
/* A point that has x = xMin should be plotted at (dx0 + lsb); fix up
* our x-position so that the curve-generating code will put stuff
* at the right place.
*
* There's no point in getting the glyph BBox here - not only can it be
* needlessly slow sometimes, but because we're about to render a single glyph,
* what we want actually *is* the CBox.
*
* This is notwithstanding that this makes extremely little sense, this
* looks like a workaround for either mishandling the start glyph on a line,
* or as a really hacky pseudo-track-kerning (in which case it works better than
* one would expect! especially since most fonts don't set track kerning).
*/
FT_BBox cbox;
FT_Outline_Get_CBox(&fontFace->glyph->outline, &cbox);
FT_Pos bx = dx - cbox.xMin;
// Yes, this is what FreeType calls left-side bearing.
// Then interchangeably uses that with "left-side bearing". Sigh.
bx += fontFace->glyph->metrics.horiBearingX;
OutlineData data = {};
data.origin = origin;
data.u = u;
data.v = v;
data.beziers = sbl;
data.factor = 1.0 / capHeight;
data.bx = bx;
if(int fterr = FT_Outline_Decompose(&fontFace->glyph->outline, &outlineFuncs, &data)) {
dbp("freetype: bezier decomposition failed (gid %d): %s",
gid, ft_error_string(fterr));
}
// And we're done, so advance our position by the requested advance
// width, plus the user-requested extra advance.
dx += fontFace->glyph->advance.x;
}
}
You can’t perform that action at this time.