自学教程：C++ FT_Render_Glyph函数代码示例

	void FontBuilder::CacheSymbol(wchar_t s)	{		CacheData* data = wcache[curSize][curFace][s];		if (!data)		{			FT_UInt glyphIndex = FT_Get_Char_Index(curFace, s);			FT_Error error = FT_Load_Glyph(curFace, glyphIndex, 0);			if (error)				out_error() << L"Error occured while loading a glyph" << std::endl;			if (curFace->glyph->format != FT_GLYPH_FORMAT_BITMAP)			{				error = FT_Render_Glyph(curFace->glyph, FT_RENDER_MODE_NORMAL);				if (error)					out_error() << L"Error occured while rendering a glyph" << std::endl;			}					FT_GlyphSlot slot = curFace->glyph;			data = new CacheData;			data->width = slot->bitmap.width;			data->height = slot->bitmap.rows;			if (data->width*data->height > 0)			{				data->buffer = new unsigned char[data->width*data->height];				memcpy(data->buffer, slot->bitmap.buffer, data->width*data->height);			}			data->x_offset = slot->bitmap_left;			data->y_offset = slot->bitmap_top;			data->x_advance = slot->advance.x >> 6;			data->y_advance = slot->advance.y >> 6;			wcache[curSize][curFace][s] = data;		}

const bitmap* freetype::get_bitmap(unsigned int char_code) const{    implement::cache& cache = impl_->get_cache();    if (cache.find(char_code) != cache.end())        return &cache[char_code];    FT_GlyphSlot glyph = impl_->load_glyph(char_code);    if (!glyph || 0 != FT_Render_Glyph(glyph, impl_->property_.render_mode))        return nullptr;    bitmap* bitmap = &cache[char_code];    unsigned int buffer_length = glyph->bitmap.rows * glyph->bitmap.pitch;    bitmap->left       = glyph->bitmap_left;    bitmap->top        = glyph->bitmap_top - ascender();    bitmap->width      = glyph->bitmap.width;    bitmap->height     = glyph->bitmap.rows;    bitmap->advance    = REAL(glyph->linearHoriAdvance, 16);    bitmap->pitch      = glyph->bitmap.pitch;    bitmap->pixel_mode = glyph->bitmap.pixel_mode;    bitmap->buffer     = reinterpret_cast<unsigned char*>(                                memcpy(new unsigned char [buffer_length],                                       glyph->bitmap.buffer,                                       buffer_length));    return bitmap;}

	void loadchar(unsigned int uc) {		FT_Bitmap* bitmap;		unsigned int index;		ubyte *Tex, *Texsrc;		int wid = (int)pow(2, ceil(log2(32 * stretch)));		index = FT_Get_Char_Index(fontface, uc);		FT_Load_Glyph(fontface, index, FT_LOAD_DEFAULT);		FT_Render_Glyph(slot, FT_RENDER_MODE_NORMAL);		bitmap = &(slot->bitmap);		Texsrc = bitmap->buffer;		Tex = new ubyte[wid * wid * 4];		memset(Tex, 0, wid * wid * 4 * sizeof(ubyte));		for (unsigned int i = 0; i < bitmap->rows; i++) {			for (unsigned int j = 0; j < bitmap->width; j++) {				Tex[(i * wid + j) * 4 + 0] = Tex[(i * wid + j) * 4 + 1] = Tex[(i * wid + j) * 4 + 2] = 255U;				Tex[(i * wid + j) * 4 + 3] = *Texsrc; Texsrc++;			}		}		glGenTextures(1, &chars[uc].tex);		glBindTexture(GL_TEXTURE_2D, chars[uc].tex);		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, wid, wid, 0, GL_RGBA, GL_UNSIGNED_BYTE, Tex);		delete[] Tex;		chars[uc].aval = true;		chars[uc].width = bitmap->width;		chars[uc].height = bitmap->rows;		chars[uc].advance = slot->advance.x >> 6;		chars[uc].xpos = slot->bitmap_left;		chars[uc].ypos = slot->bitmap_top;	}

