Example #1
0
void update_infos()
{
	//base y position of the text
	int base_y = 0;
	//height of a line of text with the current font.
	int line_height = TTF_FontLineSkip(font);
	//buffer to hold the current textto be drawn
	char buf[TEXT_BUF_SIZE];
	
	//retrieve navdata one by one
	int bat = jakopter_com_read_int(com_in, 0);
	//and format it for textual display
	snprintf(buf, TEXT_BUF_SIZE, "Battery : %d%%", bat);
	buf[TEXT_BUF_SIZE-1] = '\0';
	//finally, print it onto a texture using SDL_ttf
	graphs[0].tex = video_make_text(buf, &graphs[0].pos.w, &graphs[0].pos.h);
	//and set its draw position accordingly
	graphs[0].pos.x = 0;
	graphs[0].pos.y = base_y;
	//go to a new line
	base_y += line_height;
	
	int alt = jakopter_com_read_int(com_in, 4);
	snprintf(buf, TEXT_BUF_SIZE, "Altitude : %d", alt);
	buf[TEXT_BUF_SIZE-1] = '\0';
	graphs[1].tex = video_make_text(buf, &graphs[1].pos.w, &graphs[1].pos.h);
	graphs[1].pos.x = 0;
	graphs[1].pos.y = base_y;
	
	//update pitch, roll, yaw and speed
	pitch = jakopter_com_read_float(com_in, 8);
	roll = jakopter_com_read_float(com_in, 12);
	yaw = jakopter_com_read_float(com_in, 16);
	speed = jakopter_com_read_float(com_in, 20);
}
Example #2
0
int BEE::Font::draw_fast(int x, int y, std::string text, RGBA color) {
	if (is_loaded) {
		std::map<int,std::string> lines = handle_newlines(text);

		if (lineskip == 0) {
			if (is_sprite) {
				lineskip = sprite_font->get_height();
			} else {
				lineskip = TTF_FontLineSkip(font);
			}
		}

		int r = 0;
		for (auto& l : lines) {
			int ri = draw_fast_internal(x, y+lineskip*l.first, l.second, color);
			if (ri > r) {
				r = ri;
			}
		}
		return r;
	}

	if (!has_draw_failed) {
		game->messenger_send({"engine", "font"}, BEE_MESSAGE_WARNING, "Failed to draw text with \"" + name + "\" because it is not loaded");
		has_draw_failed = true;
	}
	return 1;
}
Example #3
0
void Font::InitFont( void )
{
	Initialized = false;
	
	if( TTFont )
		TTF_CloseFont( TTFont );
	
	TTFont = TTF_OpenFont( Name.c_str(), PointSize );
	if( ! TTFont )
	{
		// FIXME: Use TTF_Error output?
		fprintf( stderr, "Can't open font file: %s\n", Name.c_str() );
		return;
	}
	
	Height = TTF_FontHeight( TTFont );
	Ascent = TTF_FontAscent( TTFont );
	Descent = TTF_FontDescent( TTFont );
	LineSkip = TTF_FontLineSkip( TTFont );
	
	for( int i = 0; i < 256; i ++ )
	{
		Glyphs[ i ].Pic = NULL;
		Glyphs[ i ].Tex = 0;
	}
	
	LoadedTime.Reset();
	
	Initialized = true;
}
Example #4
0
int BEE::Font::get_lineskip_default() {
	if (is_loaded) {
		return TTF_FontLineSkip(font);
	}
	game->messenger_send({"engine", "font"}, BEE_MESSAGE_WARNING, "Failed to get the default lineskip for \"" + name + "\" becuase it is not loaded");
	return -1;
}
Example #5
0
TextData* BEE::Font::draw(int x, int y, std::string text, RGBA color) {
	if (is_loaded) {
		TextData *r = nullptr, *textdata = nullptr;
		std::map<int,std::string> lines = handle_newlines(text);

		if (lineskip == 0) {
			lineskip = TTF_FontLineSkip(font);
		}

		for (auto& l : lines) {
			r = draw_internal(x, y+lineskip*l.first, l.second, color);
			if (r != nullptr) {
				if (textdata == nullptr) {
					textdata = r;
				} else {
					textdata->sprite.insert(std::make_pair(textdata->sprite.size(), r->sprite[0]));
					delete r;
				}
			}
		}
		return textdata;
	}

	if (!has_draw_failed) {
		game->messenger_send({"engine", "font"}, BEE_MESSAGE_WARNING, "Failed to draw text with \"" + name + "\" because it is not loaded");
		has_draw_failed = true;
	}
	return nullptr;
}
Example #6
0
/******************************************************************************\
 Loads the font, properly scaled and generates an error message if something
 goes wrong. For some reason, SDL_ttf returns a line skip that is one pixel shy
 of the image height returned by TTF_RenderUTF8_Blended() so we account for
 that here.
\******************************************************************************/
static void load_font(r_font_t font, c_var_t *var, int size)
{
        int points;

        points = (int)ceilf(size * r_scale_2d);
        if (points < FONT_SIZE_MIN)
                points = FONT_SIZE_MIN;
        C_zero(fonts + font);
        fonts[font].ttf_font = TTF_OpenFont(var->value.s, points);
        if (!fonts[font].ttf_font) {
                C_warning("Failed to load font '%s' (%d -> %d pt)",
                          var->value.s, size, points);

                /* Fallback to the stock font file */
                fonts[font].ttf_font = TTF_OpenFont(var->stock.s, points);
                if (!fonts[font].ttf_font)
                        C_error("Failed to load font '%s' (%d -> %d pt) and "
                                "stock font '%s'", var->value.s, size, points,
                                var->stock.s);
        }
        fonts[font].height = TTF_FontHeight(fonts[font].ttf_font);
        fonts[font].line_skip = TTF_FontLineSkip(fonts[font].ttf_font) + 1;

        /* SDL_ttf won't tell us the width of the widest glyph directly so we
           assume it is the width of 'W' */
        fonts[font].width = (int)R_font_size(font, "W").x;
}
	void GlyphFont::InitFont()
	{
		mTtfFont = TTF_OpenFont(mFilename, mPointSize);

		if(mTtfFont == NULL)
			printf("Can't open font file\n");

		// 0 = TTF_STYLE_NORMAL
		// 1 = TTF_STYLE_BOLD
		// 2 = TTF_STYLE_ITALIC
		// 4 = TTF_STYLE_UNDERLINE
		// 8 = TTF_STYLE_STRIKETHROUGH
		TTF_SetFontStyle(mTtfFont, mStyle);

		mColor.r = (Uint8)(mRed * 255);
		mColor.g  = (Uint8)(mGreen * 255);
		mColor.b = (Uint8)(mBlue * 255);

		mHeight = TTF_FontHeight(mTtfFont);
		mAscent = TTF_FontAscent(mTtfFont);
		mDescent = TTF_FontDescent(mTtfFont);
		mLineSkip = TTF_FontLineSkip(mTtfFont);

		for(int i = sMinGlyph; i <= sMaxGlyph; i++)
		{
			mGlyphs[i].Surface = NULL;
			mGlyphs[i].Texture = 0;
		}
	}
