mirror of https://github.com/opencv/opencv.git
Vadim Pisarevsky
4 years ago
parent
1088d95c50
commit
d42665d9e2
26 changed files with 7786 additions and 3720 deletions
@ -0,0 +1,96 @@ |
||||
// |
||||
// Range.m |
||||
// |
||||
// Created by Giles Payne on 2019/10/08. |
||||
// |
||||
|
||||
#import "Range.h" |
||||
|
||||
@implementation Range { |
||||
cv::Range native; |
||||
} |
||||
|
||||
- (cv::Range&)nativeRef { |
||||
return native; |
||||
} |
||||
|
||||
- (instancetype)init { |
||||
return [self initWithStart:0 end: 0]; |
||||
} |
||||
|
||||
- (instancetype)initWithStart:(int)start end:(int)end { |
||||
self = [super init]; |
||||
if (self != nil) { |
||||
self.start = start; |
||||
self.end = end; |
||||
} |
||||
return self; |
||||
} |
||||
|
||||
- (instancetype)initWithVals:(NSArray<NSNumber*>*)vals { |
||||
self = [self init]; |
||||
if (self != nil) { |
||||
[self set:vals]; |
||||
} |
||||
return self; |
||||
} |
||||
|
||||
- (void)set:(NSArray<NSNumber*>*)vals { |
||||
self.start = (vals != nil && vals.count > 0) ? vals[0].intValue : 0; |
||||
self.end = (vals != nil && vals.count > 1 ) ? vals[1].intValue : 0; |
||||
} |
||||
|
||||
- (int)size { |
||||
return [self empty] ? 0 : self.end - self.start; |
||||
} |
||||
|
||||
- (BOOL)empty { |
||||
return self.end <= self.start; |
||||
} |
||||
|
||||
+ (Range*)all { |
||||
return [[Range alloc] initWithStart:INT_MIN end:INT_MAX]; |
||||
} |
||||
|
||||
- (Range*)intersection:(Range*)r1 { |
||||
Range* out = [[Range alloc] initWithStart:MAX(r1.start, self.start) end:MIN(r1.end, self.end)]; |
||||
out.end = MAX(out.end, out.start); |
||||
return out; |
||||
} |
||||
|
||||
- (Range*)shift:(int)delta { |
||||
return [[Range alloc] initWithStart:self.start + delta end:self.end + delta]; |
||||
} |
||||
|
||||
- (Range*)clone { |
||||
return [[Range alloc] initWithStart:self.start end:self.end]; |
||||
} |
||||
|
||||
- (BOOL)isEqual:(id)other { |
||||
if (other == self) { |
||||
return YES; |
||||
} else if (![other isKindOfClass:[Range class]]) { |
||||
return NO; |
||||
} else { |
||||
Range* it = (Range*)other; |
||||
return self.start == it.start && self.end == it.end; |
||||
} |
||||
} |
||||
|
||||
- (NSUInteger)hash { |
||||
int prime = 31; |
||||
uint32_t result = 1; |
||||
result = prime * result + self.start; |
||||
result = prime * result + self.end; |
||||
return result; |
||||
} |
||||
|
||||
+ (instancetype)fromNative:(cv::Range&)range { |
||||
return [[Range alloc] initWithStart:range.start end:range.end]; |
||||
} |
||||
|
||||
- (NSString *)description { |
||||
return [NSString stringWithFormat:@"Range {%d, %d}", self.start, self.end]; |
||||
} |
||||
|
||||
@end |
||||
Binary file not shown.
Binary file not shown.
@ -0,0 +1,93 @@ |
||||
Copyright 2015 The Rubik Project Authors (https://github.com/googlefonts/rubik), |
||||
|
||||
This Font Software is licensed under the SIL Open Font License, Version 1.1. |
||||
This license is copied below, and is also available with a FAQ at: |
||||
http://scripts.sil.org/OFL |
||||
|
||||
|
||||
----------------------------------------------------------- |
||||
SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007 |
||||
----------------------------------------------------------- |
||||
|
||||
PREAMBLE |
||||
The goals of the Open Font License (OFL) are to stimulate worldwide |
||||
development of collaborative font projects, to support the font creation |
||||
efforts of academic and linguistic communities, and to provide a free and |
||||
open framework in which fonts may be shared and improved in partnership |
||||
with others. |
||||
|
||||
The OFL allows the licensed fonts to be used, studied, modified and |
||||
redistributed freely as long as they are not sold by themselves. The |
||||
fonts, including any derivative works, can be bundled, embedded, |
||||
redistributed and/or sold with any software provided that any reserved |
||||
names are not used by derivative works. The fonts and derivatives, |
||||
however, cannot be released under any other type of license. The |
||||
requirement for fonts to remain under this license does not apply |
||||
to any document created using the fonts or their derivatives. |
||||
|
||||
DEFINITIONS |
||||
"Font Software" refers to the set of files released by the Copyright |
||||
Holder(s) under this license and clearly marked as such. This may |
||||
include source files, build scripts and documentation. |
||||
|
||||
"Reserved Font Name" refers to any names specified as such after the |
||||
copyright statement(s). |
||||
|
||||
"Original Version" refers to the collection of Font Software components as |
||||
distributed by the Copyright Holder(s). |
||||
|
||||
"Modified Version" refers to any derivative made by adding to, deleting, |
||||
or substituting -- in part or in whole -- any of the components of the |
||||
Original Version, by changing formats or by porting the Font Software to a |
||||
new environment. |
||||
|
||||
"Author" refers to any designer, engineer, programmer, technical |
||||
writer or other person who contributed to the Font Software. |
||||
|
||||
PERMISSION & CONDITIONS |
||||
Permission is hereby granted, free of charge, to any person obtaining |
||||
a copy of the Font Software, to use, study, copy, merge, embed, modify, |
||||
redistribute, and sell modified and unmodified copies of the Font |
||||
Software, subject to the following conditions: |
||||
|
||||
1) Neither the Font Software nor any of its individual components, |
||||
in Original or Modified Versions, may be sold by itself. |
||||
|
||||
2) Original or Modified Versions of the Font Software may be bundled, |
||||
redistributed and/or sold with any software, provided that each copy |
||||
contains the above copyright notice and this license. These can be |
||||
included either as stand-alone text files, human-readable headers or |
||||
in the appropriate machine-readable metadata fields within text or |
||||
binary files as long as those fields can be easily viewed by the user. |
||||
|
||||
3) No Modified Version of the Font Software may use the Reserved Font |
||||
Name(s) unless explicit written permission is granted by the corresponding |
||||
Copyright Holder. This restriction only applies to the primary font name as |
||||
presented to the users. |
||||
|
||||
4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font |
||||
Software shall not be used to promote, endorse or advertise any |
||||
Modified Version, except to acknowledge the contribution(s) of the |
||||
Copyright Holder(s) and the Author(s) or with their explicit written |
||||
permission. |
||||
|
||||
5) The Font Software, modified or unmodified, in part or in whole, |
||||
must be distributed entirely under this license, and must not be |
||||
distributed under any other license. The requirement for fonts to |
||||
remain under this license does not apply to any document created |
||||
using the Font Software. |
||||
|
||||
TERMINATION |
||||
This license becomes null and void if any of the above conditions are |
||||
not met. |
||||
|
||||
DISCLAIMER |
||||
THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
||||
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF |
||||
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT |
||||
OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE |
||||
COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, |
||||
INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL |
||||
DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
||||
FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM |
||||
OTHER DEALINGS IN THE FONT SOFTWARE. |
||||
@ -0,0 +1,38 @@ |
||||
//
|
||||
// FontFace.h
|
||||
//
|
||||
// Created by VP in 2020
|
||||
//
|
||||
|
||||
#pragma once |
||||
|
||||
#ifdef __cplusplus |
||||
#import "opencv.hpp" |
||||
#else |
||||
#define CV_EXPORTS |
||||
#endif |
||||
|
||||
#import <Foundation/Foundation.h> |
||||
|
||||
NS_ASSUME_NONNULL_BEGIN |
||||
|
||||
CV_EXPORTS @interface FontFace : NSObject |
||||
|
||||
@property(readonly) NSString* name; |
||||
|
||||
#ifdef __cplusplus |
||||
@property(readonly) cv::FontFace& nativeRef; |
||||
#endif |
||||
|
||||
-(instancetype)initWith:(const NSString*)name; |
||||
-(instancetype)init; |
||||
|
||||
#ifdef __cplusplus |
||||
+(instancetype)fromNative:(cv::FontFace&)fface; |
||||
#endif |
||||
|
||||
-(NSString *)description; |
||||
|
||||
@end |
||||
|
||||
NS_ASSUME_NONNULL_END |
||||
@ -0,0 +1,43 @@ |
||||
// |
||||
// FontFace.mm |
||||
// |
||||
// Created by VP in 2020. |
||||
// |
||||
|
||||
#import "FontFace.h" |
||||
|
||||
@implementation FontFace { |
||||
cv::FontFace native; |
||||
} |
||||
|
||||
-(cv::FontFace&)nativeRef { |
||||
return native; |
||||
} |
||||
|
||||
- (NSString*)name { |
||||
return [NSString stringWithUTF8String:native.getName().c_str()]; |
||||
} |
||||
|
||||
-(instancetype)init { |
||||
return [super init]; |
||||
} |
||||
|
||||
-(instancetype)initWith:(NSString*)name { |
||||
self = [super init]; |
||||
if (self) { |
||||
self.nativeRef.set(std::string(name.UTF8String)); |
||||
} |
||||
return self; |
||||
} |
||||
|
||||
+(instancetype)fromNative:(cv::FontFace&)fface { |
||||
FontFace* ff = [[FontFace alloc] init]; |
||||
ff.nativeRef = fface; |
||||
return ff; |
||||
} |
||||
|
||||
- (NSString *)description { |
||||
return [NSString stringWithFormat:@"FontFace [name=%s]", self.nativeRef.getName().c_str()]; |
||||
} |
||||
|
||||
@end |
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,692 @@ |
||||
// This file is part of OpenCV project.
|
||||
// It is subject to the license terms in the LICENSE file found in the top-level directory
|
||||
// of this distribution and at http://opencv.org/license.html.
|
||||
|
||||
// This is refactored (and split into 2 files) version of stb_truetype.h
|
||||
// from https://github.com/nothings/stb.
|
||||
// Support for variable fonts has been added and
|
||||
// a few other modifications & optimizations have been done.
|
||||
|
||||
//////////////// Below is the original copyright information /////////////////
|
||||
///////// (btw, OpenCV chooses the option A (MIT) for the license) ///////////
|
||||
|
||||
// Authored from 2009-2020 by Sean Barrett / RAD Game Tools.
|
||||
// See stb_truetype.cpp for the details
|
||||
|
||||
/*
|
||||
------------------------------------------------------------------------------ |
||||
This software is available under 2 licenses -- choose whichever you prefer. |
||||
------------------------------------------------------------------------------ |
||||
ALTERNATIVE A - MIT License |
||||
Copyright (c) 2017 Sean Barrett |
||||
Permission is hereby granted, free of charge, to any person obtaining a copy of |
||||
this software and associated documentation files (the "Software"), to deal in |
||||
the Software without restriction, including without limitation the rights to |
||||
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies |
||||
of the Software, and to permit persons to whom the Software is furnished to do |
||||
so, subject to the following conditions: |
||||
The above copyright notice and this permission notice shall be included in all |
||||
copies or substantial portions of the Software. |
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
||||
SOFTWARE. |
||||
------------------------------------------------------------------------------ |
||||
ALTERNATIVE B - Public Domain (www.unlicense.org) |
||||
This is free and unencumbered software released into the public domain. |
||||
Anyone is free to copy, modify, publish, use, compile, sell, or distribute this |
||||
software, either in source code form or as a compiled binary, for any purpose, |
||||
commercial or non-commercial, and by any means. |
||||
In jurisdictions that recognize copyright laws, the author or authors of this |
||||
software dedicate any and all copyright interest in the software to the public |
||||
domain. We make this dedication for the benefit of the public at large and to |
||||
the detriment of our heirs and successors. We intend this dedication to be an |
||||
overt act of relinquishment in perpetuity of all present and future rights to |
||||
this software under copyright law. |
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
||||
AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
||||
ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
||||
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
||||
------------------------------------------------------------------------------ |
||||
*/ |
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
////
|
||||
//// INTERFACE
|
||||
////
|
||||
////
|
||||
|
||||
#ifndef __STB_INCLUDE_STB_TRUETYPE_HPP__ |
||||
#define __STB_INCLUDE_STB_TRUETYPE_HPP__ |
||||
|
||||
#if 0 //def STBTT_STATIC
|
||||
#define STBTT_DEF static |
||||
#else |
||||
#define STBTT_DEF extern |
||||
#endif |
||||
|
||||
#ifdef __cplusplus |
||||
extern "C" { |
||||
#endif |
||||
|
||||
#define STBTT_FOURCC(a, b, c, d) \ |
||||
(unsigned)((((unsigned char)(a)) << 24) | \
|
||||
(((unsigned char)(b)) << 16) | \
|
||||
(((unsigned char)(c)) << 8) | \
|
||||
((unsigned char)(d))) |
||||
|
||||
// private structure
|
||||
typedef struct
|
||||
{ |
||||
unsigned char *data; |
||||
int cursor; |
||||
int size; |
||||
} stbtt__buf; |
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// TEXTURE BAKING API
|
||||
//
|
||||
// If you use this API, you only have to call two functions ever.
|
||||
//
|
||||
|
||||
typedef struct
|
||||
{ |
||||
unsigned short x0,y0,x1,y1; // coordinates of bbox in bitmap
|
||||
float xoff,yoff,xadvance; |
||||
} stbtt_bakedchar; |
||||
|
||||
STBTT_DEF int stbtt_BakeFontBitmap(const unsigned char *data, int offset, // font location (use offset=0 for plain .ttf)
|
||||
float pixel_height, // height of font in pixels
|
||||
unsigned char *pixels, int pw, int ph, // bitmap to be filled in
|
||||
int first_char, int num_chars, // characters to bake
|
||||
stbtt_bakedchar *chardata); // you allocate this, it's num_chars long
|
||||
// if return is positive, the first unused row of the bitmap
|
||||
// if return is negative, returns the negative of the number of characters that fit
|
||||
// if return is 0, no characters fit and no rows were used
|
||||
// This uses a very crappy packing.
|
||||
|
||||
typedef struct
|
||||
{ |
||||
float x0,y0,s0,t0; // top-left
|
||||
float x1,y1,s1,t1; // bottom-right
|
||||
} stbtt_aligned_quad; |
||||
|
||||
STBTT_DEF void stbtt_GetBakedQuad(const stbtt_bakedchar *chardata, int pw, int ph, // same data as above
|
||||
int char_index, // character to display
|
||||
float *xpos, float *ypos, // pointers to current position in screen pixel space
|
||||
stbtt_aligned_quad *q, // output: quad to draw
|
||||
int opengl_fillrule); // true if opengl fill rule; false if DX9 or earlier
|
||||
// Call GetBakedQuad with char_index = 'character - first_char', and it
|
||||
// creates the quad you need to draw and advances the current position.
|
||||
//
|
||||
// The coordinate system used assumes y increases downwards.
|
||||
//
|
||||
// Characters will extend both above and below the current position;
|
||||
// see discussion of "BASELINE" above.
|
||||
//
|
||||
// It's inefficient; you might want to c&p it and optimize it.
|
||||
|
||||
STBTT_DEF void stbtt_GetScaledFontVMetrics(const unsigned char *fontdata, int index, float size, float *ascent, float *descent, float *lineGap); |
||||
// Query the font vertical metrics without having to create a font first.
|
||||
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// NEW TEXTURE BAKING API
|
||||
//
|
||||
// This provides options for packing multiple fonts into one atlas, not
|
||||
// perfectly but better than nothing.
|
||||
|
||||
typedef struct
|
||||
{ |
||||
unsigned short x0,y0,x1,y1; // coordinates of bbox in bitmap
|
||||
float xoff,yoff,xadvance; |
||||
float xoff2,yoff2; |
||||
} stbtt_packedchar; |
||||
|
||||
typedef struct stbtt_pack_context stbtt_pack_context; |
||||
typedef struct stbtt_fontinfo stbtt_fontinfo; |
||||
#ifndef STB_RECT_PACK_VERSION |
||||
typedef struct stbrp_rect stbrp_rect; |
||||
#endif |
||||
|
||||
STBTT_DEF int stbtt_PackBegin(stbtt_pack_context *spc, unsigned char *pixels, int width, int height, int stride_in_bytes, int padding, void *alloc_context); |
||||
// Initializes a packing context stored in the passed-in stbtt_pack_context.
|
||||
// Future calls using this context will pack characters into the bitmap passed
|
||||
// in here: a 1-channel bitmap that is width * height. stride_in_bytes is
|
||||
// the distance from one row to the next (or 0 to mean they are packed tightly
|
||||
// together). "padding" is the amount of padding to leave between each
|
||||
// character (normally you want '1' for bitmaps you'll use as textures with
|
||||
// bilinear filtering).
|
||||
//
|
||||
// Returns 0 on failure, 1 on success.
|
||||
|
||||
STBTT_DEF void stbtt_PackEnd (stbtt_pack_context *spc); |
||||
// Cleans up the packing context and frees all memory.
|
||||
|
||||
#define STBTT_POINT_SIZE(x) (-(x)) |
||||
|
||||
STBTT_DEF int stbtt_PackFontRange(stbtt_pack_context *spc, const unsigned char *fontdata, int font_index, float font_size, |
||||
int first_unicode_char_in_range, int num_chars_in_range, stbtt_packedchar *chardata_for_range); |
||||
// Creates character bitmaps from the font_index'th font found in fontdata (use
|
||||
// font_index=0 if you don't know what that is). It creates num_chars_in_range
|
||||
// bitmaps for characters with unicode values starting at first_unicode_char_in_range
|
||||
// and increasing. Data for how to render them is stored in chardata_for_range;
|
||||
// pass these to stbtt_GetPackedQuad to get back renderable quads.
|
||||
//
|
||||
// font_size is the full height of the character from ascender to descender,
|
||||
// as computed by stbtt_ScaleForPixelHeight. To use a point size as computed
|
||||
// by stbtt_ScaleForMappingEmToPixels, wrap the point size in STBTT_POINT_SIZE()
|
||||
// and pass that result as 'font_size':
|
||||
// ..., 20 , ... // font max minus min y is 20 pixels tall
|
||||
// ..., STBTT_POINT_SIZE(20), ... // 'M' is 20 pixels tall
|
||||
|
||||
typedef struct
|
||||
{ |
||||
float font_size; |
||||
int first_unicode_codepoint_in_range; // if non-zero, then the chars are continuous, and this is the first codepoint
|
||||
int *array_of_unicode_codepoints; // if non-zero, then this is an array of unicode codepoints
|
||||
int num_chars; |
||||
stbtt_packedchar *chardata_for_range; // output
|
||||
unsigned char h_oversample, v_oversample; // don't set these, they're used internally
|
||||
} stbtt_pack_range; |
||||
|
||||
STBTT_DEF int stbtt_PackFontRanges(stbtt_pack_context *spc, const unsigned char *fontdata, int font_index, stbtt_pack_range *ranges, int num_ranges); |
||||
// Creates character bitmaps from multiple ranges of characters stored in
|
||||
// ranges. This will usually create a better-packed bitmap than multiple
|
||||
// calls to stbtt_PackFontRange. Note that you can call this multiple
|
||||
// times within a single PackBegin/PackEnd.
|
||||
|
||||
STBTT_DEF void stbtt_PackSetOversampling(stbtt_pack_context *spc, unsigned int h_oversample, unsigned int v_oversample); |
||||
// Oversampling a font increases the quality by allowing higher-quality subpixel
|
||||
// positioning, and is especially valuable at smaller text sizes.
|
||||
//
|
||||
// This function sets the amount of oversampling for all following calls to
|
||||
// stbtt_PackFontRange(s) or stbtt_PackFontRangesGatherRects for a given
|
||||
// pack context. The default (no oversampling) is achieved by h_oversample=1
|
||||
// and v_oversample=1. The total number of pixels required is
|
||||
// h_oversample*v_oversample larger than the default; for example, 2x2
|
||||
// oversampling requires 4x the storage of 1x1. For best results, render
|
||||
// oversampled textures with bilinear filtering. Look at the readme in
|
||||
// stb/tests/oversample for information about oversampled fonts
|
||||
//
|
||||
// To use with PackFontRangesGather etc., you must set it before calls
|
||||
// call to PackFontRangesGatherRects.
|
||||
|
||||
STBTT_DEF void stbtt_PackSetSkipMissingCodepoints(stbtt_pack_context *spc, int skip); |
||||
// If skip != 0, this tells stb_truetype to skip any codepoints for which
|
||||
// there is no corresponding glyph. If skip=0, which is the default, then
|
||||
// codepoints without a glyph recived the font's "missing character" glyph,
|
||||
// typically an empty box by convention.
|
||||
|
||||
STBTT_DEF void stbtt_GetPackedQuad(const stbtt_packedchar *chardata, int pw, int ph, // same data as above
|
||||
int char_index, // character to display
|
||||
float *xpos, float *ypos, // pointers to current position in screen pixel space
|
||||
stbtt_aligned_quad *q, // output: quad to draw
|
||||
int align_to_integer); |
||||
|
||||
STBTT_DEF int stbtt_PackFontRangesGatherRects(stbtt_pack_context *spc, const stbtt_fontinfo *info, stbtt_pack_range *ranges, int num_ranges, stbrp_rect *rects); |
||||
STBTT_DEF void stbtt_PackFontRangesPackRects(stbtt_pack_context *spc, stbrp_rect *rects, int num_rects); |
||||
STBTT_DEF int stbtt_PackFontRangesRenderIntoRects(stbtt_pack_context *spc, const stbtt_fontinfo *info, stbtt_pack_range *ranges, int num_ranges, stbrp_rect *rects); |
||||
// Calling these functions in sequence is roughly equivalent to calling
|
||||
// stbtt_PackFontRanges(). If you more control over the packing of multiple
|
||||
// fonts, or if you want to pack custom data into a font texture, take a look
|
||||
// at the source to of stbtt_PackFontRanges() and create a custom version
|
||||
// using these functions, e.g. call GatherRects multiple times,
|
||||
// building up a single array of rects, then call PackRects once,
|
||||
// then call RenderIntoRects repeatedly. This may result in a
|
||||
// better packing than calling PackFontRanges multiple times
|
||||
// (or it may not).
|
||||
|
||||
// this is an opaque structure that you shouldn't mess with which holds
|
||||
// all the context needed from PackBegin to PackEnd.
|
||||
struct stbtt_pack_context { |
||||
void *user_allocator_context; |
||||
void *pack_info; |
||||
int width; |
||||
int height; |
||||
int stride_in_bytes; |
||||
int padding; |
||||
int skip_missing; |
||||
unsigned int h_oversample, v_oversample; |
||||
unsigned char *pixels; |
||||
void *nodes; |
||||
}; |
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// FONT LOADING
|
||||
//
|
||||
//
|
||||
|
||||
STBTT_DEF int stbtt_GetNumberOfFonts(const unsigned char *data); |
||||
// This function will determine the number of fonts in a font file. TrueType
|
||||
// collection (.ttc) files may contain multiple fonts, while TrueType font
|
||||
// (.ttf) files only contain one font. The number of fonts can be used for
|
||||
// indexing with the previous function where the index is between zero and one
|
||||
// less than the total fonts. If an error occurs, -1 is returned.
|
||||
|
||||
STBTT_DEF int stbtt_GetFontOffsetForIndex(const unsigned char *data, int index); |
||||
// Each .ttf/.ttc file may have more than one font. Each font has a sequential
|
||||
// index number starting from 0. Call this function to get the font offset for
|
||||
// a given index; it returns -1 if the index is out of range. A regular .ttf
|
||||
// file will only define one font and it always be at offset 0, so it will
|
||||
// return '0' for index 0, and -1 for all other indices.
|
||||
|
||||
#ifndef STBTT_MAX_AXES |
||||
#define STBTT_MAX_AXES 16 |
||||
#endif |
||||
|
||||
typedef struct stbtt_axisinfo |
||||
{ |
||||
int tag; |
||||
int minval, defval, maxval; |
||||
int currval; |
||||
} stbtt_axisinfo; |
||||
|
||||
// The following structure is defined publicly so you can declare one on
|
||||
// the stack or as a global or etc, but you should treat it as opaque.
|
||||
struct stbtt_fontinfo |
||||
{ |
||||
void * userdata; |
||||
unsigned char * data; // pointer to .ttf file
|
||||
unsigned char * dataend; // data + size
|
||||
int fontstart; // offset of start of font
|
||||
unsigned size; // the data buffer size
|
||||
|
||||
int numGlyphs; // number of glyphs, needed for range checking
|
||||
|
||||
int loca,head,glyf,hhea,hmtx,kern,gpos,svg,avar,fvar,gvar,hvar; // table locations as offset from start of .ttf
|
||||
int index_map; // a cmap mapping for our chosen character encoding
|
||||
int indexToLocFormat; // format needed to map from glyph index to glyph
|
||||
int axis_count; // the number of variable font axes
|
||||
stbtt_axisinfo axes[STBTT_MAX_AXES]; // information about each axis
|
||||
short axes_normvalues[STBTT_MAX_AXES]; // normalized (within [-1, 1]) coordinates of
|
||||
// the currently used variation. They are already transformed
|
||||
// using avar (if any)
|
||||
int gvar_shared_count; // the number of shared tuples, used by 'gvar'
|
||||
int gvar_shared_tuples; // offset of the shared tuples
|
||||
int gvar_glob_offset; // the global offset of glyph variations table
|
||||
int gvar_glyph_offsets; // the relative offsets of glyph variations
|
||||
int gvar_off_format; // true if offsets are 32-bit
|
||||
|
||||
stbtt__buf cff; // cff font data
|
||||
stbtt__buf charstrings; // the charstring index
|
||||
stbtt__buf gsubrs; // global charstring subroutines index
|
||||
stbtt__buf subrs; // private charstring subroutines index
|
||||
stbtt__buf fontdicts; // array of font dicts
|
||||
stbtt__buf fdselect; // map from glyph to fontdict
|
||||
}; |
||||
|
||||
|
||||
STBTT_DEF int stbtt_InitFont(stbtt_fontinfo *info, const unsigned char *data, int offset); |
||||
// Given an offset into the file that defines a font, this function builds
|
||||
// the necessary cached info for the rest of the system. You must allocate
|
||||
// the stbtt_fontinfo yourself, and stbtt_InitFont will fill it out. You don't
|
||||
// need to do anything special to free it, because the contents are pure
|
||||
// value data with no additional data structures. Returns 0 on failure.
|
||||
|
||||
STBTT_DEF int stbtt_InitFont2(stbtt_fontinfo *info, const unsigned char *data, unsigned size, int offset); |
||||
// Same as stbtt_InitFont, but also takes the size of "data" buffer,
|
||||
// in order to control and avoid out of range accesses.
|
||||
|
||||
STBTT_DEF stbtt_fontinfo* stbtt_CreateFont(const unsigned char *data, unsigned size, int offset); |
||||
// Allocates font structure and initializes it. Returns 0 if there was an error.
|
||||
|
||||
STBTT_DEF void stbtt_ReleaseFont(stbtt_fontinfo **info); |
||||
// Allocates font structure and initializes it. Returns 0 if there was an error.
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// CHARACTER TO GLYPH-INDEX CONVERSIOn
|
||||
|
||||
STBTT_DEF int stbtt_FindGlyphIndex(const stbtt_fontinfo *info, int unicode_codepoint); |
||||
// If you're going to perform multiple operations on the same character
|
||||
// and you want a speed-up, call this function with the character you're
|
||||
// going to process, then use glyph-based functions instead of the
|
||||
// codepoint-based functions.
|
||||
// Returns 0 if the character codepoint is not defined in the font.
|
||||
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// CHARACTER PROPERTIES
|
||||
//
|
||||
|
||||
STBTT_DEF float stbtt_ScaleForPixelHeight(const stbtt_fontinfo *info, float pixels); |
||||
// computes a scale factor to produce a font whose "height" is 'pixels' tall.
|
||||
// Height is measured as the distance from the highest ascender to the lowest
|
||||
// descender; in other words, it's equivalent to calling stbtt_GetFontVMetrics
|
||||
// and computing:
|
||||
// scale = pixels / (ascent - descent)
|
||||
// so if you prefer to measure height by the ascent only, use a similar calculation.
|
||||
|
||||
STBTT_DEF float stbtt_ScaleForPixelHeightNoDesc(const stbtt_fontinfo *info, float height); |
||||
|
||||
STBTT_DEF float stbtt_ScaleForMappingEmToPixels(const stbtt_fontinfo *info, float pixels); |
||||
// computes a scale factor to produce a font whose EM size is mapped to
|
||||
// 'pixels' tall. This is probably what traditional APIs compute, but
|
||||
// I'm not positive.
|
||||
|
||||
STBTT_DEF void stbtt_GetFontVMetrics(const stbtt_fontinfo *info, int *ascent, int *descent, int *lineGap); |
||||
// ascent is the coordinate above the baseline the font extends; descent
|
||||
// is the coordinate below the baseline the font extends (i.e. it is typically negative)
|
||||
// lineGap is the spacing between one row's descent and the next row's ascent...
|
||||
// so you should advance the vertical position by "*ascent - *descent + *lineGap"
|
||||
// these are expressed in unscaled coordinates, so you must multiply by
|
||||
// the scale factor for a given size
|
||||
|
||||
STBTT_DEF int stbtt_GetFontVMetricsOS2(const stbtt_fontinfo *info, int *typoAscent, int *typoDescent, int *typoLineGap); |
||||
// analogous to GetFontVMetrics, but returns the "typographic" values from the OS/2
|
||||
// table (specific to MS/Windows TTF files).
|
||||
//
|
||||
// Returns 1 on success (table present), 0 on failure.
|
||||
|
||||
STBTT_DEF void stbtt_GetFontBoundingBox(const stbtt_fontinfo *info, int *x0, int *y0, int *x1, int *y1); |
||||
// the bounding box around all possible characters
|
||||
|
||||
STBTT_DEF void stbtt_GetCodepointHMetrics(const stbtt_fontinfo *info, int codepoint, int *advanceWidth, int *leftSideBearing); |
||||
// leftSideBearing is the offset from the current horizontal position to the left edge of the character
|
||||
// advanceWidth is the offset from the current horizontal position to the next horizontal position
|
||||
// these are expressed in unscaled coordinates
|
||||
|
||||
STBTT_DEF int stbtt_GetCodepointKernAdvance(const stbtt_fontinfo *info, int ch1, int ch2); |
||||
// an additional amount to add to the 'advance' value between ch1 and ch2
|
||||
|
||||
STBTT_DEF int stbtt_GetCodepointBox(const stbtt_fontinfo *info, int codepoint, int *x0, int *y0, int *x1, int *y1); |
||||
// Gets the bounding box of the visible part of the glyph, in unscaled coordinates
|
||||
|
||||
STBTT_DEF void stbtt_GetGlyphHMetrics(const stbtt_fontinfo *info, int glyph_index, int *advanceWidth, int *leftSideBearing); |
||||
STBTT_DEF int stbtt_GetGlyphKernAdvance(const stbtt_fontinfo *info, int glyph1, int glyph2); |
||||
STBTT_DEF int stbtt_GetGlyphBox(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1); |
||||
STBTT_DEF void stbtt__ScaleGlyphBox(int ix0, int iy0, int ix1, int iy1, |
||||
float scale_x, float scale_y, float shift_x, float shift_y, |
||||
int *out_ix0, int *out_iy0, int *out_ix1, int *out_iy1); |
||||
// as above, but takes one or more glyph indices for greater efficiency
|
||||
|
||||
typedef struct stbtt_kerningentry |
||||
{ |
||||
int glyph1; // use stbtt_FindGlyphIndex
|
||||
int glyph2; |
||||
int advance; |
||||
} stbtt_kerningentry; |
||||
|
||||
STBTT_DEF int stbtt_GetKerningTableLength(const stbtt_fontinfo *info); |
||||
STBTT_DEF int stbtt_GetKerningTable(const stbtt_fontinfo *info, stbtt_kerningentry* table, int table_length); |
||||
// Retrieves a complete list of all of the kerning pairs provided by the font
|
||||
// stbtt_GetKerningTable never writes more than table_length entries and returns how many entries it did write.
|
||||
// The table will be sorted by (a.glyph1 == b.glyph1)?(a.glyph2 < b.glyph2):(a.glyph1 < b.glyph1)
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// GLYPH SHAPES (you probably don't need these, but they have to go before
|
||||
// the bitmaps for C declaration-order reasons)
|
||||
//
|
||||
|
||||
#ifndef STBTT_vmove // you can predefine these to use different values (but why?)
|
||||
enum { |
||||
STBTT_vmove=1, |
||||
STBTT_vline, |
||||
STBTT_vcurve, |
||||
STBTT_vcubic |
||||
}; |
||||
#endif |
||||
|
||||
#ifndef stbtt_vertex // you can predefine this to use different values
|
||||
// (we share this with other code at RAD)
|
||||
#define stbtt_vertex_type short // can't use stbtt_int16 because that's not visible in the header file
|
||||
typedef struct
|
||||
{ |
||||
stbtt_vertex_type x,y,cx,cy,cx1,cy1; |
||||
unsigned char type,padding; |
||||
} stbtt_vertex; |
||||
#endif |
||||
|
||||
STBTT_DEF int stbtt_IsGlyphEmpty(const stbtt_fontinfo *info, int glyph_index); |
||||
// returns non-zero if nothing is drawn for this glyph
|
||||
|
||||
STBTT_DEF int stbtt_GetCodepointShape(const stbtt_fontinfo *info, int unicode_codepoint, |
||||
stbtt_vertex **vertices, int* ix0, int* iy0, int* ix1, int* iy1); |
||||
STBTT_DEF int stbtt_GetGlyphShape(const stbtt_fontinfo *info, int glyph_index, stbtt_vertex **vertices, |
||||
int* ix0, int* iy0, int* ix1, int* iy1); |
||||
// returns # of vertices and fills *vertices with the pointer to them
|
||||
// these are expressed in "unscaled" coordinates
|
||||
//
|
||||
// The shape is a series of contours. Each one starts with
|
||||
// a STBTT_moveto, then consists of a series of mixed
|
||||
// STBTT_lineto and STBTT_curveto segments. A lineto
|
||||
// draws a line from previous endpoint to its x,y; a curveto
|
||||
// draws a quadratic bezier from previous endpoint to
|
||||
// its x,y, using cx,cy as the bezier control point.
|
||||
|
||||
STBTT_DEF void stbtt_FreeShape(const stbtt_fontinfo *info, stbtt_vertex *vertices); |
||||
// frees the data allocated above
|
||||
|
||||
STBTT_DEF int stbtt_GetCodepointSVG(const stbtt_fontinfo *info, int unicode_codepoint, const char **svg); |
||||
STBTT_DEF int stbtt_GetGlyphSVG(const stbtt_fontinfo *info, int gl, const char **svg); |
||||
// fills svg with the character's SVG data.
|
||||
// returns data size or 0 if SVG not found.
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// FONT VARIATIONS
|
||||
//
|
||||
STBTT_DEF int stbtt_GetWeight(const stbtt_fontinfo* info); |
||||
STBTT_DEF int stbtt_GetInstance(const stbtt_fontinfo* info, stbtt_axisinfo* axes, int max_count); |
||||
STBTT_DEF int stbtt_SetInstance(stbtt_fontinfo* info, const int* params, int count, int reset_to_defaults); |
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// BITMAP RENDERING
|
||||
//
|
||||
|
||||
STBTT_DEF void stbtt_FreeBitmap(unsigned char *bitmap, void *userdata); |
||||
// frees the bitmap allocated below
|
||||
|
||||
STBTT_DEF void stbtt_GetCodepointBitmapBox(const stbtt_fontinfo *font, int codepoint, float scale_x, float scale_y, int *ix0, int *iy0, int *ix1, int *iy1); |
||||
// get the bbox of the bitmap centered around the glyph origin; so the
|
||||
// bitmap width is ix1-ix0, height is iy1-iy0, and location to place
|
||||
// the bitmap top left is (leftSideBearing*scale,iy0).
|
||||
// (Note that the bitmap uses y-increases-down, but the shape uses
|
||||
// y-increases-up, so CodepointBitmapBox and CodepointBox are inverted.)
|
||||
|
||||
STBTT_DEF void stbtt_GetCodepointBitmapBoxSubpixel(const stbtt_fontinfo *font, int codepoint, float scale_x, float scale_y, float shift_x, float shift_y, int *ix0, int *iy0, int *ix1, int *iy1); |
||||
// same as stbtt_GetCodepointBitmapBox, but you can specify a subpixel
|
||||
// shift for the character
|
||||
|
||||
// the following functions are equivalent to the above functions, but operate
|
||||
// on glyph indices instead of Unicode codepoints (for efficiency)
|
||||
STBTT_DEF unsigned char *stbtt_GetGlyphBitmapSubpixelRealloc(const stbtt_fontinfo *info, float scale_x, float scale_y, |
||||
float shift_x, float shift_y, |
||||
int glyph, int *width, int *height, int* step, |
||||
int *xoff, int *yoff, float* advx, |
||||
unsigned char** buf, int* bufsize); |
||||
STBTT_DEF void stbtt_MakeGlyphBitmap(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, int glyph); |
||||
STBTT_DEF void stbtt_MakeGlyphBitmapSubpixel(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int glyph); |
||||
STBTT_DEF void stbtt_MakeGlyphBitmapSubpixelPrefilter(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int oversample_x, int oversample_y, float *sub_x, float *sub_y, int glyph); |
||||
STBTT_DEF void stbtt_GetGlyphBitmapBox(const stbtt_fontinfo *font, int glyph, float scale_x, float scale_y, int *ix0, int *iy0, int *ix1, int *iy1); |
||||
STBTT_DEF void stbtt_GetGlyphBitmapBoxSubpixel(const stbtt_fontinfo *font, int glyph, float scale_x, float scale_y,float shift_x, float shift_y, int *ix0, int *iy0, int *ix1, int *iy1); |
||||
|
||||
|
||||
// @TODO: don't expose this structure
|
||||
typedef struct
|
||||
{ |
||||
int w,h,stride; |
||||
unsigned char *pixels; |
||||
} stbtt__bitmap; |
||||
|
||||
// rasterize a shape with quadratic beziers into a bitmap
|
||||
STBTT_DEF void stbtt_Rasterize(stbtt__bitmap *result, // 1-channel bitmap to draw into
|
||||
float flatness_in_pixels, // allowable error of curve in pixels
|
||||
stbtt_vertex *vertices, // array of vertices defining shape
|
||||
int num_verts, // number of vertices in above array
|
||||
float scale_x, float scale_y, // scale applied to input vertices
|
||||
float shift_x, float shift_y, // translation applied to input vertices
|
||||
int x_off, int y_off, // another translation applied to input
|
||||
int invert, // if non-zero, vertically flip shape
|
||||
void *userdata); // context for to STBTT_MALLOC
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Signed Distance Function (or Field) rendering
|
||||
|
||||
STBTT_DEF void stbtt_FreeSDF(unsigned char *bitmap, void *userdata); |
||||
// frees the SDF bitmap allocated below
|
||||
|
||||
STBTT_DEF unsigned char * stbtt_GetGlyphSDF(const stbtt_fontinfo *info, float scale, int glyph, int padding, unsigned char onedge_value, float pixel_dist_scale, int *width, int *height, int *xoff, int *yoff); |
||||
STBTT_DEF unsigned char * stbtt_GetCodepointSDF(const stbtt_fontinfo *info, float scale, int codepoint, int padding, unsigned char onedge_value, float pixel_dist_scale, int *width, int *height, int *xoff, int *yoff); |
||||
// These functions compute a discretized SDF field for a single character, suitable for storing
|
||||
// in a single-channel texture, sampling with bilinear filtering, and testing against
|
||||
// larger than some threshold to produce scalable fonts.
|
||||
// info -- the font
|
||||
// scale -- controls the size of the resulting SDF bitmap, same as it would be creating a regular bitmap
|
||||
// glyph/codepoint -- the character to generate the SDF for
|
||||
// padding -- extra "pixels" around the character which are filled with the distance to the character (not 0),
|
||||
// which allows effects like bit outlines
|
||||
// onedge_value -- value 0-255 to test the SDF against to reconstruct the character (i.e. the isocontour of the character)
|
||||
// pixel_dist_scale -- what value the SDF should increase by when moving one SDF "pixel" away from the edge (on the 0..255 scale)
|
||||
// if positive, > onedge_value is inside; if negative, < onedge_value is inside
|
||||
// width,height -- output height & width of the SDF bitmap (including padding)
|
||||
// xoff,yoff -- output origin of the character
|
||||
// return value -- a 2D array of bytes 0..255, width*height in size
|
||||
//
|
||||
// pixel_dist_scale & onedge_value are a scale & bias that allows you to make
|
||||
// optimal use of the limited 0..255 for your application, trading off precision
|
||||
// and special effects. SDF values outside the range 0..255 are clamped to 0..255.
|
||||
//
|
||||
// Example:
|
||||
// scale = stbtt_ScaleForPixelHeight(22)
|
||||
// padding = 5
|
||||
// onedge_value = 180
|
||||
// pixel_dist_scale = 180/5.0 = 36.0
|
||||
//
|
||||
// This will create an SDF bitmap in which the character is about 22 pixels
|
||||
// high but the whole bitmap is about 22+5+5=32 pixels high. To produce a filled
|
||||
// shape, sample the SDF at each pixel and fill the pixel if the SDF value
|
||||
// is greater than or equal to 180/255. (You'll actually want to antialias,
|
||||
// which is beyond the scope of this example.) Additionally, you can compute
|
||||
// offset outlines (e.g. to stroke the character border inside & outside,
|
||||
// or only outside). For example, to fill outside the character up to 3 SDF
|
||||
// pixels, you would compare against (180-36.0*3)/255 = 72/255. The above
|
||||
// choice of variables maps a range from 5 pixels outside the shape to
|
||||
// 2 pixels inside the shape to 0..255; this is intended primarily for apply
|
||||
// outside effects only (the interior range is needed to allow proper
|
||||
// antialiasing of the font at *smaller* sizes)
|
||||
//
|
||||
// The function computes the SDF analytically at each SDF pixel, not by e.g.
|
||||
// building a higher-res bitmap and approximating it. In theory the quality
|
||||
// should be as high as possible for an SDF of this size & representation, but
|
||||
// unclear if this is true in practice (perhaps building a higher-res bitmap
|
||||
// and computing from that can allow drop-out prevention).
|
||||
//
|
||||
// The algorithm has not been optimized at all, so expect it to be slow
|
||||
// if computing lots of characters or very large sizes.
|
||||
|
||||
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Finding the right font...
|
||||
//
|
||||
// You should really just solve this offline, keep your own tables
|
||||
// of what font is what, and don't try to get it out of the .ttf file.
|
||||
// That's because getting it out of the .ttf file is really hard, because
|
||||
// the names in the file can appear in many possible encodings, in many
|
||||
// possible languages, and e.g. if you need a case-insensitive comparison,
|
||||
// the details of that depend on the encoding & language in a complex way
|
||||
// (actually underspecified in truetype, but also gigantic).
|
||||
//
|
||||
// But you can use the provided functions in two possible ways:
|
||||
// stbtt_FindMatchingFont() will use *case-sensitive* comparisons on
|
||||
// unicode-encoded names to try to find the font you want;
|
||||
// you can run this before calling stbtt_InitFont()
|
||||
//
|
||||
// stbtt_GetFontNameString() lets you get any of the various strings
|
||||
// from the file yourself and do your own comparisons on them.
|
||||
// You have to have called stbtt_InitFont() first.
|
||||
|
||||
|
||||
STBTT_DEF int stbtt_FindMatchingFont(const unsigned char *fontdata, const char *name, int flags); |
||||
// returns the offset (not index) of the font that matches, or -1 if none
|
||||
// if you use STBTT_MACSTYLE_DONTCARE, use a font name like "Arial Bold".
|
||||
// if you use any other flag, use a font name like "Arial"; this checks
|
||||
// the 'macStyle' header field; i don't know if fonts set this consistently
|
||||
#define STBTT_MACSTYLE_DONTCARE 0 |
||||
#define STBTT_MACSTYLE_BOLD 1 |
||||
#define STBTT_MACSTYLE_ITALIC 2 |
||||
#define STBTT_MACSTYLE_UNDERSCORE 4 |
||||
#define STBTT_MACSTYLE_NONE 8 // <= not same as 0, this makes us check the bitfield is 0
|
||||
|
||||
STBTT_DEF int stbtt_CompareUTF8toUTF16_bigendian(const char *s1, int len1, const char *s2, int len2); |
||||
// returns 1/0 whether the first string interpreted as utf8 is identical to
|
||||
// the second string interpreted as big-endian utf16... useful for strings from next func
|
||||
|
||||
STBTT_DEF const char *stbtt_GetFontNameString(const stbtt_fontinfo *font, int *length, int platformID, int encodingID, int languageID, int nameID); |
||||
// returns the string (which may be big-endian double byte, e.g. for unicode)
|
||||
// and puts the length in bytes in *length.
|
||||
//
|
||||
// some of the values for the IDs are below; for more see the truetype spec:
|
||||
// http://developer.apple.com/textfonts/TTRefMan/RM06/Chap6name.html
|
||||
// http://www.microsoft.com/typography/otspec/name.htm
|
||||
|
||||
enum { // platformID
|
||||
STBTT_PLATFORM_ID_UNICODE =0, |
||||
STBTT_PLATFORM_ID_MAC =1, |
||||
STBTT_PLATFORM_ID_ISO =2, |
||||
STBTT_PLATFORM_ID_MICROSOFT =3 |
||||
}; |
||||
|
||||
enum { // encodingID for STBTT_PLATFORM_ID_UNICODE
|
||||
STBTT_UNICODE_EID_UNICODE_1_0 =0, |
||||
STBTT_UNICODE_EID_UNICODE_1_1 =1, |
||||
STBTT_UNICODE_EID_ISO_10646 =2, |
||||
STBTT_UNICODE_EID_UNICODE_2_0_BMP=3, |
||||
STBTT_UNICODE_EID_UNICODE_2_0_FULL=4 |
||||
}; |
||||
|
||||
enum { // encodingID for STBTT_PLATFORM_ID_MICROSOFT
|
||||
STBTT_MS_EID_SYMBOL =0, |
||||
STBTT_MS_EID_UNICODE_BMP =1, |
||||
STBTT_MS_EID_SHIFTJIS =2, |
||||
STBTT_MS_EID_UNICODE_FULL =10 |
||||
}; |
||||
|
||||
enum { // encodingID for STBTT_PLATFORM_ID_MAC; same as Script Manager codes
|
||||
STBTT_MAC_EID_ROMAN =0, STBTT_MAC_EID_ARABIC =4, |
||||
STBTT_MAC_EID_JAPANESE =1, STBTT_MAC_EID_HEBREW =5, |
||||
STBTT_MAC_EID_CHINESE_TRAD =2, STBTT_MAC_EID_GREEK =6, |
||||
STBTT_MAC_EID_KOREAN =3, STBTT_MAC_EID_RUSSIAN =7 |
||||
}; |
||||
|
||||
enum { // languageID for STBTT_PLATFORM_ID_MICROSOFT; same as LCID...
|
||||
// problematic because there are e.g. 16 english LCIDs and 16 arabic LCIDs
|
||||
STBTT_MS_LANG_ENGLISH =0x0409, STBTT_MS_LANG_ITALIAN =0x0410, |
||||
STBTT_MS_LANG_CHINESE =0x0804, STBTT_MS_LANG_JAPANESE =0x0411, |
||||
STBTT_MS_LANG_DUTCH =0x0413, STBTT_MS_LANG_KOREAN =0x0412, |
||||
STBTT_MS_LANG_FRENCH =0x040c, STBTT_MS_LANG_RUSSIAN =0x0419, |
||||
STBTT_MS_LANG_GERMAN =0x0407, STBTT_MS_LANG_SPANISH =0x0409, |
||||
STBTT_MS_LANG_HEBREW =0x040d, STBTT_MS_LANG_SWEDISH =0x041D |
||||
}; |
||||
|
||||
enum { // languageID for STBTT_PLATFORM_ID_MAC
|
||||
STBTT_MAC_LANG_ENGLISH =0 , STBTT_MAC_LANG_JAPANESE =11, |
||||
STBTT_MAC_LANG_ARABIC =12, STBTT_MAC_LANG_KOREAN =23, |
||||
STBTT_MAC_LANG_DUTCH =4 , STBTT_MAC_LANG_RUSSIAN =32, |
||||
STBTT_MAC_LANG_FRENCH =1 , STBTT_MAC_LANG_SPANISH =6 , |
||||
STBTT_MAC_LANG_GERMAN =2 , STBTT_MAC_LANG_SWEDISH =5 , |
||||
STBTT_MAC_LANG_HEBREW =10, STBTT_MAC_LANG_CHINESE_SIMPLIFIED =33, |
||||
STBTT_MAC_LANG_ITALIAN =3 , STBTT_MAC_LANG_CHINESE_TRAD =19 |
||||
}; |
||||
|
||||
#ifdef __cplusplus |
||||
} |
||||
#endif |
||||
|
||||
#endif // __STB_INCLUDE_STB_TRUETYPE_H__
|
||||
Loading…
Reference in new issue