euint32 FontRenderer::draw_letter(wchar_t _letter, vptr _target, euint32 _width){	FT_GlyphSlot slot = m_ft_face->glyph;	FT_UInt glyph_index;	FT_UInt error;	glyph_index = FT_Get_Char_Index( m_ft_face, _letter );	error = FT_Load_Glyph( m_ft_face, glyph_index, FT_LOAD_DEFAULT );	if ( error )	{		return 0;	}	/// 加粗函数 FT_Outline_Embolden( &m_ft_face->glyph->outline, 100 );	error = FT_Render_Glyph( m_ft_face->glyph, FT_RENDER_MODE_NORMAL );	if ( error )	{		return 0;	}	return draw_text( &slot->bitmap, _target, 0, 0, _width);}

Glyph Font::renderGlyph(char glyph, float font_size){    if(m_rendered_symbols[(int)glyph].find(font_size) != m_rendered_symbols[(int)glyph].end()) {        return m_rendered_symbols[(int)glyph].at(font_size);    }    Glyph new_glyph;    FT_UInt char_index = FT_Get_Char_Index(m_font_face, glyph);    if(FT_Load_Glyph(m_font_face, char_index, FT_LOAD_DEFAULT) || FT_Render_Glyph(m_font_face->glyph, FT_RENDER_MODE_NORMAL))        return new_glyph;    FT_Bitmap& bitmap   = m_font_face->glyph->bitmap;    new_glyph.bearing.x = m_font_face->glyph->metrics.horiBearingX / 64;    new_glyph.bearing.y = m_font_face->glyph->metrics.horiBearingY / 128;    new_glyph.advance   = m_font_face->glyph->metrics.horiAdvance / 64;    glGenTextures(1, &new_glyph.texture);    glBindTexture(GL_TEXTURE_2D, new_glyph.texture);    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);    checkGLError();    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, bitmap.width, bitmap.rows, 0, GL_RED, GL_UNSIGNED_BYTE, bitmap.buffer);    checkGLError();    new_glyph.id = glyph;    new_glyph.dimensions = glm::vec2(bitmap.width, bitmap.rows);    m_rendered_symbols[(int)glyph][font_size] = new_glyph;    return new_glyph;}

static void draw_text(FT_Face face, FT_Vector * pen, FT_Matrix * matrix,		      const unsigned char *out, int len, int color,		      struct rectangle *box){    FT_ULong ch;    FT_Error ans;    FT_GlyphSlot slot = face->glyph;    int i;    for (i = 0; i < len; i += 2) {	ch = (out[i] << 8) | out[i + 1];	if (ch == 10)	    continue;	/* transform */	FT_Set_Transform(face, matrix, pen);	/* get glyph image */	ans = FT_Load_Char(face, ch, FT_LOAD_NO_BITMAP);	if (ans)	    continue;	ans = FT_Render_Glyph(face->glyph, ft_render_mode_normal);	if (ans)	    continue;	/* draw bitmap */	if (!box)	    draw_bitmap(&slot->bitmap, slot->bitmap_left,			screen_height - slot->bitmap_top);	else	    set_text_box(&slot->bitmap, slot->bitmap_left,			 screen_height - slot->bitmap_top, box);	/* increment pen position */	pen->x += slot->advance.x;	pen->y += slot->advance.y;    }}

