Beispiel #1
0
bool Font::GenerateGlyph( unsigned int glyphNumber, GlyphBitmap &glyphBitmap)
{

    if(FT_Load_Glyph( face, FT_Get_Char_Index( face, glyphNumber ), FT_LOAD_DEFAULT ))
    {

        return false;
    }

    FT_Glyph glyph;
    if(FT_Get_Glyph( face->glyph, &glyph ))
    {

        return false;
    }

    FT_Glyph_To_Bitmap( &glyph, ft_render_mode_normal, 0, 1 );
    FT_BitmapGlyph bitmap_glyph = (FT_BitmapGlyph)glyph;

    FT_Bitmap &bitmap=bitmap_glyph->bitmap;


    glyphBitmap.bitmap->Generate(Bitmap::FORMAT_RGBA, bitmap.width, bitmap.rows, 0x00000000);
    unsigned int channelCount = GetChannelCount(Bitmap::FORMAT_RGBA);

    byte *glyphImageData = glyphBitmap.bitmap->GetData();

    for(int j = 0; j < bitmap.rows; j++)
    {
        for(int i=0; i < bitmap.width; i++)
        {
            glyphImageData[( bitmap.width * j + i ) * channelCount + channelCount - 1]
            = bitmap.buffer[bitmap.width * ( bitmap.rows - j - 1) + i];
        }
    }

    glyphBitmap.offsetDown = bitmap_glyph->top - bitmap.rows;
    glyphBitmap.bitmap->BlackToWhite();

    return true;
}
Beispiel #2
0
ImageHandle FreeTypeFont::createGlyphImage(int codepoint, int fontSize) const
{
    int glyph_index = FT_Get_Char_Index( fontInfo->face, codepoint );

    int error = FT_Set_Pixel_Sizes(
            fontInfo->face,     /* handle to face object */
            0,                  /* pixel_width           */
            fontSize );         /* pixel_height          */

    if ( error )
      LogError("Error setting font size");

    error = FT_Load_Glyph( fontInfo->face, glyph_index, FT_LOAD_RENDER | FT_LOAD_TARGET_LCD);
    if ( error ) 
        LogError("Error loading glyph");

    FT_Glyph  glyph; /* a handle to the glyph image */    

    error = FT_Get_Glyph( fontInfo->face->glyph, &glyph );
    if ( error ) 
        LogError("Error getting glyph");

    FT_Vector  origin;
    origin.x = origin.y = 0;

    error = FT_Glyph_To_Bitmap(
            &glyph,
            FT_RENDER_MODE_LCD,
            &origin,
            1 );

    FT_Bitmap bitmap = ((FT_BitmapGlyph) glyph)->bitmap;

    if (bitmap.width == 0 || bitmap.rows == 0)
        return HandleInvalid;

    auto image = ImageCreate(AllocatorGetHeap(), bitmap.width/3, bitmap.rows, PixelFormat::R8G8B8);
    image.Resolve()->setBuffer(bitmap.buffer, bitmap.pitch);
    return image;
}
Beispiel #3
0
FT_BitmapGlyphRec* CFontEngine::RenderGlyph(char Char)
{
	auto glyphIter = m_CachedGlyphMap.find(Char);
	if (glyphIter == m_CachedGlyphMap.end())
	{
		if (FT_Load_Char(m_FontFace, Char, FT_LOAD_DEFAULT))
		{
			throw(Wg_Ex_FreeType("Unable to render glyph.", "CFontEngine::RenderGlyph"));
		}
		FT_Glyph glyph;
		if (FT_Get_Glyph(m_FontFace->glyph, &glyph))
		{
			throw(Wg_Ex_FreeType("Unable to copy glyph.", "CFontEngine::RenderGlyph"));
		}
		if (FT_Glyph_To_Bitmap(&glyph, ft_render_mode_normal, nullptr, 1))
		{
			throw(Wg_Ex_FreeType("Unable to render glyph.", "CFontEngine::RenderGlyph"));
		}
		glyphIter = m_CachedGlyphMap.insert(std::make_pair(Char, *reinterpret_cast<FT_BitmapGlyph>(glyph))).first;
	}
	return &(glyphIter->second);
}
Beispiel #4
0
void grid_text_renderer<T>::render(glyph_positions const& pos, value_integer feature_id)
{
    glyphs_.clear();
    prepare_glyphs(pos);
    FT_Error  error;
    FT_Vector start;
    unsigned height = pixmap_.height();
    pixel_position const& base_point = pos.get_base_point();
    start.x =  static_cast<FT_Pos>(base_point.x * (1 << 6));
    start.y =  static_cast<FT_Pos>((height - base_point.y) * (1 << 6));
    start.x += transform_.tx * 64;
    start.y += transform_.ty * 64;

    // now render transformed glyphs
    double halo_radius = 0.0;
    FT_Matrix halo_matrix;
    halo_matrix.xx = halo_transform_.sx  * 0x10000L;
    halo_matrix.xy = halo_transform_.shx * 0x10000L;
    halo_matrix.yy = halo_transform_.sy  * 0x10000L;
    halo_matrix.yx = halo_transform_.shy * 0x10000L;
    for (auto & glyph : glyphs_)
    {
        halo_radius = glyph.properties.halo_radius * scale_factor_;
        FT_Glyph_Transform(glyph.image, &halo_matrix, &start);
        error = FT_Glyph_To_Bitmap(&glyph.image, FT_RENDER_MODE_NORMAL, 0, 1);
        if (!error)
        {

            FT_BitmapGlyph bit = reinterpret_cast<FT_BitmapGlyph>(glyph.image);
            render_halo_id(&bit->bitmap,
                           feature_id,
                           bit->left,
                           height - bit->top,
                           static_cast<int>(halo_radius));
        }
        FT_Done_Glyph(glyph.image);
    }
}
Beispiel #5
0
void FontPrintImageTtf_short(ge_Font* font, int x, int y, const unsigned short* text, u32 color, ge_Image* image){
	FT_GlyphSlot slot = ((FT_Face)font->face)->glyph;

	int b_x = x;
	int n = 0;
	long ch = 0;

	for (n = 0; text[n] != 0x0; n++) {
	//	gePrintDebug(0x100, "char: %d\n", n);
		ch = (u16)text[n];
		if(ch == '\n'){
			y += font->size;
			x = b_x;
			continue;
		}
		if(ch >= 0x80){
			TransformUnicodeChar(&ch);
		}

		FT_UInt glyph_index = FT_Get_Char_Index(((FT_Face)font->face), ch);
		FT_Load_Glyph(((FT_Face)font->face), glyph_index, FT_LOAD_DEFAULT);

		FT_Glyph glyph;
		FT_Get_Glyph(((FT_Face)font->face)->glyph, &glyph);

		FT_Glyph_To_Bitmap(&glyph, ft_render_mode_normal, 0, 1);
		slot = ((FT_Face)font->face)->glyph;
		
		FT_BitmapGlyph bitmap_glyph = (FT_BitmapGlyph)glyph;
		FT_Bitmap bitmap = bitmap_glyph->bitmap;

		fontPrintTextImage(&bitmap, x+bitmap_glyph->left, y+font->size-bitmap_glyph->top, color, image);

		x += slot->advance.x >> 6;
	}
	geUpdateImage(image);
}
Beispiel #6
0
static void freetype2_drawtext(PFont pfont, image_p pimage, int x, int y,
							   const void *text, int cc, int flags)
{
	PFontFreetype pf = (PFontFreetype) pfont;
	uint16_t* value;
	FT_Glyph glyph;
	int pen_x = x;
	int pen_y = y + pf->size;
	int i;
	FT_BitmapGlyph bitmap_glyph;
	FT_Bitmap* bitmap;

	value = _nge_ft_conv_encoding(pfont, text, &cc);
	if (cc <= 0)
		return;

	if(pimage->swizzle ==1){
		unswizzle_swap(pimage);
		pimage->dontswizzle = 1;
	}
	pimage->modified =1;
	for (i =0;i<cc;i++) {
		FT_Load_Glyph( pf->face, FT_Get_Char_Index( pf->face, value[i] ), FT_LOAD_DEFAULT );
		if(pf->flags & FLAGS_FREETYPE_BOLD)
			FT_GlyphSlot_Embolden(pf->face->glyph);
		if(pf->flags & FLAGS_FREETYPE_ITALICS)
			FT_GlyphSlot_Oblique(pf->face->glyph);
		FT_Get_Glyph( pf->face->glyph, &glyph );
		FT_Render_Glyph( pf->face->glyph, ft_render_mode_normal );
		FT_Glyph_To_Bitmap( &glyph, ft_render_mode_normal, 0, 1 );
		bitmap_glyph = (FT_BitmapGlyph)glyph;
		bitmap=&bitmap_glyph->bitmap;
		draw_one_word(pf,bitmap,pimage,pen_x + pf->face->glyph->bitmap_left,pen_y - pf->face->glyph->bitmap_top );
		pen_x  +=(pf->face->glyph->advance.x+pf->fix_width*72) >> 6  ;
		FT_Done_Glyph( glyph );
	}
}
Beispiel #7
0
static void ft2_draw_glyphs(GalDrawable drawable, GalPB pb, GalFont obj,
		GalRect *area, eint x, eint y, GalGlyph *glyphs, eint len)
{
	Ft2Font *ft2font = FT2_FONT_DATA(obj);
	GalImage  *image = ft2font->image;
	FT_Face     face = ft2_get_face(ft2font);
	FT_BitmapGlyph bitmap_glyph;
	FT_Bitmap     *bitmap;
	eint i, w = 0;

	egal_fill_image(image, 0, area->x, 0, area->w, image->h);
	for (i = 0; i < len; i++) {
		FT_Glyph glyph;
		FT_Load_Glyph(face, glyphs[i].glyph, FT_LOAD_DEFAULT);
		FT_Get_Glyph(face->glyph, &glyph);
		if (face->glyph->format != ft_glyph_format_bitmap)
			FT_Render_Glyph(face->glyph, ft_render_mode_normal);

		FT_Glyph_To_Bitmap(&glyph, FT_RENDER_MODE_NORMAL, 0, 1);
		bitmap_glyph = (FT_BitmapGlyph)glyph;
		bitmap       = &bitmap_glyph->bitmap;

		ft2_bitmap_to_image(bitmap, image,
				x + w + face->glyph->bitmap_left,
				ft2font->metrics.height - face->glyph->bitmap_top + ft2font->metrics.descent);
		w += glyphs[i].w;
	}

	{
		GalRect rc = {x, y, w, ft2font->metrics.height};
		egal_rect_intersect(&rc, &rc, area);
		eint _y = rc.y - y;
		egal_composite_image(drawable, pb, rc.x, rc.y, image, rc.x, _y, rc.w, rc.h - _y);
		//egal_draw_image(drawable, pb, rc.x, rc.y, image, rc.x, _y, rc.w, rc.h - _y);
	}
}
Beispiel #8
0
    bool Font::CreateFromFile( const char* path, const uint32_t font_size, const bool smooth, const uint32_t start_char, const size_t num_chars )
    {
        if( path == NULL || font_size == 0 || num_chars == 0 || _num_glyphs > 0 ) return false;

        Mojo::Services::Filesystem* filesystem = MOJO_GET_SERVICE(Filesystem);
        Mojo::Filesystem::File* file = filesystem->Open(path, Mojo::Filesystem::FILE_READ);
        if( !file ) return false;

        size_t file_len = filesystem->Length(file);
        if( file_len == 0 ) {
            filesystem->Close(file);
            return false;
        }

        // todo: Use FT_Open_Face to read the file instead?

        uint8_t* buffer = new uint8_t[file_len]; {
            uint32_t num_bytes_read = 0;
            while( num_bytes_read < file_len ) {
                size_t read = filesystem->Read(file, file_len - num_bytes_read, (void*)&buffer[num_bytes_read]);
                mojo_assertf(read > 0, "Font::CreateFromFile\n -> Services/Filesystem error?\n");
                num_bytes_read += read;
            }
        }

        filesystem->Close(file);

        FT_Face ft_face;
        if( FT_New_Memory_Face(Mojo::GetFreeTypeLibrary(), (const FT_Byte*)buffer, file_len, 0, &ft_face) ) {
            delete[] buffer;
            return false;
        }

        FT_Set_Char_Size(ft_face, font_size * 64, font_size * 64, 72, 72);

        const float line_height = ft_face->size->metrics.height >> 6;

        // Load the glyphs
        Font::Glyph*    glyphs       = new Font::Glyph[num_chars];
        FT_Glyph*       ft_glyphs    = new FT_Glyph[num_chars];
        FT_BitmapGlyph* bm_glyphs    = (FT_BitmapGlyph*)ft_glyphs;

        float blo = 0.0f;
        uint32_t bm_max_width = 0, bm_max_height = 0;
        for( uint32_t i = 0; i < num_chars; ++i ) {
            FT_Load_Char(ft_face, start_char + i, FT_LOAD_DEFAULT);
            FT_Get_Glyph(ft_face->glyph, &ft_glyphs[i]);

            glyphs[i].x_advance = ft_face->glyph->advance.x >> 6;
            glyphs[i].y_advance = ft_face->glyph->advance.y >> 6;
            glyphs[i].x_bearing = (FT_HAS_VERTICAL(ft_face) ? ft_face->glyph->metrics.vertBearingX : ft_face->glyph->metrics.horiBearingX) >> 6;
            glyphs[i].y_bearing = (FT_HAS_VERTICAL(ft_face) ? ft_face->glyph->metrics.vertBearingY : ft_face->glyph->metrics.horiBearingY) >> 6;
            
            FT_Glyph_To_Bitmap(&ft_glyphs[i], smooth ? FT_RENDER_MODE_NORMAL : FT_RENDER_MODE_MONO, 0, 1);

            const FT_Bitmap bitmap = bm_glyphs[i]->bitmap;
            glyphs[i].width  = bitmap.width;
            glyphs[i].height = bitmap.rows;

            bm_max_width  = bm_max_width < bitmap.width ? bitmap.width : bm_max_width;
            bm_max_height = bm_max_height < bitmap.rows ? bitmap.rows : bm_max_height;

            const float gbl = -glyphs[i].y_bearing + glyphs[i].height;
            blo = (blo < gbl) ? gbl : blo;
        }

        // Determine the texture atlas size
        uint32_t atlas_width = 0, atlas_height = 0; {
            static const struct { uint32_t width, height, area; } atlas_sizes[] = {
                {  64,  64,  64 *  64 }, { 128, 128, 128 * 128 },
                { 256, 256, 256 * 256 }, { 512, 512, 512 * 512 }
            };

            uint32_t min_area = 0;
            for( uint32_t i = 0; i < num_chars; ++i ) min_area += uint32_t((glyphs[i].width + 2) * (bm_max_height + 2));

            for( uint32_t i = 0; i < 4; ++i ) {
                if( atlas_sizes[i].area < min_area ) continue;

                const uint32_t index = (i > 3) ? 3 : i;
                atlas_width  = atlas_sizes[index].width;
                atlas_height = atlas_sizes[index].height;
                break;
            }

            if( atlas_width == 0 || atlas_height == 0 ) {
                for( uint32_t i = 0; i < num_chars; ++i ) FT_Done_Glyph(ft_glyphs[i]);
                delete[] ft_glyphs;
                delete[] glyphs;

                FT_Done_Face(ft_face);
                delete[] buffer;

                return false;
            }
        }

        Mojo::TextureAtlas tex_atlas = Mojo::TextureAtlas(atlas_width, atlas_height, 32);
        Mojo::BookshelfTexturePacker tex_packer = Mojo::BookshelfTexturePacker(&tex_atlas);

        uint8_t* bm_buffer = new uint8_t[bm_max_width * bm_max_height * 4];
        for( uint32_t i = 0; i < num_chars; ++i ) {
            const FT_Bitmap bitmap = bm_glyphs[i]->bitmap;
            if( bitmap.width == 0 || bitmap.rows == 0 ) continue;

            memset((void*)bm_buffer, 255, bm_max_width * bm_max_height * 4);

            switch( bitmap.pixel_mode ) {
                default: {
                    mojo_assertf(0, "Font::CreateFromFile()\n -> Pixel mode not supported.\n"); 
                } break;

                case FT_PIXEL_MODE_MONO: {
                    const uint8_t* bm_pixels = (const uint8_t*)bitmap.buffer;
                    const uint32_t y_offset = 0;

                    for( uint32_t y = 0; y < bitmap.rows; ++y ) {
                        for( uint32_t x = 0; x < bitmap.width; ++x ) bm_buffer[(x + y * bitmap.width) * 4 + 3] = ((bm_pixels[x / 8]) & (1 << (7 - (x % 8)))) ? 0xFF : 0x00;
                        bm_pixels += bitmap.pitch;
                    }
                } break;
                
                case FT_PIXEL_MODE_GRAY: {
                    const uint8_t* bm_pixels = (const uint8_t*)bitmap.buffer;

                    for( uint32_t y = 0; y < bitmap.rows; ++y ) {
                        for( uint32_t x = 0; x < bitmap.width; ++x ) bm_buffer[(x + y * bitmap.width) * 4 + 3] = bm_pixels[x];
                        bm_pixels += bitmap.pitch;
                    }
                } break;
            }

            Mojo::Recti packed_rect;
            if( !tex_packer.Pack(bitmap.width, bitmap.rows, 1, bm_buffer, packed_rect) ) {
                Mojo::DebugPrintf(DBG_WARNING, "Font::CreateFromFile()\n -> unable to pack character '%c'\n", i + start_char);              
            }

            glyphs[i].tex_coords[0] = (float)packed_rect.x / atlas_width;
            glyphs[i].tex_coords[1] = (float)packed_rect.y / atlas_height;
            glyphs[i].tex_coords[2] = (float)(packed_rect.x + packed_rect.width) / atlas_width;
            glyphs[i].tex_coords[3] = (float)(packed_rect.y + packed_rect.height) / atlas_height;
        }
        delete[] bm_buffer;

        // Unload the glyphs
        for( uint32_t i = 0; i < num_chars; ++i ) FT_Done_Glyph(ft_glyphs[i]);
        delete[] ft_glyphs;

        FT_Done_Face(ft_face);
        delete[] buffer;

        // Update
        _font_atlas  = tex_atlas.Compile();
        _start_glyph = start_char;
        _num_glyphs  = num_chars;
        _glyphs      = glyphs;
        _base_line   = bm_max_height - blo;
        _line_height = line_height;

        return true;
    }
