scratchfoundation/bgfx
1
0
Fork 0
mirror of https://github.com/scratchfoundation/bgfx.git synced 2024-12-01 11:56:58 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

update font_manager to bgfx coding style

Browse source
This commit is contained in:
Jeremie Roy 2013-04-23 20:58:57 +02:00
parent 6b8b95acd8
commit 6c956ee0c9
2 changed files with 198 additions and 198 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

330
examples/common/font/font_manager.cpp
View file

@ -49,25 +49,25 @@ public:
/// Initialize from an external buffer /// 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 /// @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 /// @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 /// return the font descriptor of the current font
FontInfo getFontInfo(); FontInfo getFontInfo();
/// raster a glyph as 8bit alpha to a memory buffer /// raster a glyph as 8bit alpha to a memory buffer
/// update the GlyphInfo according to the raster strategy /// update the GlyphInfo according to the raster strategy
/// @ remark buffer min size: glyphInfo.width * glyphInfo * height * sizeof(char) /// @ remark buffer min size: glyphInfo.m_width * glyphInfo * height * sizeof(char)
bool bakeGlyphAlpha(CodePoint_t codePoint, GlyphInfo& outGlyphInfo, uint8_t* outBuffer); bool bakeGlyphAlpha(CodePoint_t _codePoint, GlyphInfo& _outGlyphInfo, uint8_t* _outBuffer);
/// raster a glyph as 32bit subpixel rgba to a memory buffer /// raster a glyph as 32bit subpixel rgba to a memory buffer
/// update the GlyphInfo according to the raster strategy /// update the GlyphInfo according to the raster strategy
/// @ remark buffer min size: glyphInfo.width * glyphInfo * height * sizeof(uint32_t) /// @ remark buffer min size: glyphInfo.m_width * glyphInfo * height * sizeof(uint32_t)
bool bakeGlyphSubpixel(CodePoint_t codePoint, GlyphInfo& outGlyphInfo, uint8_t* outBuffer); bool bakeGlyphSubpixel(CodePoint_t _codePoint, GlyphInfo& _outGlyphInfo, uint8_t* _outBuffer);
/// raster a glyph as 8bit signed distance to a memory buffer /// raster a glyph as 8bit signed distance to a memory buffer
/// update the GlyphInfo according to the raster strategy /// update the GlyphInfo according to the raster strategy
/// @ remark buffer min size: glyphInfo.width * glyphInfo * height * sizeof(char) /// @ remark buffer min size: glyphInfo.m_width * glyphInfo * height * sizeof(char)
bool bakeGlyphDistance(CodePoint_t codePoint, GlyphInfo& outGlyphInfo, uint8_t* outBuffer); bool bakeGlyphDistance(CodePoint_t _codePoint, GlyphInfo& _outGlyphInfo, uint8_t* _outBuffer);
private: private:
void* m_font; void* m_font;
}; };
@ -75,8 +75,8 @@ private:
struct FTHolder struct FTHolder
{ {
FT_Library library; FT_Library m_library;
FT_Face face; FT_Face m_face;
}; };
FontManager::TrueTypeFont::TrueTypeFont(): m_font(NULL) FontManager::TrueTypeFont::TrueTypeFont(): m_font(NULL)
{ {
@ -87,36 +87,36 @@ FontManager::TrueTypeFont::~TrueTypeFont()
if(m_font!=NULL) if(m_font!=NULL)
{ {
FTHolder* holder = (FTHolder*) m_font; FTHolder* holder = (FTHolder*) m_font;
FT_Done_Face( holder->face ); FT_Done_Face( holder->m_face );
FT_Done_FreeType( holder->library ); FT_Done_FreeType( holder->m_library );
delete m_font; delete m_font;
m_font = NULL; 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((_bufferSize > 256 && _bufferSize < 100000000) && "TrueType buffer size is suspicious");
assert((pixelHeight > 4 && pixelHeight < 128) && "TrueType buffer size is suspicious"); assert((_pixelHeight > 4 && _pixelHeight < 128) && "TrueType buffer size is suspicious");
assert(m_font == NULL && "TrueTypeFont already initialized" ); assert(m_font == NULL && "TrueTypeFont already initialized" );
FTHolder* holder = new FTHolder(); FTHolder* holder = new FTHolder();
// Initialize Freetype library // Initialize Freetype library
FT_Error error = FT_Init_FreeType( &holder->library ); FT_Error error = FT_Init_FreeType( &holder->m_library );
if( error) if( error)
{ {
delete holder; delete holder;
return false; 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 ) if ( error == FT_Err_Unknown_File_Format )
{ {
// the font file could be opened and read, but it appears // the font file could be opened and read, but it appears
//that its font format is unsupported //that its font format is unsupported
FT_Done_FreeType( holder->library ); FT_Done_FreeType( holder->m_library );
delete holder; delete holder;
return false; 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 // another error code means that the font file could not
// be opened or read, or simply that it is broken... // be opened or read, or simply that it is broken...
FT_Done_FreeType( holder->library ); FT_Done_FreeType( holder->m_library );
delete holder; delete holder;
return false; return false;
} }
// Select unicode charmap // Select unicode charmap
error = FT_Select_Charmap( holder->face, FT_ENCODING_UNICODE ); error = FT_Select_Charmap( holder->m_face, FT_ENCODING_UNICODE );
if( error ) if( error )
{ {
FT_Done_Face( holder->face ); FT_Done_Face( holder->m_face );
FT_Done_FreeType( holder->library ); FT_Done_FreeType( holder->m_library );
return false; return false;
} }
//set size in pixels //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 ) if( error )
{ {
FT_Done_Face( holder->face ); FT_Done_Face( holder->m_face );
FT_Done_FreeType( holder->library ); FT_Done_FreeType( holder->m_library );
return false; return false;
} }
@ -155,31 +155,31 @@ FontInfo FontManager::TrueTypeFont::getFontInfo()
assert(m_font != NULL && "TrueTypeFont not initialized" ); assert(m_font != NULL && "TrueTypeFont not initialized" );
FTHolder* holder = (FTHolder*) m_font; 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 //todo manage unscalable font
FontInfo outFontInfo; FontInfo outFontInfo;
outFontInfo.scale = 1.0f; outFontInfo.m_scale = 1.0f;
outFontInfo.ascender = metrics.ascender /64.0f; outFontInfo.m_ascender = metrics.ascender /64.0f;
outFontInfo.descender = metrics.descender /64.0f; outFontInfo.m_descender = metrics.descender /64.0f;
outFontInfo.lineGap = (metrics.height - metrics.ascender + 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.m_underline_position = FT_MulFix(holder->m_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_thickness= FT_MulFix(holder->m_face->underline_thickness,metrics.y_scale) /64.0f;
return outFontInfo; 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" ); assert(m_font != NULL && "TrueTypeFont not initialized" );
FTHolder* holder = (FTHolder*) m_font; 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_GlyphSlot slot = holder->m_face->glyph;
FT_Error error = FT_Load_Glyph( holder->face, glyphInfo.glyphIndex, FT_LOAD_DEFAULT ); FT_Error error = FT_Load_Glyph( holder->m_face, _glyphInfo.m_glyphIndex, FT_LOAD_DEFAULT );
if(error) { return false; } if(error) { return false; }
FT_Glyph glyph; FT_Glyph glyph;
@ -196,34 +196,34 @@ bool FontManager::TrueTypeFont::bakeGlyphAlpha(CodePoint_t codePoint, GlyphInfo&
int w = bitmap->bitmap.width; int w = bitmap->bitmap.width;
int h = bitmap->bitmap.rows; int h = bitmap->bitmap.rows;
glyphInfo.offset_x = (float) x; _glyphInfo.m_offset_x = (float) x;
glyphInfo.offset_y = (float) y; _glyphInfo.m_offset_y = (float) y;
glyphInfo.width = (float) w; _glyphInfo.m_width = (float) w;
glyphInfo.height = (float) h; _glyphInfo.m_height = (float) h;
glyphInfo.advance_x = (float)slot->advance.x /64.0f; _glyphInfo.m_advance_x = (float)slot->advance.x /64.0f;
glyphInfo.advance_y = (float)slot->advance.y /64.0f; _glyphInfo.m_advance_y = (float)slot->advance.y /64.0f;
int charsize = 1; int charsize = 1;
int depth=1; int depth=1;
int stride = bitmap->bitmap.pitch; int stride = bitmap->bitmap.pitch;
for( int i=0; i<h; ++i ) 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 ); bitmap->bitmap.buffer + (i*stride) * charsize, w * charsize * depth );
} }
FT_Done_Glyph(glyph); FT_Done_Glyph(glyph);
return true; 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" ); assert(m_font != NULL && "TrueTypeFont not initialized" );
FTHolder* holder = (FTHolder*) m_font; 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_GlyphSlot slot = holder->m_face->glyph;
FT_Error error = FT_Load_Glyph( holder->face, glyphInfo.glyphIndex, FT_LOAD_DEFAULT ); FT_Error error = FT_Load_Glyph( holder->m_face, _glyphInfo.m_glyphIndex, FT_LOAD_DEFAULT );
if(error) { return false; } if(error) { return false; }
FT_Glyph glyph; FT_Glyph glyph;
@ -239,18 +239,18 @@ bool FontManager::TrueTypeFont::bakeGlyphSubpixel(CodePoint_t codePoint, GlyphIn
int w = bitmap->bitmap.width; int w = bitmap->bitmap.width;
int h = bitmap->bitmap.rows; int h = bitmap->bitmap.rows;
glyphInfo.offset_x = (float) x; _glyphInfo.m_offset_x = (float) x;
glyphInfo.offset_y = (float) y; _glyphInfo.m_offset_y = (float) y;
glyphInfo.width = (float) w; _glyphInfo.m_width = (float) w;
glyphInfo.height = (float) h; _glyphInfo.m_height = (float) h;
glyphInfo.advance_x = (float)slot->advance.x /64.0f; _glyphInfo.m_advance_x = (float)slot->advance.x /64.0f;
glyphInfo.advance_y = (float)slot->advance.y /64.0f; _glyphInfo.m_advance_y = (float)slot->advance.y /64.0f;
int charsize = 1; int charsize = 1;
int depth=3; int depth=3;
int stride = bitmap->bitmap.pitch; int stride = bitmap->bitmap.pitch;
for( int i=0; i<h; ++i ) 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 ); bitmap->bitmap.buffer + (i*stride) * charsize, w * charsize * depth );
} }
FT_Done_Glyph(glyph); 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" ); assert(m_font != NULL && "TrueTypeFont not initialized" );
FTHolder* holder = (FTHolder*) m_font; 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_Int32 loadMode = FT_LOAD_DEFAULT|FT_LOAD_NO_HINTING;
FT_Render_Mode renderMode = FT_RENDER_MODE_NORMAL; FT_Render_Mode renderMode = FT_RENDER_MODE_NORMAL;
FT_GlyphSlot slot = holder->face->glyph; FT_GlyphSlot slot = holder->m_face->glyph;
FT_Error error = FT_Load_Glyph( holder->face, glyphInfo.glyphIndex, loadMode ); FT_Error error = FT_Load_Glyph( holder->m_face, _glyphInfo.m_glyphIndex, loadMode );
if(error) { return false; } if(error) { return false; }
FT_Glyph glyph; FT_Glyph glyph;
@ -363,12 +363,12 @@ bool FontManager::TrueTypeFont::bakeGlyphDistance(CodePoint_t codePoint, GlyphIn
int w = bitmap->bitmap.width; int w = bitmap->bitmap.width;
int h = bitmap->bitmap.rows; int h = bitmap->bitmap.rows;
glyphInfo.offset_x = (float) x; _glyphInfo.m_offset_x = (float) x;
glyphInfo.offset_y = (float) y; _glyphInfo.m_offset_y = (float) y;
glyphInfo.width = (float) w; _glyphInfo.m_width = (float) w;
glyphInfo.height = (float) h; _glyphInfo.m_height = (float) h;
glyphInfo.advance_x = (float)slot->advance.x /64.0f; _glyphInfo.m_advance_x = (float)slot->advance.x /64.0f;
glyphInfo.advance_y = (float)slot->advance.y /64.0f; _glyphInfo.m_advance_y = (float)slot->advance.y /64.0f;
int charsize = 1; int charsize = 1;
int depth=1; int depth=1;
@ -377,7 +377,7 @@ bool FontManager::TrueTypeFont::bakeGlyphDistance(CodePoint_t codePoint, GlyphIn
for( int i=0; i<h; ++i ) 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 ); bitmap->bitmap.buffer + (i*stride) * charsize, w * charsize * depth );
} }
FT_Done_Glyph(glyph); FT_Done_Glyph(glyph);
@ -400,16 +400,16 @@ bool FontManager::TrueTypeFont::bakeGlyphDistance(CodePoint_t codePoint, GlyphIn
//copy the original buffer to the temp one //copy the original buffer to the temp one
for(uint32_t i= dh; i< nh-dh; ++i) 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); free(alphaImg);
glyphInfo.offset_x -= (float) dw; _glyphInfo.m_offset_x -= (float) dw;
glyphInfo.offset_y -= (float) dh; _glyphInfo.m_offset_y -= (float) dh;
glyphInfo.width = (float) nw ; _glyphInfo.m_width = (float) nw ;
glyphInfo.height = (float) nh; _glyphInfo.m_height = (float) nh;
} }
return true; return true;
@ -423,13 +423,13 @@ typedef stl::unordered_map<CodePoint_t, GlyphInfo> GlyphHash_t;
// cache font data // cache font data
struct FontManager::CachedFont struct FontManager::CachedFont
{ {
CachedFont(){ trueTypeFont = NULL; masterFontHandle.idx = -1; } CachedFont(){ m_trueTypeFont = NULL; m_masterFontHandle.idx = -1; }
FontInfo fontInfo; FontInfo m_fontInfo;
GlyphHash_t cachedGlyphs; GlyphHash_t m_cachedGlyphs;
FontManager::TrueTypeFont* trueTypeFont; FontManager::TrueTypeFont* m_trueTypeFont;
// an handle to a master font in case of sub distance field font // an handle to a master font in case of sub distance field font
FontHandle masterFontHandle; FontHandle m_masterFontHandle;
int16_t __padding__; int16_t m_padding;
}; };
@ -439,16 +439,16 @@ const uint16_t MAX_OPENED_FILES = 64;
const uint16_t MAX_OPENED_FONT = 64; const uint16_t MAX_OPENED_FONT = 64;
const uint32_t MAX_FONT_BUFFER_SIZE = 512*512*4; 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; m_ownAtlas = false;
init(); 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; m_ownAtlas = true;
init(); init();
} }
@ -463,8 +463,8 @@ void FontManager::init()
uint8_t buffer[4*4*4]; uint8_t buffer[4*4*4];
memset( buffer, 255, 4 * 4 * 4); memset( buffer, 255, 4 * 4 * 4);
m_blackGlyph.width=3; m_blackGlyph.m_width=3;
m_blackGlyph.height=3; m_blackGlyph.m_height=3;
assert( addBitmap(m_blackGlyph, buffer) ); assert( addBitmap(m_blackGlyph, buffer) );
//make sure the black glyph doesn't bleed //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; FILE * pFile;
pFile = fopen (fontPath, "rb"); pFile = fopen (_fontPath, "rb");
if (pFile==NULL) if (pFile==NULL)
{ {
TrueTypeHandle invalid = BGFX_INVALID_HANDLE; TrueTypeHandle invalid = BGFX_INVALID_HANDLE;
@ -544,34 +544,34 @@ TrueTypeHandle FontManager::loadTrueTypeFromFile(const char* fontPath)
return invalid; 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(); uint16_t id = m_filesHandles.alloc();
assert(id != bx::HandleAlloc::invalid); assert(id != bx::HandleAlloc::invalid);
m_cachedFiles[id].buffer = new uint8_t[size]; m_cachedFiles[id].buffer = new uint8_t[_size];
m_cachedFiles[id].bufferSize = size; m_cachedFiles[id].bufferSize = _size;
memcpy(m_cachedFiles[id].buffer, buffer, size); memcpy(m_cachedFiles[id].buffer, _buffer, _size);
//TODO validate font //TODO validate font
TrueTypeHandle ret = {id}; TrueTypeHandle ret = {id};
return ret; return ret;
} }
void FontManager::unloadTrueType(TrueTypeHandle handle) void FontManager::unloadTrueType(TrueTypeHandle _handle)
{ {
assert(bgfx::invalidHandle != handle.idx); assert(bgfx::invalidHandle != _handle.idx);
delete m_cachedFiles[handle.idx].buffer; delete m_cachedFiles[_handle.idx].buffer;
m_cachedFiles[handle.idx].bufferSize = 0; m_cachedFiles[_handle.idx].bufferSize = 0;
m_cachedFiles[handle.idx].buffer = NULL; m_cachedFiles[_handle.idx].buffer = NULL;
m_filesHandles.free(handle.idx); 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(); 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; delete ttf;
FontHandle invalid = BGFX_INVALID_HANDLE; FontHandle invalid = BGFX_INVALID_HANDLE;
@ -581,12 +581,12 @@ FontHandle FontManager::createFontByPixelSize(TrueTypeHandle handle, uint32_t ty
uint16_t fontIdx = m_fontHandles.alloc(); uint16_t fontIdx = m_fontHandles.alloc();
assert(fontIdx != bx::HandleAlloc::invalid); assert(fontIdx != bx::HandleAlloc::invalid);
m_cachedFonts[fontIdx].trueTypeFont = ttf; m_cachedFonts[fontIdx].m_trueTypeFont = ttf;
m_cachedFonts[fontIdx].fontInfo = ttf->getFontInfo(); m_cachedFonts[fontIdx].m_fontInfo = ttf->getFontInfo();
m_cachedFonts[fontIdx].fontInfo.fontType = fontType; m_cachedFonts[fontIdx].m_fontInfo.m_fontType = _fontType;
m_cachedFonts[fontIdx].fontInfo.pixelSize = pixelSize; m_cachedFonts[fontIdx].m_fontInfo.m_pixelSize = _pixelSize;
m_cachedFonts[fontIdx].cachedGlyphs.clear(); m_cachedFonts[fontIdx].m_cachedGlyphs.clear();
m_cachedFonts[fontIdx].masterFontHandle.idx = -1; m_cachedFonts[fontIdx].m_masterFontHandle.idx = -1;
FontHandle ret = {fontIdx}; FontHandle ret = {fontIdx};
return ret; return ret;
} }
@ -595,24 +595,24 @@ FontHandle FontManager::createScaledFontToPixelSize(FontHandle _baseFontHandle,
{ {
assert(bgfx::invalidHandle != _baseFontHandle.idx); assert(bgfx::invalidHandle != _baseFontHandle.idx);
CachedFont& font = m_cachedFonts[_baseFontHandle.idx]; CachedFont& font = m_cachedFonts[_baseFontHandle.idx];
FontInfo& fontInfo = font.fontInfo; FontInfo& fontInfo = font.m_fontInfo;
FontInfo newFontInfo = fontInfo; FontInfo newFontInfo = fontInfo;
newFontInfo.pixelSize = _pixelSize; newFontInfo.m_pixelSize = _pixelSize;
newFontInfo.scale = (float)_pixelSize / (float) fontInfo.pixelSize; newFontInfo.m_scale = (float)_pixelSize / (float) fontInfo.m_pixelSize;
newFontInfo.ascender = (newFontInfo.ascender * newFontInfo.scale); newFontInfo.m_ascender = (newFontInfo.m_ascender * newFontInfo.m_scale);
newFontInfo.descender = (newFontInfo.descender * newFontInfo.scale); newFontInfo.m_descender = (newFontInfo.m_descender * newFontInfo.m_scale);
newFontInfo.lineGap = (newFontInfo.lineGap * newFontInfo.scale); newFontInfo.m_lineGap = (newFontInfo.m_lineGap * newFontInfo.m_scale);
newFontInfo.underline_thickness = (newFontInfo.underline_thickness * newFontInfo.scale); newFontInfo.m_underline_thickness = (newFontInfo.m_underline_thickness * newFontInfo.m_scale);
newFontInfo.underline_position = (newFontInfo.underline_position * newFontInfo.scale); newFontInfo.m_underline_position = (newFontInfo.m_underline_position * newFontInfo.m_scale);
uint16_t fontIdx = m_fontHandles.alloc(); uint16_t fontIdx = m_fontHandles.alloc();
assert(fontIdx != bx::HandleAlloc::invalid); assert(fontIdx != bx::HandleAlloc::invalid);
m_cachedFonts[fontIdx].cachedGlyphs.clear(); m_cachedFonts[fontIdx].m_cachedGlyphs.clear();
m_cachedFonts[fontIdx].fontInfo = newFontInfo; m_cachedFonts[fontIdx].m_fontInfo = newFontInfo;
m_cachedFonts[fontIdx].trueTypeFont = NULL; m_cachedFonts[fontIdx].m_trueTypeFont = NULL;
m_cachedFonts[fontIdx].masterFontHandle = _baseFontHandle; m_cachedFonts[fontIdx].m_masterFontHandle = _baseFontHandle;
FontHandle ret = {fontIdx}; FontHandle ret = {fontIdx};
return ret; return ret;
} }
@ -635,29 +635,29 @@ void FontManager::destroyFont(FontHandle _handle)
{ {
assert(bgfx::invalidHandle != _handle.idx); 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; delete m_cachedFonts[_handle.idx].m_trueTypeFont;
m_cachedFonts[_handle.idx].trueTypeFont = NULL; 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); 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); assert(bgfx::invalidHandle != _handle.idx);
CachedFont& font = m_cachedFonts[handle.idx]; CachedFont& font = m_cachedFonts[_handle.idx];
//if truetype present //if truetype present
if(font.trueTypeFont != NULL) if(font.m_trueTypeFont != NULL)
{ {
//parse string //parse string
for( size_t i=0, end = wcslen(_string) ; i < end; ++i ) for( size_t i=0, end = wcslen(_string) ; i < end; ++i )
{ {
//if glyph cached, continue //if glyph cached, continue
CodePoint_t codePoint = _string[i]; CodePoint_t codePoint = _string[i];
if(!preloadGlyph(handle, codePoint)) if(!preloadGlyph(_handle, codePoint))
{ {
return false; return false;
} }
@ -668,37 +668,37 @@ bool FontManager::preloadGlyph(FontHandle handle, const wchar_t* _string)
return false; return false;
} }
bool FontManager::preloadGlyph(FontHandle handle, CodePoint_t codePoint) bool FontManager::preloadGlyph(FontHandle _handle, CodePoint_t _codePoint)
{ {
assert(bgfx::invalidHandle != handle.idx); assert(bgfx::invalidHandle != _handle.idx);
CachedFont& font = m_cachedFonts[handle.idx]; CachedFont& font = m_cachedFonts[_handle.idx];
FontInfo& fontInfo = font.fontInfo; FontInfo& fontInfo = font.m_fontInfo;
//check if glyph not already present //check if glyph not already present
GlyphHash_t::iterator iter = font.cachedGlyphs.find(codePoint); GlyphHash_t::iterator iter = font.m_cachedGlyphs.find(_codePoint);
if(iter != font.cachedGlyphs.end()) if(iter != font.m_cachedGlyphs.end())
{ {
return true; return true;
} }
//if truetype present //if truetype present
if(font.trueTypeFont != NULL) if(font.m_trueTypeFont != NULL)
{ {
GlyphInfo glyphInfo; GlyphInfo glyphInfo;
//bake glyph as bitmap to buffer //bake glyph as bitmap to buffer
switch(font.fontInfo.fontType) switch(font.m_fontInfo.m_fontType)
{ {
case FONT_TYPE_ALPHA: case FONT_TYPE_ALPHA:
font.trueTypeFont->bakeGlyphAlpha(codePoint, glyphInfo, m_buffer); font.m_trueTypeFont->bakeGlyphAlpha(_codePoint, glyphInfo, m_buffer);
break; break;
//case FONT_TYPE_LCD: //case FONT_TYPE_LCD:
//font.trueTypeFont->bakeGlyphSubpixel(codePoint, glyphInfo, m_buffer); //font.m_trueTypeFont->bakeGlyphSubpixel(codePoint, glyphInfo, m_buffer);
//break; //break;
case FONT_TYPE_DISTANCE: case FONT_TYPE_DISTANCE:
font.trueTypeFont->bakeGlyphDistance(codePoint, glyphInfo, m_buffer); font.m_trueTypeFont->bakeGlyphDistance(_codePoint, glyphInfo, m_buffer);
break; break;
case FONT_TYPE_DISTANCE_SUBPIXEL: case FONT_TYPE_DISTANCE_SUBPIXEL:
font.trueTypeFont->bakeGlyphDistance(codePoint, glyphInfo, m_buffer); font.m_trueTypeFont->bakeGlyphDistance(_codePoint, glyphInfo, m_buffer);
break; break;
default: default:
assert(false && "TextureType not supported yet"); assert(false && "TextureType not supported yet");
@ -710,35 +710,35 @@ bool FontManager::preloadGlyph(FontHandle handle, CodePoint_t codePoint)
return false; return false;
} }
glyphInfo.advance_x = (glyphInfo.advance_x * fontInfo.scale); glyphInfo.m_advance_x = (glyphInfo.m_advance_x * fontInfo.m_scale);
glyphInfo.advance_y = (glyphInfo.advance_y * fontInfo.scale); glyphInfo.m_advance_y = (glyphInfo.m_advance_y * fontInfo.m_scale);
glyphInfo.offset_x = (glyphInfo.offset_x * fontInfo.scale); glyphInfo.m_offset_x = (glyphInfo.m_offset_x * fontInfo.m_scale);
glyphInfo.offset_y = (glyphInfo.offset_y * fontInfo.scale); glyphInfo.m_offset_y = (glyphInfo.m_offset_y * fontInfo.m_scale);
glyphInfo.height = (glyphInfo.height * fontInfo.scale); glyphInfo.m_height = (glyphInfo.m_height * fontInfo.m_scale);
glyphInfo.width = (glyphInfo.width * fontInfo.scale); glyphInfo.m_width = (glyphInfo.m_width * fontInfo.m_scale);
// store cached glyph // store cached glyph
font.cachedGlyphs[codePoint] = glyphInfo; font.m_cachedGlyphs[_codePoint] = glyphInfo;
return true; return true;
}else }else
{ {
//retrieve glyph from parent font if any //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; GlyphInfo glyphInfo;
getGlyphInfo(font.masterFontHandle, codePoint, glyphInfo); getGlyphInfo(font.m_masterFontHandle, _codePoint, glyphInfo);
glyphInfo.advance_x = (glyphInfo.advance_x * fontInfo.scale); glyphInfo.m_advance_x = (glyphInfo.m_advance_x * fontInfo.m_scale);
glyphInfo.advance_y = (glyphInfo.advance_y * fontInfo.scale); glyphInfo.m_advance_y = (glyphInfo.m_advance_y * fontInfo.m_scale);
glyphInfo.offset_x = (glyphInfo.offset_x * fontInfo.scale); glyphInfo.m_offset_x = (glyphInfo.m_offset_x * fontInfo.m_scale);
glyphInfo.offset_y = (glyphInfo.offset_y * fontInfo.scale); glyphInfo.m_offset_y = (glyphInfo.m_offset_y * fontInfo.m_scale);
glyphInfo.height = (glyphInfo.height * fontInfo.scale); glyphInfo.m_height = (glyphInfo.m_height * fontInfo.m_scale);
glyphInfo.width = (glyphInfo.width * fontInfo.scale); glyphInfo.m_width = (glyphInfo.m_width * fontInfo.m_scale);
// store cached glyph // store cached glyph
font.cachedGlyphs[codePoint] = glyphInfo; font.m_cachedGlyphs[_codePoint] = glyphInfo;
return true; return true;
} }
} }
@ -747,34 +747,34 @@ bool FontManager::preloadGlyph(FontHandle handle, CodePoint_t codePoint)
return false; return false;
} }
const FontInfo& FontManager::getFontInfo(FontHandle handle) const FontInfo& FontManager::getFontInfo(FontHandle _handle)
{ {
assert(handle.idx != bgfx::invalidHandle); assert(_handle.idx != bgfx::invalidHandle);
return m_cachedFonts[handle.idx].fontInfo; 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); GlyphHash_t::iterator iter = m_cachedFonts[_handle.idx].m_cachedGlyphs.find(_codePoint);
if(iter == m_cachedFonts[fontHandle.idx].cachedGlyphs.end()) 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 }else
{ {
return false; return false;
} }
} }
outInfo = iter->second; _outInfo = iter->second;
return true; 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; return true;
} }