Example #8
0
void Text::setText(std::string text){
  myText = text;
  int n = 0;
  std::vector<std::string> textLines;
  std::string substring = text;
  while(n != std::string::npos){
    n = substring.find('\n', 0);
      textLines.push_back(substring.substr(0, n));
      substring = substring.substr(n + 1, std::string::npos);
  }
  numLines = textLines.size();
  image.clear();
  for(unsigned int i = 0; i < textLines.size(); i++)
    image.push_back(TTF_RenderText_Blended(font, textLines.at(i).c_str(), color));
  int wtemp, w = 0;
  for(unsigned int i = 0; i < textLines.size(); i++){
    TTF_SizeText(this->font, textLines.at(i).c_str(), &wtemp, NULL);
    if(wtemp > w)
      w = wtemp;
	}
  int h = 10;
  lineSkip = TTF_FontLineSkip(font);
  h = (textLines.size() - 1) * lineSkip + h;
  setDimensions(w, h);
}
Example #9
0
Font::Font(const char *aaddress, int alength, int apointSize, int astyle,
		float afgRed, float afgGreen, float afgBlue, float abgRed, float abgGreen,
		float abgBlue) :
		height(), ascent(), descent(), lineSkip(), address(
				aaddress), length(alength), pointSize(apointSize), style(astyle), fgRed(
				afgRed), fgGreen(afgGreen), fgBlue(afgBlue), bgRed(abgRed), bgGreen(
				abgGreen), bgBlue(abgBlue), ttfFont(), foreground(), background() {
	int i;

	ttfFont = open_font(address, pointSize);

	TTF_SetFontStyle(ttfFont, style);

	foreground.r = (Uint8) (255 * fgRed);
	foreground.g = (Uint8) (255 * fgGreen);
	foreground.b = (Uint8) (255 * fgBlue);

	background.r = (Uint8) (255 * bgRed);
	background.g = (Uint8) (255 * bgGreen);
	background.b = (Uint8) (255 * bgBlue);

	height = TTF_FontHeight(ttfFont);
	ascent = TTF_FontAscent(ttfFont);
	descent = TTF_FontDescent(ttfFont);
	lineSkip = TTF_FontLineSkip(ttfFont);

	for (i = minGlyph; i <= maxGlyph; i++) {
		glyphs[i].pic = NULL;
		glyphs[i].tex = 0;
	}
}
Example #10
0
bool TextSupervisor::LoadFont(const std::string &filename, const std::string &font_name, uint32 size)
{
    // Make sure that the font name is not already taken
    if(IsFontValid(font_name) == true) {
        IF_PRINT_WARNING(VIDEO_DEBUG) << "a font with the desired reference name already existed: " << font_name << std::endl;
        return false;
    }

    if(size == 0) {
        IF_PRINT_WARNING(VIDEO_DEBUG) << "attempted to load a font of point size zero" << font_name << std::endl;
        return false;
    }

    // Attempt to load the font
    TTF_Font *font = TTF_OpenFont(filename.c_str(), size);
    if(font == NULL) {
        IF_PRINT_WARNING(VIDEO_DEBUG) << "call to TTF_OpenFont() failed to load the font file: " << filename << std::endl;
        return false;
    }

    // Create a new FontProperties object for this font and set all of the properties according to SDL_ttf
    FontProperties *fp = new FontProperties;
    fp->ttf_font = font;
    fp->height = TTF_FontHeight(font);
    fp->line_skip = TTF_FontLineSkip(font);
    fp->ascent = TTF_FontAscent(font);
    fp->descent = TTF_FontDescent(font);

    // Create the glyph cache for the font and add it to the font map
    fp->glyph_cache = new std::vector<FontGlyph *>;
    _font_map[font_name] = fp;
    return true;
} // bool TextSupervisor::LoadFont(...)
Example #11
0
SDLFontEngine::SDLFontEngine() : FontEngine(), active_font(NULL) {
	// Initiate SDL_ttf
	if(!TTF_WasInit() && TTF_Init()==-1) {
		logError("SDLFontEngine: TTF_Init: %s", TTF_GetError());
		Exit(2);
	}

	// load the fonts
	// @CLASS SDLFontEngine: Font settings|Description of engine/font_settings.txt
	FileParser infile;
	if (infile.open("engine/font_settings.txt")) {
		while (infile.next()) {
			if (infile.new_section) {
				SDLFontStyle f;
				f.name = infile.section;
				font_styles.push_back(f);
			}

			if (font_styles.empty()) continue;

			SDLFontStyle *style = &(font_styles.back());
			if ((infile.key == "default" && style->path == "") || infile.key == LANGUAGE) {
				// @ATTR $STYLE.default, $STYLE.$LANGUAGE|filename (string), point size (integer), blending (boolean)|Filename, point size, and blend mode of the font to use for this language. $STYLE can be something like "font_normal" or "font_bold". $LANGUAGE can be a 2-letter region code.
				style->path = popFirstString(infile.val);
				style->ptsize = popFirstInt(infile.val);
				style->blend = toBool(popFirstString(infile.val));
				style->ttfont = TTF_OpenFont(mods->locate("fonts/" + style->path).c_str(), style->ptsize);
				if(style->ttfont == NULL) {
					logError("FontEngine: TTF_OpenFont: %s", TTF_GetError());
				}
				else {
					int lineskip = TTF_FontLineSkip(style->ttfont);
					style->line_height = lineskip;
					style->font_height = lineskip;
				}
			}
		}
		infile.close();
	}

	// set the font colors
	Color color;
	if (infile.open("engine/font_colors.txt")) {
		while (infile.next()) {
			// @ATTR menu_normal, menu_bonus, menu_penalty, widget_normal, widget_disabled|r (integer), g (integer), b (integer)|Colors for menus and widgets
			// @ATTR combat_givedmg, combat_takedmg, combat_crit, combat_buff, combat_miss|r (integer), g (integer), b (integer)|Colors for combat text
			// @ATTR requirements_not_met, item_bonus, item_penalty, item_flavor|r (integer), g (integer), b (integer)|Colors for tooltips
			// @ATTR item_$QUALITY|r (integer), g (integer), b (integer)|Colors for item quality. $QUALITY should match qualities used in items/items.txt
			color_map[infile.key] = toRGB(infile.val);
		}
		infile.close();
	}

	// Attempt to set the default active font
	setFont("font_regular");
	if (!active_font) {
		logError("FontEngine: Unable to determine default font!");
		Exit(1);
	}
}
Example #12
0
int GW_PlatformSDL::text_fontheight()
{
#ifndef GW_NO_SDL_TTF
    return TTF_FontLineSkip(font_);
#else
    return 1;
#endif
}
Example #13
0
void load_font(char *fname, int size)
{
    char *p;

    free_font();
    font=TTF_OpenFont(fname, size);
    if(!font)
    {
        printf("TTF_OpenFont: %s\n", TTF_GetError());
        exit(3);
    }

    /* print some metrics and attributes */
    printf("size                    : %d\n",size);
    printf("TTF_FontHeight          : %d\n",TTF_FontHeight(font));
    printf("TTF_FontAscent          : %d\n",TTF_FontAscent(font));
    printf("TTF_FontDescent         : %d\n",TTF_FontDescent(font));
    printf("TTF_FontLineSkip        : %d\n",TTF_FontLineSkip(font));
    printf("TTF_FontFaceIsFixedWidth: %d\n",TTF_FontFaceIsFixedWidth(font));
    {
        char *str=TTF_FontFaceFamilyName(font);
        if(!str)
            str="(null)";
        printf("TTF_FontFaceFamilyName  : \"%s\"\n",str);
    }
    {
        char *str=TTF_FontFaceStyleName(font);
        if(!str)
            str="(null)";
        printf("TTF_FontFaceStyleName   : \"%s\"\n",str);
    }
    if(TTF_GlyphIsProvided(font,'g'))
    {
        int minx, maxx, miny, maxy, advance;
        TTF_GlyphMetrics(font,'g', &minx, &maxx, &miny, &maxy, &advance);
        printf("TTF_GlyphMetrics('g'):\n\tminx=%d\n\tmaxx=%d\n\tminy=%d\n\tmaxy=%d\n\tadvance=%d\n",
            minx, maxx, miny, maxy, advance);
    }
    else
        printf("TTF_GlyphMetrics('g'): unavailable in font!\n");

    /* set window title and icon name, using filename and stuff */
    p=strrchr(fname,'/');
    if(!p)
        p=strrchr(fname,'\\');
    if(!p)
        p=strrchr(fname,':');
    if(!p)
        p=fname;
    else
        p++;

    /* cache new glyphs */
    cache_glyphs();
}
Example #14
0
int TTFS_FontLineSkipSecure(TTF_Font *font)
{
    int lineSkip;

    if (!WaitForYourTurn())
        return -1;
    lineSkip = TTF_FontLineSkip(font);
    YouAreOver();

    return lineSkip;
}
Example #15
0
JNIEXPORT jint JNICALL Java_sdljava_x_swig_SWIG_1SDLTTFJNI_TTF_1FontLineSkip(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jint jresult = 0 ;
    TTF_Font *arg1 = (TTF_Font *) 0 ;
    int result;
    
    (void)jenv;
    (void)jcls;
    arg1 = *(TTF_Font **)&jarg1; 
    result = (int)TTF_FontLineSkip(arg1);
    
    jresult = (jint)result; 
    return jresult;
}
Example #16
0
FontEngine::FontEngine() {
	font_pt = 10;

	// Initiate SDL_ttf
	if(!TTF_WasInit() && TTF_Init()==-1) {
		printf("TTF_Init: %s\n", TTF_GetError());
		exit(2);
	}

	// load the font
	string font_path;
	FileParser infile;
	if (infile.open(PATH_DATA + "engine/font_settings.txt")) {
		while (infile.next()) {
			if (infile.key == "font_regular"){
				font_path = infile.val;
			}
			if (infile.key == "ptsize"){
				font_pt = atoi(infile.val.c_str());
			}
		}
	}
	font_path = PATH_DATA + "fonts/" + font_path;
	font = TTF_OpenFont(font_path.c_str(), font_pt);
	if(!font) printf("TTF_OpenFont: %s\n", TTF_GetError());

	// calculate the optimal line height
	line_height = TTF_FontLineSkip(font);
	font_height = TTF_FontHeight(font); 

	// set the font colors
	SDL_Color white = {255,255,255};
	SDL_Color red = {255,0,0};
	SDL_Color green = {0,255,0};
	SDL_Color blue = {0,0,255};
	SDL_Color grey = {128,128,128};
	SDL_Color black = {0,0,0};

	colors[FONT_WHITE] = white;
	colors[FONT_RED] = red;
	colors[FONT_GREEN] = green;
	colors[FONT_BLUE] = blue;
	colors[FONT_GREY] = grey;
	colors[FONT_BLACK] = black;
}
Example #17
0
void hardwareInit()
{
	if(SDL_Init(SDL_INIT_VIDEO)<0) {
		exit(1);
	}
	atexit(SDL_Quit);
	if(TTF_Init() < 0) {
		exit(2);
	}
	atexit(TTF_Quit);
	font = TTF_OpenFont("/usr/share/fonts/TTF/DejaVuSansMono.ttf", 8*2);
	if(!font) {
		exit(3);
	}
	printf("The font line skip is: %d\n", TTF_FontLineSkip(font));
	Uint32 flags = SDL_SWSURFACE;
	screen = SDL_SetVideoMode(160*2, 80*2, 16, flags);
}
Example #18
0
KFontProperties::KFontProperties(const TTF_Font *_Font, const KFile *file, int ptSize) :
fontPath(file->getAbsolutePath().c_str()),
familyName(TTF_FontFaceFamilyName(_Font)),
styleName(TTF_FontFaceStyleName(_Font)),
ttf_Style(TTF_GetFontStyle(_Font)),
height(TTF_FontHeight(_Font)),
ascent(TTF_FontAscent(_Font)),
descent(TTF_FontDescent(_Font)),
lineSkip(TTF_FontLineSkip(_Font)),
faces(TTF_FontFaces(_Font)),
monospace(TTF_FontFaceIsFixedWidth(_Font)),
firstGlyph(getFirstGlyph(_Font)),
lastGlyph(getLastGlyph(_Font)),
totalGlyphs(getTotalGlyphs(_Font)),
glyphRanges(getRanges(_Font)),
pointSize(ptSize) {

}
Example #19
0
void GUI::TextButton::Draw() {
	SDL_Rect rect = {x, y, w, h};

	ensure_SDL_BlitSurface(m_bgs, NULL, screen, &rect);

	if(m_borders) {
		Uint32 bcolour = has_focus() ? SDL_MapRGB(screen->format, 255, 255, 0) : SDL_MapRGB(screen->format, 255, 255, 255);
		SDL_Rect ra = {x,y,w,1}, rb = {x,y,1,h}, rc = {x,y+h,w,1}, rd = {x+w,y,1,h+1};

		ensure_SDL_FillRect(screen, &ra, bcolour);
		ensure_SDL_FillRect(screen, &rb, bcolour);
		ensure_SDL_FillRect(screen, &rc, bcolour);
		ensure_SDL_FillRect(screen, &rd, bcolour);
	}

	rect.w = 0;
	rect.h = 0;

	int hoff = (h - TTF_FontLineSkip(m_font)) / 2;
	int width = FontStuff::TextWidth(m_font, m_text);

	switch(m_align) {
		case LEFT:
			rect.x = x + hoff;
			rect.y = y + hoff;
			break;

		case CENTER:
			rect.x = x + (w - width) / 2;
			rect.y = y + hoff;
			break;

		case RIGHT:
			rect.x = (x + w) - (width + hoff);
			rect.y = y + hoff;
			break;
	}

	FontStuff::BlitText(screen, rect, m_font, m_fgc, m_text);
}
Example #20
0
static void GUI_SetTextRecursive(GUI_Window w, const char * text, int line_number)
{

	SDL_Surface * text_line = NULL;
	SDL_Rect text_line_position;
	SDL_Rect text_line_dimension;

	TTF_Font * font = TTF_OpenFont(w->font_path, w->font_size);

	int x, y, new_line_length;
	TTF_SizeText(font, text, &x, &y);

	new_line_length = x - line_number * (w->dimensions_background.w - 2 * 2 * w->buttons_header_offset);

	text_line_position.x = 0;
	text_line_position.y = (Sint16)((line_number - 1) * y);

	text_line_dimension.x = (Sint16)((line_number - 1) * (w->dimensions_background.w - 2 * 2 * w->buttons_header_offset));
	text_line_dimension.y = 0;
	text_line_dimension.w = (new_line_length > 0) ? (Uint16)(w->dimensions_background.w - 2 * 2 * w->buttons_header_offset) : (Uint16)(x / line_number);
	text_line_dimension.h = (Uint16)(y);

	TTF_FontLineSkip(font);

	text_line = TTF_RenderText_Blended(font, text, GUI_GetColorFromHex(w->content_text_color));
	assert(w->text_content != NULL);
	SDL_BlitSurface(text_line, &text_line_dimension, w->text_content, &text_line_position);

	if (new_line_length > 0)
		GUI_SetTextRecursive(w, text, line_number + 1);

	SDL_FreeSurface(text_line);

	TTF_CloseFont(font);

}
Example #21
0
void FontTTF::loadMetrics(TTF_Font *font) {
    _cellHeight = TTF_FontHeight(font);
    _cellWidth = 0;
    
    int x1, x2, y1, y2, advance;
    for( int i = 0; i < 256; ++i ) {
        TTF_GlyphMetrics(font, static_cast<Uint16>(i), &x1, &x2, &y1, &y2, &advance);

        // Only handle visible characters (>32) and the 'space' character (32).
        _fontWidth[i] = i >= 32 ? advance : 0;

        if(_fontWidth[i] > _cellWidth) {
            _cellWidth = advance;
        }
    }

    // Set a tab to be the width of 4 spaces.
    _fontWidth[9] = _fontWidth[32] * 4;
    
    _fontAscent = TTF_FontAscent(font);
    _fontDescent = TTF_FontDescent(font);
    _fontHeight = _fontAscent - _fontDescent;
    _lineSkip = TTF_FontLineSkip(font);
}
Example #22
0
//
// Load a new font and create textures for each glyph
//
font *ttf_new (const char *name, int pointSize, int style)
{
    uint8 c;
    font *f;
    
    f = (fontp)zalloc(sizeof(*f));
    if (!f) {
        return (NULL);
    }

    f->name = strdup(name);
    f->ttf = TTF_OpenFont(name, pointSize);
    if (!f->ttf) {
        DIE("cannot open font file %s", name);
    }

    f->foreground.r = 255;
    f->foreground.g = 255;
    f->foreground.b = 255;
    f->background.r = 0;
    f->background.g = 0;
    f->background.b = 0;

    TTF_SetFontStyle(f->ttf, style);
    TTF_SetFontOutline(f->ttf, 0.5);
    f->height = TTF_FontHeight(f->ttf);
    f->ascent = TTF_FontAscent(f->ttf);
    f->descent = TTF_FontDescent(f->ttf);
    f->lineSkip = TTF_FontLineSkip(f->ttf);

    for (c = TTF_GLYPH_MIN; c < TTF_GLYPH_MAX; c++) {
        ttf_create_tex_from_char(f, c);
    }

    return (f);
}
Example #23
0
MessageArea::MessageArea ( SDL_Surface* dest_surface, int sizex, int sizey, int originx, int originy ) : Widget( dest_surface, sizex, sizey, originx, originy )
{
	dest.x = originx;
	dest.y = originy;
	dest.w = sizex;
	dest.h = sizey;

	font = TTF_OpenFont ( "client/data/Vera.ttf", 12 );
	if ( !font )
	{
		std::cerr << "Error creating TTF_Font: " << TTF_GetError() << "\n";
		exit ( 1 );
	}
	font_height = TTF_FontLineSkip ( font );

	message_color.r = 255;
	message_color.g = 255;
	message_color.b = 0;
	message_color.unused = 0;

	input_received = true;
	blocked = 0;
	current_message = -1;
}
Example #24
0
/*** FunciĆ³n: Pixeles recomendados para una linea nueva ***/
int GetFontLineSkip( TTF_Font* font )
{
    return TTF_FontLineSkip( font );
}
Example #25
0
osd_font sdl_osd_interface::font_open(const char *_name, int &height)
{
	TTF_Font *font = (TTF_Font *)NULL;
	bool bakedstyles = false;
	int style = 0;

	// accept qualifiers from the name
	astring name(_name);

	if (name == "default")
	{
		name = "Liberation Sans";
	}

	bool bold = (name.replace(0, "[B]", "") + name.replace(0, "[b]", "") > 0);
	bool italic = (name.replace(0, "[I]", "") + name.replace(0, "[i]", "") > 0);
	bool underline = (name.replace(0, "[U]", "") + name.replace(0, "[u]", "") > 0);
	bool strike = (name.replace(0, "[S]", "") + name.replace(0, "[s]", "") > 0);

	// first up, try it as a filename
	font = TTF_OpenFont_Magic(name, POINT_SIZE);

	// if no success, try the font path

	if (!font)
	{
		mame_printf_verbose("Searching font %s in -%s\n", name.cstr(), OPTION_FONTPATH);
		emu_file file(machine().options().font_path(), OPEN_FLAG_READ);
		if (file.open(name) == FILERR_NONE)
		{
			astring full_name = file.fullpath();
			font = TTF_OpenFont_Magic(full_name, POINT_SIZE);
			if (font)
				mame_printf_verbose("Found font %s\n", full_name.cstr());
		}
	}

	// if that didn't work, crank up the FontConfig database
#ifndef SDLMAME_HAIKU
	if (!font)
	{
		font = search_font_config(name, bold, italic, underline, bakedstyles);
	}
#endif

	if (!font)
	{
        if (!BDF_Check_Magic(name))
        {
            printf("WARNING: font %s, is not TrueType or BDF, using MAME default\n", name.cstr());
        }
		return NULL;
	}

	// apply styles
	if (!bakedstyles)
	{
		style |= bold ? TTF_STYLE_BOLD : 0;
		style |= italic ? TTF_STYLE_ITALIC : 0;
	}
	style |= underline ? TTF_STYLE_UNDERLINE : 0;
	// SDL_ttf 2.0.9 and earlier does not define TTF_STYLE_STRIKETHROUGH
#if SDL_VERSIONNUM(TTF_MAJOR_VERSION, TTF_MINOR_VERSION, TTF_PATCHLEVEL) > SDL_VERSIONNUM(2,0,9)
	style |= strike ? TTF_STYLE_STRIKETHROUGH : 0;
#else
	if (strike)
		mame_printf_warning("Ignoring strikethrough for SDL_TTF with version less 2.0.10\n");
#endif // PATCHLEVEL
	TTF_SetFontStyle(font, style);

	height = TTF_FontLineSkip(font);

	return (osd_font)font;
}
/**
 * Process the text and generate the list of formatted renderables.
 */