Beispiel #9
0
int eTextPara::appendGlyph(Font *current_font, FT_Face current_face, FT_UInt glyphIndex, int flags, int rflags, int border, bool last,
		bool activate_newcolor, unsigned long newcolor)
{
	int xadvance, top, left, width, height;
	pGlyph ng;

	if (border)
	{
		/* TODO: scale border radius with current_font scaling */
		if (current_font->getGlyphImage(glyphIndex, &ng.image, &ng.borderimage, 64 * border))
			return 1;
		if (ng.image && ng.image->format != FT_GLYPH_FORMAT_BITMAP)
		{
			FT_Glyph_To_Bitmap(&ng.image, FT_RENDER_MODE_NORMAL, NULL, 1);
			if (ng.image->format != FT_GLYPH_FORMAT_BITMAP) return 1;
		}
		if (ng.borderimage && ng.borderimage->format != FT_GLYPH_FORMAT_BITMAP)
		{
			FT_Glyph_To_Bitmap(&ng.borderimage, FT_RENDER_MODE_NORMAL, NULL, 1);
			if (ng.borderimage->format != FT_GLYPH_FORMAT_BITMAP) return 1;
		}
		FT_BitmapGlyph glyph = NULL;
		if (ng.borderimage)
		{
			xadvance = ng.borderimage->advance.x;
			/* 
			 * NOTE: our boundingbox calculation uses xadvance, and ignores glyph width.
			 * This is fine for all glyphs, except the last one (i.e. rightmost, for left-to-right rendering)
			 * For border glyphs, xadvance is significantly smaller than the glyph width.
			 * In fact, border glyphs often have the same xadvance as normal glyphs, borders
			 * are allowed to overlap.
			 * As a result, the boundingbox is calculated too small, the actual glyphs won't
			 * fit into it, and depending on the alignment, one of the borders on the sides 
			 * will be cut off.
			 * Ideally, the boundingbox calculation should be rewritten, to use both advance and glyph dimensions.
			 * However, for now we adjust xadvance of the last glyph, so the current calculation will produce
			 * a better fitting boundingbox for border glyphs.
			 *
			 * The compensation equals half of the difference between 'normal' glyph width, 
			 * and border glyph width. (half the width difference is on the left, and half on the right 
			 * of the glyph, we only need to compensate for the part on the right)
			 * And since xadvance is in 16.16 units, we use (dW/2) << 16 = dW << 15
			 */
			if (last) xadvance += (((FT_BitmapGlyph)ng.borderimage)->bitmap.width - ((FT_BitmapGlyph)ng.image)->bitmap.width) << 15;
			glyph = (FT_BitmapGlyph)ng.borderimage;
		}
		else if (ng.image)
		{
			xadvance = ng.image->advance.x;
			glyph = (FT_BitmapGlyph)ng.image;

		}
		else
		{
			return 1;
		}
		xadvance >>= 16;
		top = glyph->top;
		left = glyph->left;
		width = glyph->bitmap.width;
		height = glyph->bitmap.rows;
	}
	else
	{
Beispiel #10
0
///Create a display list coresponding to the give character.
void make_dlist ( FT_Face face, char ch, GLuint list_base, GLuint * tex_base ) {

    //The first thing we do is get FreeType to render our character
    //into a bitmap.  This actually requires a couple of FreeType commands:

    //Load the Glyph for our character.
    if(FT_Load_Glyph( face, FT_Get_Char_Index( face, ch ), FT_LOAD_DEFAULT ))
        throw std::runtime_error("FT_Load_Glyph failed");

    //Move the face's glyph into a Glyph object.
    FT_Glyph glyph;
    if(FT_Get_Glyph( face->glyph, &glyph ))
        throw std::runtime_error("FT_Get_Glyph failed");

    //Convert the glyph to a bitmap.
    FT_Glyph_To_Bitmap( &glyph, ft_render_mode_normal, 0, 1 );
    FT_BitmapGlyph bitmap_glyph = (FT_BitmapGlyph)glyph;

    //This reference will make accessing the bitmap easier
    FT_Bitmap& bitmap=bitmap_glyph->bitmap;

    //Use our helper function to get the widths of
    //the bitmap data that we will need in order to create
    //our texture.
    int width = next_p2( bitmap.width );
    int height = next_p2( bitmap.rows );

    //Allocate memory for the texture data.
    GLubyte* expanded_data = new GLubyte[ 2 * width * height];

    //Here we fill in the data for the expanded bitmap.
    //Notice that we are using two channel bitmap (one for
    //luminocity and one for alpha), but we assign
    //both luminocity and alpha to the value that we
    //find in the FreeType bitmap.
    //We use the ?: operator so that value which we use
    //will be 0 if we are in the padding zone, and whatever
    //is the the Freetype bitmap otherwise.
    for(int j=0; j <height; j++) {
        for(int i=0; i < width; i++) {
            expanded_data[2*(i+j*width)]= expanded_data[2*(i+j*width)+1] =
                                              (i>=bitmap.width || j>=bitmap.rows) ?
                                              0 : bitmap.buffer[i + bitmap.width*j];
        }
    }


    //Now we just setup some texture paramaters.
    glBindTexture( GL_TEXTURE_2D, tex_base[ch]);
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);

    //Here we actually create the texture itself, notice
    //that we are using GL_LUMINANCE_ALPHA to indicate that
    //we are using 2 channel data.
    glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, width, height,
                  0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, expanded_data );

    //With the texture created, we don't need to expanded data anymore
    delete [] expanded_data;

    //So now we can create the display list
    glNewList(list_base+ch,GL_COMPILE);

    glBindTexture(GL_TEXTURE_2D,tex_base[ch]);

    //first we need to move over a little so that
    //the character has the right amount of space
    //between it and the one before it.
    glTranslatef(bitmap_glyph->left,0,0);

    //Now we move down a little in the case that the
    //bitmap extends past the bottom of the line
    //(this is only true for characters like 'g' or 'y'.
    glPushMatrix();
    glTranslatef(0,bitmap_glyph->top-bitmap.rows,0);

    //Now we need to account for the fact that many of
    //our textures are filled with empty padding space.
    //We figure what portion of the texture is used by
    //the actual character and store that information in
    //the x and y variables, then when we draw the
    //quad, we will only reference the parts of the texture
    //that we contain the character itself.
    float	x=(float)bitmap.width / (float)width,
            y=(float)bitmap.rows / (float)height;

    //Here we draw the texturemaped quads.
    //The bitmap that we got from FreeType was not
    //oriented quite like we would like it to be,
    //so we need to link the texture to the quad
    //so that the result will be properly aligned.
    glBegin(GL_QUADS);
    glTexCoord2d(0,0);
    glVertex2f(0,bitmap.rows);
    glTexCoord2d(0,y);
    glVertex2f(0,0);
    glTexCoord2d(x,y);
    glVertex2f(bitmap.width,0);
    glTexCoord2d(x,0);
    glVertex2f(bitmap.width,bitmap.rows);
    glEnd();
    glPopMatrix();
    glTranslatef(face->glyph->advance.x >> 6 ,0,0);


    //increment the raster position as if we were a bitmap font.
    //(only needed if you want to calculate text length)
    //glBitmap(0,0,0,0,face->glyph->advance.x >> 6,0,NULL);

    //Finnish the display list
    glEndList();
}
Beispiel #11
0
bool TrueTypeFont::bakeGlyphDistance(CodePoint _codePoint, GlyphInfo& _glyphInfo, uint8_t* _outBuffer)
{
	BX_CHECK(m_font != NULL, "TrueTypeFont not initialized");

	_glyphInfo.glyphIndex = FT_Get_Char_Index(m_font->face, _codePoint);

	FT_Int32 loadMode = FT_LOAD_DEFAULT | FT_LOAD_NO_HINTING;
	FT_Render_Mode renderMode = FT_RENDER_MODE_NORMAL;

	FT_GlyphSlot slot = m_font->face->glyph;
	FT_Error error = FT_Load_Glyph(m_font->face, _glyphInfo.glyphIndex, loadMode);
	if (error)
	{
		return false;
	}

	FT_Glyph glyph;
	error = FT_Get_Glyph(slot, &glyph);
	if (error)
	{
		return false;
	}

	error = FT_Glyph_To_Bitmap(&glyph, renderMode, 0, 1);
	if (error)
	{
		return false;
	}

	FT_BitmapGlyph bitmap = (FT_BitmapGlyph)glyph;

	int32_t ww = bitmap->bitmap.width;
	int32_t hh = bitmap->bitmap.rows;

	glyphInfoInit(_glyphInfo, bitmap, slot, _outBuffer, 1);

	FT_Done_Glyph(glyph);

	if (ww * hh > 0)
	{
		uint32_t dw = 6;
		uint32_t dh = 6;

		uint32_t nw = ww + dw * 2;
		uint32_t nh = hh + dh * 2;
		BX_CHECK(nw * nh < 128 * 128, "Buffer overflow (size %d)", nw * nh);

		uint32_t buffSize = nw * nh * sizeof(uint8_t);

		uint8_t* alphaImg = (uint8_t*)malloc(buffSize);
		memset(alphaImg, 0, nw * nh * sizeof(uint8_t) );

		//copy the original buffer to the temp one
		for (uint32_t ii = dh; ii < nh - dh; ++ii)
		{
			memcpy(alphaImg + ii * nw + dw, _outBuffer + (ii - dh) * ww, ww);
		}

		makeDistanceMap(alphaImg, _outBuffer, nw, nh);
		free(alphaImg);

		_glyphInfo.offset_x -= (float)dw;
		_glyphInfo.offset_y -= (float)dh;
		_glyphInfo.width = (float)nw;
		_glyphInfo.height = (float)nh;
	}

	return true;
}
Beispiel #12
0
///Create a display list corresponding to the given character.
///glyph_id = actual font glyph id (32 bits), ch = id for printing to screen (16 bits)
void font_data::make_dlist(uint glyph_id, ushort ch) {

	// get the texture reference
	m.alloc(ch);
	GLuint tex = m.get_t(ch);

	// Translate Win-1252 with additions to Unicode
	if (remapflag) {
		if (glyph_id >= 16 && glyph_id < 32) glyph_id = unichar_low[glyph_id-16];
		else if (glyph_id >= 128 && glyph_id < 160) glyph_id = unichar_high[glyph_id-128];
	}

	// Load the Glyph for our character.
	if (FT_Load_Glyph(face, FT_Get_Char_Index(face, glyph_id), FT_LOAD_DEFAULT))
		throw std::runtime_error("FT_Load_Glyph failed");

	// Move the face's glyph into a Glyph object.
    FT_Glyph glyph;
    if (FT_Get_Glyph(face->glyph, &glyph))
		throw std::runtime_error("FT_Get_Glyph failed");

	// Convert the glyph to a bitmap.
	FT_Glyph_To_Bitmap(&glyph, ft_render_mode_normal, 0, 1);
    FT_BitmapGlyph bitmap_glyph = (FT_BitmapGlyph) glyph;

	// This reference will make accessing the bitmap easier
	FT_Bitmap& bitmap=bitmap_glyph->bitmap;

	// Use our helper function to get the widths of
	// the bitmap data that we will need in order to create
	// our texture.
	// The max(2, ...) is used to correct for OpenGL, which 
	// apparently does not like to have rows less than 4 bytes
	// long.  Probably a packing thing.
	int width = max(2, next_p2(bitmap.width));
	int height = next_p2(bitmap.rows);

	// Allocate memory (temporarily) for the texture data.
	GLubyte* expanded_data = new GLubyte[2 * width * height];

	// Here we fill in the data for the expanded bitmap.
	// Notice that we are using two channel bitmap (one for
	// luminocity and one for alpha).
	// Luma always 255.  Alpha stays alpha.
	// (unless of course, it is premultiplied, which in OpenGL it is not.)
	// We use the ?: operator so that value which we use
	// will be 0 if we are in the padding zone, and whatever
	// is the Freetype bitmap otherwise.
	for (int j = 0; j < height; j++) {
		for (int i = 0; i < width; i++) {
			expanded_data[ 2*(i+j*width)   ] = 255;
			expanded_data[ 2*(i+j*width)+1 ] = 
				(i >= bitmap.width || j >= bitmap.rows) ?
				0 : bitmap.buffer[i + bitmap.width*j];
		}
	}

	// Now we just setup some texture paramaters.
    glBindTexture(GL_TEXTURE_2D, tex);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

	// Here we actually create the texture itself, notice
	// that we are using GL_LUMINANCE_ALPHA to indicate that
	// we are using 2 channel data.
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height,
		  0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, expanded_data);


	// With the texture created, we don't need the expanded data anymore
    delete [] expanded_data;

	// So now we can create the display list
	glNewList(list_base + ch, GL_COMPILE);

	glBindTexture(GL_TEXTURE_2D, tex);

	//glPushMatrix();

	// First we need to move over a little so that
	// the character has the right amount of space
	// between it and the one before it.
	//glTranslatef((float) bitmap_glyph->left,0,0);

	// Now we move down a little in the case that the
	// bitmap extends past the bottom of the line 
	// (this is only true for characters like 'g' or 'y'.
	//glTranslatef(0,(float)bitmap_glyph->top-bitmap.rows,0);
	float left_pad = (float) bitmap_glyph->left;
	float bot_pad = (float) bitmap.rows-bitmap_glyph->top;
	glTranslatef(left_pad, -bot_pad, 0);

	// Now we need to account for the fact that many of
	// our textures are filled with empty padding space.
	// We figure what portion of the texture is used by 
	// the actual character and store that information in 
	// the x and y variables, then when we draw the
	// quad, we will only reference the parts of the texture
	// that we contain the character itself.
	float	x = (float) bitmap.width / (float) width,
			y = (float) bitmap.rows / (float) height;

	// Here we draw the texturemapped quads.
	// The bitmap that we got from FreeType was not 
	// oriented quite like we would like it to be,
	// so we need to link the texture to the quad
	// so that the result will be properly aligned.
	glBegin(GL_QUADS);
	glTexCoord2d(0, 0); glVertex2f(0, (float) bitmap.rows);
	glTexCoord2d(0, y); glVertex2f(0, 0);
	glTexCoord2d(x, y); glVertex2f((float) bitmap.width, 0);
	glTexCoord2d(x, 0); glVertex2f((float) bitmap.width, (float) bitmap.rows);
	glEnd();
	//glPopMatrix();

	// Get width, round, and translate
	short ch_width = (short)(face->glyph->linearHoriAdvance >> 16);
	if (face->glyph->linearHoriAdvance & 0x8000) ++ch_width;
	//glTranslatef(ch_width, 0, 0);
	glTranslatef(ch_width-left_pad, bot_pad, 0);

	// The two ways to do width:
	// face->glyph->linearHoriAdvance >> 16
	// face->glyph->advance.x >> 6 
	
	// Finish the display list
	glEndList();

	// Store the width of this character
	m.set_w(ch, ch_width);
}
Beispiel #13
0
static FT_Error Load_Glyph( TTF_Font* font, Uint16 ch, c_glyph* cached, int want )
{
	FT_Face face;
	FT_Error error;
	FT_GlyphSlot glyph;
	FT_Glyph_Metrics* metrics;
	FT_Outline* outline;

	if ( !font || !font->face ) {
		return FT_Err_Invalid_Handle;
	}

	face = font->face;

	/* Load the glyph */
	if ( ! cached->index ) {
		cached->index = FT_Get_Char_Index( face, ch );
	}
	error = FT_Load_Glyph( face, cached->index, FT_LOAD_DEFAULT | font->hinting);
	if( error ) {
		return error;
	}

	/* Get our glyph shortcuts */
	glyph = face->glyph;
	metrics = &glyph->metrics;
	outline = &glyph->outline;

	/* Get the glyph metrics if desired */
	if ( (want & CACHED_METRICS) && !(cached->stored & CACHED_METRICS) ) {
		if ( FT_IS_SCALABLE( face ) ) {
			/* Get the bounding box */
			cached->minx = FT_FLOOR(metrics->horiBearingX);
			cached->maxx = cached->minx + FT_CEIL(metrics->width);
			cached->maxy = FT_FLOOR(metrics->horiBearingY);
			cached->miny = cached->maxy - FT_CEIL(metrics->height);
			cached->yoffset = font->ascent - cached->maxy;
			cached->advance = FT_CEIL(metrics->horiAdvance);
		} else {
			/* Get the bounding box for non-scalable format.
			 * Again, freetype2 fills in many of the font metrics
			 * with the value of 0, so some of the values we
			 * need must be calculated differently with certain
			 * assumptions about non-scalable formats.
			 * */
			cached->minx = FT_FLOOR(metrics->horiBearingX);
			cached->maxx = cached->minx + FT_CEIL(metrics->horiAdvance);
			cached->maxy = FT_FLOOR(metrics->horiBearingY);
			cached->miny = cached->maxy - FT_CEIL(face->available_sizes[font->font_size_family].height);
			cached->yoffset = 0;
			cached->advance = FT_CEIL(metrics->horiAdvance);
		}
		
		/* Adjust for bold and italic text */
		if( TTF_HANDLE_STYLE_BOLD(font) ) {
			cached->maxx += font->glyph_overhang;
		}
		if( TTF_HANDLE_STYLE_ITALIC(font) ) {
			cached->maxx += (int)ceil(font->glyph_italics);
		}
		cached->stored |= CACHED_METRICS;
	}

	if ( ((want & CACHED_BITMAP) && !(cached->stored & CACHED_BITMAP)) ||
	     ((want & CACHED_PIXMAP) && !(cached->stored & CACHED_PIXMAP)) ) {
		int mono = (want & CACHED_BITMAP);
		int i;
		FT_Bitmap* src;
		FT_Bitmap* dst;
		FT_Glyph bitmap_glyph = NULL;

		/* Handle the italic style */
		if( TTF_HANDLE_STYLE_ITALIC(font) ) {
			FT_Matrix shear;

			shear.xx = 1 << 16;
			shear.xy = (int) ( font->glyph_italics * ( 1 << 16 ) ) / font->height;
			shear.yx = 0;
			shear.yy = 1 << 16;

			FT_Outline_Transform( outline, &shear );
		}

		/* Render as outline */
		if( (font->outline > 0) && glyph->format != FT_GLYPH_FORMAT_BITMAP ) {
			FT_Stroker stroker;
			FT_Get_Glyph( glyph, &bitmap_glyph );
			error = FT_Stroker_New( library, &stroker );
			if( error ) {
				return error;
			}
			FT_Stroker_Set( stroker, font->outline * 64, FT_STROKER_LINECAP_ROUND, FT_STROKER_LINEJOIN_ROUND, 0 ); 
			FT_Glyph_Stroke( &bitmap_glyph, stroker, 1 /* delete the original glyph */ );
			FT_Stroker_Done( stroker );
			/* Render the glyph */
			error = FT_Glyph_To_Bitmap( &bitmap_glyph, mono ? ft_render_mode_mono : ft_render_mode_normal, 0, 1 );
			if( error ) {
				FT_Done_Glyph( bitmap_glyph );
				return error;
			}
			src = &((FT_BitmapGlyph)bitmap_glyph)->bitmap;
		} else {
			/* Render the glyph */
			error = FT_Render_Glyph( glyph, mono ? ft_render_mode_mono : ft_render_mode_normal );
			if( error ) {
				return error;
			}
			src = &glyph->bitmap;
		}
		/* Copy over information to cache */
		if ( mono ) {
			dst = &cached->bitmap;
		} else {
			dst = &cached->pixmap;
		}
		memcpy( dst, src, sizeof( *dst ) );

		/* FT_Render_Glyph() and .fon fonts always generate a
		 * two-color (black and white) glyphslot surface, even
		 * when rendered in ft_render_mode_normal. */
		/* FT_IS_SCALABLE() means that the font is in outline format,
		 * but does not imply that outline is rendered as 8-bit
		 * grayscale, because embedded bitmap/graymap is preferred
		 * (see FT_LOAD_DEFAULT section of FreeType2 API Reference).
		 * FT_Render_Glyph() canreturn two-color bitmap or 4/16/256-
		 * color graymap according to the format of embedded bitmap/
		 * graymap. */
		if ( src->pixel_mode == FT_PIXEL_MODE_MONO ) {
			dst->pitch *= 8;
		} else if ( src->pixel_mode == FT_PIXEL_MODE_GRAY2 ) {
			dst->pitch *= 4;
		} else if ( src->pixel_mode == FT_PIXEL_MODE_GRAY4 ) {
			dst->pitch *= 2;
		}

		/* Adjust for bold and italic text */
		if( TTF_HANDLE_STYLE_BOLD(font) ) {
			int bump = font->glyph_overhang;
			dst->pitch += bump;
			dst->width += bump;
		}
		if( TTF_HANDLE_STYLE_ITALIC(font) ) {
			int bump = (int)ceil(font->glyph_italics);
			dst->pitch += bump;
			dst->width += bump;
		}

		if (dst->rows != 0) {
			dst->buffer = (unsigned char *)malloc( dst->pitch * dst->rows );
			if( !dst->buffer ) {
				return FT_Err_Out_Of_Memory;
			}
			memset( dst->buffer, 0, dst->pitch * dst->rows );

			for( i = 0; i < src->rows; i++ ) {
				int soffset = i * src->pitch;
				int doffset = i * dst->pitch;
				if ( mono ) {
					unsigned char *srcp = src->buffer + soffset;
					unsigned char *dstp = dst->buffer + doffset;
					int j;
					if ( src->pixel_mode == FT_PIXEL_MODE_MONO ) {
						for ( j = 0; j < src->width; j += 8 ) {
							unsigned char c = *srcp++;
							*dstp++ = (c&0x80) >> 7;
							c <<= 1;
							*dstp++ = (c&0x80) >> 7;
							c <<= 1;
							*dstp++ = (c&0x80) >> 7;
							c <<= 1;
							*dstp++ = (c&0x80) >> 7;
							c <<= 1;
							*dstp++ = (c&0x80) >> 7;
							c <<= 1;
							*dstp++ = (c&0x80) >> 7;
							c <<= 1;
							*dstp++ = (c&0x80) >> 7;
							c <<= 1;
							*dstp++ = (c&0x80) >> 7;
						}
					}  else if ( src->pixel_mode == FT_PIXEL_MODE_GRAY2 ) {
						for ( j = 0; j < src->width; j += 4 ) {
							unsigned char c = *srcp++;
							*dstp++ = (((c&0xA0) >> 6) >= 0x2) ? 1 : 0;
							c <<= 2;
							*dstp++ = (((c&0xA0) >> 6) >= 0x2) ? 1 : 0;
							c <<= 2;
							*dstp++ = (((c&0xA0) >> 6) >= 0x2) ? 1 : 0;
							c <<= 2;
							*dstp++ = (((c&0xA0) >> 6) >= 0x2) ? 1 : 0;
						}
					} else if ( src->pixel_mode == FT_PIXEL_MODE_GRAY4 ) {
						for ( j = 0; j < src->width; j += 2 ) {
							unsigned char c = *srcp++;
							*dstp++ = (((c&0xF0) >> 4) >= 0x8) ? 1 : 0;
							c <<= 4;
							*dstp++ = (((c&0xF0) >> 4) >= 0x8) ? 1 : 0;
						}
					} else {
						for ( j = 0; j < src->width; j++ ) {
Beispiel #14
0
// ----------------------------------------------- texture_font_load_glyphs ---
size_t
texture_font_load_glyphs( texture_font_t * self,
                          const wchar_t * charcodes )
{
    assert( self );
    assert( charcodes );

    size_t i, x, y, width, height, depth, w, h;
    FT_Library library;
    FT_Error error;
    FT_Face face;
    FT_Glyph ft_glyph;
    FT_GlyphSlot slot;
    FT_Bitmap ft_bitmap;

    FT_UInt glyph_index;
    texture_glyph_t *glyph;
    ivec4 region;
    size_t missed = 0;
    width  = self->atlas->width;
    height = self->atlas->height;
    depth  = self->atlas->depth;

    region.x=1;
    region.y=1;

#ifdef RENDERSTRING
    stringwidth=0;
    stringheight=0;
    stringshift=0;
#endif

    if( !texture_font_load_face( &library, self->filename, self->size, &face ) )
    {
        return wcslen(charcodes);
    }

    /* Load each glyph */
    for( i=0; i<wcslen(charcodes); ++i )
    {
        glyph_index = FT_Get_Char_Index( face, charcodes[i] );
        // WARNING: We use texture-atlas depth to guess if user wants
        //          LCD subpixel rendering
        FT_Int32 flags = 0;

        if( self->outline_type > 0 )
        {
            flags |= FT_LOAD_NO_BITMAP;
        }
        else
        {
            flags |= FT_LOAD_RENDER;
        }

        if( !self->hinting )
        {
            flags |= FT_LOAD_NO_HINTING | FT_LOAD_NO_AUTOHINT;
        }
        else
        {
            flags |= FT_LOAD_FORCE_AUTOHINT;
        }


        if( depth == 3 )
        {
            FT_Library_SetLcdFilter( library, FT_LCD_FILTER_LIGHT );
            flags |= FT_LOAD_TARGET_LCD;
            if( self->filtering )
            {
//                FT_Library_SetLcdFilterWeights( library, self->lcd_weights );
            }
        }
        error = FT_Load_Glyph( face, glyph_index, flags );

        if( error )
        {
            fprintf( stderr, "FT_Error (line %d, code 0x%02x) : %s\n",
                     __LINE__, FT_Errors[error].code, FT_Errors[error].message );
            FT_Done_FreeType( library );
            return wcslen(charcodes)-i;
        }

        int ft_bitmap_width = 0;
        int ft_bitmap_rows = 0;
        int ft_bitmap_pitch = 0;
        int ft_glyph_top = 0;
        int ft_glyph_left = 0;
        if( self->outline_type == 0 )
        {
            slot            = face->glyph;
            ft_bitmap       = slot->bitmap;
            ft_bitmap_width = slot->bitmap.width;
            ft_bitmap_rows  = slot->bitmap.rows;
            ft_bitmap_pitch = slot->bitmap.pitch;
            ft_glyph_top    = slot->bitmap_top;
            ft_glyph_left   = slot->bitmap_left;
        }
        else
        {
            FT_Stroker stroker;
            error = FT_Stroker_New( library, &stroker );
            if( error )
            {
                fprintf(stderr, "FT_Error (0x%02x) : %s\n",
                        FT_Errors[error].code, FT_Errors[error].message);
                return 0;
            }
            FT_Stroker_Set( stroker,
                            (int)(self->outline_thickness *64),
                            FT_STROKER_LINECAP_ROUND,
                            FT_STROKER_LINEJOIN_ROUND,
                            0);
            error = FT_Get_Glyph( face->glyph, &ft_glyph);
            if( error )
            {
                fprintf(stderr, "FT_Error (0x%02x) : %s\n",
                        FT_Errors[error].code, FT_Errors[error].message);
                return 0;
            }

            if( self->outline_type == 1 )
            {
                error = FT_Glyph_Stroke( &ft_glyph, stroker, 1 );
            }
            else if ( self->outline_type == 2 )
            {
                error = FT_Glyph_StrokeBorder( &ft_glyph, stroker, 0, 1 );
            }
            else if ( self->outline_type == 3 )
            {
                error = FT_Glyph_StrokeBorder( &ft_glyph, stroker, 1, 1 );
            }
            if( error )
            {
                fprintf(stderr, "FT_Error (0x%02x) : %s\n",
                        FT_Errors[error].code, FT_Errors[error].message);
                return 0;
            }
          
            if( depth == 1)
            {
                error = FT_Glyph_To_Bitmap( &ft_glyph, FT_RENDER_MODE_NORMAL, 0, 1);
                if( error )
                {
                    fprintf(stderr, "FT_Error (0x%02x) : %s\n",
                            FT_Errors[error].code, FT_Errors[error].message);
                    return 0;
                }
            }
            else
            {
                error = FT_Glyph_To_Bitmap( &ft_glyph, FT_RENDER_MODE_LCD, 0, 1);
                if( error )
                {
                    fprintf(stderr, "FT_Error (0x%02x) : %s\n",
                            FT_Errors[error].code, FT_Errors[error].message);
                    return 0;
                }
            }
            FT_BitmapGlyph ft_bitmap_glyph = (FT_BitmapGlyph) ft_glyph;
            ft_bitmap       = ft_bitmap_glyph->bitmap;
            ft_bitmap_width = ft_bitmap.width;
            ft_bitmap_rows  = ft_bitmap.rows;
            ft_bitmap_pitch = ft_bitmap.pitch;
            ft_glyph_top    = ft_bitmap_glyph->top;
            ft_glyph_left   = ft_bitmap_glyph->left;
            FT_Stroker_Done(stroker);
        }


        // We want each glyph to be separated by at least one black pixel
        // (for example for shader used in demo-subpixel.c)
        w = ft_bitmap_width/depth + 1;
        h = ft_bitmap_rows + 1;

#ifdef RENDERSTRING
        static size_t maxh=0;
        if (charcodes[i]==13) { stringshift+=maxh+1; region.x=1; }
        if (h>maxh) maxh=h;
        //region.y=stringshift+maxh-h+1+(h-ft_glyph_top);
        region.y=stringshift+maxh-ft_glyph_top+1;
       // if (stringshift+h+h-ft_glyph_top+1>stringheight) stringheight=stringshift+h+h-ft_glyph_top+1;
        if (region.y+h>stringheight) stringheight=region.y+h;
        if (region.x+w>stringwidth) stringwidth=region.x+w;
//        if (region.y>=height) { missed++; continue; }
//        if (region.x+w>=width) {missed++; continue; }
       // if (h+h-ft_glyph_top+1>=height) { missed++; continue; }
       // if (h+h-ft_glyph_top+2>=height) { missed++; continue; }
//        if (region.y+maxh>=height) { missed++; continue; }
#else
        region = texture_atlas_get_region( self->atlas, w, h );
        if ( region.x < 0 )
        {
            missed++;
        //    fprintf( stderr, "Texture atlas is full (line %d)\n",  __LINE__ );
            continue;
        }
#endif
        w = w - 1;
        h = h - 1;
        x = region.x;
        y = region.y;
        if (charcodes[i]!=13) {

#ifdef RENDERSTRING
     if (!(x<width)||!((x+w)<=width)||!(y<height)||!((y+h)<=height)) { missed++; continue; }
#endif

          texture_atlas_set_region( self->atlas, x, y, w, h,
                                  ft_bitmap.buffer, ft_bitmap.pitch );
}
        glyph = texture_glyph_new( );
        glyph->charcode = charcodes[i];
        glyph->width    = w;
        glyph->height   = h;
        glyph->outline_type = self->outline_type;
        glyph->outline_thickness = self->outline_thickness;
        glyph->offset_x = ft_glyph_left;
        glyph->offset_y = ft_glyph_top;
        glyph->s0       = x/(float)width;
        glyph->t0       = y/(float)height;
        glyph->s1       = (x + glyph->width)/(float)width;
        glyph->t1       = (y + glyph->height)/(float)height;

        // Discard hinting to get advance
        FT_Load_Glyph( face, glyph_index, FT_LOAD_RENDER | FT_LOAD_NO_HINTING);
        slot = face->glyph;
        glyph->advance_x = slot->advance.x/64.0;
        glyph->advance_y = slot->advance.y/64.0;

#ifdef RENDERSTRING
        if (charcodes[i]!=13) region.x+=(int)glyph->advance_x;
#endif

        vector_push_back( self->glyphs, &glyph );
    }
    if( self->outline_type > 0 )
    {
        FT_Done_Glyph( ft_glyph );
    }
    FT_Done_Face( face );
    FT_Done_FreeType( library );
 //   texture_atlas_upload( self->atlas );
    texture_font_generate_kerning( self );
    return missed;
}
long EMSCRIPTEN_KEEPALIVE c_Glyph_toBitmap(long glyph, int renderMode) {
    FT_Glyph bitmap = (FT_Glyph)glyph;
    FT_Error error = FT_Glyph_To_Bitmap(&bitmap, (FT_Render_Mode)renderMode, NULL, 1);
    if(error) return 0;
    return (long)bitmap;
}
Beispiel #16
0
/** 转换FT_GlyphSlot类型数据为LCUI_FontBMP */
static int Convert_FTGlyph( LCUI_FontBMP *bmp, FT_GlyphSlot slot, int mode )
{
	int error;
	size_t size;
	FT_BitmapGlyph bitmap_glyph;
	FT_Glyph  glyph;

	/* 从字形槽中提取一个字形图像
	 * 请注意,创建的FT_Glyph对象必须与FT_Done_Glyph成对使用 */
	error = FT_Get_Glyph( slot, &glyph );
	if(error) {
		return -1;
	}
	/*---------------------- 打印字体信息 --------------------------
	printf(" width= %ld,  met->height= %ld\n"
	"horiBearingX = %ld, horiBearingY = %ld, horiAdvance = %ld\n"
	"vertBearingX = %ld, vertBearingY = %ld,  vertAdvance = %ld\n",
	slot->metrics.width>>6, slot->metrics.height>>6,
	slot->metrics.horiBearingX>>6, slot->metrics.horiBearingY>>6,
	slot->metrics.horiAdvance>>6, slot->metrics.vertBearingX>>6,
	slot->metrics.vertBearingY>>6, slot->metrics.vertAdvance>>6 );
	------------------------------------------------------------*/
	if ( glyph->format != FT_GLYPH_FORMAT_BITMAP ) {
		error = FT_Glyph_To_Bitmap(&glyph, mode, 0 ,1);
		if(error) {
			return -1;
		}
	}
	bitmap_glyph = (FT_BitmapGlyph)glyph;
	/*
	 * FT_Glyph_Metrics结构体中保存字形度量,通过face->glyph->metrics结
	 * 构访问,可得到字形的宽、高、左边界距、上边界距、水平跨距等等。
	 * 注意:因为不是所有的字体都包含垂直度量,当FT_HAS_VERTICAL为假时,
	 * vertBearingX,vertBearingY和vertAdvance的值是不可靠的,目前暂不考虑
	 * 此情况的处理。
	 * */
	bmp->top = bitmap_glyph->top;
	bmp->left = slot->metrics.horiBearingX>>6;
	bmp->rows = bitmap_glyph->bitmap.rows;
	bmp->width = bitmap_glyph->bitmap.width;
	bmp->advance.x = slot->metrics.horiAdvance>>6;	/* 水平跨距 */
	bmp->advance.y = slot->metrics.vertAdvance>>6;	/* 垂直跨距 */
	/* 分配内存,用于保存字体位图 */
	size = bmp->rows * bmp->width * sizeof(uchar_t);
	bmp->buffer = (uchar_t*)malloc( size );
	if( !bmp->buffer ) {
		FT_Done_Glyph(glyph);
		return -1;
	}

	switch( bitmap_glyph->bitmap.pixel_mode ) {
	    /* 8位灰度位图,直接拷贝 */
	    case FT_PIXEL_MODE_GRAY:
		memcpy( bmp->buffer, bitmap_glyph->bitmap.buffer, size );
		break;
	    /* 单色点阵图,需要转换 */
	    case FT_PIXEL_MODE_MONO: {
		FT_Bitmap bitmap;
		FT_Library lib;
		FT_Int x, y;
		uchar_t *t, *s;

		lib = FontLIB_GetLibrary();
		FT_Bitmap_New( &bitmap );
		/* 转换位图bitmap_glyph->bitmap至bitmap,1个像素占1个字节 */
		FT_Bitmap_Convert( lib, &bitmap_glyph->bitmap, &bitmap, 1);
		s = bitmap.buffer;
		t = bmp->buffer;
		for( y=0; y<bmp->rows; ++y ) {
			for( x=0; x<bmp->width; ++x ) {
				*t = *s?255:0;
				++t,++s;
			}
		}
		FT_Bitmap_Done( lib, &bitmap );
		break;
	    }
	    /* 其它像素模式的位图,暂时先直接填充255,等需要时再完善 */
	    default:
		memset( bmp->buffer, 255, size );
		break;
	}
	FT_Done_Glyph(glyph);
	return size;
}
Beispiel #17
0
void freetype_genFontTexture_ascii(FT_Face face, c_font *gameFont, unsigned int pixel_height)
{    
    const unsigned int glyphsToRender = 256;    // ASCII set, change at your peril
    GLubyte *pixel_data;
    
    unsigned int glyph_pixel_width = 0;
    unsigned int glyph_pixel_height = 0;
    
    unsigned int texture_width = 0;
    unsigned int texture_height = 0;
    
    FT_Glyph        glyphArray[glyphsToRender];
    FT_BitmapGlyph  bitmapGlyphArray[glyphsToRender];
    
    unsigned int lv;    // loop variable
    
    // first loop through glyphs to determine how big the bigest one is.
    for (lv=0 ; lv<glyphsToRender ; lv++)
    {
        int error;
        
        error = FT_Load_Glyph(face, FT_Get_Char_Index( face, lv), FT_LOAD_DEFAULT);
        if (error)
        {
            printf("FT_Load_Glyph [%u]  ", error);
        }
        error = FT_Get_Glyph( face->glyph, &glyphArray[lv] );
        if (error)
        {
            printf("FT_Get_Glyph [%u]  ", error);
        }
        
        FT_Glyph_To_Bitmap( &glyphArray[lv], ft_render_mode_normal, 0, 1 );
        
        bitmapGlyphArray[lv] = (FT_BitmapGlyph)glyphArray[lv];
        FT_Bitmap& bitmap = bitmapGlyphArray[lv]->bitmap;
        
        if ((unsigned int)bitmap.rows > glyph_pixel_height) glyph_pixel_height = bitmap.rows;
        if ((unsigned int)bitmap.width > glyph_pixel_width) glyph_pixel_width = bitmap.width;
    }
    
    // make sure each glyph is a power of 2
    // not 100% necessary, but if we want each glyph to have an equal percentage
    //  of texture space we better do it.
    glyph_pixel_width = next_power_of_2(glyph_pixel_width);
    glyph_pixel_height = next_power_of_2(glyph_pixel_height);
    
    // now all glyph specs are pretty much finalized (so lets brag about it)
    printf(" character size: %ux%u, ", glyph_pixel_width, glyph_pixel_height);
    texture_width = glyph_pixel_width * 16;
    texture_height = glyph_pixel_height * 16;
    printf("ascii texture size: %ux%u\n", texture_width, texture_height);
    
    // make some pixel data in ram (this will be the font texture)
    unsigned int bytesForImage = 2 * texture_width * texture_height;
    pixel_data = new GLubyte[bytesForImage];
    
    // zero out all the newly allocated data
    for (unsigned int clearloop=0 ; clearloop < bytesForImage ; clearloop++ )
    {
        pixel_data[clearloop] = 0;
    }
    
    unsigned int glyphX_start = 0;
    unsigned int glyphY_start = 0;
    
    // now to go through each glyph again
    for (lv=0 ; lv<glyphsToRender ; lv++ )
    {
        FT_Bitmap& bitmap = bitmapGlyphArray[lv]->bitmap;
        
        glyphX_start = lv % 16;
        glyphY_start = lv / 16;
        
        glyphX_start *= glyph_pixel_width;
        glyphY_start *= glyph_pixel_height;
        
        // draw glyph out in the correct spot on the 16x16 glyph texture
        for(unsigned int gx=0; gx< (unsigned int)bitmap.width; gx++)
        {
            for(unsigned int gy=0; gy< (unsigned int)bitmap.rows ; gy++)
            {
                unsigned char *byte_luminence;
                unsigned char *byte_alpha;
                
                // calculate which pixels to work on
                unsigned int pixel_mem_loc =
                2 * (        // channels: luminence & alpha
                     texture_width *
                     (glyphY_start + gy) +
                     glyphX_start + gx
                     );
                
                byte_luminence = &pixel_data[  pixel_mem_loc  ];
                byte_alpha = &pixel_data[ pixel_mem_loc + 1 ];
                
                *byte_luminence = 255;      // or this if you'd rather do this to blacken the alpha edges:  bitmap.buffer[gx + bitmap.width * gy];
                *byte_alpha = bitmap.buffer[gx + bitmap.width * gy];
            }
        }
        
        // pixel coordinates for glyph
        unsigned int top = (lv / 16) * glyph_pixel_height;
        unsigned int left = (lv % 16) * glyph_pixel_width;
        unsigned int bottom = top + bitmap.rows;
        unsigned int right = left + bitmap.width;
        
        // texture coordinates for glyph
        float uv_top = (float)top / texture_height;
        float uv_left = (float)left / texture_width;
        float uv_bottom = (float)bottom / texture_height;
        float uv_right = (float)right / texture_width;
        
        // seems some letters get cut too short to see their nice anti-aliasing - should probably do this when rendering
        //  but then again it's probably a single pixel of low alpha that's getting cut so it may be best to do a single
        //  pixel pad here, on the left and right sides.
        uv_top -= 1 * (1.0f / texture_height);
        uv_left -= 1 * (1.0f / texture_width);
        uv_bottom += 1 * (1.0f / texture_height);
        uv_right += 1 * (1.0f / texture_width);
        
        //////////////////////////////////////////////////////////////////
        // actually assign this data to the class
        gameFont->glyph[lv].set_uv(pixel_height, texture_width, texture_height, uv_top, uv_left, uv_bottom, uv_right);
        
        // figure out how much to lower characters that hang below the line
        float shift_y = (float)bitmap.rows - (float)bitmapGlyphArray[lv]->top;
        shift_y /= texture_height;
        
        gameFont->glyph[lv].set_shift(pixel_height, texture_height, shift_y);
        
        // set the advance - not used yet
        //face->glyph->advance;
        float advance = glyphArray[lv]->advance.x;
        gameFont->glyph[lv].set_advance(pixel_height, texture_width, advance);
        
        // test to see if glyph uv coordinates are what they should be
        /*if (lv == (unsigned int)'g')
         {
         printf("%c - uv(t=%f, l=%f, b=%f, r=%f) - shift(y=%f) - advance(x=%f)\n",
         (char)lv,
         gameFont->glyph[lv].uv_top(),
         gameFont->glyph[lv].uv_left(),
         gameFont->glyph[lv].uv_bottom(),
         gameFont->glyph[lv].uv_right(),
         gameFont->glyph[lv].shift_y(),
         gameFont->glyph[lv].advance_x());
         
         }*/
    }
    
    glGenTextures(1, &gameFont->opengl_texture_id);
    glBindTexture( GL_TEXTURE_2D, gameFont->opengl_texture_id);
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR_MIPMAP_LINEAR);
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
    
    //Here we actually create the texture itself, notice
    //that we are using GL_LUMINANCE_ALPHA to indicate that
    //we are using 2 channel data.
    
    //glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, texture_width, texture_height, 0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, pixel_data );
    
    // do that line above - or build some mipmaps for trilinear filtering
    gluBuild2DMipmaps( GL_TEXTURE_2D, GL_LUMINANCE_ALPHA, texture_width, texture_height, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, pixel_data );
    
    //printf("texture specs: %ux%u\n", wsf, height);
    
    // now that all of that the image has been loading into the
    //  graphics card, we can free up the copy we built in the ram
    delete pixel_data;
}
Beispiel #18
0
static int LayoutLine( filter_t *p_filter,
                       paragraph_t *p_paragraph,
                       int i_start_offset, int i_end_offset,
                       line_desc_t **pp_line )
{
    if( p_paragraph->i_size <= 0 || p_paragraph->i_runs_count <= 0
     || i_start_offset >= i_end_offset
     || i_start_offset < 0 || i_start_offset >= p_paragraph->i_size
     || i_end_offset <= 0  || i_end_offset > p_paragraph->i_size )
    {
        msg_Err( p_filter,
                 "LayoutLine() invalid parameters. "
                 "Paragraph size: %d. Runs count: %d. "
                 "Start offset: %d. End offset: %d",
                 p_paragraph->i_size, p_paragraph->i_runs_count,
                 i_start_offset, i_end_offset );
        return VLC_EGENERIC;
    }

    line_desc_t *p_line = NewLine( i_end_offset - i_start_offset );

    if( !p_line )
        return VLC_ENOMEM;

    filter_sys_t *p_sys = p_filter->p_sys;
    int i_last_run = -1;
    run_desc_t *p_run = 0;
    text_style_t *p_style = 0;
    FT_Face p_face = 0;
    FT_Vector pen = { .x = 0, .y = 0 };
    int i_line_index = 0;

    int i_font_width = 0;
    int i_ul_offset = 0;
    int i_ul_thickness = 0;

#ifdef HAVE_FRIBIDI
    fribidi_reorder_line( 0, p_paragraph->p_types + i_start_offset,
                          i_end_offset - i_start_offset,
                          0, p_paragraph->paragraph_type,
                          p_paragraph->p_levels + i_start_offset,
                          0, p_paragraph->pi_reordered_indices + i_start_offset );
#endif

    for( int i = i_start_offset; i < i_end_offset; ++i, ++i_line_index )
    {
        int i_paragraph_index;
#ifdef HAVE_FRIBIDI
        i_paragraph_index = p_paragraph->pi_reordered_indices[ i ];
#else
        i_paragraph_index = i;
#endif

        line_character_t *p_ch = p_line->p_character + i_line_index;
        glyph_bitmaps_t *p_bitmaps =
                p_paragraph->p_glyph_bitmaps + i_paragraph_index;

        if( !p_bitmaps->p_glyph )
        {
            --i_line_index;
            continue;
        }

        if( i_last_run != p_paragraph->pi_run_ids[ i_paragraph_index ] )
        {
            i_last_run = p_paragraph->pi_run_ids[ i_paragraph_index ];
            p_run = p_paragraph->p_runs + i_last_run;
            p_style = p_run->p_style;
            p_face = p_run->p_face;

            i_font_width = p_style->i_style_flags & STYLE_HALFWIDTH ?
                           p_style->i_font_size / 2 : p_style->i_font_size;
        }

        FT_Vector pen_new = {
            .x = pen.x + p_paragraph->p_glyph_bitmaps[ i_paragraph_index ].i_x_offset,
            .y = pen.y + p_paragraph->p_glyph_bitmaps[ i_paragraph_index ].i_y_offset
        };
        FT_Vector pen_shadow = {
            .x = pen_new.x + p_sys->f_shadow_vector_x * ( i_font_width << 6 ),
            .y = pen_new.y + p_sys->f_shadow_vector_y * ( p_style->i_font_size << 6 )
        };

        if( p_bitmaps->p_shadow )
        {
            if( FT_Glyph_To_Bitmap( &p_bitmaps->p_shadow, FT_RENDER_MODE_NORMAL,
                                    &pen_shadow, 0 ) )
                p_bitmaps->p_shadow = 0;
            else
                FT_Glyph_Get_CBox( p_bitmaps->p_shadow, ft_glyph_bbox_pixels,
                                   &p_bitmaps->shadow_bbox );
        }
        if( p_bitmaps->p_glyph )
        {
            if( FT_Glyph_To_Bitmap( &p_bitmaps->p_glyph, FT_RENDER_MODE_NORMAL,
                                    &pen_new, 1 ) )
            {
                FT_Done_Glyph( p_bitmaps->p_glyph );
                if( p_bitmaps->p_outline )
                    FT_Done_Glyph( p_bitmaps->p_outline );
                if( p_bitmaps->p_shadow )
                    FT_Done_Glyph( p_bitmaps->p_shadow );
                --i_line_index;
                continue;
            }
            else
                FT_Glyph_Get_CBox( p_bitmaps->p_glyph, ft_glyph_bbox_pixels,
                                   &p_bitmaps->glyph_bbox );
        }
        if( p_bitmaps->p_outline )
        {
            if( FT_Glyph_To_Bitmap( &p_bitmaps->p_outline, FT_RENDER_MODE_NORMAL,
                                    &pen_new, 1 ) )
            {
                FT_Done_Glyph( p_bitmaps->p_outline );
                p_bitmaps->p_outline = 0;
            }
            else
                FT_Glyph_Get_CBox( p_bitmaps->p_outline, ft_glyph_bbox_pixels,
                                   &p_bitmaps->outline_bbox );
        }

        FixGlyph( p_bitmaps->p_glyph, &p_bitmaps->glyph_bbox,
                  p_bitmaps->i_x_advance, p_bitmaps->i_y_advance,
                  &pen_new );
        if( p_bitmaps->p_outline )
            FixGlyph( p_bitmaps->p_outline, &p_bitmaps->outline_bbox,
                      p_bitmaps->i_x_advance, p_bitmaps->i_y_advance,
                      &pen_new );
        if( p_bitmaps->p_shadow )
            FixGlyph( p_bitmaps->p_shadow, &p_bitmaps->shadow_bbox,
                      p_bitmaps->i_x_advance, p_bitmaps->i_y_advance,
                      &pen_shadow );

        int i_line_offset    = 0;
        int i_line_thickness = 0;
        text_style_t *p_glyph_style = p_paragraph->pp_styles[ i_paragraph_index ];
        if( p_glyph_style->i_style_flags & (STYLE_UNDERLINE | STYLE_STRIKEOUT) )
        {
            i_line_offset =
                abs( FT_FLOOR( FT_MulFix( p_face->underline_position,
                                          p_face->size->metrics.y_scale ) ) );

            i_line_thickness =
                abs( FT_CEIL( FT_MulFix( p_face->underline_thickness,
                                         p_face->size->metrics.y_scale ) ) );

            if( p_glyph_style->i_style_flags & STYLE_STRIKEOUT )
            {
                /* Move the baseline to make it strikethrough instead of
                 * underline. That means that strikethrough takes precedence
                 */
                i_line_offset -=
                    abs( FT_FLOOR( FT_MulFix( p_face->descender * 2,
                                              p_face->size->metrics.y_scale ) ) );
            }
            else if( i_line_thickness > 0 )
            {
                p_bitmaps->glyph_bbox.yMin =
                    __MIN( p_bitmaps->glyph_bbox.yMin,
                           - i_line_offset - i_line_thickness );

                /* The real underline thickness and position are
                 * updated once the whole line has been parsed */
                i_ul_offset = __MAX( i_ul_offset, i_line_offset );
                i_ul_thickness = __MAX( i_ul_thickness, i_line_thickness );
                i_line_thickness = -1;
            }
        }

        p_ch->p_glyph = ( FT_BitmapGlyph ) p_bitmaps->p_glyph;
        p_ch->p_outline = ( FT_BitmapGlyph ) p_bitmaps->p_outline;
        p_ch->p_shadow = ( FT_BitmapGlyph ) p_bitmaps->p_shadow;

        bool b_karaoke = p_paragraph->pi_karaoke_bar[ i_paragraph_index ] != 0;
        p_ch->i_color = b_karaoke ?
                        ( uint32_t ) p_glyph_style->i_karaoke_background_color
                      |              p_glyph_style->i_karaoke_background_alpha << 24
                      : ( uint32_t ) p_glyph_style->i_font_color
                      |              p_glyph_style->i_font_alpha << 24;

        p_ch->i_line_thickness = i_line_thickness;
        p_ch->i_line_offset = i_line_offset;

        BBoxEnlarge( &p_line->bbox, &p_bitmaps->glyph_bbox );
        if( p_bitmaps->p_outline )
            BBoxEnlarge( &p_line->bbox, &p_bitmaps->outline_bbox );
        if( p_bitmaps->p_shadow )
            BBoxEnlarge( &p_line->bbox, &p_bitmaps->shadow_bbox );

        pen.x += p_bitmaps->i_x_advance;
        pen.y += p_bitmaps->i_y_advance;
    }

    p_line->i_width = __MAX( 0, p_line->bbox.xMax - p_line->bbox.xMin );
    p_line->i_height = __MAX( 0, p_line->bbox.yMax - p_line->bbox.yMin );
    p_line->i_character_count = i_line_index;

    if( i_ul_thickness > 0 )
    {
        for( int i = 0; i < p_line->i_character_count; i++ )
        {
            line_character_t *ch = &p_line->p_character[i];
            if( ch->i_line_thickness < 0 )
            {
                ch->i_line_offset    = i_ul_offset;
                ch->i_line_thickness = i_ul_thickness;
            }
        }
    }

    *pp_line = p_line;
    return VLC_SUCCESS;
}

static int LayoutParagraph( filter_t *p_filter, paragraph_t *p_paragraph,
                            int i_max_pixel_width, line_desc_t **pp_lines )
{
    if( p_paragraph->i_size <= 0 || p_paragraph->i_runs_count <= 0 )
    {
        msg_Err( p_filter, "LayoutParagraph() invalid parameters. "
                 "Paragraph size: %d. Runs count %d",
                 p_paragraph->i_size, p_paragraph->i_runs_count );
        return VLC_EGENERIC;
    }

    int i_line_start = 0;
    FT_Pos i_width = 0;
    FT_Pos i_max_width = i_max_pixel_width << 6;
    FT_Pos i_preferred_width = 0;
    FT_Pos i_total_width = 0;
    FT_Pos i_last_space_width = 0;
    int i_last_space = -1;
    line_desc_t *p_first_line = 0;
    line_desc_t **pp_line = &p_first_line;

    for( int i = 0; i < p_paragraph->i_size; ++i )
    {
#ifdef HAVE_FRIBIDI
        p_paragraph->pi_reordered_indices[ i ] = i;
#endif
        i_total_width += p_paragraph->p_glyph_bitmaps[ i ].i_x_advance;
    }

    int i_line_count = i_total_width / i_max_width + 1;
    i_preferred_width = i_total_width / i_line_count;

    for( int i = 0; i <= p_paragraph->i_size; ++i )
    {
        if( i == p_paragraph->i_size )
        {
            if( i_line_start < i )
                if( LayoutLine( p_filter, p_paragraph,
                                i_line_start, i, pp_line ) )
                    goto error;

            break;
        }

        if( p_paragraph->p_code_points[ i ] == ' '
#ifdef HAVE_FRIBIDI
            || p_paragraph->p_types[ i ] == FRIBIDI_TYPE_WS
#endif
          )
        {
            if( i_line_start == i )
            {
                /*
                 * Free orphaned white space glyphs not belonging to any lines.
                 * At this point p_shadow points to either p_glyph or p_outline,
                 * so we should not free it explicitly.
                 */
                if( p_paragraph->p_glyph_bitmaps[ i ].p_glyph )
                    FT_Done_Glyph( p_paragraph->p_glyph_bitmaps[ i ].p_glyph );
                if( p_paragraph->p_glyph_bitmaps[ i ].p_outline )
                    FT_Done_Glyph( p_paragraph->p_glyph_bitmaps[ i ].p_outline );

                i_line_start = i + 1;
                continue;
            }

            if( i_last_space == i - 1 )
            {
                p_paragraph->p_glyph_bitmaps[ i - 1 ].i_x_advance = 0;
                i_last_space = i;
                continue;
            }

            i_last_space = i;
            i_last_space_width = i_width;
        }

        i_width += p_paragraph->p_glyph_bitmaps[ i ].i_x_advance;

        if( i_last_space_width >= i_preferred_width
         || i_width >= i_max_width )
        {
            if( i_line_start == i )
            {
                msg_Err( p_filter,
                         "LayoutParagraph(): Width of single glyph exceeds maximum" );
                goto error;
            }

            int i_end_offset;
            if( i_last_space > i_line_start )
                i_end_offset = i_last_space;
            else
                i_end_offset = i;

            if( LayoutLine( p_filter, p_paragraph, i_line_start,
                            i_end_offset, pp_line ) )
                goto error;

            pp_line = &( *pp_line )->p_next;
            i_line_start = i_end_offset;
            i = i_line_start - 1;
            i_width = 0;
            i_last_space_width = 0;
        }
    }

    *pp_lines = p_first_line;
    return VLC_SUCCESS;

error:
    for( int i = i_line_start; i < p_paragraph->i_size; ++i )
    {
        if( p_paragraph->p_glyph_bitmaps[ i ].p_glyph )
            FT_Done_Glyph( p_paragraph->p_glyph_bitmaps[ i ].p_glyph );
        if( p_paragraph->p_glyph_bitmaps[ i ].p_outline )
            FT_Done_Glyph( p_paragraph->p_glyph_bitmaps[ i ].p_outline );
    }
    if( p_first_line )
        FreeLines( p_first_line );
    return VLC_EGENERIC;
}

int LayoutText( filter_t *p_filter, line_desc_t **pp_lines,
                FT_BBox *p_bbox, int *pi_max_face_height,

                uni_char_t *psz_text, text_style_t **pp_styles,
                uint32_t *pi_k_dates, int i_len )
{
    line_desc_t *p_first_line = 0;
    line_desc_t **pp_line = &p_first_line;
    paragraph_t *p_paragraph = 0;
    int i_paragraph_start = 0;
    int i_max_height = 0;

    for( int i = 0; i <= i_len; ++i )
    {
        if( i == i_len || psz_text[ i ] == '\n' )
        {
            if( i_paragraph_start == i )
            {
                i_paragraph_start = i + 1;
                continue;
            }

            p_paragraph = NewParagraph( p_filter, i - i_paragraph_start,
                                        psz_text + i_paragraph_start,
                                        pp_styles + i_paragraph_start,
                                        pi_k_dates ?
                                        pi_k_dates + i_paragraph_start : 0,
                                        20 );
            if( !p_paragraph )
            {
                if( p_first_line ) FreeLines( p_first_line );
                return VLC_ENOMEM;
            }

#ifdef HAVE_FRIBIDI
            if( AnalyzeParagraph( p_paragraph ) )
                goto error;
#endif

            if( ItemizeParagraph( p_filter, p_paragraph ) )
                goto error;

#if defined HAVE_HARFBUZZ
            if( ShapeParagraphHarfBuzz( p_filter, &p_paragraph ) )
                goto error;

            if( LoadGlyphs( p_filter, p_paragraph, true, false ) )
                goto error;

#elif defined HAVE_FRIBIDI
            if( ShapeParagraphFriBidi( p_filter, p_paragraph ) )
                goto error;
            if( LoadGlyphs( p_filter, p_paragraph, false, true ) )
                goto error;
            if( RemoveZeroWidthCharacters( p_paragraph ) )
                goto error;
            if( ZeroNsmAdvance( p_paragraph ) )
                goto error;
#else
            if( LoadGlyphs( p_filter, p_paragraph, false, true ) )
                goto error;
#endif

            /*
             * Set max line width to allow for outline and shadow glyphs,
             * and any extra width caused by visual reordering
             */
            int i_max_width = ( int ) p_filter->fmt_out.video.i_visible_width
                              - 2 * p_filter->p_sys->style.i_font_size;
            if( LayoutParagraph( p_filter, p_paragraph,
                                 i_max_width, pp_line ) )
                goto error;

            FreeParagraph( p_paragraph );
            p_paragraph = 0;

            for( ; *pp_line; pp_line = &( *pp_line )->p_next )
                i_max_height = __MAX( i_max_height, ( *pp_line )->i_height );

            i_paragraph_start = i + 1;
        }
    }

    int i_base_line = 0;
    FT_BBox bbox = {
        .xMin = INT_MAX,
        .yMin = INT_MAX,
        .xMax = INT_MIN,
        .yMax = INT_MIN
    };

    for( line_desc_t *p_line = p_first_line; p_line; p_line = p_line->p_next )
    {
        p_line->i_base_line = i_base_line;
        p_line->bbox.yMin -= i_base_line;
        p_line->bbox.yMax -= i_base_line;
        BBoxEnlarge( &bbox, &p_line->bbox );

        i_base_line += i_max_height;
    }

    *pp_lines = p_first_line;
    *p_bbox = bbox;
    *pi_max_face_height = i_max_height;
    return VLC_SUCCESS;

error:
    if( p_first_line ) FreeLines( p_first_line );
    if( p_paragraph ) FreeParagraph( p_paragraph );
    return VLC_EGENERIC;
}
Beispiel #19
0
/*
    TODO: Font rendering MUST be redesigned.
*/
Font* GuiRendererD3D11::MakeFont(const char* pPath, int height)
{
    Common::Timer timer;
    timer.Start();

    FT_Face face;
    int texWidth = 4096;
    int texHeight = 4096;

    //create pixels array
    unsigned char* pTexData = (unsigned char*)malloc(texWidth * texHeight);
    ZeroMemory(pTexData, texWidth * texHeight);

    if (FT_New_Face(mFreeTypeLibrary, pPath, 0, &face) != 0)
    {
        free(pTexData);
        // TODO
        // LOG_ERROR("Failed to load font '%s'.", pPath);
        return 0;
    }

    //FT_Set_Pixel_Sizes(face, 2*height, 2*height);
    FT_Set_Char_Size(face, 0, height * 64, 96, 96);


    Font* pFont = new Font;

    /*
    FT_Matrix Transform;
    Transform.xx = (FT_Fixed)(1.0f * 0x10000L);
    Transform.xy = (FT_Fixed)(0.0f * 0x10000L);
    Transform.yx = (FT_Fixed)(0.0f * 0x10000L);
    Transform.yy = (FT_Fixed)(1.0f * 0x10000L);
    FT_Set_Transform(face, &Transform, 0);
    */

    int Width;
    int Height;
    int OffsetX = 0;
    int OffsetY = 0;

    pFont->height = height;
    pFont->charCount = 65536;
    pFont->characters = (CharacterInfo*)malloc(sizeof(CharacterInfo) * pFont->charCount);

    int Index = 0;
    for (int ChrId = 0; ChrId < (65536); ChrId++)
    {
        // Load The Glyph For Our Character.
        unsigned int GlyphIndex = FT_Get_Char_Index(face, ChrId);
        if (GlyphIndex == 0)
        {
            pFont->characters[ChrId].exists = false;
            continue;
        }

        FT_Load_Glyph(face, GlyphIndex, FT_LOAD_DEFAULT);


        // Move The Face's Glyph Into A Glyph Object.
        FT_Glyph glyph;
        FT_Get_Glyph(face->glyph, &glyph);


        // Convert The Glyph To A Bitmap.
        FT_Glyph_To_Bitmap(&glyph, FT_RENDER_MODE_NORMAL, 0, 1);
        FT_BitmapGlyph bitmap_glyph = (FT_BitmapGlyph)glyph;

        // This Reference Will Make Accessing The Bitmap Easier.
        FT_Bitmap& bitmap = bitmap_glyph->bitmap;


        Width = bitmap.width;
        Height = bitmap.rows;

        //char won't fit to texture
        if (OffsetX + Width + 2 > texWidth)
        {
            OffsetX = 0;
            OffsetY += 2 * height;
        }

        for (int y = 0; y < Height; y++)
        {
            for (int x = 0; x < Width; x++)
            {
                unsigned char Value = bitmap.buffer[x + Width * y];

                int PxOffset = (y + OffsetY) * texWidth + x + OffsetX;
                pTexData[PxOffset] = Value;
            }
        }


        pFont->characters[ChrId].exists = true;
        pFont->characters[ChrId].top = (short)bitmap_glyph->top;
        pFont->characters[ChrId].left = (short)bitmap_glyph->left;
        pFont->characters[ChrId].height = (short)Height;
        pFont->characters[ChrId].width = (short)Width;
        pFont->characters[ChrId].u = (short)OffsetX;
        pFont->characters[ChrId].v = (short)OffsetY;
        pFont->characters[ChrId].spacing = (short)(face->glyph->advance.x >> 6) + 1;
        FT_Done_Glyph(glyph);

        OffsetX += pFont->characters[ChrId].width + 1;
        Index++;
    }

    //close font
    FT_Done_Face(face);

    OffsetY += 2 * height; // Used texture height
    texHeight = CeilToPowerOf2(OffsetY);


    Common::Image fontImage;
    fontImage.SetData(pTexData, texWidth, texHeight, Common::ImageFormat::A_UBYTE);
//  pFont->texture = pRenderer->CreateTexture(&fontImage, false);
    pFont->texture = new RendererTextureD3D11;
    pFont->texture->FromImage(fontImage);


    pFont->texHeight = texHeight;
    pFont->texWidth = texWidth;

    free(pTexData);

    // TODO
    // LOG_SUCCESS("Font '%s', size %i loaded in %.3lf seconds.", pPath, height, timer.Stop());
    return pFont;
}
/*
 * Renders a glyph immediately, then tries to puts it into cache.
 * rend and rend->face must be not 0
 */
static GLYPH* _gk_rend_workout(GLYPH_REND* const rend,const unsigned unicode)
{
    unsigned glyph_index;
    int bmp_size;
    int error;
    int center_x = 0,center_y = 0;
    FT_Glyph ft_glyph = 0;
    GLYPH* glyph;
    GLYPH_FACE* actual_face;
    unsigned actual_code;

#ifdef GLYPH_LOG
    if (glyph_log) fprintf(glyph_log,"_gk_rend_workout(%p,%d) begin\n",(void*)rend,unicode);
#endif

    CARE(rend && rend->face);
    CARE(unicode > 0);
    CARE(unicode <= GK_MAX_UNICODE);

    funcname = "_gk_rend_workout()";

    _gk_find_mapping(rend->face,unicode,&actual_face,&actual_code);
    if (!actual_face || !actual_code) return 0;
    if (!actual_face->face) return 0;

    glyph_index = FT_Get_Char_Index(actual_face->face,actual_code);
    if (!glyph_index)
    {
        if (unicode==rend->undefined_char || unicode==rend->error_char) return 0;
        else return _gk_rend_render(rend,rend->undefined_char);
    }

#ifdef GLYPH_LOG
    if (glyph_log) fprintf(glyph_log,"    glyph_index is %u\n",glyph_index);
#endif

    /* Preparing for glyph loading: setting size */
    /*FT_Activate_Size(size);*/
    if (actual_face == rend->face)
    {
        error = (rend->size == 0);
        if (!error) actual_face->face->size = rend->size;
    }
    else
    {
        error = (actual_face->own_size == 0);
        if (!error)
        {
            actual_face->face->size = actual_face->own_size;
            error = FT_Set_Char_Size(actual_face->face,rend->hsize,rend->vsize,72,72);
        }
    }

#ifdef GLYPH_LOG
    if (error)
    {
        if (glyph_log) fprintf(glyph_log,"    Failed to select size\n");
    }
    else
    {
        if (glyph_log) fprintf(glyph_log,"    Size selected successfully\n");
    }
#endif

    /* Loading a glyph with FreeType */
    if (!error)
    {
        error = FT_Load_Glyph(actual_face->face,glyph_index,rend->load_flags);
        if (error)
            _gk_msg("Error: %s: FT_Load_Glyph() bugs on glyph (#%d) for character U+%04X\n",funcname,glyph_index,unicode);
        else
        {
            error = (actual_face->face->glyph == 0);
            if (error) _gk_msg("Error: %s: Empty glyph slot after FT_Load_Glyph()\n",funcname);
        }

/*#ifdef GLYPH_LOG
        if (error)
        {
            if (glyph_log) fprintf(glyph_log,"    Could not load a glyph with FT_Load_Glyph()\n");
        }
        else
        {
            if (glyph_log) fprintf(glyph_log,"    Loaded a glyph with FT_Load_Glyph()\n");
        }
#endif*/
    }


    /* Getting center coordinates (MEGA-HACK) */
    /* This whole idea should be re-made in more optimal way */
    if (!error)
    {
/*#ifdef GLYPH_LOG
        if (glyph_log) fprintf(glyph_log,"    Getting a center point\n");
#endif*/
        FT_Glyph g = 0;
        error = FT_Get_Glyph(actual_face->face->glyph, &g);
/*#ifdef GLYPH_LOG
        if (glyph_log)
        {
            if (error)
                fprintf(glyph_log,"    FT_Get_Glyph() failed\n");
            else
                fprintf(glyph_log,"    FT_Get_Glyph() succeeded\n");
            if (g)
                fprintf(glyph_log,"    FT_Get_Glyph() returned not 0\n");
            else
                fprintf(glyph_log,"    FT_Get_Glyph() returned 0\n");
        }
#endif*/

        error = error || !g;
        if (!error && g->format==FT_GLYPH_FORMAT_OUTLINE)
        {
/*#ifdef GLYPH_LOG
            if (glyph_log) fprintf(glyph_log,"    Calling FT_Glyph_To_Bitmap()\n");
#endif*/
            error = FT_Glyph_To_Bitmap(&g,rend->render_mode,0,1);
/*#ifdef GLYPH_LOG
            if (glyph_log)
            {
                if (error)
                    fprintf(glyph_log,"    FT_Glyph_To_Bitmap() failed\n");
                else
                    fprintf(glyph_log,"    FT_Glyph_To_Bitmap() succeeded\n");
            }
#endif*/
            if (!error)
            {
                center_x = 64 * ((FT_BitmapGlyph)g)->left + 64 * ((FT_BitmapGlyph)g)->bitmap.width / 2;
                center_y = 64 * ((FT_BitmapGlyph)g)->top - 64 * ((FT_BitmapGlyph)g)->bitmap.rows / 2;
                /*center_x = 64 * ((FT_BitmapGlyph)g)->bitmap.width / 2;
                center_y = -64 * ((FT_BitmapGlyph)g)->bitmap.rows / 2;*/
            }
        }
        if (g)
        {
/*#ifdef GLYPH_LOG
            if (glyph_log) fprintf(glyph_log,"    Calling FT_Done_Glyph()\n");
#endif*/
            FT_Done_Glyph(g);
        }
/*#ifdef GLYPH_LOG
        if (glyph_log)
        {
            if (error)
                fprintf(glyph_log,"    Could not find a center point\n");
            else
                fprintf(glyph_log,"    Computed a center point\n");
        }
#endif*/
    }




    /* Emboldening the glyph */
    if (!error)
    {
        if (rend->bold_strength && actual_face->face->glyph->format==FT_GLYPH_FORMAT_OUTLINE)
        {
            int xstr, ystr, xstr2, ystr2;
            int xmin,xmax,ymin,ymax;
            int center_dx, center_dy;
            FT_GlyphSlot slot = actual_face->face->glyph;

#ifdef GLYPH_LOG
            if (glyph_log) fprintf(glyph_log,"        Emboldening the glyph by %d\n",rend->bold_strength);
#endif

            xstr = rend->bold_strength * 
                   FT_MulFix( actual_face->face->units_per_EM, actual_face->face->size->metrics.y_scale ) / 2400;
            ystr = xstr;
#ifdef GLYPH_LOG
            if (glyph_log) fprintf(glyph_log,"            xstr = %d, ystr = %d\n",xstr,ystr);
#endif
            GK_Outline_Embolden(&slot->outline,xstr,&xmin,&xmax,&ymin,&ymax);
#ifdef GLYPH_LOG
            if (glyph_log) fprintf(glyph_log,"            xmin = %d, xmax = %d\n",xmin,xmax);
            if (glyph_log) fprintf(glyph_log,"            ymin = %d, ymax = %d\n",ymin,ymax);
#endif
            /*xstr = xstr * 2;
            ystr = xstr;*/
#ifdef GLYPH_LOG
            if (glyph_log) fprintf(glyph_log,"            xstr = %d, ystr = %d\n",xstr,ystr);
#endif

            xstr2 = xmin+xmax;
            ystr2 = ymin+ymax;
#ifdef GLYPH_LOG
            if (glyph_log) fprintf(glyph_log,"            xstr2 = %d, ystr2 = %d\n",xstr2,ystr2);
            if (glyph_log) fprintf(glyph_log,"            xscale = %.5f\n",((double)actual_face->face->size->metrics.x_scale)/65536);
            if (glyph_log) fprintf(glyph_log,"            yscale = %.5f\n",((double)actual_face->face->size->metrics.y_scale)/65536);
#endif

            if (slot->advance.x) slot->advance.x += xstr;
            if (slot->advance.y) slot->advance.y += ystr;

            slot->metrics.width        += xstr * 2;
            slot->metrics.height       += ystr * 2;
            /*slot->metrics.horiBearingX -= xmin;*/
            slot->metrics.horiBearingY += ystr * 2;
            slot->metrics.horiAdvance  += xstr * 2;
            slot->metrics.vertBearingX -= xstr;
            slot->metrics.vertBearingY += ystr * 2;
            slot->metrics.vertAdvance  += ystr * 2;

            /*center_dx = (int)( (double)xstr / 2 * (double)actual_face->face->size->metrics.x_scale / (80000) );
            center_dy = (int)( (double)ystr / 2 * (double)actual_face->face->size->metrics.y_scale / (65536) );*/

            center_dx = (int)( (double)rend->bold_strength * (double)actual_face->face->size->metrics.x_ppem / 80);
            center_dy = (int)( (double)rend->bold_strength * (double)actual_face->face->size->metrics.y_ppem / 80);

#ifdef GLYPH_LOG
            if (glyph_log) fprintf(glyph_log,"            center_x += %.1f\n",((double)center_dx)/64);
            if (glyph_log) fprintf(glyph_log,"            center_y += %.1f\n",((double)center_dx)/64);
#endif

            center_x += center_dx;
            center_y += center_dy;

            /*center_x += xstr;*/
            /*center_y += ymin;*/

            /*FT_GlyphSlot_Embolden(slot);*/
        }
    }

    /* Getting a glyph from FreeType */
    if (!error)
    {
        error = FT_Get_Glyph(actual_face->face->glyph, &ft_glyph);
        error = error || !ft_glyph;
        if (error)
            _gk_msg("Error: %s: Can't get a glyph with FT_Get_Glyph() call. Glyph (#%d) for character U+%04X\n",
            funcname,glyph_index,unicode);
    }

    /* Transforming the glyph to apply rotation and italics */
    if (!error && ft_glyph->format==FT_GLYPH_FORMAT_OUTLINE && rend->do_matrix_transform)
    {
        error = FT_Glyph_Transform(ft_glyph,&rend->matrix,0);
        if (!error)
        {
            FT_Vector c;
            c.x = center_x;
            c.y = center_y;
            FT_Vector_Transform(&c,&rend->matrix);
            center_x = c.x;
            center_y = c.y;
        }
    }

    /* Converting glyph to bitmap */
    if (!error && ft_glyph->format==FT_GLYPH_FORMAT_OUTLINE)
    {
        error = FT_Glyph_To_Bitmap(&ft_glyph,rend->render_mode,0,1);
        if (error) _gk_msg("Error: %s: FT_Glyph_To_Bitmap() bugs on character U+%04X\n",funcname,unicode);
    }

    /* Checking if we have bitmap now */
    if (!error)
    {
        error = (ft_glyph->format!=FT_GLYPH_FORMAT_BITMAP);
        if (error) _gk_msg("Error: %s: Glyph is not FT_GLYPH_FORMAT_BITMAP after rendering with FT_Glyph_To_Bitmap()\n",funcname);
    }

#ifdef GLYPH_LOG
/*    {
        if (glyph_log)
        {
            fprintf(glyph_log,"    We got a bitmap glyph from FreeType!\n");
            if (ft_glyph->format==FT_GLYPH_FORMAT_BITMAP)
            {
                fprintf(glyph_log,"        Format: FT_GLYPH_FORMAT_BITMAP\n");
                fprintf(glyph_log,"        Size: %dx%d, pitch: %d\n",
                                  ((FT_BitmapGlyph)ft_glyph)->bitmap.width,
                                  ((FT_BitmapGlyph)ft_glyph)->bitmap.rows,
                                  ((FT_BitmapGlyph)ft_glyph)->bitmap.pitch);
                if (((FT_BitmapGlyph)ft_glyph)->bitmap.pixel_mode==FT_PIXEL_MODE_MONO)
                {
                    int x,y;
                    int pitch = ((FT_BitmapGlyph)ft_glyph)->bitmap.pitch;
                    fprintf(glyph_log,"        Pixel mode: FT_PIXEL_MODE_MONO\n");
                    fprintf(glyph_log,"        Buffer:\n");
                    for (y=0; y < ((FT_BitmapGlyph)ft_glyph)->bitmap.rows; y++)
                    {
                        fprintf(glyph_log,"            ");
                        for (x=0; x < ((FT_BitmapGlyph)ft_glyph)->bitmap.width; x++)
                        {
                            unsigned char byte = ((unsigned char*)((FT_BitmapGlyph)ft_glyph)->bitmap.buffer)[y*pitch+x];
                            unsigned char mask = 128 >> (x%8);
                            fprintf(glyph_log,"%s",(byte&mask)?" *":" .");
                        }
                        fprintf(glyph_log,"\n");
                    }
                }
                else if (((FT_BitmapGlyph)ft_glyph)->bitmap.pixel_mode==FT_PIXEL_MODE_GRAY)
                    fprintf(glyph_log,"        Pixel mode: FT_PIXEL_MODE_GRAY\n");
                else if (((FT_BitmapGlyph)ft_glyph)->bitmap.pixel_mode==FT_PIXEL_MODE_GRAY2)
                    fprintf(glyph_log,"        Pixel mode: FT_PIXEL_MODE_GRAY2\n");
                else if (((FT_BitmapGlyph)ft_glyph)->bitmap.pixel_mode==FT_PIXEL_MODE_GRAY4)
                    fprintf(glyph_log,"        Pixel mode: FT_PIXEL_MODE_GRAY4\n");
                else if (((FT_BitmapGlyph)ft_glyph)->bitmap.pixel_mode==FT_PIXEL_MODE_LCD)
                    fprintf(glyph_log,"        Pixel mode: FT_PIXEL_MODE_LCD\n");
                else if (((FT_BitmapGlyph)ft_glyph)->bitmap.pixel_mode==FT_PIXEL_MODE_LCD_V)
                    fprintf(glyph_log,"        Pixel mode: FT_PIXEL_MODE_LCD_V\n");
            }
            else if (ft_glyph->format==FT_GLYPH_FORMAT_OUTLINE)
            {
                fprintf(glyph_log,"        Format: FT_GLYPH_FORMAT_OUTLINE\n");
            }
            fprintf(glyph_log,"        Advance: ( %.1f , %.1f ) pixels\n",
                    ((double)ft_glyph->advance.x)/0x10000,((double)ft_glyph->advance.y)/0x10000);
        }
    }*/
#endif

    if (!error)
    {
        error = ( ((FT_BitmapGlyph)ft_glyph)->bitmap.pitch < 0 );
        if (error) _gk_msg("Error: rend_workout(): Rendered glyph has negative pitch value, can't handle\n"); /* FIXME */
    }

    if (!error)
    {
        glyph = (GLYPH*)_gk_malloc(sizeof(GLYPH));
        error = (glyph == 0);
    }

    if (error || !ft_glyph)
    {
        if (ft_glyph) FT_Done_Glyph(ft_glyph);

        if (unicode==rend->error_char) return 0;
        else return _gk_rend_render(rend,rend->error_char);
    }

    glyph->unicode = unicode;
    glyph->width = ((FT_BitmapGlyph)ft_glyph)->bitmap.width;
    glyph->height = ((FT_BitmapGlyph)ft_glyph)->bitmap.rows;
    glyph->left = ((FT_BitmapGlyph)ft_glyph)->left;
    glyph->top = ((FT_BitmapGlyph)ft_glyph)->top;
    glyph->advance_x = ft_glyph->advance.x >> 10;
    glyph->advance_y = ft_glyph->advance.y >> 10;
    glyph->center_x = (center_x + 31) / 64;
    glyph->center_y = (center_y + 31) / 64;

    glyph->index = 0;
    glyph->prev = 0;
    glyph->next = 0;
    glyph->bmp = 0;
    glyph->bmpsize = 0;

    _gk_msg("rendering character '%c'\n",unicode);

    bmp_size = glyph->width*glyph->height;
    if (!bmp_size) /* empty glyph, like space (' ') character */
    {
        if (rend->index) _gk_glyph_index_add_glyph(rend->index,glyph);
        FT_Done_Glyph(ft_glyph);
        return glyph;
    }

    if (((FT_BitmapGlyph)ft_glyph)->bitmap.pixel_mode == FT_PIXEL_MODE_MONO)
    {
#ifdef GLYPH_TARGET_KNOWS_MONO_BITPACK
        int pitch1 = (glyph->width+7)>>3;
        int bitpack_size = glyph->height*pitch1;

#ifdef GLYPH_TARGET_KNOWS_MONO_RLE7
        int rle_size = 0;

        if (rend->index)
              rle_size = _gk_make_RLE7( ((FT_BitmapGlyph)ft_glyph)->bitmap.buffer,
                         glyph->width, glyph->height, ((FT_BitmapGlyph)ft_glyph)->bitmap.pitch);

        if (rle_size>0 && rle_size<=bitpack_size)
        {
            glyph->bmp = (unsigned char*)_gk_malloc(rle_size);
            if (!glyph->bmp) { _gk_free(glyph); return 0; }
            memcpy(glyph->bmp,rle_buffer,rle_size);
            glyph->bmpsize = rle_size;
        }
        else
#endif  /* GLYPH_TARGET_KNOWS_MONO_RLE7 */
        {
            glyph->bmp = (unsigned char*)_gk_malloc(bitpack_size+1);
            if (!glyph->bmp) { _gk_free(glyph); return 0; }
            glyph->bmp[0] = GLYPH_MONO_BITPACK;
            if ( ((FT_BitmapGlyph)ft_glyph)->bitmap.pitch == pitch1 )
                memcpy( glyph->bmp+1, ((FT_BitmapGlyph)ft_glyph)->bitmap.buffer, bitpack_size );
            else
            {
                unsigned char *d = glyph->bmp+1;
                int y = 0;
                for (; y<glyph->height; y++,d+=pitch1)
                    memcpy( d, ((FT_BitmapGlyph)ft_glyph)->bitmap.buffer + y * ((FT_BitmapGlyph)ft_glyph)->bitmap.pitch, pitch1 );
            }
            glyph->bmpsize = bitpack_size+1;
        }
#else  /* GLYPH_TARGET_KNOWS_MONO_BITPACK */
        {
            int y = 0;
            unsigned char* b;

            glyph->bmp = (unsigned char*)_gk_malloc(bmp_size+1);
            if (!glyph->bmp) { _gk_free(glyph); return 0; }
            glyph->bmp[0] = GLYPH_UNCOMPRESSED;
            glyph->bmpsize = bmp_size+1;
            b = glyph->bmp + 1;

            for (; y<glyph->height; y++)
            {
                int x = 0;
                unsigned char* a = ((FT_BitmapGlyph)ft_glyph)->bitmap.buffer + y * ((FT_BitmapGlyph)ft_glyph)->bitmap.pitch;
                while (x<glyph->width)
                {
                    if (x < glyph->width) { *b++ = *a&0x80 ? 255 : 0; x++; }
                    if (x < glyph->width) { *b++ = *a&0x40 ? 255 : 0; x++; }
                    if (x < glyph->width) { *b++ = *a&0x20 ? 255 : 0; x++; }
                    if (x < glyph->width) { *b++ = *a&0x10 ? 255 : 0; x++; }
                    if (x < glyph->width) { *b++ = *a&0x08 ? 255 : 0; x++; }
                    if (x < glyph->width) { *b++ = *a&0x04 ? 255 : 0; x++; }
                    if (x < glyph->width) { *b++ = *a&0x02 ? 255 : 0; x++; }
                    if (x < glyph->width) { *b++ = *a&0x01 ? 255 : 0; x++; }
                    a++;
                }
            }
        }
#endif  /* GLYPH_TARGET_KNOWS_MONO_BITPACK */
    }
Beispiel #21
0
/**
 * Load glyphs corresponding to the UTF-32 codepoint code.
 */
static int load_glyph(AVFilterContext *ctx, Glyph **glyph_ptr, uint32_t code)
{
    DrawTextContext *s = ctx->priv;
    FT_BitmapGlyph bitmapglyph;
    Glyph *glyph;
    struct AVTreeNode *node = NULL;
    int ret;

    /* load glyph into s->face->glyph */
    if (FT_Load_Char(s->face, code, s->ft_load_flags))
        return AVERROR(EINVAL);

    glyph = av_mallocz(sizeof(*glyph));
    if (!glyph) {
        ret = AVERROR(ENOMEM);
        goto error;
    }
    glyph->code  = code;

    if (FT_Get_Glyph(s->face->glyph, &glyph->glyph)) {
        ret = AVERROR(EINVAL);
        goto error;
    }
    if (s->borderw) {
        glyph->border_glyph = glyph->glyph;
        if (FT_Glyph_StrokeBorder(&glyph->border_glyph, s->stroker, 0, 0) ||
            FT_Glyph_To_Bitmap(&glyph->border_glyph, FT_RENDER_MODE_NORMAL, 0, 1)) {
            ret = AVERROR_EXTERNAL;
            goto error;
        }
        bitmapglyph = (FT_BitmapGlyph) glyph->border_glyph;
        glyph->border_bitmap = bitmapglyph->bitmap;
    }
    if (FT_Glyph_To_Bitmap(&glyph->glyph, FT_RENDER_MODE_NORMAL, 0, 1)) {
        ret = AVERROR_EXTERNAL;
        goto error;
    }
    bitmapglyph = (FT_BitmapGlyph) glyph->glyph;

    glyph->bitmap      = bitmapglyph->bitmap;
    glyph->bitmap_left = bitmapglyph->left;
    glyph->bitmap_top  = bitmapglyph->top;
    glyph->advance     = s->face->glyph->advance.x >> 6;

    /* measure text height to calculate text_height (or the maximum text height) */
    FT_Glyph_Get_CBox(glyph->glyph, ft_glyph_bbox_pixels, &glyph->bbox);

    /* cache the newly created glyph */
    if (!(node = av_tree_node_alloc())) {
        ret = AVERROR(ENOMEM);
        goto error;
    }
    av_tree_insert(&s->glyphs, glyph, glyph_cmp, &node);

    if (glyph_ptr)
        *glyph_ptr = glyph;
    return 0;

error:
    if (glyph)
        av_freep(&glyph->glyph);

    av_freep(&glyph);
    av_freep(&node);
    return ret;
}
Beispiel #22
0
void Font::makeDisplayList(FT_Face face, char ch) {
    // Load Glyph for character
    if (FT_Load_Glyph(face, FT_Get_Char_Index(face, ch), FT_LOAD_DEFAULT))
        throw std::runtime_error("FT_Load_Glyph failed");

    // Move Glyph into object
    FT_Glyph glyph;
    if (FT_Get_Glyph(face->glyph, &glyph))
        throw std::runtime_error("FT_Get_Glyph failed");

    // Convert Glyph to Bitmap
    FT_Glyph_To_Bitmap(&glyph, ft_render_mode_normal, 0, 1);
    FT_BitmapGlyph bitmap_glyph = (FT_BitmapGlyph)glyph;
    FT_Bitmap &bitmap = bitmap_glyph->bitmap;

    // Resize to OpenGL power of 2 and two channels (luminosity and alpha)
    int width = nextPow2(bitmap.width);
    int height = nextPow2(bitmap.rows);
    GLubyte *expandedData = new GLubyte[2 * width * height];
    for (int y = 0; y < height; y++) {
        for (int x = 0; x < width; x++) {
            int pos = 2 * (x + y*width);
            expandedData[pos] = expandedData[pos+1] =
                                    (x >= bitmap.width || y >= bitmap.rows) ?
                                    0 : bitmap.buffer[x + bitmap.width * y];
        }
    }

    // Create OpenGL texture
    glBindTexture(GL_TEXTURE_2D, m_textures[ch]);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0,
                 GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, expandedData);

    delete[] expandedData;

    // Now we create the Display List
    glNewList(m_displayLists+ch, GL_COMPILE);
    glBindTexture(GL_TEXTURE_2D, m_textures[ch]);
    glPushMatrix();

    // Center character correctly
    glTranslatef(bitmap_glyph->left, 0, 0);
    glTranslatef(0, bitmap_glyph->top - bitmap.rows, 0);

    // Calculate real size versus padding space
    float x = float(bitmap.width) / float(width);
    float y = float(bitmap.rows) / float(height);

    // Draw the quad
    glBegin(GL_QUADS);
    glTexCoord2d(0, 0);
    glVertex2f(0, bitmap.rows);
    glTexCoord2d(0, y);
    glVertex2f(0, 0);
    glTexCoord2d(x, y);
    glVertex2f(bitmap.width, 0);
    glTexCoord2d(x, 0);
    glVertex2f(bitmap.width, bitmap.rows);
    glEnd();
    glPopMatrix();
    glTranslatef(face->glyph->advance.x >> 6, 0, 0);

    // Increment the raster position as if it were a bitmap font
    // glBitmap(0, 0, 0, 0, face->glyph->advance.x >> 6, 0, NULL);

    glEndList();
}
Beispiel #23
0
void agg_text_renderer<T>::render(glyph_positions const& pos)
{
    glyphs_.clear();
    prepare_glyphs(pos);
    FT_Error  error;
    FT_Vector start;
    FT_Vector start_halo;
    int height = pixmap_.height();
    pixel_position const& base_point = pos.get_base_point();

    start.x =  static_cast<FT_Pos>(base_point.x * (1 << 6));
    start.y =  static_cast<FT_Pos>((height - base_point.y) * (1 << 6));
    start_halo = start;
    start.x += transform_.tx * 64;
    start.y += transform_.ty * 64;
    start_halo.x += halo_transform_.tx * 64;
    start_halo.y += halo_transform_.ty * 64;

    FT_Matrix halo_matrix;
    halo_matrix.xx = halo_transform_.sx  * 0x10000L;
    halo_matrix.xy = halo_transform_.shx * 0x10000L;
    halo_matrix.yy = halo_transform_.sy  * 0x10000L;
    halo_matrix.yx = halo_transform_.shy * 0x10000L;

    FT_Matrix matrix;
    matrix.xx = transform_.sx  * 0x10000L;
    matrix.xy = transform_.shx * 0x10000L;
    matrix.yy = transform_.sy  * 0x10000L;
    matrix.yx = transform_.shy * 0x10000L;

    // default formatting
    double halo_radius = 0;
    color black(0,0,0);
    unsigned fill = black.rgba();
    unsigned halo_fill = black.rgba();
    double text_opacity = 1.0;
    double halo_opacity = 1.0;

    for (auto const& glyph : glyphs_)
    {
        halo_fill = glyph.properties.halo_fill.rgba();
        halo_opacity = glyph.properties.halo_opacity;
        halo_radius = glyph.properties.halo_radius * scale_factor_;
        // make sure we've got reasonable values.
        if (halo_radius <= 0.0 || halo_radius > 1024.0) continue;
        FT_Glyph g;
        error = FT_Glyph_Copy(glyph.image, &g);
        if (!error)
        {
            FT_Glyph_Transform(g, &halo_matrix, &start_halo);
            if (rasterizer_ == HALO_RASTERIZER_FULL)
            {
                stroker_->init(halo_radius);
                FT_Glyph_Stroke(&g, stroker_->get(), 1);
                error = FT_Glyph_To_Bitmap(&g, FT_RENDER_MODE_NORMAL, 0, 1);
                if (!error)
                {
                    FT_BitmapGlyph bit = reinterpret_cast<FT_BitmapGlyph>(g);
                    composite_bitmap(pixmap_,
                                     &bit->bitmap,
                                     halo_fill,
                                     bit->left,
                                     height - bit->top,
                                     halo_opacity,
                                     halo_comp_op_);
                }
            }
            else
            {
                error = FT_Glyph_To_Bitmap(&g, FT_RENDER_MODE_NORMAL, 0, 1);
                if (!error)
                {
                    FT_BitmapGlyph bit = reinterpret_cast<FT_BitmapGlyph>(g);
                    render_halo(&bit->bitmap,
                                halo_fill,
                                bit->left,
                                height - bit->top,
                                halo_radius,
                                halo_opacity,
                                halo_comp_op_);
                }
            }
        }
        FT_Done_Glyph(g);
    }

    // render actual text
    for (auto & glyph : glyphs_)
    {
        fill = glyph.properties.fill.rgba();
        text_opacity = glyph.properties.text_opacity;
        FT_Glyph_Transform(glyph.image, &matrix, &start);
        error = FT_Glyph_To_Bitmap(&glyph.image ,FT_RENDER_MODE_NORMAL, 0, 1);
        if (!error)
        {
            FT_BitmapGlyph bit = reinterpret_cast<FT_BitmapGlyph>(glyph.image);
            composite_bitmap(pixmap_,
                             &bit->bitmap,
                             fill,
                             bit->left,
                             height - bit->top,
                             text_opacity,
                             comp_op_);
        }
        FT_Done_Glyph(glyph.image);
    }

}
Beispiel #24
0
YUV_error text_to_overlay_player(p_info_rec* p_info, overlay* ovly, char* text,
                          int max_width, int min_width,
                          int x_margin, int y_margin,
                          int center,
                          int tab_width,
                          int enable_align_right,
                          char* font, const int size,
                          const int aspect_ratio_num,
                          const int aspect_ratio_den)
{
    info_rec*   info;
    BYTE*   srcLine;
    BYTE*   dstLine;
    int     j;
    int     error;
    int     result;

    // initialise our data
    if (*p_info == NULL)
    {
        result = allocate_info(p_info);
        if (result < 0)
            return result;
    }
    info = *p_info;
    result = set_font(info, font, size, aspect_ratio_num, aspect_ratio_den);
    if (result < 0)
        return result;
    // render text using freetype2
    {
        #define MAX_GLYPHS 100
        FT_GlyphSlot    slot = info->face->glyph;  /* a small shortcut */
        FT_UInt     glyph_idx;
        FT_UInt     last_glyph;
        FT_Vector   delta;
        FT_Bool     use_kerning;
        int     pen_x, pen_y, n, margin;
        FT_Glyph    glyphs[MAX_GLYPHS];   /* glyph image    */
        FT_Vector   pos   [MAX_GLYPHS];   /* glyph position */
        FT_UInt     num_glyphs;
        FT_UInt     render_num_glyphs;
        FT_UInt     vis_last_glyph;
        int     vis_last;   // index of end of last "word"
        int     vis_width;  // width to vis_last
        int     x_offset = 0;
        int     align_right = 0;
        int     align_right_glyph = 0;
        int     align_right_shift;

        use_kerning = FT_HAS_KERNING(info->face);
        // compute initial pen position using font metrics
        n = info->face->bbox.yMax - info->face->bbox.yMin;//info->face->ascender - info->face->descender;
        pen_x = ((-info->face->bbox.xMin * size) + (n / 2)) / n;
        pen_y = ((info->face->bbox.yMax * size) + (n / 2)) / n;
        margin = pen_x;
        // convert each character to a glyph and set its position
        num_glyphs = 0;
        vis_last = -1;
        vis_last_glyph = 0;
        vis_width = 0;
        last_glyph = FT_Get_Char_Index(info->face, ' ');
        for (n = 0; n < (int)strlen(text); n++)
        {
            if (text[n] == '\n')
                break;
            if (num_glyphs >= MAX_GLYPHS)
                break;
            if (tab_width > 0 && text[n] == '\t')
            {
                pen_x += size - (pen_x % size);
            }
            // a '>>' sequence results in alignment of the following text to the right
            else if (enable_align_right && !align_right && text[n] == '>' && text[n + 1] == '>')
            {
                n += 1;
                align_right = 1;
                align_right_glyph = num_glyphs;
                continue;
            }
            else
            {
                glyph_idx = FT_Get_Char_Index(info->face, text[n]);
                if (use_kerning && last_glyph && glyph_idx)
                {
                    FT_Get_Kerning(info->face, last_glyph, glyph_idx,
                                   FT_KERNING_DEFAULT, &delta);
                    pen_x += delta.x / 64;
                }
                error = FT_Load_Glyph(info->face, glyph_idx, FT_LOAD_DEFAULT);
                if (error)
                    continue;  /* ignore errors */
                error = FT_Get_Glyph(info->face->glyph, &glyphs[num_glyphs]);
                if (error)
                    continue;  /* ignore errors */
                if (pen_y - slot->bitmap_top < 0)
                {
                    fprintf(stderr, "Character '%c' ascends too high\n", text[n]);
                    pen_y = slot->bitmap_top;
                }
                if (pen_y - slot->bitmap_top + slot->bitmap.rows > size)
                {
                    fprintf(stderr, "Character '%c' descends too low\n", text[n]);
                    exit(1);
                }
                pos[num_glyphs].x = pen_x;
                pos[num_glyphs].y = pen_y;

                pen_x += slot->advance.x / 64;
                last_glyph = glyph_idx;
                num_glyphs++;
            }

            if (pen_x + (margin * 2) + (x_margin * 2) > max_width)
                break;

            if (text[n] != ' ' &&
               (text[n+1] == ' ' || text[n+1] == '\0' || text[n+1] == '\n'))
            {
                vis_last_glyph = num_glyphs;
                vis_last = n;
                vis_width = pen_x;
            }
        }
        // truncate string to end of last word
        if (vis_last < 0)   // haven't found end of first word!
        {
            vis_last_glyph = num_glyphs;
            vis_last = n - 1;
            vis_width = pen_x;
        }
        if (vis_width + (margin * 2) + (x_margin * 2) > max_width)
        {
            vis_last_glyph--;
            vis_last--;
            vis_width -= slot->advance.x / 64;
        }
        render_num_glyphs = vis_last_glyph;
        result = vis_last + 1;
        // do right alignment if there is space
        if (align_right)
        {
            align_right_shift = max_width - (vis_width + (margin * 2) + (x_margin * 2));
            if (align_right_shift > 0)
            {
                for (n = align_right_glyph; n < (int)render_num_glyphs; n++)
                {
                    pos[n].x += align_right_shift;
                }
            }
        }
        // find start of next word
        while (text[result] == ' ' || text[result] == '\n')
            result++;
        // set overlay dimensions
        ovly->w = vis_width + (margin * 2) + (x_margin * 2);
        // set width >= min_width and center
        if (ovly->w < min_width && min_width <= max_width)
        {
            if (center)
            {
                x_offset = (min_width - ovly->w) / 2;
            }
            ovly->w = min_width;
        }
        ovly->h = size + 2 * y_margin;
//        fprintf(stderr, "Area of '%s' = (%d x %d)\n", text, ovly->w, ovly->h);
        ovly->ssx = -1;
        ovly->ssy = -1;
        // alloc memory
        ovly->buff = malloc(ovly->w * ovly->h * 2);
        if (ovly->buff == NULL)
            return YUV_no_memory;
        memset(ovly->buff, 0, ovly->w * ovly->h * 2);
        ovly->Cbuff = NULL;
        // render glyphs
        for (n = 0; n < (int)render_num_glyphs; n++)
        {
            error = FT_Glyph_To_Bitmap(&glyphs[n], FT_RENDER_MODE_NORMAL,
                                       0, 1);
            if (!error)
            {
                FT_BitmapGlyph  bit = (FT_BitmapGlyph)glyphs[n];
                srcLine = bit->bitmap.buffer;
                dstLine = ovly->buff + ((pos[n].y - bit->top) * ovly->w) +
                                        pos[n].x + bit->left +
                                        x_margin +
                                        y_margin * ovly->w +
                                        x_offset;
                // TODO: fix the problem with offsets
                if (dstLine < ovly->buff)
                    dstLine = ovly->buff;
                for (j = 0; j < bit->bitmap.rows; j++)
                {
                    memcpy(dstLine, srcLine, bit->bitmap.width);
                    srcLine += bit->bitmap.width;
                    dstLine += ovly->w;
                }
            }
        }
        // cleanup glyphs
        for (n = 0; n < (int)num_glyphs; n++)
        {
            FT_Done_Glyph(glyphs[n]);
        }
    }
    return result;  // length of string actually rendered
}
Beispiel #25
0
Text *text_create(Font *font, const char *char_string, int size)
{
	const uint8_t *string = (const uint8_t *) char_string;
	Text *text;
	FT_Face face = font->face;
	FT_Glyph *glyph_string;
	FT_Vector *pos;
	FT_BBox bbox;
	FT_Long width, height;
	size_t len;
	float x, y;
	int i;

	if (FT_Set_Char_Size(face, 0, size*64, 0, 0) != 0)
	{
		log_err("Error setting character size\n");
		return NULL;
	}

	text = ralloc(font, Text);
	if (text == NULL)
	{
		log_err("Out of memory\n");
		return NULL;
	}
	text->size = size;
	text->vao = text->vbo = text->texture = 0;
	text->texture_image = NULL;
	text->string = (uint8_t *) ralloc_strdup(text, (const char *) string);
	len = strlen((const char *) string); /* Bytecount */
	/* We allocate more space than necessary for the glyph string, better safe
	 * than sorry. */
	glyph_string = ralloc_array(text, FT_Glyph, len);
	pos = ralloc_array(text, FT_Vector, len);
	if (text->string == NULL || glyph_string == NULL || pos == NULL)
	{
		log_err("Out of memory\n");
		ralloc_free(text);
		return NULL;
	}

	/* The UTF-8 bytestring is converted to an array of glyphs */
	glyphstring_create(face, text, glyph_string, pos);
	/* We determine how big the text will be. This information is used
	 * to compute the size of the texture we'll store the text in */
	compute_glyphstring_bbox(glyph_string, pos, text->num_glyphs, &bbox);

	width  = bbox.xMax - bbox.xMin;
	height = bbox.yMax - bbox.yMin;
	text->width = (width/64 + 0x3) & ~0x3; /* Align to 4 bytes */
	text->height = height/64;
	text->texture_image = rzalloc_array(text, GLubyte,
			text->width * text->height);
	if (text->texture_image == NULL)
	{
		log_err("Out of memory\n");
		for (i = 0; i < text->num_glyphs; i++)
			FT_Done_Glyph(glyph_string[i]);
		ralloc_free(text);
		return NULL;
	}
	/* Now we can render the text to a texture */
	for (i = 0; i < text->num_glyphs; i++)
	{
		FT_Glyph glyph;
		FT_BitmapGlyph bitmap_glyph;
		FT_Vector pen;

		glyph = glyph_string[i];
		pen.x = pos[i].x;
		pen.y = pos[i].y;

		/* Render the new glyph and destroy the old one */
		if (FT_Glyph_To_Bitmap(&glyph, FT_LOAD_TARGET_NORMAL, &pen, 1) != 0)
		{
			log_err("Error rendering glyph to bitmap for character '%c'\n",
					string[i]);
			FT_Done_Glyph(glyph_string[i]);
			continue;
		}

		bitmap_glyph = (FT_BitmapGlyph) glyph;
		blit_glyph(bitmap_glyph, text->texture_image, (pen.x - bbox.xMin)/64,
				(pen.y - bbox.yMin)/64, text->width, text->height);
		FT_Done_Glyph(glyph);
	}
	ralloc_free(glyph_string);
	ralloc_free(pos);

	x = bbox.xMin/64;
	y = bbox.yMin/64;

	/* Why do we add text->width and not bbox.xMax? Because OpenGL wants
	 * textures aligned at 4 bytes. This fixes a very subtle bug with 
	 * a very noticeable effect */
	text->vertex[0].x = x;
	text->vertex[0].y = y;
	text->vertex[0].u = 0;
	text->vertex[0].v = 0;

	text->vertex[1].x = x + text->width;
	text->vertex[1].y = y;
	text->vertex[1].u = 1;
	text->vertex[1].v = 0;

	text->vertex[2].x = x + text->width;
	text->vertex[2].y = y + text->height;
	text->vertex[2].u = 1;
	text->vertex[2].v = 1;

	text->vertex[3].x = x;
	text->vertex[3].y = y + text->height;
	text->vertex[3].u = 0;
	text->vertex[3].v = 1;

	for (i = 0; i < 4; i++)
	{
		text->vertex[i].r = 0;
		text->vertex[i].g = 0;
		text->vertex[i].b = 1;
		text->vertex[i].a = 1;
	}

	return text;
}
Beispiel #26
0
bool TGLFont::Load(const char* fontname)
{
	char full_filename[512];
	sprintf_s(full_filename,sizeof(full_filename),"Data/Fonts/%s", fontname);
	FT_Face ftFace;
	FT_Error err_code = FT_New_Face(ftLibrary,full_filename,0,&ftFace);
	if(err_code == FT_Err_Unknown_File_Format)
	{
		LogFile->Write("Bad font file format: "+string(fontname),LT_ERROR);
		return false;
	}
	else if (err_code)
	{
		LogFile->Write("Can't load font: "+string(fontname),LT_ERROR);
		return false;
	}
	if (iFontSize > min(ftFace->max_advance_width,ftFace->max_advance_height))
	{
		FT_Done_Face(ftFace);
		LogFile->Write("Font size greater that supported font: "+string(fontname),LT_ERROR);
		return false;
	}
	if (FT_Set_Char_Size(ftFace, iFontSize*64, iFontSize*64, iHorizDPI, iVertDPI))
	{
		FT_Done_Face(ftFace);
		LogFile->Write("Can't set font size for font: "+string(fontname),LT_ERROR);
		return false;
	}

	// new code
	FT_Long glyphs_count = ftFace->num_glyphs;
	if (glyphs_count == 0)
	{
		FT_Done_Face(ftFace);
		LogFile->Write("No glyphs in font: "+string(fontname),LT_ERROR);
		return false;
	}

	try
	{
		PLuint gridsize = GetGridSize(iFontSize);
		/*sprintf_s(full_filename,sizeof(full_filename),"???%s-%d", fontname, fontsize);
		pTex = pTextureSpool->CreateFontCashe(full_filename, gridsize*16, gridsize*16);*/
		((Texture::Texture2D&)pTex.GetObj()).LoadFromMem(0, gridsize*16, gridsize*16, Loader::Image::DT_RGBA);
		pGlyph = new Glyph2D*[MAXBYTE+1];
		PLuint xoffset = 2 + iFontSize / 2 + 2; // reverse space for empty glyph
		PLuint yoffset = 2;
		PLint max_in_line = 0;
		for(PLuint i = 0; i <= MAXBYTE; i++)
		{
			wchar_t unicode_char = ctowc(i,iCodepage);
			if ((unicode_char != 0)&&(unicode_char < glyphs_count))
			{
				FT_UInt ch_index = FT_Get_Char_Index(ftFace, unicode_char);
				if (ch_index)
				{
					if (FT_Load_Glyph( ftFace, ch_index, FT_LOAD_DEFAULT ))
					{
						pGlyph[i] = new Glyph2D(gridsize*16, 2, 2, iFontSize / 2, 1, 0); // empty glyph
						continue;
					}
					FT_Glyph ftGlyph;
					if (FT_Get_Glyph( ftFace->glyph, &ftGlyph ))
					{
						pGlyph[i] = new Glyph2D(gridsize*16, 2, 2, iFontSize / 2, 1, 0); // empty glyph
						continue;
					}
					if (FT_Glyph_To_Bitmap( &ftGlyph, FT_RENDER_MODE_NORMAL, 0, 1 ))
					{
						pGlyph[i] = new Glyph2D(gridsize*16, 2, 2, iFontSize / 2, 1, 0); // empty glyph
						continue;
					}
					FT_BitmapGlyph ftBitmapGlyph = (FT_BitmapGlyph)ftGlyph;
					FT_Bitmap& bitmap = ftBitmapGlyph->bitmap;

					if ((bitmap.rows == 0) || (bitmap.width == 0))
					{
						pGlyph[i] = new Glyph2D(gridsize*16, 2, 2, iFontSize / 2, 1, 0); // empty glyph
						continue;
					}

					GLubyte* pExpData = new GLubyte[4*bitmap.width*bitmap.rows];
					for (PLint k = 0; k < bitmap.rows; k++)
					{
						for(PLint j = 0; j < bitmap.width; j++)
						{
							unsigned char buf = bitmap.buffer[j + bitmap.width*k];
							pExpData[4*(j+k*bitmap.width)] = 255;
							pExpData[4*(j+k*bitmap.width)+1] = 255;
							pExpData[4*(j+k*bitmap.width)+2] = 255;
							pExpData[4*(j+k*bitmap.width)+3] = buf;
						}
					}
					if (xoffset + bitmap.width >= gridsize*16)
					{
						xoffset = 2;
						yoffset += max_in_line + 2;
					}
					if (bitmap.rows > max_in_line)
						max_in_line = bitmap.rows;
					((Texture::Texture2D&)pTex.GetObj()).SetRectFromMem(xoffset,yoffset,pExpData,bitmap.width,bitmap.rows,Loader::Image::DT_RGBA);
					pGlyph[i] = new Glyph2D(gridsize*16, xoffset, yoffset, bitmap.width, bitmap.rows, ftBitmapGlyph->top-bitmap.rows);
					delete[] pExpData;
					xoffset += bitmap.width + 2;
				}
				else
					pGlyph[i] = new Glyph2D(gridsize*16, 2, 2, iFontSize / 2, 1, 0); // empty glyph
			}
			else
				pGlyph[i] = new Glyph2D(gridsize*16, 2, 2, iFontSize / 2, 1, 0); // empty glyph
		}
		pTex->SendGPU(false);
	}
	catch(...)
	{
		delete[] pGlyph;
		return false;
	}
	FT_Done_Face(ftFace);
	sFontname = fontname;
	return true;
}
Beispiel #27
0
void RenderText::draw(){
	//glClearColor(1, 1, 1, 0);
	glEnable(GL_BLEND);
    //glEnable(GL_TEXTURE_2D);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
	//glDisable(GL_DEPTH_TEST);
	//glDisable(GL_CULL_FACE);
	//glDisable(GL_TEXTURE_2D);
	//glDisable(GL_LIGHTING);
	
	glMatrixMode(GL_PROJECTION);
	glPushMatrix();
	glLoadIdentity();
	int stageWidth, stageHeight;
	glfwGetWindowSize(&stageWidth, &stageHeight);
	glOrtho(0.0f, stageWidth, 0.0f, stageHeight, 0.0f, 1.0f);

	glMatrixMode(GL_MODELVIEW);
	int i;
	if(selectedInputs.size()>0&&selectedInputs[0]!=this&&inputAllowed&&text==""){
		dispText = "Click to type here";
	}else {
		dispText=text;
	}

	if(selectedInputs.size()>0&&selectedInputs[0]==this&&inputAllowed){
		static int curserOn = 0;
		static float prevSwitchTime=glfwGetTime();
		if(glfwGetTime()-prevSwitchTime>0.3){
			curserOn = !curserOn;
			prevSwitchTime=glfwGetTime();
		}
		if(curserOn){
			dispText.append("_");
		}
	}

	const size_t length = dispText.length();
	textures = (GLuint*)calloc(length, sizeof(GLuint));
    glGenTextures(length, textures);
	glPushMatrix();
    glTranslatef(x, y, 0);
	glPushMatrix();
    for (i = 0; i < length; ++i) {
		FT_Load_Glyph(face, FT_Get_Char_Index(face, dispText.at(i)), FT_LOAD_DEFAULT);
        FT_Get_Glyph(face->glyph, &glyph);
        FT_Glyph_To_Bitmap(&glyph, FT_RENDER_MODE_NORMAL, 0, 1);
        bitmap_glyph = (FT_BitmapGlyph)glyph;
        bitmap = bitmap_glyph->bitmap;

        int width = RenderText::npo2(bitmap.width);
        int height = RenderText::npo2(bitmap.rows);
        float x = (float)bitmap.width / (float)width;
        float y = (float)bitmap.rows / (float)height;

        glBindTexture(GL_TEXTURE_2D, textures[i]);
        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, width, height, 0, GL_ALPHA, GL_UNSIGNED_BYTE, 0);
		glPixelStorei(GL_UNPACK_ALIGNMENT,1); // no alignment
		glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, bitmap.width, bitmap.rows, GL_ALPHA, GL_UNSIGNED_BYTE, bitmap.buffer);

        glPushMatrix();
        glTranslatef(0, bitmap_glyph->top - bitmap.rows, 0);
        glBindTexture(GL_TEXTURE_2D, textures[i]);
        glBegin(GL_QUADS);
            glTexCoord2f(0, 0); glVertex2f(0, bitmap.rows);
            glTexCoord2f(0, y); glVertex2f(0, 0);
            glTexCoord2f(x, y); glVertex2f(bitmap.width, 0);
            glTexCoord2f(x, 0); glVertex2f(bitmap.width, bitmap.rows);
        glEnd();
        glPopMatrix();
        glTranslatef(glyph->advance.x / 65536, 0, 0);
        FT_Done_Glyph(glyph);
    }
	glPopMatrix();
	glPopMatrix();
	glMatrixMode(GL_PROJECTION);
	glPopMatrix();
	glDeleteTextures(length, textures);
    free(textures);
}
Beispiel #28
0
// Load a character glyph
Font::Glyph Font::LoadGlyph( char ch, unsigned int size )
{
    Glyph glyph;

    // Ensure we can even retrieve the glyph
    if ( !_fontFace || !SetCurrentSize( size ) )
    {
        return glyph;
    }

    // Attempt to load the font's glyph for the given character
    if ( 0 != FT_Load_Char( _myFontFace, ch, FT_LOAD_TARGET_NORMAL | FT_LOAD_FORCE_AUTOHINT ) )
    {
        return glyph;
    }

    // Get the glyph's description
    FT_Glyph ftGlyph;
    if ( 0 != FT_Get_Glyph( _myFontFace->glyph, &ftGlyph ) )
    {
        return glyph;
    }

    // Rasterize the glyph
    FT_Glyph_To_Bitmap( &ftGlyph, FT_RENDER_MODE_NORMAL, 0, 1 );
    FT_Bitmap& bitmap = reinterpret_cast<FT_BitmapGlyph>( ftGlyph )->bitmap;

    // Get the glyph's advance
    glyph.Advance = static_cast<float>( _myFontFace->glyph->metrics.horiAdvance ) * KerningScale;

    int width = bitmap.width;
    int height = bitmap.rows;

    if ( ( width > 0 ) && ( height > 0 ) )
    {
        // Get the glyph's page
        GlyphPage& page = _pages[ size ];

        // Leave a small padding around characters, so that filtering doesn't
        // pollute them with pixels from neighbors
        const unsigned int padding = 1;
        
        // Find a good position for the new glyph into the texture
        UintRect emptyArea = FindGlyphRect( page, width + 2 * padding, height + 2 * padding );;

        // Ensure the texture data is in the center of the texture rectangle
        emptyArea.X += padding;
        emptyArea.Y += padding;
        emptyArea.Width -= 2 * padding;
        emptyArea.Height -= 2 * padding;
        glyph.TextureBounds = emptyArea;

        // Set the glyph's bounding box
        glyph.Bounds.X      =  ( _myFontFace->glyph->metrics.horiBearingX ) * KerningScale;
        glyph.Bounds.Y      = -( _myFontFace->glyph->metrics.horiBearingY ) * KerningScale;
        glyph.Bounds.Width  =  ( _myFontFace->glyph->metrics.width        ) * KerningScale;
        glyph.Bounds.Height =  ( _myFontFace->glyph->metrics.height       ) * KerningScale;


        // Extract the glyph's pixels from the bitmap
        _pixelBuffer.resize( width * height * 4, 255 );
        const unsigned char* pixels = bitmap.buffer;
        if ( bitmap.pixel_mode == FT_PIXEL_MODE_MONO )
        {
            // Pixels are 1 bit monochrome values
            for ( int y = 0; y < height; ++y )
            {
                for ( int x = 0; x < width; ++x )
                {
                    // The color channels remain white, just fill the alpha channel
                    std::size_t index = ( x + y * width ) * 4 + 3;
                    _pixelBuffer[ index ] = ( ( pixels[ x / 8 ] ) & ( 1 << ( 7 - ( x % 8 ) ) ) ) ? 255 : 0;
                }
                pixels += bitmap.pitch;
            }
        }
        else
        {
            // Pixels are 8 bits gray levels
            for ( int y = 0; y < height; ++y )
            {
                for ( int x = 0; x < width; ++x )
                {
                    // The color channels remain white, just fill the alpha channel
                    std::size_t index = ( x + y * width ) * 4 + 3;
                    _pixelBuffer[ index ] = pixels[ x ];
                }
                pixels += bitmap.pitch;
            }
        }

        // Write the pixels to the texture
        page.Texture->UpdateArea( emptyArea.X, emptyArea.Y, emptyArea.Width, emptyArea.Height, &_pixelBuffer[ 0 ] );
    }

    // Cleanup
    FT_Done_Glyph( ftGlyph );

    return glyph;
}
void SubtitleRenderer::load_glyph(char32_t codepoint) {
  VGfloat escapement[2]{};

  auto load_glyph_internal =
  [&](FT_Face ft_face, VGFont vg_font, bool border) {
    try {
      auto glyph_index = FT_Get_Char_Index(ft_face, codepoint);
      ENFORCE(!FT_Load_Glyph(ft_face, glyph_index, FT_LOAD_NO_HINTING));

      FT_Glyph glyph;
      ENFORCE(!FT_Get_Glyph(ft_face->glyph, &glyph));
      SCOPE_EXIT {FT_Done_Glyph(glyph);};

      if (border)
        ENFORCE(!FT_Glyph_StrokeBorder(&glyph, ft_stroker_, 0, 1));

      ENFORCE(!FT_Glyph_To_Bitmap(&glyph, FT_RENDER_MODE_NORMAL, NULL, 1));
      FT_BitmapGlyph bit_glyph = (FT_BitmapGlyph) glyph;
      FT_Bitmap& bitmap = bit_glyph->bitmap;

      VGImage image{};
      VGfloat glyph_origin[2]{};

      if (bitmap.width > 0 && bitmap.rows > 0) {
        constexpr VGfloat blur_stddev = 0.6;
        const int padding = static_cast<int>(3*blur_stddev + 0.5);
        const int image_width = bitmap.width + padding*2;
        const int image_height = bitmap.rows + padding*2;

        image = vgCreateImage(VG_A_8, image_width, image_height,
                              VG_IMAGE_QUALITY_NONANTIALIASED);
        assert(image);
        
        if (bitmap.pitch > 0) {
          vgImageSubData(image,
                         bitmap.buffer + bitmap.pitch*(bitmap.rows-1),
                         -bitmap.pitch,
                         VG_A_8,
                         padding,
                         padding,
                         bitmap.width,
                         bitmap.rows);
          assert(!vgGetError());
        } else {
          vgImageSubData(image,
                         bitmap.buffer,
                         bitmap.pitch,
                         VG_A_8,
                         padding,
                         padding,
                         bitmap.width,
                         bitmap.rows);
          assert(!vgGetError());
        }

        auto softened_image = vgCreateImage(VG_A_8,
                                            image_width,
                                            image_height,
                                            VG_IMAGE_QUALITY_NONANTIALIASED);
        assert(image);

        // Even out hard and soft edges
        vgGaussianBlur(softened_image, image, blur_stddev, blur_stddev, VG_TILE_FILL);
        assert(!vgGetError());

        vgDestroyImage(image);
        assert(!vgGetError());

        image = softened_image;

        glyph_origin[0] = static_cast<VGfloat>(padding - bit_glyph->left);
        glyph_origin[1] = static_cast<VGfloat>(padding + bitmap.rows - bit_glyph->top - 1);
      }

      escapement[0] = static_cast<VGfloat>((ft_face->glyph->advance.x + 32) / 64);
      escapement[1] = 0;

      vgSetGlyphToImage(vg_font, codepoint, image, glyph_origin, escapement);
      assert(!vgGetError());

      if (image) {
        vgDestroyImage(image);
        assert(!vgGetError());
      }
    } catch(...) {
      escapement[0] = 0;
      escapement[1] = 0;
      vgSetGlyphToImage(vg_font, codepoint, VG_INVALID_HANDLE, escapement, escapement);
      assert(!vgGetError());
    }
  };

  load_glyph_internal(ft_face_, vg_font_, false);
  glyphs_[codepoint].advance = escapement[0];
  load_glyph_internal(ft_face_, vg_font_border_, true);
}
Beispiel #30
0
int text_to_overlay(p_info_rec* p_info, overlay* ovly, char* text,
                    int max_width, char* font, const int size, 
                    const int aspect_ratio_num,
                    const int aspect_ratio_den)
{
    info_rec*	info;
    BYTE*	srcLine;
    BYTE*	dstLine;
    int		j;
    int		error;
    int		result;

    // initialise our data
    if (*p_info == NULL)
    {
        result = allocate_info(p_info);
        if (result < 0)
            return result;
    }
    info = *p_info;
    result = set_font(info, font, size, aspect_ratio_num, aspect_ratio_den);
    if (result < 0)
        return result;
    // render text using freetype2
    {
        #define MAX_GLYPHS 100
        FT_GlyphSlot	slot = info->face->glyph;  /* a small shortcut */
        FT_UInt		glyph_idx;
        FT_UInt		last_glyph;
        FT_Vector	delta;
        FT_Bool		use_kerning;
        int		pen_x, pen_y, n, margin;
        FT_Glyph	glyphs[MAX_GLYPHS];   /* glyph image    */    
        FT_Vector	pos   [MAX_GLYPHS];   /* glyph position */    
        FT_UInt		num_glyphs;
        int		vis_last;	// index of end of last "word"
        int		vis_width;	// width to vis_last

        use_kerning = FT_HAS_KERNING(info->face);
        // font metrics are unreliable, so use actual rendered characters
        // set left margin using a capital M character
        glyph_idx = FT_Get_Char_Index(info->face, 'M');
        FT_Load_Glyph(info->face, glyph_idx, FT_LOAD_DEFAULT);
        FT_Get_Glyph(info->face->glyph, &glyphs[0]);
        pen_x = slot->metrics.horiBearingX;
        margin = pen_x;
        FT_Done_Glyph(glyphs[0]);
        // set baseline using a capital A character
        glyph_idx = FT_Get_Char_Index(info->face, 'A');
        FT_Load_Glyph(info->face, glyph_idx, FT_LOAD_DEFAULT);
        FT_Get_Glyph(info->face->glyph, &glyphs[0]);
        pen_y = slot->metrics.horiBearingY;
        FT_Done_Glyph(glyphs[0]);
        // convert each character to a glyph and set its position
        num_glyphs = 0;
        vis_last = -1;
        vis_width = 0;
        last_glyph = FT_Get_Char_Index(info->face, ' ');
        for (n = 0; n < (int)strlen(text); n++)
        {
            if (text[n] == '\n')
                break;
            if (num_glyphs >= MAX_GLYPHS)
                break;
            glyph_idx = FT_Get_Char_Index(info->face, text[n]);
            if (use_kerning && last_glyph && glyph_idx)
            {
                FT_Get_Kerning(info->face, last_glyph, glyph_idx,
                               FT_KERNING_DEFAULT, &delta);
                pen_x += delta.x;
            }
            error = FT_Load_Glyph(info->face, glyph_idx, FT_LOAD_DEFAULT);
            if (error)
                continue;  /* ignore errors */
            error = FT_Get_Glyph(info->face->glyph, &glyphs[num_glyphs]);
            if (error)
                continue;  /* ignore errors */
            if (pen_y - slot->metrics.horiBearingY < 0)
            {
                fprintf(stderr, "Character '%c' ascends too high\n", text[n]);
                pen_y = slot->metrics.horiBearingY;
            }
            if (pen_y - slot->metrics.horiBearingY +
                        slot->metrics.height > size * 64)
            {
                fprintf(stderr, "Character '%c' descends too low\n", text[n]);
                exit(1);
            }
            pos[num_glyphs].x = pen_x;
            pos[num_glyphs].y = -pen_y;

            pen_x += slot->advance.x;
            last_glyph = glyph_idx;
            num_glyphs++;

            if (pen_x + (margin * 2) > max_width * 64)
                break;

            if (text[n] != ' ' &&
               (text[n+1] == ' ' || text[n+1] == '\0' || text[n+1] == '\n'))
            {
                vis_last = n;
                vis_width = pen_x;
            }
        }
        // truncate string to end of last word
        if (vis_last < 0)	// haven't found end of first word!
        {
            vis_last = num_glyphs - 1;
            vis_width = pen_x;
        }
        num_glyphs = vis_last + 1;
        // find start of next word
        result = num_glyphs;
        while (text[result] == ' ' || text[result] == '\n')
            result++;
        // set overlay dimensions
        ovly->w = (vis_width + (margin * 2)) / 64;
        ovly->h = size;
//        fprintf(stderr, "Area of '%s' = (%d x %d)\n", text, ovly->w, ovly->h);
        ovly->ssx = -1;
        ovly->ssy = -1;
        // alloc memory
        ovly->buff = malloc(ovly->w * ovly->h * 2);
        if (ovly->buff == NULL)
            return YUV_no_memory;
        memset(ovly->buff, 0, ovly->w * ovly->h * 2);
        ovly->Cbuff = NULL;
        // render glyphs in pre-calculated positions
        for (n = 0; n < (int)num_glyphs; n++)
        {
            error = FT_Glyph_To_Bitmap(&glyphs[n], FT_RENDER_MODE_NORMAL,
                                       &pos[n], 1);
            if (!error)
            {
                FT_BitmapGlyph	bit = (FT_BitmapGlyph)glyphs[n];
                srcLine = bit->bitmap.buffer;
                dstLine = ovly->buff - (bit->top * ovly->w) + bit->left;
                for (j = 0; j < bit->bitmap.rows; j++)
                {
                    memcpy(dstLine, srcLine, bit->bitmap.width);
                    srcLine += bit->bitmap.width;
                    dstLine += ovly->w;
                }
            }
            FT_Done_Glyph(glyphs[n]);
        }
    }
    return result;	// length of string actually rendered
}