66
examples/common/font/font_manager.h
View file

@ -18,23 +18,23 @@ enum FontType
struct FontInfo struct FontInfo
{ {
//the font height in pixel //the font height in pixel
uint16_t pixelSize; uint16_t m_pixelSize;
/// Rendering type used for the font /// Rendering type used for the font
int16_t fontType; int16_t m_fontType;
/// The pixel extents above the baseline in pixels (typically positive) /// The pixel extents above the baseline in pixels (typically positive)
float ascender; float m_ascender;
/// The extents below the baseline in pixels (typically negative) /// 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 /// 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 /// 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 /// The position of the underline relatively to the baseline
float underline_position; float m_underline_position;
//scale to apply to glyph data //scale to apply to glyph data
float scale; float m_scale;
}; };
// Glyph metrics: // Glyph metrics:
@ -75,34 +75,34 @@ typedef int32_t CodePoint_t;
struct GlyphInfo struct GlyphInfo
{ {
/// Index for faster retrieval /// Index for faster retrieval
int32_t glyphIndex; int32_t m_glyphIndex;
/// Glyph's width in pixels. /// Glyph's width in pixels.
float width; float m_width;
/// Glyph's height in pixels. /// Glyph's height in pixels.
float height; float m_height;
/// Glyph's left offset in pixels /// Glyph's left offset in pixels
float offset_x; float m_offset_x;
/// Glyph's top offset in pixels /// Glyph's top offset in pixels
/// Remember that this is the distance from the baseline to the top-most /// Remember that this is the distance from the baseline to the top-most
/// glyph scan line, upwards y coordinates being positive. /// 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 /// 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. /// 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 /// 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. /// 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 /// region index in the atlas storing textures
uint16_t regionIndex; uint16_t m_regionIndex;
///32 bits alignment ///32 bits alignment
int16_t padding; int16_t m_padding;
}; };
BGFX_HANDLE(TrueTypeHandle); BGFX_HANDLE(TrueTypeHandle);
@ -112,9 +112,9 @@ class FontManager
{ {
public: public:
/// create the font manager using an external cube atlas (doesn't take ownership of the atlas) /// 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 /// 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(); ~FontManager();
@ -123,29 +123,29 @@ public:
/// load a TrueType font from a file path /// load a TrueType font from a file path
/// @return invalid handle if the loading fail /// @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. /// load a TrueType font from a given buffer.
/// the buffer is copied and thus can be freed or reused after this call /// the buffer is copied and thus can be freed or reused after this call
/// @return invalid handle if the loading fail /// @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 /// 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 /// 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 /// 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) /// load a baked font (the set of glyph is fixed)
/// @return INVALID_HANDLE if the loading fail /// @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) /// load a baked font (the set of glyph is fixed)
/// @return INVALID_HANDLE if the loading fail /// @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) /// destroy a font (truetype or baked)
void destroyFont(FontHandle _handle); void destroyFont(FontHandle _handle);
@ -153,23 +153,23 @@ public:
/// Preload a set of glyphs from a TrueType file /// Preload a set of glyphs from a TrueType file
/// @return true if every glyph could be preloaded, false otherwise /// @return true if every glyph could be preloaded, false otherwise
/// if the Font is a baked font, this only do validation on the characters /// 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 /// 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) /// bake a font to disk (the set of preloaded glyph)
/// @return true if the baking succeed, false otherwise /// @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 /// return the font descriptor of a font
/// @remark the handle is required to be valid /// @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 /// Return the rendering informations about the glyph region
/// Load the glyph from a TrueType font if possible /// Load the glyph from a TrueType font if possible
/// @return true if the Glyph is available /// @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; } GlyphInfo& getBlackGlyph(){ return m_blackGlyph; }
@ -184,10 +184,10 @@ private:
}; };
void init(); void init();
bool addBitmap(GlyphInfo& glyphInfo, const uint8_t* data); bool addBitmap(GlyphInfo& _glyphInfo, const uint8_t* _data);
bool m_ownAtlas; bool m_ownAtlas;
(Atlas* m_atlas; Atlas* m_atlas;
bx::HandleAlloc m_fontHandles; bx::HandleAlloc m_fontHandles;
CachedFont* m_cachedFonts; CachedFont* m_cachedFonts;