void FmtTextDecor::Reformat()
{
    int lineHeight = TTF_FontLineSkip(**font);
    int spaceWidth = font->spaceLayoutWidth;
    if (text) s = **text;
    int x = 0, y = 0;
    int fmtColor = 7;

    sizeWidth = 0;
    sizeHeight = 0;

    rends.clear();
    rends.reserve(s.length());

    uint32_t ch = 0;
    for (auto iter = s.cbegin(), iend = s.cend(); iter != iend; ) {
        ch = utf8::next(iter, iend);

        // Only handle characters which we have included in the type case.
        if (ch > font->glyphs.size()) {
            SDL_Log("Unrenderable code point: %d", ch);
            continue;
        }

        switch (ch) {
        case '\n':  // Newlines.
            x = 0;
            y += lineHeight;
            break;

        case '^':  // Color codes.
            if (iter == iend) {
                return;
            }
            else {
                uint32_t idx = utf8::next(iter, iend);

                // Allow "^^" as an escape sequence for "^".
                if (idx == '^') {
                    const Ttf::Glyph &glyph = font->glyphs['^'];
                    if (glyph.avail) {
                        rends.emplace_back(Rend(&glyph, x, y, fmtColor));
                        x += glyph.layoutW;
                    }
                    break;
                }

                fmtColor = (idx + 16) & 31;
            }
            break;

        case '\r':  // Ignore CRs.
            break;

        case ' ':
            x += spaceWidth;
            break;

        default: {
            const Ttf::Glyph &glyph = font->glyphs[ch];
            if (!glyph.avail) continue;

            rends.emplace_back(Rend(&glyph, x, y, fmtColor));

            x += glyph.layoutW;
        }
        }

        if (x >= sizeWidth) {
            sizeWidth = x;
        }
    }

    // If the last char wasn't a newline, adjust the height otherwise we'll
    // cut off the bottom line of text.
    if (ch != '\n') {
        y += lineHeight;
    }
    sizeHeight = y;
}
Example #27
0
/*
 * create_font
 */
