-
Notifications
You must be signed in to change notification settings - Fork 24
/
text_renderer.h
448 lines (386 loc) · 13.5 KB
/
text_renderer.h
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
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
#ifndef TEXTREN_INCLUDED
#define TEXTREN_INCLUDED
#include <vector>
#include <cstdint>
#include <systemfonts.h>
#include <textshaping.h>
#include "ragg.h"
#include "agg_font_freetype.h"
#include "agg_span_interpolator_linear.h"
#include "agg_image_accessors.h"
#include "agg_span_image_filter_rgba.h"
#include "agg_span_allocator.h"
#include "agg_path_storage.h"
#include "util/agg_color_conv.h"
typedef agg::font_engine_freetype_int32 font_engine_type;
typedef agg::font_cache_manager<font_engine_type> font_manager_type;
/*
Basic UTF-8 manipulation routines
by Jeff Bezanson
placed in the public domain Fall 2005
This code is designed to provide the utilities you need to manipulate
UTF-8 as an internal string encoding. These functions do not perform the
error checking normally needed when handling UTF-8 data, so if you happen
to be from the Unicode Consortium you will want to flay me alive.
I do this because error checking can be performed at the boundaries (I/O),
with these routines reserved for higher performance on data known to be
valid.
Source: https://www.cprogramming.com/tutorial/utf8.c
Modified 2019 by Thomas Lin Pedersen to work with const char*
*/
static const uint32_t offsetsFromUTF8[6] = {
0x00000000UL, 0x00003080UL, 0x000E2080UL,
0x03C82080UL, 0xFA082080UL, 0x82082080UL
};
static const char trailingBytesForUTF8[256] = {
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, 3,3,3,3,3,3,3,3,4,4,4,4,5,5,5,5
};
/* conversions without error checking
only works for valid UTF-8, i.e. no 5- or 6-byte sequences
srcsz = source size in bytes, or -1 if 0-terminated
sz = dest size in # of wide characters
returns # characters converted
dest will always be L'\0'-terminated, even if there isn't enough room
for all the characters.
if sz = srcsz+1 (i.e. 4*srcsz+4 bytes), there will always be enough space.
*/
static int u8_toucs(uint32_t *dest, int sz, const char *src, int srcsz)
{
uint32_t ch;
const char *src_end = src + srcsz;
int nb;
int i=0;
while (i < sz-1) {
nb = trailingBytesForUTF8[(unsigned char)*src];
if (srcsz == -1) {
if (*src == 0)
goto done_toucs;
}
else {
if (src + nb >= src_end)
goto done_toucs;
}
ch = 0;
switch (nb) {
/* these fall through deliberately */
case 5: ch += (unsigned char)*src++; ch <<= 6;
case 4: ch += (unsigned char)*src++; ch <<= 6;
case 3: ch += (unsigned char)*src++; ch <<= 6;
case 2: ch += (unsigned char)*src++; ch <<= 6;
case 1: ch += (unsigned char)*src++; ch <<= 6;
case 0: ch += (unsigned char)*src++;
}
ch -= offsetsFromUTF8[nb];
dest[i++] = ch;
}
done_toucs:
dest[i] = 0;
return i;
}
/*
End of Basic UTF-8 manipulation routines
by Jeff Bezanson
*/
class UTF_UCS {
std::vector<uint32_t> buffer;
public:
UTF_UCS() {
// Allocate space in buffer
buffer.resize(1024);
}
~UTF_UCS() {
}
uint32_t * convert(const char * string, int &n_conv) {
int n_bytes = strlen(string) + 1;
unsigned int max_size = n_bytes * 4;
if (buffer.size() < max_size) {
buffer.resize(max_size);
}
n_conv = u8_toucs(buffer.data(), max_size, string, -1);
return buffer.data();
}
};
template<typename PIXFMT>
class TextRenderer {
UTF_UCS converter;
FontSettings last_font;
agg::glyph_rendering last_gren;
std::vector<textshaping::Point> loc_buffer;
std::vector<uint32_t> id_buffer;
std::vector<int> cluster_buffer;
std::vector<unsigned int> font_buffer;
std::vector<FontSettings> fallback_buffer;
std::vector<double> scaling_buffer;
double current_font_height;
double current_font_size;
bool no_bearings;
public:
TextRenderer() :
converter()
{
last_gren = agg::glyph_ren_native_mono;
get_engine().hinting(true);
get_engine().flip_y(true);
get_engine().gamma(agg::gamma_power(1.6));
}
bool load_font(agg::glyph_rendering gren, const char *family, int face,
double size) {
FontSettings font = get_font_file(family,
face == 2 || face == 4,
face == 3 || face == 4,
face == 5);
current_font_size = size;
if (!load_font_from_file(font, gren, size)) {
Rf_warning("Unable to load font: %s", family);
current_font_height = 0;
return false;
}
current_font_height = size;
no_bearings = false;
#if defined(_WIN32)
// Windows emojis have weird right bearings
if (strcmp("Segoe UI Emoji", get_engine().family()) == 0) {
no_bearings = true;
}
#endif
return true;
}
double get_text_width(const char* string) {
double width = 0.0;
int error = textshaping::string_width(
string,
last_font,
current_font_size,
72.0,
no_bearings ? 0 : 1,
&width
);
if (error) {
return 0.0;
}
return width;
}
void get_char_metric(int c, double *ascent, double *descent, double *width) {
unsigned index = get_engine().get_glyph_index(c);
const agg::glyph_cache* glyph = get_manager().glyph(index);
if (glyph->data_type == agg::glyph_data_color) {
double mod = current_font_height / get_engine().height();
if (c != 77 && glyph) {
*ascent = mod * (double) -glyph->bounds.y1;
*descent = mod * (double) glyph->bounds.y2;
*width = mod * glyph->advance_x;
} else {
*ascent = mod * get_engine().ascent();
*descent = mod * get_engine().descent();
*width = mod * get_engine().max_advance();
}
#if defined(__APPLE__)
// Apple emojis have no descender
double y_shift = double(glyph->bounds.y1 - glyph->bounds.y2) * 0.1;
*descent += y_shift;
*ascent += y_shift;
#endif
} else if (glyph && !(c == 77 && index == 0)) { // Only use 77 glyph if found
*ascent = (double) -glyph->bounds.y1;
*descent = (double) glyph->bounds.y2;
*width = glyph->advance_x;
} else {
// Use global font metrics
*ascent = get_engine().ascent();
*descent = get_engine().descent();
*width = get_engine().max_advance();
}
}
template<typename renderer_solid, typename renderer>
void plot_text(double x, double y, const char *string, double rot, double hadj,
renderer_solid &ren_solid, renderer &ren) {
agg::scanline_u8 sl;
agg::rasterizer_scanline_aa<> ras;
agg::conv_curve<font_manager_type::path_adaptor_type> curves(get_manager().path_adaptor());
curves.approximation_scale(2.0);
double width = get_text_width(string);
if (width == 0.0) {
return;
}
int expected_max = strlen(string) * 16;
loc_buffer.reserve(expected_max);
id_buffer.reserve(expected_max);
cluster_buffer.reserve(expected_max);
font_buffer.reserve(expected_max);
fallback_buffer.reserve(expected_max);
scaling_buffer.reserve(expected_max);
int err = textshaping::string_shape(
string,
last_font,
current_font_size,
72.0,
loc_buffer,
id_buffer,
cluster_buffer,
font_buffer,
fallback_buffer,
scaling_buffer
);
if (err != 0) {
Rf_warning("textshaping failed to shape the string");
return;
}
int n_glyphs = loc_buffer.size();
if (n_glyphs == 0) {
return;
}
if (rot != 0) {
rot = agg::deg2rad(-rot);
agg::trans_affine mtx;
mtx *= agg::trans_affine_rotation(rot);
get_engine().transform(mtx);
}
double cos_rot = cos(rot);
double sin_rot = sin(rot);
x -= (width * hadj) * cos_rot;
y -= (width * hadj) * sin_rot;
// Snap to pixel grid for vertical or horizontal text
if (fmod(rot, 180) < 1e-6) {
y = std::round(y);
} else if (fmod(rot + 90, 180) < 1e-6) {
x = std::round(x);
}
int text_run_start = 0;
for (int j = 1; j <= n_glyphs; ++j) {
if (j == n_glyphs || font_buffer[j] != font_buffer[j - 1]) {
if (fallback_buffer.size() == 0 || // To guard against old textshaping version/solaris mock
load_font_from_file(fallback_buffer[font_buffer[text_run_start]], last_gren, current_font_size)) {
for (int i = text_run_start; i < j; ++i) {
const agg::glyph_cache* glyph = get_manager().glyph(id_buffer[i]);
if (glyph) {
double x_offset = loc_buffer[i].x * cos_rot + loc_buffer[i].y * sin_rot;
double y_offset = loc_buffer[i].y * cos_rot + loc_buffer[i].x * sin_rot;
get_manager().init_embedded_adaptors(glyph, x + x_offset, y + y_offset);
switch(glyph->data_type) {
default: break;
case agg::glyph_data_gray8:
agg::render_scanlines(get_manager().gray8_adaptor(),
get_manager().gray8_scanline(),
ren_solid);
break;
case agg::glyph_data_color:
renderColourGlyph(glyph, x + x_offset, y + y_offset, rot, ren, scaling_buffer[font_buffer[text_run_start]]);
break;
case agg::glyph_data_outline:
ras.reset();
ras.add_path(curves);
agg::render_scanlines(ras, sl, ren_solid);
break;
}
}
}
}
text_run_start = j;
}
}
if (rot != 0) {
get_engine().transform(agg::trans_affine());
}
}
private:
inline font_engine_type& get_engine() {
static font_engine_type engine;
return engine;
}
inline font_manager_type& get_manager() {
static font_manager_type manager(get_engine());
return manager;
}
FontSettings get_font_file(const char* family, int bold, int italic,
int symbol) {
const char* fontfamily = family;
if (symbol) {
#if defined _WIN32
fontfamily = "Segoe UI Symbol";
#else
fontfamily = "Symbol";
#endif
}
return locate_font_with_features(fontfamily, italic, bold);
}
bool load_font_from_file(FontSettings font, agg::glyph_rendering gren, double size) {
if (!(gren == last_gren &&
font.index == last_font.index &&
strncmp(font.file, last_font.file, PATH_MAX) == 0)) {
if (!get_engine().load_font(font.file, font.index, gren)) {
return false;
}
last_gren = gren;
get_engine().height(size);
} else if (size != get_engine().height()) {
get_engine().height(size);
}
last_font = font;
return true;
}
template<typename ren>
void renderColourGlyph(const agg::glyph_cache* glyph, double x, double y, double rot, ren &renderer, double scaling) {
int w = glyph->bounds.x2 - glyph->bounds.x1;
int h = glyph->bounds.y1 - glyph->bounds.y2;
agg::rendering_buffer rbuf(glyph->data, w, h, w * 4);
unsigned char * buffer = new unsigned char[w * h * PIXFMT::pix_width];
agg::rendering_buffer rbuf_conv(buffer, w, h, w * PIXFMT::pix_width);
agg::convert<PIXFMT, pixfmt_col_glyph>(&rbuf_conv, &rbuf);
agg::trans_affine img_mtx;
img_mtx *= agg::trans_affine_translation(0, -glyph->bounds.y1);
if (scaling > 0) {
img_mtx *= agg::trans_affine_translation(-double(w)/2, 0);
img_mtx *= agg::trans_affine_scaling(scaling);
img_mtx *= agg::trans_affine_translation(scaling * double(w)/2, 0);
}
#if defined(__APPLE__)
// Apple emojis have no descender
if (strcmp("Apple Color Emoji", get_engine().family()) == 0) {
if (scaling < 0) scaling = 1.0; //shouldn't happen as Apple emojis are not scalable
img_mtx *= agg::trans_affine_translation(0, scaling * double(h) * 0.12);
}
#endif
img_mtx *= agg::trans_affine_rotation(rot);
img_mtx *= agg::trans_affine_translation(x, y);
agg::trans_affine src_mtx = img_mtx;
img_mtx.invert();
typedef agg::span_interpolator_linear<> interpolator_type;
interpolator_type interpolator(img_mtx);
typedef agg::image_accessor_clone<PIXFMT> img_source_type;
PIXFMT img_pixf(rbuf_conv);
img_source_type img_src(img_pixf);
agg::span_allocator<typename PIXFMT::blender_type::color_type> sa;
agg::rasterizer_scanline_aa<> ras;
agg::scanline_u8 sl;
agg::path_storage rect;
rect.remove_all();
rect.move_to(0, 0);
rect.line_to(0, h);
rect.line_to(w, h);
rect.line_to(w, 0);
rect.close_polygon();
agg::conv_transform<agg::path_storage> tr(rect, src_mtx);
ras.add_path(tr);
if (scaling >= 1 || scaling < 0) {
typedef agg::span_image_filter_rgba_bilinear<img_source_type, interpolator_type> span_gen_type;
span_gen_type sg(img_src, interpolator);
agg::render_scanlines_aa(ras, sl, renderer, sa, sg);
} else {
agg::image_filter_bilinear filter_kernel;
agg::image_filter_lut filter(filter_kernel, true);
typedef agg::span_image_resample_rgba_affine<img_source_type> span_gen_type;
span_gen_type sg(img_src, interpolator, filter);
sg.blur(1);
agg::render_scanlines_aa(ras, sl, renderer, sa, sg);
}
delete [] buffer;
}
};
#endif