/** * Caches the given font glyph in the instance font texture buffer. * * This routine renders and stores the requested glyph's bitmap and relevant information into its own quickly addressible * structure within an instance-specific map. * * @param charCode	The requested glyph's character code. * @return A pointer to the allocated font structure. */ftgxCharData *FreeTypeGX::cacheGlyphData(wchar_t charCode){	FT_UInt gIndex;	uint16_t textureWidth = 0, textureHeight = 0;	gIndex = FT_Get_Char_Index( ftFace, charCode );	if (!FT_Load_Glyph(ftFace, gIndex, FT_LOAD_DEFAULT )) {		FT_Render_Glyph( ftSlot, FT_RENDER_MODE_NORMAL );		if(ftSlot->format == FT_GLYPH_FORMAT_BITMAP) {			FT_Bitmap *glyphBitmap = &ftSlot->bitmap;			textureWidth = adjustTextureWidth(glyphBitmap->width, this->textureFormat);			textureHeight = adjustTextureHeight(glyphBitmap->rows, this->textureFormat);			this->fontData[charCode] = (ftgxCharData){				ftSlot->bitmap_left,				ftSlot->advance.x >> 6,				gIndex,				textureWidth,				textureHeight,				ftSlot->bitmap_top,				ftSlot->bitmap_top,				glyphBitmap->rows - ftSlot->bitmap_top,				NULL			};			this->loadGlyphData(glyphBitmap, &this->fontData[charCode]);			return &this->fontData[charCode];		}

void		Freetype::drawText(const char *txt, unsigned int x, unsigned int y){	int	error;	while (*txt) {		FT_UInt  glyph_index;		glyph_index = FT_Get_Char_Index(_face, *txt);		if ((error = FT_Load_Glyph(_face, glyph_index, FT_LOAD_DEFAULT)))			continue;		if ((error = FT_Render_Glyph(_face->glyph, FT_RENDER_MODE_NORMAL)))			continue;		my_draw_bitmap(&_slot->bitmap,				x + _slot->bitmap_left,				y - _slot->bitmap_top, _slot, _size);		x += _slot->advance.x >> 6;		y += _slot->advance.y >> 6;		x += _padding;		txt++;	}}

BitmapRef FTFont::Glyph(char32_t glyph) {	if(!check_face()) {		return Font::Default()->Glyph(glyph);	}	if (FT_Load_Char(face_.get(), glyph, FT_LOAD_NO_BITMAP) != FT_Err_Ok) {		Output::Error("Couldn't load FreeType character %d", glyph);	}    if (FT_Render_Glyph(face_->glyph, FT_RENDER_MODE_MONO) != FT_Err_Ok) {		Output::Error("Couldn't render FreeType character %d", glyph);	}	FT_Bitmap const& ft_bitmap = face_->glyph->bitmap;	assert(face_->glyph->bitmap.pixel_mode == FT_PIXEL_MODE_MONO);	size_t const pitch = std::abs(ft_bitmap.pitch);	int const width = ft_bitmap.width;	int const height = ft_bitmap.rows;	BitmapRef bm = Bitmap::Create(nullptr, width, height, 0, DynamicFormat(8,8,0,8,0,8,0,8,0,PF::Alpha));	uint8_t* data = reinterpret_cast<uint8_t*>(bm->pixels());	int dst_pitch = bm->pitch();	for(int row = 0; row < height; ++row) {		for(int col = 0; col < width; ++col) {			unsigned c = ft_bitmap.buffer[pitch * row + (col/8)];			unsigned bit = 7 - (col%8);			data[row * dst_pitch + col] = (c & (0x01 << bit)) ? 255 : 0;		}	}	return bm;}

//-------------------------------------------------------------------------------------------------------StringManager::BChar* StringManager::_LoadChar(wchar_t wchar){    //参考http://my.unix-center.net/~Simon_fu/?p=385    bool space = false;    if( L' ' == wchar )    {        space = true;        wchar = L'_';    }    FT_Load_Glyph(m_FT_Face,  FT_Get_Char_Index( m_FT_Face, wchar ), FT_LOAD_DEFAULT);//FT_LOAD_FORCE_AUTOHINT| FT_LOAD_TARGET_NORMAL);    //得到字模    FT_Glyph glyph;    FT_Get_Glyph( m_FT_Face->glyph, &glyph );    //转化成位图    FT_Render_Glyph( m_FT_Face->glyph,   FT_RENDER_MODE_LCD );    FT_Glyph_To_Bitmap( &glyph, ft_render_mode_normal, 0, 1 );    FT_BitmapGlyph bitmap_glyph = (FT_BitmapGlyph)glyph;    //取道位图数据    FT_Bitmap& bitmap=bitmap_glyph->bitmap;    //重新计算数据    float scale = static_cast<float>(bitmap.rows) / static_cast<float>(m_FT_Face->glyph->metrics.height);//计算文本高宽缩放到bitmap高宽的缩放比    int beginY =  Math::Ceil( m_FT_Face->glyph->metrics.horiBearingY * scale );//y偏移    //FT_Done_Glyph(glyph);    vector2d size = vector2d(bitmap.width, bitmap.rows);    return NEW BChar(beginY, size, glyph, space);}

	RasterizedGlyph get(uint32_t codePoint, Vector2i subpixeloffset64)	{		FT_Error error = FT_Load_Glyph(m_face,			codePoint, // the glyph_index in the font file			FT_LOAD_NO_HINTING // by default hb load fonts without hinting		);		if (error != FT_Err_Ok)		{			debug(LOG_FATAL, "unable to load glyph");		}		FT_GlyphSlot slot = m_face->glyph;		FT_Render_Glyph(m_face->glyph, FT_RENDER_MODE_LCD);		FT_Bitmap ftBitmap = slot->bitmap;		RasterizedGlyph g;		g.buffer.reset(new unsigned char[ftBitmap.pitch * ftBitmap.rows]);		memcpy(g.buffer.get(), ftBitmap.buffer, ftBitmap.pitch * ftBitmap.rows);		g.width = ftBitmap.width / 3;		g.height = ftBitmap.rows;		g.bearing_x = slot->bitmap_left;		g.bearing_y = slot->bitmap_top;		g.pitch = ftBitmap.pitch;		return g;	}

  static void  TestFace( FT_Face  face )  {    unsigned int  gid;    int           load_flags = FT_LOAD_DEFAULT;    if ( check_outlines         &&         FT_IS_SCALABLE( face ) )      load_flags = FT_LOAD_NO_BITMAP;    if ( nohints )      load_flags |= FT_LOAD_NO_HINTING;    FT_Set_Char_Size( face, 0, font_size, 72, 72 );    for ( gid = 0; gid < face->num_glyphs; gid++ )    {      if ( check_outlines         &&           FT_IS_SCALABLE( face ) )      {        if ( !FT_Load_Glyph( face, gid, load_flags ) )          FT_Outline_Decompose( &face->glyph->outline, &outlinefuncs, NULL );      }      else        FT_Load_Glyph( face, gid, load_flags );      if ( rasterize )        FT_Render_Glyph( face->glyph, ft_render_mode_normal );    }    FT_Done_Face( face );  }

FTTextureGlyph::FTTextureGlyph (FT_GlyphSlot glyph, int id, int xOffset,								int yOffset, GLsizei width, GLsizei height)	: FTGlyph (glyph), destWidth(0), destHeight(0), glTextureID(id) {	err = FT_Render_Glyph (glyph, FT_RENDER_MODE_NORMAL);	if (err || glyph->format != ft_glyph_format_bitmap) return;		FT_Bitmap bitmap = glyph->bitmap;	destWidth  = bitmap.width;	destHeight = bitmap.rows;		if (destWidth && destHeight) {#ifndef USE_GLES1		glPushClientAttrib (GL_CLIENT_PIXEL_STORE_BIT);		glPixelStorei (GL_UNPACK_LSB_FIRST, GL_FALSE);		glPixelStorei (GL_UNPACK_ROW_LENGTH, 0);#endif		glPixelStorei (GL_UNPACK_ALIGNMENT, 1);				glBindTexture (GL_TEXTURE_2D, glTextureID);		glTexSubImage2D (GL_TEXTURE_2D, 0, xOffset, yOffset,						 destWidth, destHeight, GL_ALPHA, GL_UNSIGNED_BYTE, bitmap.buffer);		#ifndef USE_GLES1		glPopClientAttrib();#endif	}	uv[0].X (static_cast<float>(xOffset) / static_cast<float>(width));	uv[0].Y (static_cast<float>(yOffset) / static_cast<float>(height));	uv[1].X (static_cast<float> (xOffset + destWidth) / static_cast<float>(width));	uv[1].Y (static_cast<float> (yOffset + destHeight) / static_cast<float>(height));	pos.X (glyph->bitmap_left);	pos.Y (glyph->bitmap_top);}

int glyphinfo(FT_Face face, FT_ULong ul){    FT_UInt glyph_index;    FT_GlyphSlot slot = face->glyph;    int error;    glyph_index = FT_Get_Char_Index(face, ul);    error = FT_Load_Glyph( face, /* handle to face object */                           glyph_index, /* glyph index */                           FT_LOAD_DEFAULT ); /* load flags, see below */    if ( error )    {        printf("FT_Load_Glyph() failed: %d (0x%08X)/n", error, error);        return -1;    }     error = FT_Render_Glyph( face->glyph, FT_RENDER_MODE_NORMAL );     if ( error )     {         printf("FT_Render_Glyph() failed: %d (0x%08X)/n", error, error);         return -1;     }     if (face->glyph->advance.x <= HALF_WIDTH_MAX)     {         return HALF_WIDTH;     }     else     {         return DOUBLE_WIDTH;     }}

void FreeTypeFont::doFillGlyphCache(GlyphCache& cache, const std::vector<char32_t>& characters)#endif{    /** @bug Crash when atlas is too small */    /* Get glyph codes from characters */    std::vector<FT_UInt> charIndices;    charIndices.resize(characters.size()+1);    charIndices[0] = 0;    std::transform(characters.begin(), characters.end(), charIndices.begin()+1,        [this](const char32_t c) { return FT_Get_Char_Index(ftFont, c); });    /* Remove duplicates (e.g. uppercase and lowercase mapped to same glyph) */    std::sort(charIndices.begin(), charIndices.end());    charIndices.erase(std::unique(charIndices.begin(), charIndices.end()), charIndices.end());    /* Sizes of all characters */    std::vector<Vector2i> charSizes;    charSizes.reserve(charIndices.size());    for(FT_UInt c: charIndices) {        CORRADE_INTERNAL_ASSERT_OUTPUT(FT_Load_Glyph(ftFont, c, FT_LOAD_DEFAULT) == 0);        charSizes.push_back(Vector2i(ftFont->glyph->metrics.width, ftFont->glyph->metrics.height)/64);    }    /* Create texture atlas */    const std::vector<Rectanglei> charPositions = cache.reserve(charSizes);    /* Render all characters to the atlas and create character map */    unsigned char* pixmap = new unsigned char[cache.textureSize().product()]();    /** @todo Some better way for this */    #ifndef MAGNUM_TARGET_GLES2    Image2D image(ImageFormat::Red, ImageType::UnsignedByte, cache.textureSize(), pixmap);    #else    Image2D image(Context::current() && Context::current()->isExtensionSupported<Extensions::GL::EXT::texture_rg>() ?        ImageFormat::Red : ImageFormat::Luminance, ImageType::UnsignedByte, cache.textureSize(), pixmap);    #endif    for(std::size_t i = 0; i != charPositions.size(); ++i) {        /* Load and render glyph */        /** @todo B&W only if radius != 0 */        FT_GlyphSlot glyph = ftFont->glyph;        CORRADE_INTERNAL_ASSERT_OUTPUT(FT_Load_Glyph(ftFont, charIndices[i], FT_LOAD_DEFAULT) == 0);        CORRADE_INTERNAL_ASSERT_OUTPUT(FT_Render_Glyph(glyph, FT_RENDER_MODE_NORMAL) == 0);        /* Copy rendered bitmap to texture image */        const FT_Bitmap& bitmap = glyph->bitmap;        CORRADE_INTERNAL_ASSERT(std::abs(bitmap.width-charPositions[i].width()) <= 2);        CORRADE_INTERNAL_ASSERT(std::abs(bitmap.rows-charPositions[i].height()) <= 2);        for(Int yin = 0, yout = charPositions[i].bottom(), ymax = bitmap.rows; yin != ymax; ++yin, ++yout)            for(Int xin = 0, xout = charPositions[i].left(), xmax = bitmap.width; xin != xmax; ++xin, ++xout)                pixmap[yout*cache.textureSize().x() + xout] = bitmap.buffer[(bitmap.rows-yin-1)*bitmap.width + xin];        /* Insert glyph parameters into cache */        cache.insert(charIndices[i],            Vector2i(glyph->bitmap_left, glyph->bitmap_top-charPositions[i].height()),            charPositions[i]);    }    /* Set cache image */    cache.setImage({}, image);}

void FTFont::Render(Bitmap& bmp, int const x, int const y, Color const& color, unsigned const glyph) {	if(!check_face()) {		Font::Default()->Render(bmp, x, y, color, glyph);		return;	}	if (FT_Load_Char(face_.get(), glyph, FT_LOAD_NO_BITMAP) != FT_Err_Ok) {		Output::Error("Couldn't load FreeType character %d/n", glyph);		return;	}    if (FT_Render_Glyph(face_->glyph, FT_RENDER_MODE_MONO) != FT_Err_Ok) {		Output::Error("Couldn't render FreeType character %d/n", glyph);		return;	}	FT_Bitmap const& ft_bitmap = face_->glyph->bitmap;	assert(face_->glyph->bitmap.pixel_mode == FT_PIXEL_MODE_MONO);	size_t const pitch = std::abs(ft_bitmap.pitch);	for(int row = 0; row < ft_bitmap.rows; ++row) {		for(size_t col = 0; col < pitch; ++col) {			unsigned c = ft_bitmap.buffer[pitch * row + col];			for(int bit = 7; bit >= 0; --bit) {				if(c & (0x01 << bit)) {					bmp.SetPixel(x + col * 8 + (7 - bit), y + row, color);				}			}		}	}}

void renderString(SDL_Surface *screen, char *glyphs, int x, int y){	int error;	int c;	int cx = x;	int cy = y;	for(c = 0;c<strlen(glyphs);c++)	{		if(glyphs[c] == '/n')		{			cy+=60;			cx = x;			continue;		}	   int glyph_index = FT_Get_Char_Index( face, glyphs[c]);	   error = FT_Load_Glyph( face, glyph_index, 0 ); // Load 'A' glyph with default parameters (0)	   if(error)	   {			continue;	   }		   error = FT_Render_Glyph( face->glyph, FT_RENDER_MODE_NORMAL ); // Can haz bitmap?		   if(error)	   {			continue;	   }			int i, j;		for(i = 0; i<face->glyph->bitmap.rows;i++)			for(j = 0;j<face->glyph->bitmap.width;j++)				put_pixel(screen,face->glyph->bitmap.buffer[i*face->glyph->bitmap.pitch+j],cx+j,cy+i+(32-face->glyph->bitmap.rows));		cx += face->glyph->bitmap.width+5;		}}

int FreeType::plotGlyph(GlyphDescr* f, Glyph* g){    unsigned int glyphIndex = FT_Get_Char_Index(m_face, f->c);    int r = FT_Load_Glyph(m_face, glyphIndex, FT_LOAD_DEFAULT);    if (r) {        clc::Log::error(LOG_NAME, "FT_Load_Glyph failed: %d", r);        return -1;    }    if (m_face->glyph->format != FT_GLYPH_FORMAT_BITMAP) {        r = FT_Render_Glyph(m_face->glyph, FT_RENDER_MODE_NORMAL);        if (r) {            clc::Log::error(LOG_NAME, "FT_Render_Glyph failed: %d", r);            return -1;        }    }    FT_GlyphSlot slot = m_face->glyph;    g->w = slot->bitmap.width;    g->h = slot->bitmap.rows;    g->bitmap = new uint8_t[g->w * g->h];    memcpy(g->bitmap, slot->bitmap.buffer, g->w * g->h);    g->offsetX = slot->bitmap_left;    g->offsetY = slot->bitmap_top;    g->advanceX = slot->advance.x >> 6;    g->advanceY = slot->advance.y >> 6;    g->height = m_face->size->metrics.height >> 6;    return 0;}

cv::Mat SampleGenetator::genSample(const wchar_t wc, const uchar bgColor, const uchar fgColor){	cv::Mat result;    FT_UInt glyph_index = FT_Get_Char_Index(face, wc);    FT_Load_Glyph(face, glyph_index, FT_LOAD_DEFAULT);	FT_Render_Glyph(face->glyph, FT_RENDER_MODE_NORMAL);    FT_GlyphSlot slot = face->glyph;    int rows = slot->bitmap.rows;    int cols = slot->bitmap.width;	result = cv::Mat(rows, cols, CV_8UC1);	result.setTo(bgColor);    for (int row = 0; row < rows; ++row) 	{        for (int col = 0; col < cols; ++col) 		{            const int offset = row  * slot->bitmap.pitch + col;            if (slot->bitmap.buffer[offset]) 			{				result.at<uchar>(row, col) = fgColor;            }        }    }	return result;}

FontPixelBuffer FontEngine_Freetype::get_font_glyph_subpixel(int glyph){	FontPixelBuffer font_buffer;	FT_GlyphSlot slot = face->glyph;	FT_UInt glyph_index;	// Get glyph index	glyph_index = FT_Get_Char_Index(face, glyph);	FT_Error error;	error = FT_Load_Glyph(face, glyph_index, FT_LOAD_TARGET_LCD );	if (error) return font_buffer;	error = FT_Render_Glyph( face->glyph, FT_RENDER_MODE_LCD);	font_buffer.glyph = glyph;	// Set Increment pen position	font_buffer.increment.x = (slot->advance.x+32) >> 6;	font_buffer.increment.y = (slot->advance.y+32) >> 6;	if (error || slot->bitmap.rows == 0 || slot->bitmap.width == 0)		return font_buffer;	// Set destination offset	font_buffer.offset.x = slot->bitmap_left;	font_buffer.offset.y = -slot->bitmap_top;	int src_width = slot->bitmap.width;	int src_height = slot->bitmap.rows;	int src_pitch = slot->bitmap.pitch;	// Convert the bitmap	PixelBuffer pixelbuffer(src_width/3, src_height, tf_rgba8);	font_buffer.buffer = pixelbuffer;	font_buffer.buffer_rect = pixelbuffer.get_size();	font_buffer.empty_buffer = false;	unsigned char *src_data = slot->bitmap.buffer;	unsigned char *pixel_data = (unsigned char *) font_buffer.buffer.get_data();	int dest_pitch = font_buffer.buffer.get_pitch();	// For 8bit bitmaps	for (int ycnt = 0; ycnt < src_height; ycnt++)	{		unsigned char *dest_data = pixel_data;		for (int xcnt = 0; xcnt < src_width/3; xcnt++)		{			*(dest_data++)= src_data[xcnt*3+2];			*(dest_data++)= src_data[xcnt*3+1];			*(dest_data++)= src_data[xcnt*3+0];			*(dest_data++)= 0;		}		pixel_data += dest_pitch;		src_data += src_pitch;	}	return font_buffer;}

void draw_string(gfx_context_t * ctx, int x, int y, uint32_t fg, char * string) {	slot = face->glyph;	int pen_x = x, pen_y = y, i = 0;	int len = strlen(string);	int error;	for (i = 0; i < len; ++i) {		FT_UInt glyph_index;		glyph_index = FT_Get_Char_Index( face, string[i]);		error = FT_Load_Glyph(face, glyph_index, FT_LOAD_DEFAULT);		if (error) {			printf("Error loading glyph for '%c'/n", string[i]);			continue;		}		slot = (face)->glyph;		if (slot->format == FT_GLYPH_FORMAT_OUTLINE) {			error = FT_Render_Glyph((face)->glyph, FT_RENDER_MODE_NORMAL);			if (error) {				printf("Error rendering glyph for '%c'/n", string[i]);				continue;			}		}		draw_char(&slot->bitmap, pen_x + slot->bitmap_left, pen_y - slot->bitmap_top, fg, ctx);		pen_x += slot->advance.x >> 6;		pen_y += slot->advance.y >> 6;	}}

TTF_Font* TTF_New_Memory_Face(const FT_Byte* file_base, FT_Long file_size, int ptsize)	{	TTF_Font *font = (TTF_Font*)malloc(sizeof *font);	if (font == NULL)		E_Exit("TTF: Out of memory");	memset(font, 0, sizeof(*font));	if (FT_New_Memory_Face(library, file_base, file_size, 0, &font->face))		E_Exit("TTF: Couldn't init font");	FT_Face face = font->face;	if (!FT_IS_SCALABLE(face))														// Make sure that our font face is scalable (global metrics)		E_Exit("TTF: Font is not scalable");	for (int i = 0; i < face->num_charmaps; i++)									// Set charmap for loaded font		{		FT_CharMap charmap = face->charmaps[i];		if (charmap->platform_id == 3 && charmap->encoding_id == 1)					// Windows Unicode			{			FT_Set_Charmap(face, charmap);			break;			}		} 	TTF_SetCharSize(font, ptsize);	bool fontOK = false;	if (!FT_Load_Glyph(face, 0, FT_LOAD_DEFAULT))									// Test pixel mode		if (!FT_Render_Glyph(font->face->glyph, FT_RENDER_MODE_NORMAL))				// Render the glyph			if (font->face->glyph->bitmap.pixel_mode == FT_PIXEL_MODE_GRAY)				fontOK = true;	if (!fontOK)		E_Exit("TTF: Font is not 8 bits gray scale");	return font;	}

static c_glyph* LoadGlyph(TTF_Font* font, Uint8 ch)	{	c_glyph* cached = &font->cache[ch];	if (cached->pixmap.buffer)														// If already cached		return cached;	FT_Face face = font->face;	if (FT_Load_Glyph(face, FT_Get_Char_Index(face, cpMap[ch]), FT_LOAD_NO_AUTOHINT))		return 0;	FT_GlyphSlot glyph = face->glyph;	FT_Glyph_Metrics* metrics = &glyph->metrics;	cached->minx = FT_FLOOR(metrics->horiBearingX);	cached->maxx = FT_CEIL(metrics->horiBearingX+metrics->width);	cached->maxy = FT_FLOOR(metrics->horiBearingY);	cached->miny = cached->maxy-FT_CEIL(metrics->height);	cached->yoffset = font->ascent-cached->maxy;	if (FT_Render_Glyph(glyph, FT_RENDER_MODE_NORMAL))								// Render the glyph		return 0;	FT_Bitmap* src = &glyph->bitmap;												// Copy information to cache	FT_Bitmap* dst = &cached->pixmap;	memcpy(dst, src, sizeof(*dst));	if (dst->rows != 0)		{		int len = dst->pitch*dst->rows;		dst->buffer = (unsigned char *)malloc(len);		if (!dst->buffer)			return 0;		memcpy(dst->buffer, src->buffer, len);		}	return cached;	}

	Bitmap FreetypeFontProvider::GetGlyphBitmap(wchar_t code)	{		unsigned int index = 0;		int rc = 0;		if ( FontProvider::HasGlyph(code) || (index = FT_Get_Char_Index(m_font_face, code)) == 0 )		{			return FontProvider::GetGlyphBitmap(code);		}				if ( FT_Load_Glyph(m_font_face, index, /*m_render_mode == FT_RENDER_MODE_MONO? 0:*/ FT_LOAD_FORCE_AUTOHINT) )		{			throw std::runtime_error("[FreetypeFontProvider::GetGlyphBitmap] Can't load character glyph");		}		if ( m_font_face->glyph->format != FT_GLYPH_FORMAT_BITMAP )		{			FT_Render_Mode render_mode = m_render_mode;			if ( (rc = FT_Render_Glyph(m_font_face->glyph, render_mode)) != 0 )			{				//ShowMessageBox(to_string(rc));				//FT_Err_Unknown_File_Format;				throw std::runtime_error("[FreetypeFontProvider::GetGlyphBitmap] Can't render glyph");			}		}		return PrepareBitmap(m_font_face->glyph);	}

int createText(char c,Char* cha){  FT_UInt  glyph_index;  glyph_index = FT_Get_Char_Index(face, c);  error = FT_Load_Glyph( face, glyph_index, FT_LOAD_DEFAULT );  if ( error ) { printf("e  %d",error); return error; }   error = FT_Render_Glyph( face->glyph, FT_RENDER_MODE_NORMAL );  if ( error ) { printf("e1 %d",error); return error; }  FT_Bitmap* bitmap = &slot->bitmap;  int i,j;  FT_Int x0 = slot->bitmap_left, y0 = slot->bitmap_top , w = bitmap->width , h = bitmap->rows ;  //printf("x0=%d;y0=%d;w=%d;h=%d/n",x0,y0,w,h );  cha->w=w;  cha->h=h;  cha->a = slot->advance.x >> 6;  cha->bx=x0;  cha->by=y0;  cha->data = malloc(w*h*sizeof(unsigned char));  for ( i=0; i<w*h; i++ ) cha->data[i] = bitmap->buffer[i];  // {  //   if(bitmap->buffer[i]==0)   //   {  //     printf("-");  //   }    //   else  //   {  //     printf("0");  //   }   //   if ( (i+1)%w==0 ) printf("/n");  // }  return 0;} 

JNIEXPORT jboolean JNICALL Java_com_badlogic_gdx_graphics_g2d_freetype_FreeType_renderGlyph(JNIEnv* env, jclass clazz, jlong slot, jint renderMode) {//@line:648		return !FT_Render_Glyph((FT_GlyphSlot)slot, (FT_Render_Mode)renderMode);	}

bool TrueTypeFont::renderGlyph(uint32 unicode, Glyph &glyph) {	uint32 index = FT_Get_Char_Index(_sjisFont, unicode);	if (!index)		return false;	FT_Error err = FT_Load_Glyph(_sjisFont, index, FT_LOAD_MONOCHROME | FT_LOAD_NO_HINTING);	if (err)		return false;	err = FT_Render_Glyph(_sjisFont->glyph, FT_RENDER_MODE_MONO);	if (err)		return false;	FT_Glyph_Metrics &metrics = _sjisFont->glyph->metrics;	glyph.xOffset = ftFloor26_6(metrics.horiBearingX);	glyph.yOffset = _ascent - ftFloor26_6(metrics.horiBearingY);	// In case we got a negative xMin we adjust that, this might make some	// characters give a odd layout though.	if (glyph.xOffset < 0)		glyph.xOffset = 0;	const FT_Bitmap &bitmap = _sjisFont->glyph->bitmap;	glyph.height = bitmap.rows;	glyph.width = bitmap.width;	glyph.pitch = bitmap.pitch;	glyph.plainData = 0;	// We only accept monochrome characters.	if (bitmap.pixel_mode != FT_PIXEL_MODE_MONO)		return false;	if (glyph.height) {		glyph.plainData = new uint8[glyph.height * abs(glyph.pitch)];		if (!glyph.plainData)			return false;		const uint8 *src = bitmap.buffer;		uint8 *dst = glyph.plainData;		if (glyph.pitch < 0)			dst += (glyph.height - 1) * (-glyph.pitch);		for (int i = 0; i < bitmap.rows; ++i) {			memcpy(dst, src, abs(glyph.pitch));			src += bitmap.pitch;			dst += glyph.pitch;		}	}	glyph.pitch = abs(glyph.pitch);	return true;}

void loadGlyph(char letter){   int glyph_index = FT_Get_Char_Index( face, letter);   FT_Load_Glyph(face,glyph_index,FT_LOAD_RENDER);      FT_Render_Glyph(face->glyph,FT_RENDER_MODE_NORMAL);   FT_Get_Glyph(face->glyph,(FT_Glyph *) &glyphs[letter -32]);}

const xd::detail::font::glyph& xd::font::load_glyph(utf8::uint32_t char_index, int size){	// check if glyph is already loaded	glyph_map_t::iterator i = m_glyph_map.find(char_index);	if (i != m_glyph_map.end())		return *i->second;	FT_UInt glyph_index = FT_Get_Char_Index(m_face->handle, char_index);	int error = FT_Load_Glyph(m_face->handle, glyph_index, FT_LOAD_DEFAULT);	if (error)		throw glyph_load_failed(m_filename, char_index);	error = FT_Render_Glyph(m_face->handle->glyph, FT_RENDER_MODE_NORMAL);	if (error)		throw glyph_load_failed(m_filename, char_index);	// create glyph    m_glyph_map[char_index] = std::unique_ptr<detail::font::glyph>(new detail::font::glyph);	detail::font::glyph& glyph = *m_glyph_map[char_index];	glyph.glyph_index = glyph_index;	glyph.advance.x = static_cast<float>(m_face->handle->glyph->advance.x >> 6);	glyph.advance.y = static_cast<float>(m_face->handle->glyph->advance.y >> 6);	// get the handle to the bitmap	FT_Bitmap bitmap = m_face->handle->glyph->bitmap;	glGenTextures(1, &glyph.texture_id);	glBindTexture(GL_TEXTURE_2D, glyph.texture_id);	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);	glPixelStorei(GL_UNPACK_ALIGNMENT, 1);	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, bitmap.width, bitmap.rows,		0, GL_LUMINANCE, GL_UNSIGNED_BYTE, bitmap.buffer);	// create quad for it	detail::font::vertex data[4];	data[0].pos = glm::vec2(0, 0);	data[1].pos = glm::vec2(0, bitmap.rows);	data[2].pos = glm::vec2(bitmap.width, bitmap.rows);	data[3].pos = glm::vec2(bitmap.width, 0);	data[0].tex = glm::vec2(0, 1);	data[1].tex = glm::vec2(0, 0);	data[2].tex = glm::vec2(1, 0);	data[3].tex = glm::vec2(1, 1);	// create a batch	glyph.quad_ptr = detail::font::vertex_batch_ptr_t(new detail::font::vertex_batch_t(GL_QUADS));	glyph.quad_ptr->load(data, 4);	glyph.offset.x = static_cast<float>(m_face->handle->glyph->bitmap_left);	glyph.offset.y = static_cast<float>(m_face->handle->glyph->bitmap_top - bitmap.rows);	return glyph;}

void LLFontFreetype::renderGlyph(const U32 glyph_index) const{	if (mFTFace == NULL)		return;	llassert_always(! FT_Load_Glyph(mFTFace, glyph_index, FT_LOAD_DEFAULT));	llassert_always(! FT_Render_Glyph(mFTFace->glyph, gFontRenderMode) );	mRenderGlyphCount++;}