int create_font(char *filename,
                FONT **font,
                int size,
                int style,
                SDL_Color color)
{
  TTF_Font* ttffont;
  SDL_Surface* character_surface;
  int ret_code = BUILD_FONT_OK;
  int rc;
  Uint16 ii;

  /*
   * Allocate the memory required for the font object.
   */
  (*font) = (FONT *) DT_MALLOC(sizeof(FONT));

  /*
   * Set the font attributes.
   */
  memcpy(&((*font)->color), &color, sizeof(SDL_Color));
  (*font)->pointsize = size;
  (*font)->style = style;

  /*
   * The font loading may fail if the file does not exist or permissions are
   * incorrect etc.
   */
  ttffont = TTF_OpenFont(filename, (*font)->pointsize);
  if (ttffont == NULL)
  {
    DT_DEBUG_LOG("Error opening font (%s): %s\n", filename, TTF_GetError());
    ret_code = BUILD_FONT_LOAD_FAIL;
    goto EXIT_LABEL;
  }

  /*
   * Set the style of the font to whatever we passed in.
   */
  TTF_SetFontStyle(ttffont, (*font)->style);

  /*
   * Retrieve the font information to store in our font structure.
   */
  (*font)->ascent = TTF_FontAscent(ttffont);
  (*font)->descent = TTF_FontDescent(ttffont);
  (*font)->height = TTF_FontHeight(ttffont);
  (*font)->lineskip = TTF_FontLineSkip(ttffont);

  /*
   * For each possible glyph, attempt to load the font character and create a
   * texture for it. If any of these fail we attempt to close down gracefully
   * and exit the function.
   */
  for (ii = ' '; ii <= '~'; ii++)
  {
    character_surface = TTF_RenderGlyph_Blended(ttffont, ii, (*font)->color);
    if (NULL == character_surface)
    {
      DT_DEBUG_LOG("Error rendering glyph %c whilst creating font (%s): %s\n",
                   (char) ii,
                   filename,
                   TTF_GetError());
      ret_code = BUILD_FONT_RENDER_FAIL;
      goto EXIT_LABEL;
    }

    /*
     * Retrieve the metric info from the font object and store it in our local
     * structure.
     */
    TTF_GlyphMetrics(ttffont,
                     ii,
                     &((*font)->glyphs[ii].minx),
                     &((*font)->glyphs[ii].maxx),
                     &((*font)->glyphs[ii].miny),
                     &((*font)->glyphs[ii].maxy),
                     &((*font)->glyphs[ii].advance));

    /*
     * This function can fail if opengl cannot allocate any more memory for
     * textures.
     */
    rc = SDL_GL_LoadTexture(character_surface, &((*font)->glyphs[ii].texid), false);
    if (LOAD_TEXTURE_OK != rc)
    {
      DT_DEBUG_LOG("Failed creating texture for glyph %c from font %s\n",
                   (char) ii,
                   TTF_GetError());
      SDL_FreeSurface(character_surface);
      ret_code = BUILD_FONT_CREATE_TEXTURE_FAIL;
      goto EXIT_LABEL;
    }

    /*
     * Set the texture coordinates for the glyph (note this is the same for all
     * glyphs).
     */
    (*font)->glyphs[ii].texcoord[0] = 0.0f;
    (*font)->glyphs[ii].texcoord[1] = 0.0f;
    (*font)->glyphs[ii].texcoord[2] = 1.0f;
    (*font)->glyphs[ii].texcoord[3] = 1.0f;

    /*
     * The surface used for that character is no longer required.
     */
    SDL_FreeSurface(character_surface);
  }

EXIT_LABEL:

  if (NULL != ttffont)
  {
    TTF_CloseFont(ttffont);
  }

  return ret_code;
}
Example #28
0
	//prep page
	void Book::drawPage(Screen &screen, int pageNum) {

		//clean screen
		screen.cleanScreen();

		//init vars
		int textureWidth, textureHeight, txtSize, imgSizeX, imgSizeY, destX, destY, textFontSize, warningFontSize, textWidth, textFontGap, endTextSize, endMarkerX, endMarkerY;
		SDL_Rect destRect;

		//set vars
		textFontSize = int(screen.resY / 35);
		warningFontSize = int(screen.resY / 12);
		textWidth = screen.resX * this->pages[pageNum].textScaleX;

		//sample font vertical size of choice and page end text
		textFontGap = int(TTF_FontLineSkip(TTF_OpenFont("fonts/benguiat_bold.ttf", textFontSize)) * .79);

		//draw warning (if warning exists)
		if (this->pages[pageNum].itemType == "WARNING") {
			//draw text to texture
			screen.makeTextTexture("fonts/souvenir.ttf", warningFontSize, this->pages[pageNum].item, { 0,0,0 }, (screen.resX / 2));
			//get dimensions
			SDL_QueryTexture(screen.texture, NULL, NULL, &textureWidth, &textureHeight);
			//calc text destination
			destX = (screen.resX * this->pages[pageNum].itemX) - (textureWidth / 2);
			destY = (screen.resY * this->pages[pageNum].itemY) - (textureHeight / 2);
			//set destination
			destRect = { destX, destY, textureWidth, textureHeight };
			//draw texture to buffer
			screen.drawTexture(screen.texture, destRect);
		}

		//draw image (if image exists)
		if (this->pages[pageNum].itemType == "IMAGE") {
			//draw image to texture
			screen.makeImageTexture(this->pages[pageNum].item);
			//get dimensions
			SDL_QueryTexture(screen.texture, NULL, NULL, &textureWidth, &textureHeight);
			//calc scaled image dimensions and destination			
			imgSizeY = int(screen.resY * this->pages[pageNum].itemScaleY);
			imgSizeX = int(textureWidth * (double(imgSizeY) / double(textureHeight))); 
			destX = (screen.resX * this->pages[pageNum].itemX) - (imgSizeX / 2);
			destY = (screen.resY * this->pages[pageNum].itemY) - (imgSizeY / 2);
			//set destination
			destRect = { destX, destY, imgSizeX, imgSizeY };
			//draw texture to buffer
			screen.drawTexture(screen.texture, destRect);
		}

		//draw page text
			//determine how many lines are needed below the text block
			if (this->pages[pageNum].type == "CHOICE") { //adjust size based on number of choices
				endTextSize = this->pages[pageNum].choices.size() * (textFontGap * 2);
			}
			else { //only one thing will be written, so just need one set
				endTextSize = (textFontGap * 2);
			}
			//draw text to texture
			screen.makeTextTexture("fonts/souvenir.ttf", textFontSize, this->pages[pageNum].text, { 50,50,50 }, textWidth);
			//get dimensions
			SDL_QueryTexture(screen.texture, NULL, NULL, &textureWidth, &textureHeight);
			//calc text destination
			destX = (screen.resX * this->pages[pageNum].textX) - (textureWidth / 2);
			destY = (screen.resY * this->pages[pageNum].textY) - ((textureHeight + endTextSize) / 2);
			//set destination
			destRect = { destX, destY, textureWidth, textureHeight };
			//prepare end markers 
			endMarkerX = destX;
			endMarkerY = destY + textureHeight + textFontGap;
			//draw texture to buffer
			screen.drawTexture(screen.texture, destRect);

		//draw text at the end of the page depending on page type
		if (this->pages[pageNum].type == "CHOICE") { //write choices
			//loop through choice array and write all choices to the buffer
			for (size_t i = 0; i < this->pages[pageNum].choices.size(); i++) {
				//draw text to texture
				screen.makeTextTexture("fonts/souvenir.ttf", textFontSize, this->pages[pageNum].choices[i].text, { 50,50,50 }, textWidth);
				//get dimensions
				SDL_QueryTexture(screen.texture, NULL, NULL, &textureWidth, &textureHeight);
				//set destination
				destRect = { endMarkerX, endMarkerY, textureWidth, textureHeight };
				//draw texture to buffer
				screen.drawTexture(screen.texture, destRect);
				//increment choiceMarkerY
				endMarkerY = (endMarkerY + (textFontGap * 2));
			}
		}
		else { //write text from the page format map
			//draw text to texture
			screen.makeTextTexture("fonts/souvenir.ttf", textFontSize, this->pageFormat[this->pages[pageNum].type].text, { 50,50,50 }, textWidth);
			//get dimensions
			SDL_QueryTexture(screen.texture, NULL, NULL, &textureWidth, &textureHeight);
			//set destination
			destRect = { endMarkerX, endMarkerY, textureWidth, textureHeight };
			//draw texture to buffer
			screen.drawTexture(screen.texture, destRect);
		}

		//render buffer to screen
		screen.renderBuffer();

	}
