mirror of
https://github.com/scratchfoundation/bgfx.git
synced 2024-11-28 18:45:54 -05:00
update font_manager to bgfx coding style
This commit is contained in:
Jeremie Roy
parent
6b8b95acd8
commit
6c956ee0c9
2 changed files with 198 additions and 198 deletions
|
|
@ -49,25 +49,25 @@ public:
|
|||
/// Initialize from an external buffer
|
||||
/// @remark The ownership of the buffer is external, and you must ensure it stays valid up to this object lifetime
|
||||
/// @return true if the initialization succeed
|
||||
bool init(const uint8_t* buffer, uint32_t bufferSize, int32_t fontIndex, uint32_t pixelHeight );
|
||||
bool init(const uint8_t* _buffer, uint32_t _bufferSize, int32_t _fontIndex, uint32_t _pixelHeight );
|
||||
|
||||
/// return the font descriptor of the current font
|
||||
FontInfo getFontInfo();
|
||||
|
||||
/// raster a glyph as 8bit alpha to a memory buffer
|
||||
/// update the GlyphInfo according to the raster strategy
|
||||
/// @ remark buffer min size: glyphInfo.width * glyphInfo * height * sizeof(char)
|
||||
bool bakeGlyphAlpha(CodePoint_t codePoint, GlyphInfo& outGlyphInfo, uint8_t* outBuffer);
|
||||
/// @ remark buffer min size: glyphInfo.m_width * glyphInfo * height * sizeof(char)
|
||||
bool bakeGlyphAlpha(CodePoint_t _codePoint, GlyphInfo& _outGlyphInfo, uint8_t* _outBuffer);
|
||||
|
||||
/// raster a glyph as 32bit subpixel rgba to a memory buffer
|
||||
/// update the GlyphInfo according to the raster strategy
|
||||
/// @ remark buffer min size: glyphInfo.width * glyphInfo * height * sizeof(uint32_t)
|
||||
bool bakeGlyphSubpixel(CodePoint_t codePoint, GlyphInfo& outGlyphInfo, uint8_t* outBuffer);
|
||||
/// @ remark buffer min size: glyphInfo.m_width * glyphInfo * height * sizeof(uint32_t)
|
||||
bool bakeGlyphSubpixel(CodePoint_t _codePoint, GlyphInfo& _outGlyphInfo, uint8_t* _outBuffer);
|
||||
|
||||
/// raster a glyph as 8bit signed distance to a memory buffer
|
||||
/// update the GlyphInfo according to the raster strategy
|
||||
/// @ remark buffer min size: glyphInfo.width * glyphInfo * height * sizeof(char)
|
||||
bool bakeGlyphDistance(CodePoint_t codePoint, GlyphInfo& outGlyphInfo, uint8_t* outBuffer);
|
||||
/// @ remark buffer min size: glyphInfo.m_width * glyphInfo * height * sizeof(char)
|
||||
bool bakeGlyphDistance(CodePoint_t _codePoint, GlyphInfo& _outGlyphInfo, uint8_t* _outBuffer);
|
||||
private:
|
||||
void* m_font;
|
||||
};
|
||||
|
|
@ -75,8 +75,8 @@ private:
|
|||
|
||||
struct FTHolder
|
||||
{
|
||||
FT_Library library;
|
||||
FT_Face face;
|
||||
FT_Library m_library;
|
||||
FT_Face m_face;
|
||||
};
|
||||
FontManager::TrueTypeFont::TrueTypeFont(): m_font(NULL)
|
||||
{
|
||||
|
|
@ -87,36 +87,36 @@ FontManager::TrueTypeFont::~TrueTypeFont()
|
|||
if(m_font!=NULL)
|
||||
{
|
||||
FTHolder* holder = (FTHolder*) m_font;
|
||||
FT_Done_Face( holder->face );
|
||||
FT_Done_FreeType( holder->library );
|
||||
FT_Done_Face( holder->m_face );
|
||||
FT_Done_FreeType( holder->m_library );
|
||||
delete m_font;
|
||||
m_font = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
bool FontManager::TrueTypeFont::init(const uint8_t* buffer, uint32_t bufferSize, int32_t fontIndex, uint32_t pixelHeight)
|
||||
bool FontManager::TrueTypeFont::init(const uint8_t* _buffer, uint32_t _bufferSize, int32_t _fontIndex, uint32_t _pixelHeight)
|
||||
{
|
||||
assert((bufferSize > 256 && bufferSize < 100000000) && "TrueType buffer size is suspicious");
|
||||
assert((pixelHeight > 4 && pixelHeight < 128) && "TrueType buffer size is suspicious");
|
||||
assert((_bufferSize > 256 && _bufferSize < 100000000) && "TrueType buffer size is suspicious");
|
||||
assert((_pixelHeight > 4 && _pixelHeight < 128) && "TrueType buffer size is suspicious");
|
||||
|
||||
assert(m_font == NULL && "TrueTypeFont already initialized" );
|
||||
|
||||
FTHolder* holder = new FTHolder();
|
||||
|
||||
// Initialize Freetype library
|
||||
FT_Error error = FT_Init_FreeType( &holder->library );
|
||||
FT_Error error = FT_Init_FreeType( &holder->m_library );
|
||||
if( error)
|
||||
{
|
||||
delete holder;
|
||||
return false;
|
||||
}
|
||||
|
||||
error = FT_New_Memory_Face( holder->library, buffer, bufferSize, fontIndex, &holder->face );
|
||||
error = FT_New_Memory_Face( holder->m_library, _buffer, _bufferSize, _fontIndex, &holder->m_face );
|
||||
if ( error == FT_Err_Unknown_File_Format )
|
||||
{
|
||||
// the font file could be opened and read, but it appears
|
||||
//that its font format is unsupported
|
||||
FT_Done_FreeType( holder->library );
|
||||
FT_Done_FreeType( holder->m_library );
|
||||
delete holder;
|
||||
return false;
|
||||
}
|
||||
|
|
@ -124,25 +124,25 @@ bool FontManager::TrueTypeFont::init(const uint8_t* buffer, uint32_t bufferSize,
|
|||
{
|
||||
// another error code means that the font file could not
|
||||
// be opened or read, or simply that it is broken...
|
||||
FT_Done_FreeType( holder->library );
|
||||
FT_Done_FreeType( holder->m_library );
|
||||
delete holder;
|
||||
return false;
|
||||
}
|
||||
|
||||
// Select unicode charmap
|
||||
error = FT_Select_Charmap( holder->face, FT_ENCODING_UNICODE );
|
||||
error = FT_Select_Charmap( holder->m_face, FT_ENCODING_UNICODE );
|
||||
if( error )
|
||||
{
|
||||
FT_Done_Face( holder->face );
|
||||
FT_Done_FreeType( holder->library );
|
||||
FT_Done_Face( holder->m_face );
|
||||
FT_Done_FreeType( holder->m_library );
|
||||
return false;
|
||||
}
|
||||
//set size in pixels
|
||||
error = FT_Set_Pixel_Sizes( holder->face, 0, pixelHeight );
|
||||
error = FT_Set_Pixel_Sizes( holder->m_face, 0, _pixelHeight );
|
||||
if( error )
|
||||
{
|
||||
FT_Done_Face( holder->face );
|
||||
FT_Done_FreeType( holder->library );
|
||||
FT_Done_Face( holder->m_face );
|
||||
FT_Done_FreeType( holder->m_library );
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
@ -155,31 +155,31 @@ FontInfo FontManager::TrueTypeFont::getFontInfo()
|
|||
assert(m_font != NULL && "TrueTypeFont not initialized" );
|
||||
FTHolder* holder = (FTHolder*) m_font;
|
||||
|
||||
assert(FT_IS_SCALABLE (holder->face));
|
||||
assert(FT_IS_SCALABLE (holder->m_face));
|
||||
|
||||
FT_Size_Metrics metrics = holder->face->size->metrics;
|
||||
FT_Size_Metrics metrics = holder->m_face->size->metrics;
|
||||
|
||||
//todo manage unscalable font
|
||||
FontInfo outFontInfo;
|
||||
outFontInfo.scale = 1.0f;
|
||||
outFontInfo.ascender = metrics.ascender /64.0f;
|
||||
outFontInfo.descender = metrics.descender /64.0f;
|
||||
outFontInfo.lineGap = (metrics.height - metrics.ascender + metrics.descender) /64.0f;
|
||||
outFontInfo.m_scale = 1.0f;
|
||||
outFontInfo.m_ascender = metrics.ascender /64.0f;
|
||||
outFontInfo.m_descender = metrics.descender /64.0f;
|
||||
outFontInfo.m_lineGap = (metrics.height - metrics.ascender + metrics.descender) /64.0f;
|
||||
|
||||
outFontInfo.underline_position = FT_MulFix(holder->face->underline_position, metrics.y_scale) /64.0f;
|
||||
outFontInfo.underline_thickness= FT_MulFix(holder->face->underline_thickness,metrics.y_scale) /64.0f;
|
||||
outFontInfo.m_underline_position = FT_MulFix(holder->m_face->underline_position, metrics.y_scale) /64.0f;
|
||||
outFontInfo.m_underline_thickness= FT_MulFix(holder->m_face->underline_thickness,metrics.y_scale) /64.0f;
|
||||
return outFontInfo;
|
||||
}
|
||||
|
||||
bool FontManager::TrueTypeFont::bakeGlyphAlpha(CodePoint_t codePoint, GlyphInfo& glyphInfo, uint8_t* outBuffer)
|
||||
bool FontManager::TrueTypeFont::bakeGlyphAlpha(CodePoint_t _codePoint, GlyphInfo& _glyphInfo, uint8_t* _outBuffer)
|
||||
{
|
||||
assert(m_font != NULL && "TrueTypeFont not initialized" );
|
||||
FTHolder* holder = (FTHolder*) m_font;
|
||||
|
||||
glyphInfo.glyphIndex = FT_Get_Char_Index( holder->face, codePoint );
|
||||
_glyphInfo.m_glyphIndex = FT_Get_Char_Index( holder->m_face, _codePoint );
|
||||
|
||||
FT_GlyphSlot slot = holder->face->glyph;
|
||||
FT_Error error = FT_Load_Glyph( holder->face, glyphInfo.glyphIndex, FT_LOAD_DEFAULT );
|
||||
FT_GlyphSlot slot = holder->m_face->glyph;
|
||||
FT_Error error = FT_Load_Glyph( holder->m_face, _glyphInfo.m_glyphIndex, FT_LOAD_DEFAULT );
|
||||
if(error) { return false; }
|
||||
|
||||
FT_Glyph glyph;
|
||||
|
|
@ -196,34 +196,34 @@ bool FontManager::TrueTypeFont::bakeGlyphAlpha(CodePoint_t codePoint, GlyphInfo&
|
|||
int w = bitmap->bitmap.width;
|
||||
int h = bitmap->bitmap.rows;
|
||||
|
||||
glyphInfo.offset_x = (float) x;
|
||||
glyphInfo.offset_y = (float) y;
|
||||
glyphInfo.width = (float) w;
|
||||
glyphInfo.height = (float) h;
|
||||
glyphInfo.advance_x = (float)slot->advance.x /64.0f;
|
||||
glyphInfo.advance_y = (float)slot->advance.y /64.0f;
|
||||
_glyphInfo.m_offset_x = (float) x;
|
||||
_glyphInfo.m_offset_y = (float) y;
|
||||
_glyphInfo.m_width = (float) w;
|
||||
_glyphInfo.m_height = (float) h;
|
||||
_glyphInfo.m_advance_x = (float)slot->advance.x /64.0f;
|
||||
_glyphInfo.m_advance_y = (float)slot->advance.y /64.0f;
|
||||
|
||||
int charsize = 1;
|
||||
int depth=1;
|
||||
int stride = bitmap->bitmap.pitch;
|
||||
for( int i=0; i<h; ++i )
|
||||
{
|
||||
memcpy(outBuffer+(i*w) * charsize * depth,
|
||||
memcpy(_outBuffer+(i*w) * charsize * depth,
|
||||
bitmap->bitmap.buffer + (i*stride) * charsize, w * charsize * depth );
|
||||
}
|
||||
FT_Done_Glyph(glyph);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool FontManager::TrueTypeFont::bakeGlyphSubpixel(CodePoint_t codePoint, GlyphInfo& glyphInfo, uint8_t* outBuffer)
|
||||
bool FontManager::TrueTypeFont::bakeGlyphSubpixel(CodePoint_t _codePoint, GlyphInfo& _glyphInfo, uint8_t* _outBuffer)
|
||||
{
|
||||
assert(m_font != NULL && "TrueTypeFont not initialized" );
|
||||
FTHolder* holder = (FTHolder*) m_font;
|
||||
|
||||
glyphInfo.glyphIndex = FT_Get_Char_Index( holder->face, codePoint );
|
||||
_glyphInfo.m_glyphIndex = FT_Get_Char_Index( holder->m_face, _codePoint );
|
||||
|
||||
FT_GlyphSlot slot = holder->face->glyph;
|
||||
FT_Error error = FT_Load_Glyph( holder->face, glyphInfo.glyphIndex, FT_LOAD_DEFAULT );
|
||||
FT_GlyphSlot slot = holder->m_face->glyph;
|
||||
FT_Error error = FT_Load_Glyph( holder->m_face, _glyphInfo.m_glyphIndex, FT_LOAD_DEFAULT );
|
||||
if(error) { return false; }
|
||||
|
||||
FT_Glyph glyph;
|
||||
|
|
@ -239,18 +239,18 @@ bool FontManager::TrueTypeFont::bakeGlyphSubpixel(CodePoint_t codePoint, GlyphIn
|
|||
int w = bitmap->bitmap.width;
|
||||
int h = bitmap->bitmap.rows;
|
||||
|
||||
glyphInfo.offset_x = (float) x;
|
||||
glyphInfo.offset_y = (float) y;
|
||||
glyphInfo.width = (float) w;
|
||||
glyphInfo.height = (float) h;
|
||||
glyphInfo.advance_x = (float)slot->advance.x /64.0f;
|
||||
glyphInfo.advance_y = (float)slot->advance.y /64.0f;
|
||||
_glyphInfo.m_offset_x = (float) x;
|
||||
_glyphInfo.m_offset_y = (float) y;
|
||||
_glyphInfo.m_width = (float) w;
|
||||
_glyphInfo.m_height = (float) h;
|
||||
_glyphInfo.m_advance_x = (float)slot->advance.x /64.0f;
|
||||
_glyphInfo.m_advance_y = (float)slot->advance.y /64.0f;
|
||||
int charsize = 1;
|
||||
int depth=3;
|
||||
int stride = bitmap->bitmap.pitch;
|
||||
for( int i=0; i<h; ++i )
|
||||
{
|
||||
memcpy(outBuffer+(i*w) * charsize * depth,
|
||||
memcpy(_outBuffer+(i*w) * charsize * depth,
|
||||
bitmap->bitmap.buffer + (i*stride) * charsize, w * charsize * depth );
|
||||
}
|
||||
FT_Done_Glyph(glyph);
|
||||
|
|
@ -335,18 +335,18 @@ void make_distance_map( unsigned char *img, unsigned char *outImg, unsigned int
|
|||
}
|
||||
|
||||
|
||||
bool FontManager::TrueTypeFont::bakeGlyphDistance(CodePoint_t codePoint, GlyphInfo& glyphInfo, uint8_t* outBuffer)
|
||||
bool FontManager::TrueTypeFont::bakeGlyphDistance(CodePoint_t _codePoint, GlyphInfo& _glyphInfo, uint8_t* _outBuffer)
|
||||
{
|
||||
assert(m_font != NULL && "TrueTypeFont not initialized" );
|
||||
FTHolder* holder = (FTHolder*) m_font;
|
||||
|
||||
glyphInfo.glyphIndex = FT_Get_Char_Index( holder->face, codePoint );
|
||||
_glyphInfo.m_glyphIndex = FT_Get_Char_Index( holder->m_face, _codePoint );
|
||||
|
||||
FT_Int32 loadMode = FT_LOAD_DEFAULT|FT_LOAD_NO_HINTING;
|
||||
FT_Render_Mode renderMode = FT_RENDER_MODE_NORMAL;
|
||||
|
||||
FT_GlyphSlot slot = holder->face->glyph;
|
||||
FT_Error error = FT_Load_Glyph( holder->face, glyphInfo.glyphIndex, loadMode );
|
||||
FT_GlyphSlot slot = holder->m_face->glyph;
|
||||
FT_Error error = FT_Load_Glyph( holder->m_face, _glyphInfo.m_glyphIndex, loadMode );
|
||||
if(error) { return false; }
|
||||
|
||||
FT_Glyph glyph;
|
||||
|
|
@ -363,12 +363,12 @@ bool FontManager::TrueTypeFont::bakeGlyphDistance(CodePoint_t codePoint, GlyphIn
|
|||
int w = bitmap->bitmap.width;
|
||||
int h = bitmap->bitmap.rows;
|
||||
|
||||
glyphInfo.offset_x = (float) x;
|
||||
glyphInfo.offset_y = (float) y;
|
||||
glyphInfo.width = (float) w;
|
||||
glyphInfo.height = (float) h;
|
||||
glyphInfo.advance_x = (float)slot->advance.x /64.0f;
|
||||
glyphInfo.advance_y = (float)slot->advance.y /64.0f;
|
||||
_glyphInfo.m_offset_x = (float) x;
|
||||
_glyphInfo.m_offset_y = (float) y;
|
||||
_glyphInfo.m_width = (float) w;
|
||||
_glyphInfo.m_height = (float) h;
|
||||
_glyphInfo.m_advance_x = (float)slot->advance.x /64.0f;
|
||||
_glyphInfo.m_advance_y = (float)slot->advance.y /64.0f;
|
||||
|
||||
int charsize = 1;
|
||||
int depth=1;
|
||||
|
|
@ -377,7 +377,7 @@ bool FontManager::TrueTypeFont::bakeGlyphDistance(CodePoint_t codePoint, GlyphIn
|
|||
for( int i=0; i<h; ++i )
|
||||
{
|
||||
|
||||
memcpy(outBuffer+(i*w) * charsize * depth,
|
||||
memcpy(_outBuffer+(i*w) * charsize * depth,
|
||||
bitmap->bitmap.buffer + (i*stride) * charsize, w * charsize * depth );
|
||||
}
|
||||
FT_Done_Glyph(glyph);
|
||||
|
|
@ -400,16 +400,16 @@ bool FontManager::TrueTypeFont::bakeGlyphDistance(CodePoint_t codePoint, GlyphIn
|
|||
//copy the original buffer to the temp one
|
||||
for(uint32_t i= dh; i< nh-dh; ++i)
|
||||
{
|
||||
memcpy(alphaImg+i*nw+dw, outBuffer+(i-dh)*w, w);
|
||||
memcpy(alphaImg+i*nw+dw, _outBuffer+(i-dh)*w, w);
|
||||
}
|
||||
|
||||
make_distance_map(alphaImg, outBuffer, nw, nh);
|
||||
make_distance_map(alphaImg, _outBuffer, nw, nh);
|
||||
free(alphaImg);
|
||||
|
||||
glyphInfo.offset_x -= (float) dw;
|
||||
glyphInfo.offset_y -= (float) dh;
|
||||
glyphInfo.width = (float) nw ;
|
||||
glyphInfo.height = (float) nh;
|
||||
_glyphInfo.m_offset_x -= (float) dw;
|
||||
_glyphInfo.m_offset_y -= (float) dh;
|
||||
_glyphInfo.m_width = (float) nw ;
|
||||
_glyphInfo.m_height = (float) nh;
|
||||
}
|
||||
|
||||
return true;
|
||||
|
|
@ -423,13 +423,13 @@ typedef stl::unordered_map<CodePoint_t, GlyphInfo> GlyphHash_t;
|
|||
// cache font data
|
||||
struct FontManager::CachedFont
|
||||
{
|
||||
CachedFont(){ trueTypeFont = NULL; masterFontHandle.idx = -1; }
|
||||
FontInfo fontInfo;
|
||||
GlyphHash_t cachedGlyphs;
|
||||
FontManager::TrueTypeFont* trueTypeFont;
|
||||
CachedFont(){ m_trueTypeFont = NULL; m_masterFontHandle.idx = -1; }
|
||||
FontInfo m_fontInfo;
|
||||
GlyphHash_t m_cachedGlyphs;
|
||||
FontManager::TrueTypeFont* m_trueTypeFont;
|
||||
// an handle to a master font in case of sub distance field font
|
||||
FontHandle masterFontHandle;
|
||||
int16_t __padding__;
|
||||
FontHandle m_masterFontHandle;
|
||||
int16_t m_padding;
|
||||
};
|
||||
|
||||
|
||||
|
|
@ -439,16 +439,16 @@ const uint16_t MAX_OPENED_FILES = 64;
|
|||
const uint16_t MAX_OPENED_FONT = 64;
|
||||
const uint32_t MAX_FONT_BUFFER_SIZE = 512*512*4;
|
||||
|
||||
FontManager::FontManager(Atlas* atlas):m_filesHandles(MAX_OPENED_FILES), m_fontHandles(MAX_OPENED_FONT)
|
||||
FontManager::FontManager(Atlas* _atlas):m_filesHandles(MAX_OPENED_FILES), m_fontHandles(MAX_OPENED_FONT)
|
||||
{
|
||||
m_atlas = atlas;
|
||||
m_atlas = _atlas;
|
||||
m_ownAtlas = false;
|
||||
init();
|
||||
}
|
||||
|
||||
FontManager::FontManager(uint32_t textureSideWidth):m_filesHandles(MAX_OPENED_FILES), m_fontHandles(MAX_OPENED_FONT)
|
||||
FontManager::FontManager(uint32_t _textureSideWidth):m_filesHandles(MAX_OPENED_FILES), m_fontHandles(MAX_OPENED_FONT)
|
||||
{
|
||||
m_atlas = new Atlas(textureSideWidth);
|
||||
m_atlas = new Atlas(_textureSideWidth);
|
||||
m_ownAtlas = true;
|
||||
init();
|
||||
}
|
||||
|
|
@ -463,8 +463,8 @@ void FontManager::init()
|
|||
uint8_t buffer[4*4*4];
|
||||
memset( buffer, 255, 4 * 4 * 4);
|
||||
|
||||
m_blackGlyph.width=3;
|
||||
m_blackGlyph.height=3;
|
||||
m_blackGlyph.m_width=3;
|
||||
m_blackGlyph.m_height=3;
|
||||
assert( addBitmap(m_blackGlyph, buffer) );
|
||||
//make sure the black glyph doesn't bleed
|
||||
|
||||
|
|
@ -494,10 +494,10 @@ FontManager::~FontManager()
|
|||
|
||||
|
||||
|
||||
TrueTypeHandle FontManager::loadTrueTypeFromFile(const char* fontPath)
|
||||
TrueTypeHandle FontManager::loadTrueTypeFromFile(const char* _fontPath)
|
||||
{
|
||||
FILE * pFile;
|
||||
pFile = fopen (fontPath, "rb");
|
||||
pFile = fopen (_fontPath, "rb");
|
||||
if (pFile==NULL)
|
||||
{
|
||||
TrueTypeHandle invalid = BGFX_INVALID_HANDLE;
|
||||
|
|
@ -544,34 +544,34 @@ TrueTypeHandle FontManager::loadTrueTypeFromFile(const char* fontPath)
|
|||
return invalid;
|
||||
}
|
||||
|
||||
TrueTypeHandle FontManager::loadTrueTypeFromMemory(const uint8_t* buffer, uint32_t size)
|
||||
TrueTypeHandle FontManager::loadTrueTypeFromMemory(const uint8_t* _buffer, uint32_t _size)
|
||||
{
|
||||
uint16_t id = m_filesHandles.alloc();
|
||||
assert(id != bx::HandleAlloc::invalid);
|
||||
m_cachedFiles[id].buffer = new uint8_t[size];
|
||||
m_cachedFiles[id].bufferSize = size;
|
||||
memcpy(m_cachedFiles[id].buffer, buffer, size);
|
||||
m_cachedFiles[id].buffer = new uint8_t[_size];
|
||||
m_cachedFiles[id].bufferSize = _size;
|
||||
memcpy(m_cachedFiles[id].buffer, _buffer, _size);
|
||||
|
||||
//TODO validate font
|
||||
TrueTypeHandle ret = {id};
|
||||
return ret;
|
||||
}
|
||||
|
||||
void FontManager::unloadTrueType(TrueTypeHandle handle)
|
||||
void FontManager::unloadTrueType(TrueTypeHandle _handle)
|
||||
{
|
||||
assert(bgfx::invalidHandle != handle.idx);
|
||||
delete m_cachedFiles[handle.idx].buffer;
|
||||
m_cachedFiles[handle.idx].bufferSize = 0;
|
||||
m_cachedFiles[handle.idx].buffer = NULL;
|
||||
m_filesHandles.free(handle.idx);
|
||||
assert(bgfx::invalidHandle != _handle.idx);
|
||||
delete m_cachedFiles[_handle.idx].buffer;
|
||||
m_cachedFiles[_handle.idx].bufferSize = 0;
|
||||
m_cachedFiles[_handle.idx].buffer = NULL;
|
||||
m_filesHandles.free(_handle.idx);
|
||||
}
|
||||
|
||||
FontHandle FontManager::createFontByPixelSize(TrueTypeHandle handle, uint32_t typefaceIndex, uint32_t pixelSize, FontType fontType)
|
||||
FontHandle FontManager::createFontByPixelSize(TrueTypeHandle _tt_handle, uint32_t _typefaceIndex, uint32_t _pixelSize, FontType _fontType)
|
||||
{
|
||||
assert(bgfx::invalidHandle != handle.idx);
|
||||
assert(bgfx::invalidHandle != _tt_handle.idx);
|
||||
|
||||
TrueTypeFont* ttf = new TrueTypeFont();
|
||||
if(!ttf->init( m_cachedFiles[handle.idx].buffer, m_cachedFiles[handle.idx].bufferSize, typefaceIndex, pixelSize))
|
||||
if(!ttf->init( m_cachedFiles[_tt_handle.idx].buffer, m_cachedFiles[_tt_handle.idx].bufferSize, _typefaceIndex, _pixelSize))
|
||||
{
|
||||
delete ttf;
|
||||
FontHandle invalid = BGFX_INVALID_HANDLE;
|
||||
|
|
@ -581,12 +581,12 @@ FontHandle FontManager::createFontByPixelSize(TrueTypeHandle handle, uint32_t ty
|
|||
uint16_t fontIdx = m_fontHandles.alloc();
|
||||
assert(fontIdx != bx::HandleAlloc::invalid);
|
||||
|
||||
m_cachedFonts[fontIdx].trueTypeFont = ttf;
|
||||
m_cachedFonts[fontIdx].fontInfo = ttf->getFontInfo();
|
||||
m_cachedFonts[fontIdx].fontInfo.fontType = fontType;
|
||||
m_cachedFonts[fontIdx].fontInfo.pixelSize = pixelSize;
|
||||
m_cachedFonts[fontIdx].cachedGlyphs.clear();
|
||||
m_cachedFonts[fontIdx].masterFontHandle.idx = -1;
|
||||
m_cachedFonts[fontIdx].m_trueTypeFont = ttf;
|
||||
m_cachedFonts[fontIdx].m_fontInfo = ttf->getFontInfo();
|
||||
m_cachedFonts[fontIdx].m_fontInfo.m_fontType = _fontType;
|
||||
m_cachedFonts[fontIdx].m_fontInfo.m_pixelSize = _pixelSize;
|
||||
m_cachedFonts[fontIdx].m_cachedGlyphs.clear();
|
||||
m_cachedFonts[fontIdx].m_masterFontHandle.idx = -1;
|
||||
FontHandle ret = {fontIdx};
|
||||
return ret;
|
||||
}
|
||||
|
|
@ -595,24 +595,24 @@ FontHandle FontManager::createScaledFontToPixelSize(FontHandle _baseFontHandle,
|
|||
{
|
||||
assert(bgfx::invalidHandle != _baseFontHandle.idx);
|
||||
CachedFont& font = m_cachedFonts[_baseFontHandle.idx];
|
||||
FontInfo& fontInfo = font.fontInfo;
|
||||
FontInfo& fontInfo = font.m_fontInfo;
|
||||
|
||||
FontInfo newFontInfo = fontInfo;
|
||||
newFontInfo.pixelSize = _pixelSize;
|
||||
newFontInfo.scale = (float)_pixelSize / (float) fontInfo.pixelSize;
|
||||
newFontInfo.ascender = (newFontInfo.ascender * newFontInfo.scale);
|
||||
newFontInfo.descender = (newFontInfo.descender * newFontInfo.scale);
|
||||
newFontInfo.lineGap = (newFontInfo.lineGap * newFontInfo.scale);
|
||||
newFontInfo.underline_thickness = (newFontInfo.underline_thickness * newFontInfo.scale);
|
||||
newFontInfo.underline_position = (newFontInfo.underline_position * newFontInfo.scale);
|
||||
newFontInfo.m_pixelSize = _pixelSize;
|
||||
newFontInfo.m_scale = (float)_pixelSize / (float) fontInfo.m_pixelSize;
|
||||
newFontInfo.m_ascender = (newFontInfo.m_ascender * newFontInfo.m_scale);
|
||||
newFontInfo.m_descender = (newFontInfo.m_descender * newFontInfo.m_scale);
|
||||
newFontInfo.m_lineGap = (newFontInfo.m_lineGap * newFontInfo.m_scale);
|
||||
newFontInfo.m_underline_thickness = (newFontInfo.m_underline_thickness * newFontInfo.m_scale);
|
||||
newFontInfo.m_underline_position = (newFontInfo.m_underline_position * newFontInfo.m_scale);
|
||||
|
||||
|
||||
uint16_t fontIdx = m_fontHandles.alloc();
|
||||
assert(fontIdx != bx::HandleAlloc::invalid);
|
||||
m_cachedFonts[fontIdx].cachedGlyphs.clear();
|
||||
m_cachedFonts[fontIdx].fontInfo = newFontInfo;
|
||||
m_cachedFonts[fontIdx].trueTypeFont = NULL;
|
||||
m_cachedFonts[fontIdx].masterFontHandle = _baseFontHandle;
|
||||
m_cachedFonts[fontIdx].m_cachedGlyphs.clear();
|
||||
m_cachedFonts[fontIdx].m_fontInfo = newFontInfo;
|
||||
m_cachedFonts[fontIdx].m_trueTypeFont = NULL;
|
||||
m_cachedFonts[fontIdx].m_masterFontHandle = _baseFontHandle;
|
||||
FontHandle ret = {fontIdx};
|
||||
return ret;
|
||||
}
|
||||
|
|
@ -635,29 +635,29 @@ void FontManager::destroyFont(FontHandle _handle)
|
|||
{
|
||||
assert(bgfx::invalidHandle != _handle.idx);
|
||||
|
||||
if(m_cachedFonts[_handle.idx].trueTypeFont != NULL)
|
||||
if(m_cachedFonts[_handle.idx].m_trueTypeFont != NULL)
|
||||
{
|
||||
delete m_cachedFonts[_handle.idx].trueTypeFont;
|
||||
m_cachedFonts[_handle.idx].trueTypeFont = NULL;
|
||||
delete m_cachedFonts[_handle.idx].m_trueTypeFont;
|
||||
m_cachedFonts[_handle.idx].m_trueTypeFont = NULL;
|
||||
}
|
||||
m_cachedFonts[_handle.idx].cachedGlyphs.clear();
|
||||
m_cachedFonts[_handle.idx].m_cachedGlyphs.clear();
|
||||
m_fontHandles.free(_handle.idx);
|
||||
}
|
||||
|
||||
bool FontManager::preloadGlyph(FontHandle handle, const wchar_t* _string)
|
||||
bool FontManager::preloadGlyph(FontHandle _handle, const wchar_t* _string)
|
||||
{
|
||||
assert(bgfx::invalidHandle != handle.idx);
|
||||
CachedFont& font = m_cachedFonts[handle.idx];
|
||||
assert(bgfx::invalidHandle != _handle.idx);
|
||||
CachedFont& font = m_cachedFonts[_handle.idx];
|
||||
|
||||
//if truetype present
|
||||
if(font.trueTypeFont != NULL)
|
||||
if(font.m_trueTypeFont != NULL)
|
||||
{
|
||||
//parse string
|
||||
for( size_t i=0, end = wcslen(_string) ; i < end; ++i )
|
||||
{
|
||||
//if glyph cached, continue
|
||||
CodePoint_t codePoint = _string[i];
|
||||
if(!preloadGlyph(handle, codePoint))
|
||||
if(!preloadGlyph(_handle, codePoint))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
|
@ -668,37 +668,37 @@ bool FontManager::preloadGlyph(FontHandle handle, const wchar_t* _string)
|
|||
return false;
|
||||
}
|
||||
|
||||
bool FontManager::preloadGlyph(FontHandle handle, CodePoint_t codePoint)
|
||||
bool FontManager::preloadGlyph(FontHandle _handle, CodePoint_t _codePoint)
|
||||
{
|
||||
assert(bgfx::invalidHandle != handle.idx);
|
||||
CachedFont& font = m_cachedFonts[handle.idx];
|
||||
FontInfo& fontInfo = font.fontInfo;
|
||||
assert(bgfx::invalidHandle != _handle.idx);
|
||||
CachedFont& font = m_cachedFonts[_handle.idx];
|
||||
FontInfo& fontInfo = font.m_fontInfo;
|
||||
//check if glyph not already present
|
||||
GlyphHash_t::iterator iter = font.cachedGlyphs.find(codePoint);
|
||||
if(iter != font.cachedGlyphs.end())
|
||||
GlyphHash_t::iterator iter = font.m_cachedGlyphs.find(_codePoint);
|
||||
if(iter != font.m_cachedGlyphs.end())
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
//if truetype present
|
||||
if(font.trueTypeFont != NULL)
|
||||
if(font.m_trueTypeFont != NULL)
|
||||
{
|
||||
GlyphInfo glyphInfo;
|
||||
|
||||
//bake glyph as bitmap to buffer
|
||||
switch(font.fontInfo.fontType)
|
||||
switch(font.m_fontInfo.m_fontType)
|
||||
{
|
||||
case FONT_TYPE_ALPHA:
|
||||
font.trueTypeFont->bakeGlyphAlpha(codePoint, glyphInfo, m_buffer);
|
||||
font.m_trueTypeFont->bakeGlyphAlpha(_codePoint, glyphInfo, m_buffer);
|
||||
break;
|
||||
//case FONT_TYPE_LCD:
|
||||
//font.trueTypeFont->bakeGlyphSubpixel(codePoint, glyphInfo, m_buffer);
|
||||
//font.m_trueTypeFont->bakeGlyphSubpixel(codePoint, glyphInfo, m_buffer);
|
||||
//break;
|
||||
case FONT_TYPE_DISTANCE:
|
||||
font.trueTypeFont->bakeGlyphDistance(codePoint, glyphInfo, m_buffer);
|
||||
font.m_trueTypeFont->bakeGlyphDistance(_codePoint, glyphInfo, m_buffer);
|
||||
break;
|
||||
case FONT_TYPE_DISTANCE_SUBPIXEL:
|
||||
font.trueTypeFont->bakeGlyphDistance(codePoint, glyphInfo, m_buffer);
|
||||
font.m_trueTypeFont->bakeGlyphDistance(_codePoint, glyphInfo, m_buffer);
|
||||
break;
|
||||
default:
|
||||
assert(false && "TextureType not supported yet");
|
||||
|
|
@ -710,35 +710,35 @@ bool FontManager::preloadGlyph(FontHandle handle, CodePoint_t codePoint)
|
|||
return false;
|
||||
}
|
||||
|
||||
glyphInfo.advance_x = (glyphInfo.advance_x * fontInfo.scale);
|
||||
glyphInfo.advance_y = (glyphInfo.advance_y * fontInfo.scale);
|
||||
glyphInfo.offset_x = (glyphInfo.offset_x * fontInfo.scale);
|
||||
glyphInfo.offset_y = (glyphInfo.offset_y * fontInfo.scale);
|
||||
glyphInfo.height = (glyphInfo.height * fontInfo.scale);
|
||||
glyphInfo.width = (glyphInfo.width * fontInfo.scale);
|
||||
glyphInfo.m_advance_x = (glyphInfo.m_advance_x * fontInfo.m_scale);
|
||||
glyphInfo.m_advance_y = (glyphInfo.m_advance_y * fontInfo.m_scale);
|
||||
glyphInfo.m_offset_x = (glyphInfo.m_offset_x * fontInfo.m_scale);
|
||||
glyphInfo.m_offset_y = (glyphInfo.m_offset_y * fontInfo.m_scale);
|
||||
glyphInfo.m_height = (glyphInfo.m_height * fontInfo.m_scale);
|
||||
glyphInfo.m_width = (glyphInfo.m_width * fontInfo.m_scale);
|
||||
|
||||
// store cached glyph
|
||||
font.cachedGlyphs[codePoint] = glyphInfo;
|
||||
font.m_cachedGlyphs[_codePoint] = glyphInfo;
|
||||
return true;
|
||||
}else
|
||||
{
|
||||
//retrieve glyph from parent font if any
|
||||
if(font.masterFontHandle.idx != bgfx::invalidHandle)
|
||||
if(font.m_masterFontHandle.idx != bgfx::invalidHandle)
|
||||
{
|
||||
if(preloadGlyph(font.masterFontHandle, codePoint))
|
||||
if(preloadGlyph(font.m_masterFontHandle, _codePoint))
|
||||
{
|
||||
GlyphInfo glyphInfo;
|
||||
getGlyphInfo(font.masterFontHandle, codePoint, glyphInfo);
|
||||
getGlyphInfo(font.m_masterFontHandle, _codePoint, glyphInfo);
|
||||
|
||||
glyphInfo.advance_x = (glyphInfo.advance_x * fontInfo.scale);
|
||||
glyphInfo.advance_y = (glyphInfo.advance_y * fontInfo.scale);
|
||||
glyphInfo.offset_x = (glyphInfo.offset_x * fontInfo.scale);
|
||||
glyphInfo.offset_y = (glyphInfo.offset_y * fontInfo.scale);
|
||||
glyphInfo.height = (glyphInfo.height * fontInfo.scale);
|
||||
glyphInfo.width = (glyphInfo.width * fontInfo.scale);
|
||||
glyphInfo.m_advance_x = (glyphInfo.m_advance_x * fontInfo.m_scale);
|
||||
glyphInfo.m_advance_y = (glyphInfo.m_advance_y * fontInfo.m_scale);
|
||||
glyphInfo.m_offset_x = (glyphInfo.m_offset_x * fontInfo.m_scale);
|
||||
glyphInfo.m_offset_y = (glyphInfo.m_offset_y * fontInfo.m_scale);
|
||||
glyphInfo.m_height = (glyphInfo.m_height * fontInfo.m_scale);
|
||||
glyphInfo.m_width = (glyphInfo.m_width * fontInfo.m_scale);
|
||||
|
||||
// store cached glyph
|
||||
font.cachedGlyphs[codePoint] = glyphInfo;
|
||||
font.m_cachedGlyphs[_codePoint] = glyphInfo;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
|
@ -747,34 +747,34 @@ bool FontManager::preloadGlyph(FontHandle handle, CodePoint_t codePoint)
|
|||
return false;
|
||||
}
|
||||
|
||||
const FontInfo& FontManager::getFontInfo(FontHandle handle)
|
||||
const FontInfo& FontManager::getFontInfo(FontHandle _handle)
|
||||
{
|
||||
assert(handle.idx != bgfx::invalidHandle);
|
||||
return m_cachedFonts[handle.idx].fontInfo;
|
||||
assert(_handle.idx != bgfx::invalidHandle);
|
||||
return m_cachedFonts[_handle.idx].m_fontInfo;
|
||||
}
|
||||
|
||||
bool FontManager::getGlyphInfo(FontHandle fontHandle, CodePoint_t codePoint, GlyphInfo& outInfo)
|
||||
bool FontManager::getGlyphInfo(FontHandle _handle, CodePoint_t _codePoint, GlyphInfo& _outInfo)
|
||||
{
|
||||
GlyphHash_t::iterator iter = m_cachedFonts[fontHandle.idx].cachedGlyphs.find(codePoint);
|
||||
if(iter == m_cachedFonts[fontHandle.idx].cachedGlyphs.end())
|
||||
GlyphHash_t::iterator iter = m_cachedFonts[_handle.idx].m_cachedGlyphs.find(_codePoint);
|
||||
if(iter == m_cachedFonts[_handle.idx].m_cachedGlyphs.end())
|
||||
{
|
||||
if(preloadGlyph(fontHandle, codePoint))
|
||||
if(preloadGlyph(_handle, _codePoint))
|
||||
{
|
||||
iter = m_cachedFonts[fontHandle.idx].cachedGlyphs.find(codePoint);
|
||||
iter = m_cachedFonts[_handle.idx].m_cachedGlyphs.find(_codePoint);
|
||||
}else
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
outInfo = iter->second;
|
||||
_outInfo = iter->second;
|
||||
return true;
|
||||
}
|
||||
|
||||
// ****************************************************************************
|
||||
|
||||
|
||||
bool FontManager::addBitmap(GlyphInfo& glyphInfo, const uint8_t* data)
|
||||
bool FontManager::addBitmap(GlyphInfo& _glyphInfo, const uint8_t* _data)
|
||||
{
|
||||
glyphInfo.regionIndex = m_atlas->addRegion((uint16_t) ceil(glyphInfo.width),(uint16_t) ceil(glyphInfo.height), data, AtlasRegion::TYPE_GRAY);
|
||||
_glyphInfo.m_regionIndex = m_atlas->addRegion((uint16_t) ceil(_glyphInfo.m_width),(uint16_t) ceil(_glyphInfo.m_height), _data, AtlasRegion::TYPE_GRAY);
|
||||
return true;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -18,23 +18,23 @@ enum FontType
|
|||
struct FontInfo
|
||||
{
|
||||
//the font height in pixel
|
||||
uint16_t pixelSize;
|
||||
uint16_t m_pixelSize;
|
||||
/// Rendering type used for the font
|
||||
int16_t fontType;
|
||||
int16_t m_fontType;
|
||||
|
||||
/// The pixel extents above the baseline in pixels (typically positive)
|
||||
float ascender;
|
||||
float m_ascender;
|
||||
/// The extents below the baseline in pixels (typically negative)
|
||||
float descender;
|
||||
float m_descender;
|
||||
/// The spacing in pixels between one row's descent and the next row's ascent
|
||||
float lineGap;
|
||||
float m_lineGap;
|
||||
/// The thickness of the under/hover/striketrough line in pixels
|
||||
float underline_thickness;
|
||||
float m_underline_thickness;
|
||||
/// The position of the underline relatively to the baseline
|
||||
float underline_position;
|
||||
float m_underline_position;
|
||||
|
||||
//scale to apply to glyph data
|
||||
float scale;
|
||||
float m_scale;
|
||||
};
|
||||
|
||||
// Glyph metrics:
|
||||
|
|
@ -75,34 +75,34 @@ typedef int32_t CodePoint_t;
|
|||
struct GlyphInfo
|
||||
{
|
||||
/// Index for faster retrieval
|
||||
int32_t glyphIndex;
|
||||
int32_t m_glyphIndex;
|
||||
|
||||
/// Glyph's width in pixels.
|
||||
float width;
|
||||
float m_width;
|
||||
|
||||
/// Glyph's height in pixels.
|
||||
float height;
|
||||
float m_height;
|
||||
|
||||
/// Glyph's left offset in pixels
|
||||
float offset_x;
|
||||
float m_offset_x;
|
||||
|
||||
/// Glyph's top offset in pixels
|
||||
/// Remember that this is the distance from the baseline to the top-most
|
||||
/// glyph scan line, upwards y coordinates being positive.
|
||||
float offset_y;
|
||||
float m_offset_y;
|
||||
|
||||
/// For horizontal text layouts, this is the unscaled horizontal distance in pixels
|
||||
/// used to increment the pen position when the glyph is drawn as part of a string of text.
|
||||
float advance_x;
|
||||
float m_advance_x;
|
||||
|
||||
/// For vertical text layouts, this is the unscaled vertical distance in pixels
|
||||
/// used to increment the pen position when the glyph is drawn as part of a string of text.
|
||||
float advance_y;
|
||||
float m_advance_y;
|
||||
|
||||
/// region index in the atlas storing textures
|
||||
uint16_t regionIndex;
|
||||
uint16_t m_regionIndex;
|
||||
///32 bits alignment
|
||||
int16_t padding;
|
||||
int16_t m_padding;
|
||||
};
|
||||
|
||||
BGFX_HANDLE(TrueTypeHandle);
|
||||
|
|
@ -112,9 +112,9 @@ class FontManager
|
|||
{
|
||||
public:
|
||||
/// create the font manager using an external cube atlas (doesn't take ownership of the atlas)
|
||||
FontManager(Atlas* atlas);
|
||||
FontManager(Atlas* _atlas);
|
||||
/// create the font manager and create the texture cube as BGRA8 with linear filtering
|
||||
FontManager(uint32_t textureSideWidth = 512);
|
||||
FontManager(uint32_t _textureSideWidth = 512);
|
||||
|
||||
~FontManager();
|
||||
|
||||
|
|
@ -123,29 +123,29 @@ public:
|
|||
|
||||
/// load a TrueType font from a file path
|
||||
/// @return invalid handle if the loading fail
|
||||
TrueTypeHandle loadTrueTypeFromFile(const char* fontPath);
|
||||
TrueTypeHandle loadTrueTypeFromFile(const char* _fontPath);
|
||||
|
||||
/// load a TrueType font from a given buffer.
|
||||
/// the buffer is copied and thus can be freed or reused after this call
|
||||
/// @return invalid handle if the loading fail
|
||||
TrueTypeHandle loadTrueTypeFromMemory(const uint8_t* buffer, uint32_t size);
|
||||
TrueTypeHandle loadTrueTypeFromMemory(const uint8_t* _buffer, uint32_t _size);
|
||||
|
||||
/// unload a TrueType font (free font memory) but keep loaded glyphs
|
||||
void unloadTrueType(TrueTypeHandle handle);
|
||||
void unloadTrueType(TrueTypeHandle _handle);
|
||||
|
||||
/// return a font whose height is a fixed pixel size
|
||||
FontHandle createFontByPixelSize(TrueTypeHandle handle, uint32_t typefaceIndex, uint32_t pixelSize, FontType fontType = FONT_TYPE_ALPHA);
|
||||
FontHandle createFontByPixelSize(TrueTypeHandle _handle, uint32_t _typefaceIndex, uint32_t _pixelSize, FontType _fontType = FONT_TYPE_ALPHA);
|
||||
|
||||
/// return a scaled child font whose height is a fixed pixel size
|
||||
FontHandle createScaledFontToPixelSize(FontHandle baseFontHandle, uint32_t pixelSize);
|
||||
FontHandle createScaledFontToPixelSize(FontHandle _baseFontHandle, uint32_t _pixelSize);
|
||||
|
||||
/// load a baked font (the set of glyph is fixed)
|
||||
/// @return INVALID_HANDLE if the loading fail
|
||||
FontHandle loadBakedFontFromFile(const char* imagePath, const char* descriptorPath);
|
||||
FontHandle loadBakedFontFromFile(const char* _imagePath, const char* _descriptorPath);
|
||||
|
||||
/// load a baked font (the set of glyph is fixed)
|
||||
/// @return INVALID_HANDLE if the loading fail
|
||||
FontHandle loadBakedFontFromMemory(const uint8_t* imageBuffer, uint32_t imageSize, const uint8_t* descriptorBuffer, uint32_t descriptorSize);
|
||||
FontHandle loadBakedFontFromMemory(const uint8_t* _imageBuffer, uint32_t _imageSize, const uint8_t* _descriptorBuffer, uint32_t _descriptorSize);
|
||||
|
||||
/// destroy a font (truetype or baked)
|
||||
void destroyFont(FontHandle _handle);
|
||||
|
|
@ -153,23 +153,23 @@ public:
|
|||
/// Preload a set of glyphs from a TrueType file
|
||||
/// @return true if every glyph could be preloaded, false otherwise
|
||||
/// if the Font is a baked font, this only do validation on the characters
|
||||
bool preloadGlyph(FontHandle handle, const wchar_t* _string);
|
||||
bool preloadGlyph(FontHandle _handle, const wchar_t* _string);
|
||||
|
||||
/// Preload a single glyph, return true on success
|
||||
bool preloadGlyph(FontHandle handle, CodePoint_t character);
|
||||
bool preloadGlyph(FontHandle _handle, CodePoint_t _character);
|
||||
|
||||
/// bake a font to disk (the set of preloaded glyph)
|
||||
/// @return true if the baking succeed, false otherwise
|
||||
bool saveBakedFont(FontHandle handle, const char* fontDirectory, const char* fontName );
|
||||
bool saveBakedFont(FontHandle _handle, const char* _fontDirectory, const char* _fontName );
|
||||
|
||||
/// return the font descriptor of a font
|
||||
/// @remark the handle is required to be valid
|
||||
const FontInfo& getFontInfo(FontHandle handle);
|
||||
const FontInfo& getFontInfo(FontHandle _handle);
|
||||
|
||||
/// Return the rendering informations about the glyph region
|
||||
/// Load the glyph from a TrueType font if possible
|
||||
/// @return true if the Glyph is available
|
||||
bool getGlyphInfo(FontHandle fontHandle, CodePoint_t codePoint, GlyphInfo& outInfo);
|
||||
bool getGlyphInfo(FontHandle _handle, CodePoint_t _codePoint, GlyphInfo& _outInfo);
|
||||
|
||||
GlyphInfo& getBlackGlyph(){ return m_blackGlyph; }
|
||||
|
||||
|
|
@ -184,10 +184,10 @@ private:
|
|||
};
|
||||
|
||||
void init();
|
||||
bool addBitmap(GlyphInfo& glyphInfo, const uint8_t* data);
|
||||
bool addBitmap(GlyphInfo& _glyphInfo, const uint8_t* _data);
|
||||
|
||||
bool m_ownAtlas;
|
||||
(Atlas* m_atlas;
|
||||
Atlas* m_atlas;
|
||||
|
||||
bx::HandleAlloc m_fontHandles;
|
||||
CachedFont* m_cachedFonts;
|
||||
|
|
|
|||
Loading…
Reference in a new issue