ReactOS 0.4.15-dev-7889-g76290a6
afshaper.c
Go to the documentation of this file.
1/***************************************************************************/
2/* */
3/* afshaper.c */
4/* */
5/* HarfBuzz interface for accessing OpenType features (body). */
6/* */
7/* Copyright 2013-2018 by */
8/* David Turner, Robert Wilhelm, and Werner Lemberg. */
9/* */
10/* This file is part of the FreeType project, and may only be used, */
11/* modified, and distributed under the terms of the FreeType project */
12/* license, LICENSE.TXT. By continuing to use, modify, or distribute */
13/* this file you indicate that you have read the license and */
14/* understand and accept it fully. */
15/* */
16/***************************************************************************/
17
18
19#include <ft2build.h>
20#include FT_FREETYPE_H
21#include FT_ADVANCES_H
22#include "afglobal.h"
23#include "aftypes.h"
24#include "afshaper.h"
25
26#ifdef FT_CONFIG_OPTION_USE_HARFBUZZ
27
28
29 /*************************************************************************/
30 /* */
31 /* The macro FT_COMPONENT is used in trace mode. It is an implicit */
32 /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */
33 /* messages during execution. */
34 /* */
35#undef FT_COMPONENT
36#define FT_COMPONENT trace_afshaper
37
38
39 /*
40 * We use `sets' (in the HarfBuzz sense, which comes quite near to the
41 * usual mathematical meaning) to manage both lookups and glyph indices.
42 *
43 * 1. For each coverage, collect lookup IDs in a set. Note that an
44 * auto-hinter `coverage' is represented by one `feature', and a
45 * feature consists of an arbitrary number of (font specific) `lookup's
46 * that actually do the mapping job. Please check the OpenType
47 * specification for more details on features and lookups.
48 *
49 * 2. Create glyph ID sets from the corresponding lookup sets.
50 *
51 * 3. The glyph set corresponding to AF_COVERAGE_DEFAULT is computed
52 * with all lookups specific to the OpenType script activated. It
53 * relies on the order of AF_DEFINE_STYLE_CLASS entries so that
54 * special coverages (like `oldstyle figures') don't get overwritten.
55 *
56 */
57
58
59 /* load coverage tags */
60#undef COVERAGE
61#define COVERAGE( name, NAME, description, \
62 tag1, tag2, tag3, tag4 ) \
63 static const hb_tag_t name ## _coverage[] = \
64 { \
65 HB_TAG( tag1, tag2, tag3, tag4 ), \
66 HB_TAG_NONE \
67 };
68
69
70#include "afcover.h"
71
72
73 /* define mapping between coverage tags and AF_Coverage */
74#undef COVERAGE
75#define COVERAGE( name, NAME, description, \
76 tag1, tag2, tag3, tag4 ) \
77 name ## _coverage,
78
79
80 static const hb_tag_t* coverages[] =
81 {
82#include "afcover.h"
83
84 NULL /* AF_COVERAGE_DEFAULT */
85 };
86
87
88 /* load HarfBuzz script tags */
89#undef SCRIPT
90#define SCRIPT( s, S, d, h, H, ss ) h,
91
92
93 static const hb_script_t scripts[] =
94 {
95#include "afscript.h"
96 };
97
98
101 AF_StyleClass style_class,
102 FT_UShort* gstyles,
103 FT_Bool default_script )
104 {
105 hb_face_t* face;
106
107 hb_set_t* gsub_lookups = NULL; /* GSUB lookups for a given script */
108 hb_set_t* gsub_glyphs = NULL; /* glyphs covered by GSUB lookups */
109 hb_set_t* gpos_lookups = NULL; /* GPOS lookups for a given script */
110 hb_set_t* gpos_glyphs = NULL; /* glyphs covered by GPOS lookups */
111
112 hb_script_t script;
113 const hb_tag_t* coverage_tags;
114 hb_tag_t script_tags[] = { HB_TAG_NONE,
115 HB_TAG_NONE,
116 HB_TAG_NONE,
117 HB_TAG_NONE };
118
119 hb_codepoint_t idx;
120#ifdef FT_DEBUG_LEVEL_TRACE
121 int count;
122#endif
123
124
125 if ( !globals || !style_class || !gstyles )
126 return FT_THROW( Invalid_Argument );
127
128 face = hb_font_get_face( globals->hb_font );
129
130 coverage_tags = coverages[style_class->coverage];
131 script = scripts[style_class->script];
132
133 /* Convert a HarfBuzz script tag into the corresponding OpenType */
134 /* tag or tags -- some Indic scripts like Devanagari have an old */
135 /* and a new set of features. */
136 hb_ot_tags_from_script( script,
137 &script_tags[0],
138 &script_tags[1] );
139
140 /* `hb_ot_tags_from_script' usually returns HB_OT_TAG_DEFAULT_SCRIPT */
141 /* as the second tag. We change that to HB_TAG_NONE except for the */
142 /* default script. */
143 if ( default_script )
144 {
145 if ( script_tags[0] == HB_TAG_NONE )
146 script_tags[0] = HB_OT_TAG_DEFAULT_SCRIPT;
147 else
148 {
149 if ( script_tags[1] == HB_TAG_NONE )
150 script_tags[1] = HB_OT_TAG_DEFAULT_SCRIPT;
151 else if ( script_tags[1] != HB_OT_TAG_DEFAULT_SCRIPT )
152 script_tags[2] = HB_OT_TAG_DEFAULT_SCRIPT;
153 }
154 }
155 else
156 {
157 /* we use non-standard tags like `khms' for special purposes; */
158 /* HarfBuzz maps them to `DFLT', which we don't want to handle here */
159 if ( script_tags[0] == HB_OT_TAG_DEFAULT_SCRIPT )
160 goto Exit;
161
162 if ( script_tags[1] == HB_OT_TAG_DEFAULT_SCRIPT )
163 script_tags[1] = HB_TAG_NONE;
164 }
165
166 gsub_lookups = hb_set_create();
167 hb_ot_layout_collect_lookups( face,
168 HB_OT_TAG_GSUB,
169 script_tags,
170 NULL,
171 coverage_tags,
172 gsub_lookups );
173
174 if ( hb_set_is_empty( gsub_lookups ) )
175 goto Exit; /* nothing to do */
176
177 FT_TRACE4(( "GSUB lookups (style `%s'):\n"
178 " ",
179 af_style_names[style_class->style] ));
180
181#ifdef FT_DEBUG_LEVEL_TRACE
182 count = 0;
183#endif
184
185 gsub_glyphs = hb_set_create();
186 for ( idx = HB_SET_VALUE_INVALID; hb_set_next( gsub_lookups, &idx ); )
187 {
188#ifdef FT_DEBUG_LEVEL_TRACE
189 FT_TRACE4(( " %d", idx ));
190 count++;
191#endif
192
193 /* get output coverage of GSUB feature */
194 hb_ot_layout_lookup_collect_glyphs( face,
195 HB_OT_TAG_GSUB,
196 idx,
197 NULL,
198 NULL,
199 NULL,
200 gsub_glyphs );
201 }
202
203#ifdef FT_DEBUG_LEVEL_TRACE
204 if ( !count )
205 FT_TRACE4(( " (none)" ));
206 FT_TRACE4(( "\n\n" ));
207#endif
208
209 FT_TRACE4(( "GPOS lookups (style `%s'):\n"
210 " ",
211 af_style_names[style_class->style] ));
212
213 gpos_lookups = hb_set_create();
214 hb_ot_layout_collect_lookups( face,
215 HB_OT_TAG_GPOS,
216 script_tags,
217 NULL,
218 coverage_tags,
219 gpos_lookups );
220
221#ifdef FT_DEBUG_LEVEL_TRACE
222 count = 0;
223#endif
224
225 gpos_glyphs = hb_set_create();
226 for ( idx = HB_SET_VALUE_INVALID; hb_set_next( gpos_lookups, &idx ); )
227 {
228#ifdef FT_DEBUG_LEVEL_TRACE
229 FT_TRACE4(( " %d", idx ));
230 count++;
231#endif
232
233 /* get input coverage of GPOS feature */
234 hb_ot_layout_lookup_collect_glyphs( face,
235 HB_OT_TAG_GPOS,
236 idx,
237 NULL,
238 gpos_glyphs,
239 NULL,
240 NULL );
241 }
242
243#ifdef FT_DEBUG_LEVEL_TRACE
244 if ( !count )
245 FT_TRACE4(( " (none)" ));
246 FT_TRACE4(( "\n\n" ));
247#endif
248
249 /*
250 * We now check whether we can construct blue zones, using glyphs
251 * covered by the feature only. In case there is not a single zone
252 * (this is, not a single character is covered), we skip this coverage.
253 *
254 */
255 if ( style_class->coverage != AF_COVERAGE_DEFAULT )
256 {
257 AF_Blue_Stringset bss = style_class->blue_stringset;
259
260 FT_Bool found = 0;
261
262
263 for ( ; bs->string != AF_BLUE_STRING_MAX; bs++ )
264 {
265 const char* p = &af_blue_strings[bs->string];
266
267
268 while ( *p )
269 {
270 hb_codepoint_t ch;
271
272
273 GET_UTF8_CHAR( ch, p );
274
275 for ( idx = HB_SET_VALUE_INVALID; hb_set_next( gsub_lookups,
276 &idx ); )
277 {
278 hb_codepoint_t gidx = FT_Get_Char_Index( globals->face, ch );
279
280
281 if ( hb_ot_layout_lookup_would_substitute( face, idx,
282 &gidx, 1, 1 ) )
283 {
284 found = 1;
285 break;
286 }
287 }
288 }
289 }
290
291 if ( !found )
292 {
293 FT_TRACE4(( " no blue characters found; style skipped\n" ));
294 goto Exit;
295 }
296 }
297
298 /*
299 * Various OpenType features might use the same glyphs at different
300 * vertical positions; for example, superscript and subscript glyphs
301 * could be the same. However, the auto-hinter is completely
302 * agnostic of OpenType features after the feature analysis has been
303 * completed: The engine then simply receives a glyph index and returns a
304 * hinted and usually rendered glyph.
305 *
306 * Consider the superscript feature of font `pala.ttf': Some of the
307 * glyphs are `real', this is, they have a zero vertical offset, but
308 * most of them are small caps glyphs shifted up to the superscript
309 * position (this is, the `sups' feature is present in both the GSUB and
310 * GPOS tables). The code for blue zones computation actually uses a
311 * feature's y offset so that the `real' glyphs get correct hints. But
312 * later on it is impossible to decide whether a glyph index belongs to,
313 * say, the small caps or superscript feature.
314 *
315 * For this reason, we don't assign a style to a glyph if the current
316 * feature covers the glyph in both the GSUB and the GPOS tables. This
317 * is quite a broad condition, assuming that
318 *
319 * (a) glyphs that get used in multiple features are present in a
320 * feature without vertical shift,
321 *
322 * and
323 *
324 * (b) a feature's GPOS data really moves the glyph vertically.
325 *
326 * Not fulfilling condition (a) makes a font larger; it would also
327 * reduce the number of glyphs that could be addressed directly without
328 * using OpenType features, so this assumption is rather strong.
329 *
330 * Condition (b) is much weaker, and there might be glyphs which get
331 * missed. However, the OpenType features we are going to handle are
332 * primarily located in GSUB, and HarfBuzz doesn't provide an API to
333 * directly get the necessary information from the GPOS table. A
334 * possible solution might be to directly parse the GPOS table to find
335 * out whether a glyph gets shifted vertically, but this is something I
336 * would like to avoid if not really necessary.
337 *
338 * Note that we don't follow this logic for the default coverage.
339 * Complex scripts like Devanagari have mandatory GPOS features to
340 * position many glyph elements, using mark-to-base or mark-to-ligature
341 * tables; the number of glyphs missed due to condition (b) would be far
342 * too large.
343 *
344 */
345 if ( style_class->coverage != AF_COVERAGE_DEFAULT )
346 hb_set_subtract( gsub_glyphs, gpos_glyphs );
347
348#ifdef FT_DEBUG_LEVEL_TRACE
349 FT_TRACE4(( " glyphs without GPOS data (`*' means already assigned)" ));
350 count = 0;
351#endif
352
353 for ( idx = HB_SET_VALUE_INVALID; hb_set_next( gsub_glyphs, &idx ); )
354 {
355#ifdef FT_DEBUG_LEVEL_TRACE
356 if ( !( count % 10 ) )
357 FT_TRACE4(( "\n"
358 " " ));
359
360 FT_TRACE4(( " %d", idx ));
361 count++;
362#endif
363
364 /* glyph indices returned by `hb_ot_layout_lookup_collect_glyphs' */
365 /* can be arbitrary: some fonts use fake indices for processing */
366 /* internal to GSUB or GPOS, which is fully valid */
367 if ( idx >= (hb_codepoint_t)globals->glyph_count )
368 continue;
369
370 if ( gstyles[idx] == AF_STYLE_UNASSIGNED )
371 gstyles[idx] = (FT_UShort)style_class->style;
373 else
374 FT_TRACE4(( "*" ));
375#endif
376 }
377
378#ifdef FT_DEBUG_LEVEL_TRACE
379 if ( !count )
380 FT_TRACE4(( "\n"
381 " (none)" ));
382 FT_TRACE4(( "\n\n" ));
383#endif
384
385 Exit:
386 hb_set_destroy( gsub_lookups );
387 hb_set_destroy( gsub_glyphs );
388 hb_set_destroy( gpos_lookups );
389 hb_set_destroy( gpos_glyphs );
390
391 return FT_Err_Ok;
392 }
393
394
395 /* construct HarfBuzz features */
396#undef COVERAGE
397#define COVERAGE( name, NAME, description, \
398 tag1, tag2, tag3, tag4 ) \
399 static const hb_feature_t name ## _feature[] = \
400 { \
401 { \
402 HB_TAG( tag1, tag2, tag3, tag4 ), \
403 1, 0, (unsigned int)-1 \
404 } \
405 };
406
407
408#include "afcover.h"
409
410
411 /* define mapping between HarfBuzz features and AF_Coverage */
412#undef COVERAGE
413#define COVERAGE( name, NAME, description, \
414 tag1, tag2, tag3, tag4 ) \
415 name ## _feature,
416
417
418 static const hb_feature_t* features[] =
419 {
420#include "afcover.h"
421
422 NULL /* AF_COVERAGE_DEFAULT */
423 };
424
425
426 void*
428 {
429 FT_UNUSED( face );
430
431 return (void*)hb_buffer_create();
432 }
433
434
435 void
437 void* buf )
438 {
439 FT_UNUSED( face );
440
441 hb_buffer_destroy( (hb_buffer_t*)buf );
442 }
443
444
445 const char*
446 af_shaper_get_cluster( const char* p,
448 void* buf_,
449 unsigned int* count )
450 {
451 AF_StyleClass style_class;
452 const hb_feature_t* feature;
453 FT_Int upem;
454 const char* q;
455 int len;
456
457 hb_buffer_t* buf = (hb_buffer_t*)buf_;
458 hb_font_t* font;
459 hb_codepoint_t dummy;
460
461
462 upem = (FT_Int)metrics->globals->face->units_per_EM;
463 style_class = metrics->style_class;
464 feature = features[style_class->coverage];
465
466 font = metrics->globals->hb_font;
467
468 /* we shape at a size of units per EM; this means font units */
469 hb_font_set_scale( font, upem, upem );
470
471 while ( *p == ' ' )
472 p++;
473
474 /* count bytes up to next space (or end of buffer) */
475 q = p;
476 while ( !( *q == ' ' || *q == '\0' ) )
478 len = (int)( q - p );
479
480 /* feed character(s) to the HarfBuzz buffer */
481 hb_buffer_clear_contents( buf );
482 hb_buffer_add_utf8( buf, p, len, 0, len );
483
484 /* we let HarfBuzz guess the script and writing direction */
485 hb_buffer_guess_segment_properties( buf );
486
487 /* shape buffer, which means conversion from character codes to */
488 /* glyph indices, possibly applying a feature */
489 hb_shape( font, buf, feature, feature ? 1 : 0 );
490
491 if ( feature )
492 {
493 hb_buffer_t* hb_buf = metrics->globals->hb_buf;
494
495 unsigned int gcount;
496 hb_glyph_info_t* ginfo;
497
498 unsigned int hb_gcount;
499 hb_glyph_info_t* hb_ginfo;
500
501
502 /* we have to check whether applying a feature does actually change */
503 /* glyph indices; otherwise the affected glyph or glyphs aren't */
504 /* available at all in the feature */
505
506 hb_buffer_clear_contents( hb_buf );
507 hb_buffer_add_utf8( hb_buf, p, len, 0, len );
508 hb_buffer_guess_segment_properties( hb_buf );
509 hb_shape( font, hb_buf, NULL, 0 );
510
511 ginfo = hb_buffer_get_glyph_infos( buf, &gcount );
512 hb_ginfo = hb_buffer_get_glyph_infos( hb_buf, &hb_gcount );
513
514 if ( gcount == hb_gcount )
515 {
516 unsigned int i;
517
518
519 for (i = 0; i < gcount; i++ )
520 if ( ginfo[i].codepoint != hb_ginfo[i].codepoint )
521 break;
522
523 if ( i == gcount )
524 {
525 /* both buffers have identical glyph indices */
526 hb_buffer_clear_contents( buf );
527 }
528 }
529 }
530
531 *count = hb_buffer_get_length( buf );
532
533#ifdef FT_DEBUG_LEVEL_TRACE
534 if ( feature && *count > 1 )
535 FT_TRACE1(( "af_shaper_get_cluster:"
536 " input character mapped to multiple glyphs\n" ));
537#endif
538
539 return q;
540 }
541
542
545 void* buf_,
546 unsigned int idx,
548 FT_Long* y_offset )
549 {
550 hb_buffer_t* buf = (hb_buffer_t*)buf_;
551 hb_glyph_info_t* ginfo;
552 hb_glyph_position_t* gpos;
553 unsigned int gcount;
554
556
557
558 ginfo = hb_buffer_get_glyph_infos( buf, &gcount );
559 gpos = hb_buffer_get_glyph_positions( buf, &gcount );
560
561 if ( idx >= gcount )
562 return 0;
563
564 if ( advance )
565 *advance = gpos[idx].x_advance;
566 if ( y_offset )
567 *y_offset = gpos[idx].y_offset;
568
569 return ginfo[idx].codepoint;
570 }
571
572
573#else /* !FT_CONFIG_OPTION_USE_HARFBUZZ */
574
575
578 AF_StyleClass style_class,
579 FT_UShort* gstyles,
580 FT_Bool default_script )
581 {
582 FT_UNUSED( globals );
583 FT_UNUSED( style_class );
584 FT_UNUSED( gstyles );
585 FT_UNUSED( default_script );
586
587 return FT_Err_Ok;
588 }
589
590
591 void*
593 {
595 FT_Memory memory = face->memory;
596 FT_ULong* buf;
597
598
599 FT_MEM_ALLOC( buf, sizeof ( FT_ULong ) );
600
601 return (void*)buf;
602 }
603
604
605 void
607 void* buf )
608 {
609 FT_Memory memory = face->memory;
610
611
612 FT_FREE( buf );
613 }
614
615
616 const char*
619 void* buf_,
620 unsigned int* count )
621 {
622 FT_Face face = metrics->globals->face;
623 FT_ULong ch, dummy = 0;
624 FT_ULong* buf = (FT_ULong*)buf_;
625
626
627 while ( *p == ' ' )
628 p++;
629
630 GET_UTF8_CHAR( ch, p );
631
632 /* since we don't have an engine to handle clusters, */
633 /* we scan the characters but return zero */
634 while ( !( *p == ' ' || *p == '\0' ) )
636
637 if ( dummy )
638 {
639 *buf = 0;
640 *count = 0;
641 }
642 else
643 {
644 *buf = FT_Get_Char_Index( face, ch );
645 *count = 1;
646 }
647
648 return p;
649 }
650
651
654 void* buf_,
655 unsigned int idx,
657 FT_Long* y_offset )
658 {
659 FT_Face face = metrics->globals->face;
660 FT_ULong glyph_index = *(FT_ULong*)buf_;
661
662 FT_UNUSED( idx );
663
664
665 if ( advance )
667 glyph_index,
671 advance );
672
673 if ( y_offset )
674 *y_offset = 0;
675
676 return glyph_index;
677 }
678
679
680#endif /* !FT_CONFIG_OPTION_USE_HARFBUZZ */
681
682
683/* END */
_STLP_MOVE_TO_STD_NAMESPACE void _STLP_CALL advance(_InputIterator &__i, _Distance __n)
af_blue_stringsets[]
Definition: afblue.c:439
af_blue_strings[]
Definition: afblue.c:26
@ AF_BLUE_STRING_MAX
Definition: afblue.h:280
#define GET_UTF8_CHAR(ch, p)
Definition: afblue.h:31
enum AF_Blue_Stringset_ AF_Blue_Stringset
#define AF_STYLE_UNASSIGNED
Definition: afglobal.h:79
void * af_shaper_buf_create(FT_Face face)
Definition: afshaper.c:592
const char * af_shaper_get_cluster(const char *p, AF_StyleMetrics metrics, void *buf_, unsigned int *count)
Definition: afshaper.c:617
FT_ULong af_shaper_get_elem(AF_StyleMetrics metrics, void *buf_, unsigned int idx, FT_Long *advance, FT_Long *y_offset)
Definition: afshaper.c:653
FT_Error af_shaper_get_coverage(AF_FaceGlobals globals, AF_StyleClass style_class, FT_UShort *gstyles, FT_Bool default_script)
Definition: afshaper.c:577
void af_shaper_buf_destroy(FT_Face face, void *buf)
Definition: afshaper.c:606
@ AF_COVERAGE_DEFAULT
Definition: aftypes.h:412
#define FT_DEBUG_LEVEL_TRACE
Definition: ftoption.h:397
#define NULL
Definition: types.h:112
WORD face[3]
Definition: mesh.c:4747
unsigned int idx
Definition: utils.c:41
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31
#define FT_LOAD_IGNORE_TRANSFORM
Definition: freetype.h:3019
#define FT_LOAD_NO_SCALE
Definition: freetype.h:3009
#define FT_LOAD_NO_HINTING
Definition: freetype.h:3010
FT_Get_Char_Index(FT_Face face, FT_ULong charcode)
Definition: ftobjs.c:3668
FT_Get_Advance(FT_Face face, FT_UInt gindex, FT_Int32 load_flags, FT_Fixed *padvance)
Definition: ftadvanc.c:75
return FT_Err_Ok
Definition: ftbbox.c:511
#define FT_UNUSED(arg)
Definition: ftconfig.h:101
#define FT_THROW(e)
Definition: ftdebug.h:213
#define FT_TRACE1(varformat)
Definition: ftdebug.h:158
#define FT_TRACE4(varformat)
Definition: ftdebug.h:161
#define FT_MEM_ALLOC(ptr, size)
Definition: ftmemory.h:151
#define FT_FREE(ptr)
Definition: ftmemory.h:329
typedefFT_BEGIN_HEADER struct FT_MemoryRec_ * FT_Memory
Definition: ftsystem.h:66
FT_BEGIN_HEADER typedef unsigned char FT_Bool
Definition: fttypes.h:108
unsigned long FT_ULong
Definition: fttypes.h:253
int FT_Error
Definition: fttypes.h:300
signed long FT_Long
Definition: fttypes.h:242
unsigned short FT_UShort
Definition: fttypes.h:209
signed int FT_Int
Definition: fttypes.h:220
GLuint GLuint GLsizei count
Definition: gl.h:1545
GLdouble GLdouble GLdouble GLdouble q
Definition: gl.h:2063
GLenum GLuint GLint GLenum face
Definition: glext.h:7025
GLsizei GLenum const GLvoid GLuint GLsizei GLfloat * metrics
Definition: glext.h:11745
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
GLfloat GLfloat p
Definition: glext.h:8902
GLenum GLsizei len
Definition: glext.h:6722
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
static struct msdos_boot_sector bs
Definition: mkdosfs.c:539
#define error(str)
Definition: mkdosfs.c:1605
static char memory[1024 *256]
Definition: process.c:116
INTERNETFEATURELIST feature
Definition: misc.c:1719
script
Definition: msipriv.h:383
Definition: mk_font.cpp:20
static void Exit(void)
Definition: sock.c:1330
FT_Long glyph_count
Definition: afglobal.h:108
AF_Style style
Definition: aftypes.h:447
AF_Script script
Definition: aftypes.h:450
AF_Blue_Stringset blue_stringset
Definition: aftypes.h:451
AF_Coverage coverage
Definition: aftypes.h:452