Example #29
0
SDLFontEngine::SDLFontEngine() : FontEngine(), active_font(NULL) {
	// Initiate SDL_ttf
	if(!TTF_WasInit() && TTF_Init()==-1) {
		logError("SDLFontEngine: TTF_Init: %s", TTF_GetError());
		Exit(2);
	}

	// load the fonts
	// @CLASS SDLFontEngine: Font settings|Description of engine/font_settings.txt
	FileParser infile;
	if (infile.open("engine/font_settings.txt")) {
		while (infile.next()) {
			if (infile.new_section && infile.section == "font") {
				SDLFontStyle f;
				f.name = infile.section;
				font_styles.push_back(SDLFontStyle());
			}

			if (font_styles.empty()) continue;

			SDLFontStyle *style = &(font_styles.back());

			if (infile.key == "id") {
				// @ATTR font.id|string|An identifier used to reference this font.
				style->name = infile.val;
			}
			else if (infile.key == "style") {
				// @ATTR font.style|repeatable(["default", predefined_string], filename, int, bool) : Language, Font file, Point size, Blending|Filename, point size, and blend mode of the font to use for this language. Language can be "default" or a 2-letter region code.

				std::string lang = popFirstString(infile.val);

				if ((lang == "default" && style->path == "") || lang == LANGUAGE) {
					style->path = popFirstString(infile.val);
					style->ptsize = popFirstInt(infile.val);
					style->blend = toBool(popFirstString(infile.val));

					style->ttfont = TTF_OpenFont(mods->locate("fonts/" + style->path).c_str(), style->ptsize);
					if(style->ttfont == NULL) {
						logError("FontEngine: TTF_OpenFont: %s", TTF_GetError());
					}
					else {
						int lineskip = TTF_FontLineSkip(style->ttfont);
						style->line_height = lineskip;
						style->font_height = lineskip;
					}
				}
			}
		}
		infile.close();
	}

	// set the font colors
	Color color;
	if (infile.open("engine/font_colors.txt")) {
		while (infile.next()) {
			// @ATTR menu_normal|color|Basic menu text color. Recommended: white.
			// @ATTR menu_bonus|color|Positive menu text color. Recommended: green.
			// @ATTR menu_penalty|color|Negative menu text color. Recommended: red.
			// @ATTR widget_normal|color|Basic widget text color. Recommended: white.
			// @ATTR widget_disabled|color|Disabled widget text color. Recommended: grey.
			// @ATTR combat_givedmg|color|Enemy damage text color. Recommended: white.
			// @ATTR combat_takedmg|color|Player damage text color. Recommended: red.
			// @ATTR combat_crit|color|Enemy critical damage text color. Recommended: yellow.
			// @ATTR requirements_no_met|color|Unmet requirements text color. Recommended: red.
			// @ATTR item_bonus|color|Item bonus text color. Recommended: green.
			// @ATTR item_penalty|color|Item penalty text color. Recommended: red.
			// @ATTR item_flavor|color|Item flavor text color. Recommended: grey.
			color_map[infile.key] = toRGB(infile.val);
		}
		infile.close();
	}

	// Attempt to set the default active font
	setFont("font_regular");
	if (!active_font) {
		logError("FontEngine: Unable to determine default font!");
		Exit(1);
	}
}
Example #30
0
File: main.cpp Project: newobj/taz
int main(int argc, char* argv[])
{
	if ( argc < 4 )
	{
		fprintf(stderr, "usage: tool_font filename.ttf chars.txt ptsize <style> <supersample>\n");
		return -1;
	}

	char szFont[256];
	strcpy(szFont, argv[1]);
	*strstr(szFont, ".ttf") = 0;
	int nFontSize = atol(argv[3]);

	int nStyle = TTF_STYLE_NORMAL;

	if ( argc > 3 )
	{
		for ( int i = 0 ; argv[4][i] != 0 ; i++ )
		{
			switch ( argv[4][i] )
			{
				case 'b':
					nStyle |= TTF_STYLE_BOLD;
					break;
				case 'i':
					nStyle |= TTF_STYLE_ITALIC;
					break;
				case 'u':
					nStyle |= TTF_STYLE_UNDERLINE;
					break;
			}
		}
	}

	float fScale = 1.0f;
	if ( argc > 5 )
	{
		fScale = 1.0f/atof(argv[6]);
	}

	SDL_Init(SDL_INIT_VIDEO);
	TTF_Init();
	TTF_Font* pFont = TTF_OpenFont(argv[1], nFontSize/fScale);
	if ( !pFont )
	{
		fprintf(stderr, "could not open %s @ %d points\n", argv[1], nFontSize);
		return -1;
	}

	int nAscent = TTF_FontAscent(pFont);
	int nDescent = TTF_FontDescent(pFont);
	int nHeight = TTF_FontHeight(pFont);

	char szStyle[4] = { 0 };
	char* pchStyle = szStyle;
	if ( nStyle & TTF_STYLE_BOLD ) *pchStyle++ = 'b';
	if ( nStyle & TTF_STYLE_ITALIC ) *pchStyle++ = 'i';
	if ( nStyle & TTF_STYLE_UNDERLINE ) *pchStyle++ = 'u';

	TTF_SetFontStyle(pFont, nStyle);

	char achGlyphs[1024];
	int cGlyphs = 0;
	FILE* fpChars = fopen(argv[2], "r");
	while ( EOF != (achGlyphs[cGlyphs++] = fgetc(fpChars)) );
	fclose(fpChars);
	cGlyphs--;
		
	SDL_Rect* aRects = new SDL_Rect[cGlyphs];
	SDL_Surface** apSurfaces = new SDL_Surface*[cGlyphs];

	for ( int iGlyph = 0 ; iGlyph < cGlyphs ; ++iGlyph )
	{
		SDL_Color color = { 255, 255, 255, 0 };
		char szGlyph[2] = { 0 };
		szGlyph[0] = achGlyphs[iGlyph];
		apSurfaces[iGlyph] = TTF_RenderText_Blended(pFont, szGlyph, color);
//		char szFile[128];
//		sprintf(szFile, "textures/fonts/%s/%d.raw", argv[1], szGlyph[0]);
//		FILE* fp = fopen(szFile, "wb");
//		fwrite(apSurfaces[iGlyph]->pixels, apSurfaces[iGlyph]->pitch*apSurfaces[iGlyph]->h, 1, fp);
//		fclose(fp);
	}

	struct DIMS
	{
		int w, h;
	};

	DIMS aDims[] = 
	{	
		64, 64,
		64, 128,
		64, 256,
		128, 64,
		128, 128,
		128, 256,
		256, 64,
		256, 128,
		256, 256,
		64, 512,
		128, 512,
		256, 512,
		512, 64,
		512, 128,
		512, 256,
		512, 512,
		64, 1024,
		128, 1024,
		256, 1024,
		256, 1024,
		512, 1024,
		1024, 64,
		1024, 128,
		1024, 256,
		1024, 512,
		1024, 1024,
		64, 2048,
		128, 2048,
		256, 2048,
		512, 2048,
		1024, 2048,
		2048, 64,
		2048, 128,
		2048, 256,
		2048, 512,
		2048, 1024,
		2048, 2048,
/*		512, 64,
		512, 128,
		512, 256,
		512, 512,
		64, 512,
		128, 512,
		256, 512,
		1024, 64,
		1024, 128,
		1024, 256,
		1024, 512,
		64,	1024,
		128, 1024,
		256, 1024,
		512, 1024, 
		2048, 64,
		2048, 128,
		2048, 256,
		2048, 1024,
		2048, 2048,
		64,	2048,
		128, 2048,
		256, 2048,
		512, 2048,
		1024, 2048
*/	};

	int cDims = sizeof(aDims)/sizeof(DIMS);

	for ( int iDims = 0 ; iDims < cDims ; ++iDims )
	{
		int nWidth = aDims[iDims].w;
		int nHeight = aDims[iDims].h;

		SDL_Surface* pSurfaceGeneric = SDL_CreateRGBSurface(SDL_SWSURFACE, nWidth, nHeight, 32, 0, 0, 0, 0);
		SDL_Surface* pSurface = SDL_ConvertSurface(pSurfaceGeneric, apSurfaces[0]->format, 0);
		SDL_FillRect(pSurface, NULL, SDL_MapRGBA(pSurface->format, 0,0,0,0));
		bool* aabyUsage = new bool[nHeight*nWidth];
		memset(aabyUsage, 0, nHeight*nWidth*sizeof(bool));
		bool bFit = true;

		for ( int iGlyph = 0 ; iGlyph < cGlyphs ; ++iGlyph )
		{
			if ( !Fit(aabyUsage, pSurface, apSurfaces[iGlyph], &aRects[iGlyph], fScale) )
			{
				bFit = false;
				break;
			}
		}

		if ( bFit )
		{
			fprintf(stderr, "glyphs fit into %d x %d texture\n", nWidth, nHeight);
			char szFile[256];
			sprintf(szFile, "textures/fonts/%s%d%s.png", szFont, nFontSize, szStyle);

			for ( int y = 0 ; y < pSurface->h ; ++y )
			{
				for ( int x = 0 ; x < pSurface->w ; ++x )
				{
					unsigned char r = ((unsigned char*)pSurface->pixels)[x*4 + y*pSurface->w*4 + 0];
					unsigned char g = ((unsigned char*)pSurface->pixels)[x*4 + y*pSurface->w*4 + 1];
					unsigned char b = ((unsigned char*)pSurface->pixels)[x*4 + y*pSurface->w*4 + 2];

					unsigned char a = (r+g+b)/3;
					r = g = b = 255;

					((unsigned char*)pSurface->pixels)[x*4 + y*pSurface->w*4 + 0] = r;
					((unsigned char*)pSurface->pixels)[x*4 + y*pSurface->w*4 + 1] = g;
					((unsigned char*)pSurface->pixels)[x*4 + y*pSurface->w*4 + 2] = b;
					((unsigned char*)pSurface->pixels)[x*4 + y*pSurface->w*4 + 3] = a;
				}
			}

			ILuint iImage = 0;
			ilInit();
			ilGenImages(1, &iImage);
			ilBindImage(iImage);
			ilTexImage(pSurface->w, pSurface->h, 1, 4, IL_RGBA, IL_UNSIGNED_BYTE, pSurface->pixels);
//			ilConvertImage(IL_LUMINANCE, IL_UNSIGNED_BYTE);
			iluFlipImage();
			iluImageParameter(ILU_FILTER, ILU_SCALE_LANCZOS3);
			iluScale(pSurface->w*fScale, pSurface->h*fScale, 1);
			ilSaveImage(szFile);

			int nDescent = TTF_FontDescent(pFont);

			char szFontFile[256];
			sprintf(szFontFile, "fonts/%s%d%s.font", szFont, nFontSize, szStyle);
			FILE* fp = fopen(szFontFile, "w");
			fprintf(fp, "<font name=\"%s\" height=\"%d\" lineskip=\"%d\" shader=\"%s,srcalpha,invsrcalpha\">\n", szFont, int(TTF_FontHeight(pFont)*fScale), int(TTF_FontLineSkip(pFont)*fScale), szFile);
			for ( int iGlyph = 0 ; iGlyph < cGlyphs ; ++iGlyph )
			{
				int xmin, xmax, ymin, ymax, adv;
				TTF_GlyphMetrics(pFont, achGlyphs[iGlyph], &xmin, &xmax, &ymin, &ymax, &adv);
				fprintf(fp, "%c<glyph ascii=\"%d\" adv=\"%d\" dims=\"%d,%d\" origin=\"%d,%d\" u0=\"%f\" v0=\"%f\" u1=\"%f\" v1=\"%f\"/>\n",
					9,
					achGlyphs[iGlyph],
					int(adv*fScale),
					int(aRects[iGlyph].w*fScale), int(aRects[iGlyph].h*fScale),
					int(xmin*fScale),
					int(-nDescent*fScale),
					float(aRects[iGlyph].x)/float(pSurface->w),
					float(aRects[iGlyph].y)/float(pSurface->h),
					float(aRects[iGlyph].x+aRects[iGlyph].w)/float(pSurface->w),
					float(aRects[iGlyph].y+aRects[iGlyph].h)/float(pSurface->h));
			}
			fprintf(fp, "</font>\n");
			fclose(fp);
//				FILE* fp = fopen("textures/fonts/blockup.raw", "wb");
//				fwrite(pSurface->pixels, pSurface->pitch*pSurface->h, 1, fp);
//				fclose(fp);
			return 0;
		}
			
		delete [] aabyUsage;
		SDL_FreeSurface(pSurface);
		SDL_FreeSurface(pSurfaceGeneric);
	}

	return 0;
}