| 0,0 → 1,1193 |
|---|
| |
| #include <math.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <assert.h> |
| |
| #include <freetype/freetype.h> |
| |
| #include "SDL.h" |
| #include "SDL_ttf.h" |
| |
| /* Macro to convert a character to a Unicode value -- assume already Unicode */ |
| #define UNICODE(c) c |
| |
| /* Round a float up to the nearest integeter and return that integer */ |
| static int round(float x) |
| { |
| int value; |
| |
| value = (int)x; |
| if ( x > value ) { |
| value = value + 1; |
| } else |
| if ( x < value ) { |
| value = value - 1; |
| } |
| return value; |
| } |
| |
| /* The structure used to hold glyph information (cached) */ |
| struct glyph { |
| int cached; |
| TT_Raster_Map bitmap; |
| TT_Raster_Map pixmap; |
| int minx; |
| int maxx; |
| int miny; |
| int maxy; |
| int advance; |
| }; |
| |
| /* The structure used to hold internal font information */ |
| struct _TTF_Font { |
| TT_Face face; |
| TT_Instance inst; |
| TT_Glyph glyph; |
| TT_CharMap map; |
| |
| /* Font metrics */ |
| int pointsize; |
| int height; /* ascent - descent */ |
| float ascent; |
| float descent; |
| float lineskip; |
| |
| /* The font style */ |
| int style; |
| |
| /* Extra width in glyph bounds for text styles */ |
| int glyph_overhang; |
| float glyph_italics; |
| |
| /* For now, support Latin-1 character set caching */ |
| struct glyph *current; |
| struct glyph cache[256]; |
| struct glyph scratch; |
| }; |
| |
| /* The FreeType font engine */ |
| static TT_Engine engine; |
| |
| int TTF_Init(void) |
| { |
| int error; |
| |
| error = TT_Init_FreeType(&engine); |
| if ( error ) { |
| SDL_SetError("Couldn't init FreeType engine"); |
| return(-1); |
| } |
| return(0); |
| } |
| |
| TTF_Font *TTF_OpenFont(const char *file, int ptsize) |
| { |
| TTF_Font *font; |
| TT_Face_Properties properties; |
| TT_Instance_Metrics imetrics; |
| int i, n; |
| TT_UShort platform, encoding; |
| TT_Error error; |
| |
| font = (TTF_Font *)malloc(sizeof(*font)); |
| if ( font == NULL ) { |
| SDL_SetError("Out of memory"); |
| return(NULL); |
| } |
| memset(font, 0, sizeof(*font)); |
| |
| /* Open the font and create ancillary data */ |
| error = TT_Open_Face(engine, file, &font->face); |
| if ( error ) { |
| SDL_SetError("Couldn't load font file"); |
| free(font); |
| return(NULL); |
| } |
| error = TT_New_Glyph(font->face, &font->glyph); |
| if ( error ) { |
| SDL_SetError("Couldn't create glyph container"); |
| TTF_CloseFont(font); |
| return(NULL); |
| } |
| error = TT_New_Instance(font->face, &font->inst); |
| if ( error ) { |
| SDL_SetError("Couldn't create font instance"); |
| TTF_CloseFont(font); |
| return(NULL); |
| } |
| |
| /* Set the display resolution */ |
| error = TT_Set_Instance_Resolutions(font->inst, 72, 72); |
| if ( error ) { |
| SDL_SetError("Couldn't set font resolution"); |
| TTF_CloseFont(font); |
| return(NULL); |
| } |
| error = TT_Set_Instance_CharSize(font->inst, ptsize*64); |
| if ( error ) { |
| SDL_SetError("Couldn't set font size"); |
| TTF_CloseFont(font); |
| return(NULL); |
| } |
| |
| /* Get a Unicode mapping for this font */ |
| n = TT_Get_CharMap_Count(font->face); |
| for ( i=0; i<n; ++i ) { |
| TT_Get_CharMap_ID(font->face, i, &platform, &encoding); |
| if ( ((platform == TT_PLATFORM_MICROSOFT) && |
| (encoding == TT_MS_ID_UNICODE_CS)) || |
| ((platform == TT_PLATFORM_APPLE_UNICODE) && |
| (encoding == TT_APPLE_ID_DEFAULT)) ) { |
| TT_Get_CharMap(font->face, i, &font->map); |
| break; |
| } |
| } |
| if ( i == n ) { |
| SDL_SetError("Font doesn't have a Unicode mapping"); |
| TTF_CloseFont(font); |
| return(NULL); |
| } |
| |
| /* Get the font metrics for this font */ |
| TT_Get_Face_Properties(font->face, &properties ); |
| TT_Get_Instance_Metrics(font->inst, &imetrics); |
| font->pointsize = imetrics.y_ppem; |
| font->ascent = (float)properties.horizontal->Ascender / |
| properties.header->Units_Per_EM; |
| font->ascent *= font->pointsize; |
| font->descent = (float)properties.horizontal->Descender / |
| properties.header->Units_Per_EM; |
| font->descent *= font->pointsize; |
| font->lineskip = (float)properties.horizontal->Line_Gap / |
| properties.header->Units_Per_EM; |
| font->lineskip *= font->pointsize; |
| font->height = round(font->ascent - font->descent); |
| |
| /* Set the default font style */ |
| font->style = TTF_STYLE_NORMAL; |
| font->glyph_overhang = font->pointsize/10; |
| /* x offset = cos(((90.0-12)/360)*2*M_PI), or 12 degree angle */ |
| font->glyph_italics = 0.207; |
| font->glyph_italics *= font->height; |
| |
| return(font); |
| } |
| |
| static void Flush_Glyph(struct glyph *glyph) |
| { |
| if ( glyph->bitmap.bitmap ) { |
| free(glyph->bitmap.bitmap); |
| glyph->bitmap.bitmap = 0; |
| } |
| if ( glyph->pixmap.bitmap ) { |
| free(glyph->pixmap.bitmap); |
| glyph->pixmap.bitmap = 0; |
| } |
| glyph->cached = 0; |
| } |
| |
| static void Flush_Cache(TTF_Font *font) |
| { |
| int i; |
| |
| for ( i=0; i<(sizeof font->cache)/(sizeof font->cache[0]); ++i ) { |
| if ( font->cache[i].cached ) { |
| Flush_Glyph(&font->cache[i]); |
| } |
| } |
| if ( font->scratch.cached ) { |
| Flush_Glyph(&font->scratch); |
| } |
| } |
| |
| static TT_Error Load_Glyph(TTF_Font *font, Uint16 ch, struct glyph *glyph) |
| { |
| TT_UShort index; |
| TT_Glyph_Metrics metrics; |
| TT_Outline outline; |
| int x_offset; |
| int y_offset; |
| TT_Error error; |
| |
| /* Load the glyph */ |
| index = TT_Char_Index(font->map, UNICODE(ch)); |
| error = TT_Load_Glyph(font->inst, font->glyph, index, TTLOAD_DEFAULT); |
| if ( error ) return error; |
| |
| /* Get the bounding box */ |
| TT_Get_Glyph_Metrics(font->glyph, &metrics); |
| glyph->minx = (metrics.bbox.xMin & -64) / 64; |
| glyph->maxx = ((metrics.bbox.xMax + 63) & -64) / 64; |
| glyph->miny = (metrics.bbox.yMin & -64) / 64; |
| glyph->maxy = ((metrics.bbox.yMax + 63) & -64) / 64; |
| glyph->advance = (metrics.advance & -64) / 64; |
| |
| /* Adjust for bold and italic text */ |
| if ( font->style & TTF_STYLE_BOLD ) { |
| glyph->maxx += font->glyph_overhang; |
| } |
| if ( font->style & TTF_STYLE_ITALIC ) { |
| glyph->maxx += round(font->glyph_italics); |
| } |
| |
| /* Get the bitmap memory */ |
| glyph->bitmap.width = ((glyph->maxx - glyph->minx) + 7) & ~7; |
| glyph->bitmap.rows = font->height; |
| glyph->bitmap.cols = glyph->bitmap.width/8; |
| glyph->bitmap.flow = TT_Flow_Down; |
| glyph->bitmap.size = (glyph->bitmap.rows * glyph->bitmap.cols); |
| if ( glyph->bitmap.size ) { |
| glyph->bitmap.bitmap = malloc(glyph->bitmap.size); |
| if ( ! glyph->bitmap.bitmap ) { |
| error = TT_Err_Out_Of_Memory; |
| goto was_error; |
| } |
| memset(glyph->bitmap.bitmap, 0, glyph->bitmap.size); |
| } else { |
| glyph->bitmap.bitmap = 0; |
| } |
| |
| /* Get the pixmap memory */ |
| glyph->pixmap.width = ((glyph->maxx - glyph->minx) + 3) & ~3; |
| glyph->pixmap.rows = font->height; |
| glyph->pixmap.cols = glyph->pixmap.width; |
| glyph->pixmap.flow = TT_Flow_Down; |
| glyph->pixmap.size = (glyph->pixmap.rows * glyph->pixmap.cols); |
| if ( glyph->pixmap.size ) { |
| glyph->pixmap.bitmap = malloc(glyph->pixmap.size); |
| if ( ! glyph->pixmap.bitmap ) { |
| error = TT_Err_Out_Of_Memory; |
| goto was_error; |
| } |
| memset(glyph->pixmap.bitmap, 0, glyph->pixmap.size); |
| } else { |
| glyph->pixmap.bitmap = 0; |
| } |
| |
| /* Render the glyph into the bitmap and pixmap */ |
| error = TT_Get_Glyph_Outline(font->glyph, &outline); |
| /* Handle the italic style */ |
| if ( font->style & TTF_STYLE_ITALIC ) { |
| TT_Matrix shear; |
| |
| shear.xx = 1<<16; |
| shear.xy = (int)(font->glyph_italics*(1<<16))/font->height; |
| shear.yx = 0; |
| shear.yy = 1<<16; |
| TT_Transform_Outline(&outline, &shear); |
| } |
| x_offset = -glyph->minx * 64; |
| y_offset = -round(font->descent) * 64; |
| TT_Translate_Outline(&outline, x_offset, y_offset); |
| error += TT_Get_Outline_Bitmap(engine, &outline, &glyph->bitmap); |
| error += TT_Get_Outline_Pixmap(engine, &outline, &glyph->pixmap); |
| /* Handle the bold style */ |
| if ( font->style & TTF_STYLE_BOLD ) { |
| int row, col; |
| int offset; |
| int pixel; |
| Uint8 *pixmap; |
| |
| /* The bitmap is easy, just render another copy */ |
| for ( offset=0; offset < font->glyph_overhang; ++offset ) { |
| TT_Translate_Outline(&outline, 64, 0); |
| error += TT_Get_Outline_Bitmap(engine, |
| &outline,&glyph->bitmap); |
| } |
| x_offset += font->glyph_overhang*64; |
| |
| /* The pixmap is a little harder, we have to add and clamp */ |
| for ( row=glyph->pixmap.rows-1; row >= 0; --row ) { |
| pixmap = (Uint8 *)glyph->pixmap.bitmap + |
| row*glyph->pixmap.cols; |
| for (offset=1; offset<=font->glyph_overhang; ++offset) { |
| for (col=glyph->pixmap.cols-1; col > 0; --col) { |
| pixel=(pixmap[col]+pixmap[col-1]); |
| if ( pixel > 4 ) { |
| pixel = 4; |
| } |
| pixmap[col] = (Uint8)pixel; |
| } |
| } |
| } |
| } |
| TT_Translate_Outline(&outline, -x_offset, -y_offset); |
| was_error: |
| if ( error ) { |
| if ( glyph->bitmap.bitmap ) { |
| free(glyph->bitmap.bitmap); |
| glyph->bitmap.bitmap = 0; |
| } |
| if ( glyph->pixmap.bitmap ) { |
| free(glyph->pixmap.bitmap); |
| glyph->pixmap.bitmap = 0; |
| } |
| return error; |
| } |
| |
| /* We're done, mark this glyph cached */ |
| glyph->cached = ch; |
| return TT_Err_Ok; |
| } |
| |
| static TT_Error Find_Glyph(TTF_Font *font, Uint16 ch) |
| { |
| int retval; |
| |
| retval = 0; |
| if ( ch < 256 ) { |
| font->current = &font->cache[ch]; |
| } else { |
| if ( font->scratch.cached != ch ) { |
| Flush_Glyph(&font->scratch); |
| } |
| font->current = &font->scratch; |
| } |
| if ( ! font->current->cached ) { |
| retval = Load_Glyph(font, ch, font->current); |
| } |
| return retval; |
| } |
| |
| void TTF_CloseFont(TTF_Font *font) |
| { |
| Flush_Cache(font); |
| TT_Close_Face(font->face); |
| free(font); |
| } |
| |
| static Uint16 *ASCII_to_UNICODE(Uint16 *unicode, const char *text, int len) |
| { |
| int i; |
| |
| for ( i=0; i < len; ++i ) { |
| unicode[i] = ((const unsigned char *)text)[i]; |
| } |
| unicode[i] = 0; |
| |
| return unicode; |
| } |
| |
| static Uint16 *UTF8_to_UNICODE(Uint16 *unicode, const char *utf8, int len) |
| { |
| int i, j; |
| Uint16 ch; |
| |
| for ( i=0, j=0; i < len; ++i, ++j ) { |
| ch = ((const unsigned char *)utf8)[i]; |
| if ( ch >= 0xF0 ) { |
| ch = (Uint16)(utf8[i]&0x07) << 18; |
| ch |= (Uint16)(utf8[++i]&0x3F) << 12; |
| ch |= (Uint16)(utf8[++i]&0x3F) << 6; |
| ch |= (Uint16)(utf8[++i]&0x3F); |
| } else |
| if ( ch >= 0xE0 ) { |
| ch = (Uint16)(utf8[i]&0x3F) << 12; |
| ch |= (Uint16)(utf8[++i]&0x3F) << 6; |
| ch |= (Uint16)(utf8[++i]&0x3F); |
| } else |
| if ( ch >= 0xC0 ) { |
| ch = (Uint16)(utf8[i]&0x3F) << 6; |
| ch |= (Uint16)(utf8[++i]&0x3F); |
| } |
| unicode[j] = ch; |
| } |
| unicode[j] = 0; |
| |
| return unicode; |
| } |
| |
| int TTF_FontHeight(TTF_Font *font) |
| { |
| return(font->height); |
| } |
| |
| int TTF_FontAscent(TTF_Font *font) |
| { |
| return(round(font->ascent)); |
| } |
| |
| int TTF_FontDescent(TTF_Font *font) |
| { |
| return(round(font->descent)); |
| } |
| |
| int TTF_FontLineSkip(TTF_Font *font) |
| { |
| return(round(font->lineskip)); |
| } |
| |
| int TTF_GlyphMetrics(TTF_Font *font, Uint16 ch, |
| int* minx, int* maxx, int* miny, int* maxy, int* advance) |
| { |
| TT_Error error; |
| |
| error = Find_Glyph(font, ch); |
| |
| if ( error ) { |
| return -1; |
| } |
| |
| if ( minx ) { |
| *minx = font->current->minx; |
| } |
| if ( maxx ) { |
| *maxx = font->current->maxx; |
| } |
| if ( miny ) { |
| *miny = font->current->miny; |
| } |
| if ( maxy ) { |
| *maxy = font->current->maxy; |
| } |
| if ( advance ) { |
| *advance = font->current->advance; |
| } |
| return 0; |
| } |
| |
| int TTF_SizeText(TTF_Font *font, const char *text, int *w, int *h) |
| { |
| Uint16 *unicode_text; |
| int unicode_len; |
| int status; |
| |
| /* Copy the Latin-1 text to a UNICODE text buffer */ |
| unicode_len = strlen(text); |
| unicode_text = (Uint16 *)malloc((unicode_len+1)*(sizeof *unicode_text)); |
| if ( unicode_text == NULL ) { |
| SDL_SetError("Out of memory"); |
| return -1; |
| } |
| ASCII_to_UNICODE(unicode_text, text, unicode_len); |
| |
| /* Render the new text */ |
| status = TTF_SizeUNICODE(font, unicode_text, w, h); |
| |
| /* Free the text buffer and return */ |
| free(unicode_text); |
| return status; |
| } |
| |
| int TTF_SizeUTF8(TTF_Font *font, const char *text, int *w, int *h) |
| { |
| Uint16 *unicode_text; |
| int unicode_len; |
| int status; |
| |
| /* Copy the UTF-8 text to a UNICODE text buffer */ |
| unicode_len = strlen(text); |
| unicode_text = (Uint16 *)malloc((unicode_len+1)*(sizeof *unicode_text)); |
| if ( unicode_text == NULL ) { |
| SDL_SetError("Out of memory"); |
| return -1; |
| } |
| UTF8_to_UNICODE(unicode_text, text, unicode_len); |
| |
| /* Render the new text */ |
| status = TTF_SizeUNICODE(font, unicode_text, w, h); |
| |
| /* Free the text buffer and return */ |
| free(unicode_text); |
| return status; |
| } |
| |
| int TTF_SizeUNICODE(TTF_Font *font, const Uint16 *text, int *w, int *h) |
| { |
| int status; |
| const Uint16 *ch; |
| int x, z, minx, maxx; |
| TT_Error error; |
| |
| /* Initialize everything to 0 */ |
| status = 0; |
| minx = maxx = 0; |
| |
| /* Load each character and sum it's bounding box */ |
| x= 0; |
| for ( ch=text; *ch; ++ch ) { |
| error = Find_Glyph(font, *ch); |
| if ( ! error ) { |
| z = x + font->current->minx; |
| if ( minx > z ) { |
| minx = z; |
| } |
| if ( font->style & TTF_STYLE_BOLD ) { |
| x += font->glyph_overhang; |
| } |
| if ( font->current->advance > font->current->maxx ) { |
| z = x + font->current->advance; |
| } else { |
| z = x + font->current->maxx; |
| } |
| if ( maxx < z ) { |
| maxx = z; |
| } |
| x += font->current->advance; |
| } |
| } |
| |
| /* Fill the bounds rectangle */ |
| if ( w ) { |
| *w = (maxx - minx); |
| } |
| if ( h ) { |
| *h = font->height; |
| } |
| return status; |
| } |
| |
| /* Convert the Latin-1 text to UNICODE and render it |
| */ |
| SDL_Surface *TTF_RenderText_Solid(TTF_Font *font, |
| const char *text, SDL_Color fg) |
| { |
| SDL_Surface *textbuf; |
| Uint16 *unicode_text; |
| int unicode_len; |
| |
| /* Copy the Latin-1 text to a UNICODE text buffer */ |
| unicode_len = strlen(text); |
| unicode_text = (Uint16 *)malloc((unicode_len+1)*(sizeof *unicode_text)); |
| if ( unicode_text == NULL ) { |
| SDL_SetError("Out of memory"); |
| return(NULL); |
| } |
| ASCII_to_UNICODE(unicode_text, text, unicode_len); |
| |
| /* Render the new text */ |
| textbuf = TTF_RenderUNICODE_Solid(font, unicode_text, fg); |
| |
| /* Free the text buffer and return */ |
| free(unicode_text); |
| return(textbuf); |
| } |
| |
| /* Convert the UTF-8 text to UNICODE and render it |
| */ |
| SDL_Surface *TTF_RenderUTF8_Solid(TTF_Font *font, |
| const char *text, SDL_Color fg) |
| { |
| SDL_Surface *textbuf; |
| Uint16 *unicode_text; |
| int unicode_len; |
| |
| /* Copy the UTF-8 text to a UNICODE text buffer */ |
| unicode_len = strlen(text); |
| unicode_text = (Uint16 *)malloc((unicode_len+1)*(sizeof *unicode_text)); |
| if ( unicode_text == NULL ) { |
| SDL_SetError("Out of memory"); |
| return(NULL); |
| } |
| UTF8_to_UNICODE(unicode_text, text, unicode_len); |
| |
| /* Render the new text */ |
| textbuf = TTF_RenderUNICODE_Solid(font, unicode_text, fg); |
| |
| /* Free the text buffer and return */ |
| free(unicode_text); |
| return(textbuf); |
| } |
| |
| SDL_Surface *TTF_RenderUNICODE_Solid(TTF_Font *font, |
| const Uint16 *text, SDL_Color fg) |
| { |
| int xstart, width; |
| int w, h; |
| SDL_Surface *textbuf; |
| SDL_Palette *palette; |
| const Uint16 *ch; |
| Uint8 *src, *dst; |
| int row, col; |
| TT_Error error; |
| |
| /* Get the dimensions of the text surface */ |
| if ( (TTF_SizeUNICODE(font, text, &w, &h) < 0) || !w ) { |
| TTF_SetError("Text has zero width"); |
| return(NULL); |
| } |
| |
| /* Create the target surface */ |
| width = w; |
| w = (w+7)&~7; |
| textbuf = SDL_AllocSurface(SDL_SWSURFACE, w, h, 8, 0, 0, 0, 0); |
| if ( textbuf == NULL ) { |
| return(NULL); |
| } |
| |
| /* Fill the palette with the foreground color */ |
| palette = textbuf->format->palette; |
| palette->colors[0].r = 255-fg.r; |
| palette->colors[0].g = 255-fg.g; |
| palette->colors[0].b = 255-fg.b; |
| palette->colors[1].r = fg.r; |
| palette->colors[1].g = fg.g; |
| palette->colors[1].b = fg.b; |
| SDL_SetColorKey(textbuf, SDL_SRCCOLORKEY, 0); |
| |
| /* Load and render each character */ |
| xstart = 0; |
| for ( ch=text; *ch; ++ch ) { |
| error = Find_Glyph(font, *ch); |
| if ( ! error ) { |
| w = font->current->bitmap.width; |
| src = (Uint8 *)font->current->bitmap.bitmap; |
| for ( row = 0; row < h; ++row ) { |
| dst = (Uint8 *)textbuf->pixels + |
| row * textbuf->pitch + |
| xstart + font->current->minx; |
| for ( col = 0; col < w; col += 8 ) { |
| Uint8 c = *src++; |
| *dst++ |= (c&0x80)>>7; |
| c <<= 1; |
| *dst++ |= (c&0x80)>>7; |
| c <<= 1; |
| *dst++ |= (c&0x80)>>7; |
| c <<= 1; |
| *dst++ |= (c&0x80)>>7; |
| c <<= 1; |
| *dst++ |= (c&0x80)>>7; |
| c <<= 1; |
| *dst++ |= (c&0x80)>>7; |
| c <<= 1; |
| *dst++ |= (c&0x80)>>7; |
| c <<= 1; |
| *dst++ |= (c&0x80)>>7; |
| } |
| } |
| xstart += font->current->advance; |
| if ( font->style & TTF_STYLE_BOLD ) { |
| xstart += font->glyph_overhang; |
| } |
| } |
| } |
| /* Handle the underline style */ |
| if ( font->style & TTF_STYLE_UNDERLINE ) { |
| int row_offset; |
| |
| row_offset = round(font->ascent) + 1; |
| if ( row_offset > font->height ) { |
| row_offset = font->height-1; |
| } |
| memset((Uint8 *)textbuf->pixels+row_offset*textbuf->pitch, |
| 1, width); |
| } |
| return(textbuf); |
| } |
| |
| SDL_Surface *TTF_RenderGlyph_Solid(TTF_Font *font, Uint16 ch, SDL_Color fg) |
| { |
| SDL_Surface *textbuf; |
| SDL_Palette *palette; |
| Uint8 *src, *dst; |
| int row, col; |
| TT_Error error; |
| struct glyph *glyph; |
| |
| /* Get the glyph itself */ |
| error = Find_Glyph(font, ch); |
| if ( error ) { |
| return(NULL); |
| } |
| glyph = font->current; |
| |
| /* Create the target surface */ |
| textbuf = SDL_CreateRGBSurface(SDL_SWSURFACE, |
| glyph->bitmap.width, glyph->bitmap.rows, 8, 0, 0, 0, 0); |
| if ( ! textbuf ) { |
| return(NULL); |
| } |
| |
| /* Fill the palette with the foreground color */ |
| palette = textbuf->format->palette; |
| palette->colors[0].r = 255-fg.r; |
| palette->colors[0].g = 255-fg.g; |
| palette->colors[0].b = 255-fg.b; |
| palette->colors[1].r = fg.r; |
| palette->colors[1].g = fg.g; |
| palette->colors[1].b = fg.b; |
| SDL_SetColorKey(textbuf, SDL_SRCCOLORKEY, 0); |
| |
| /* Load and render each character */ |
| src = (Uint8 *)font->current->bitmap.bitmap; |
| for ( row = 0; row < textbuf->h; ++row ) { |
| dst = (Uint8 *)textbuf->pixels + row * textbuf->pitch; |
| for ( col = 0; col < textbuf->w; col += 8 ) { |
| Uint8 c = *src++; |
| *dst++ |= (c&0x80)>>7; |
| c <<= 1; |
| *dst++ |= (c&0x80)>>7; |
| c <<= 1; |
| *dst++ |= (c&0x80)>>7; |
| c <<= 1; |
| *dst++ |= (c&0x80)>>7; |
| c <<= 1; |
| *dst++ |= (c&0x80)>>7; |
| c <<= 1; |
| *dst++ |= (c&0x80)>>7; |
| c <<= 1; |
| *dst++ |= (c&0x80)>>7; |
| c <<= 1; |
| *dst++ |= (c&0x80)>>7; |
| } |
| } |
| |
| /* Handle the underline style */ |
| if ( font->style & TTF_STYLE_UNDERLINE ) { |
| int row_offset; |
| |
| row_offset = round(font->ascent) + 1; |
| if ( row_offset > font->height ) { |
| row_offset = font->height-1; |
| } |
| memset((Uint8 *)textbuf->pixels+row_offset*textbuf->pitch, |
| 1, textbuf->w); |
| } |
| return(textbuf); |
| } |
| |
| |
| /* Convert the Latin-1 text to UNICODE and render it |
| */ |
| SDL_Surface *TTF_RenderText_Shaded(TTF_Font *font, |
| const char *text, SDL_Color fg, SDL_Color bg) |
| { |
| SDL_Surface *textbuf; |
| Uint16 *unicode_text; |
| int unicode_len; |
| |
| /* Copy the Latin-1 text to a UNICODE text buffer */ |
| unicode_len = strlen(text); |
| unicode_text = (Uint16 *)malloc((unicode_len+1)*(sizeof *unicode_text)); |
| if ( unicode_text == NULL ) { |
| SDL_SetError("Out of memory"); |
| return(NULL); |
| } |
| ASCII_to_UNICODE(unicode_text, text, unicode_len); |
| |
| /* Render the new text */ |
| textbuf = TTF_RenderUNICODE_Shaded(font, unicode_text, fg, bg); |
| |
| /* Free the text buffer and return */ |
| free(unicode_text); |
| return(textbuf); |
| } |
| |
| /* Convert the UTF-8 text to UNICODE and render it |
| */ |
| SDL_Surface *TTF_RenderUTF8_Shaded(TTF_Font *font, |
| const char *text, SDL_Color fg, SDL_Color bg) |
| { |
| SDL_Surface *textbuf; |
| Uint16 *unicode_text; |
| int unicode_len; |
| |
| /* Copy the UTF-8 text to a UNICODE text buffer */ |
| unicode_len = strlen(text); |
| unicode_text = (Uint16 *)malloc((unicode_len+1)*(sizeof *unicode_text)); |
| if ( unicode_text == NULL ) { |
| SDL_SetError("Out of memory"); |
| return(NULL); |
| } |
| UTF8_to_UNICODE(unicode_text, text, unicode_len); |
| |
| /* Render the new text */ |
| textbuf = TTF_RenderUNICODE_Shaded(font, unicode_text, fg, bg); |
| |
| /* Free the text buffer and return */ |
| free(unicode_text); |
| return(textbuf); |
| } |
| |
| SDL_Surface *TTF_RenderUNICODE_Shaded(TTF_Font *font, |
| const Uint16 *text, SDL_Color fg, SDL_Color bg) |
| { |
| int xstart, width; |
| int w, h; |
| SDL_Surface *textbuf; |
| SDL_Palette *palette; |
| int index; |
| int rdiff, gdiff, bdiff; |
| const Uint16 *ch; |
| Uint8 *src, *dst; |
| int row, col; |
| TT_Error error; |
| |
| /* Get the dimensions of the text surface */ |
| if ( (TTF_SizeUNICODE(font, text, &w, &h) < 0) || !w ) { |
| TTF_SetError("Text has zero width"); |
| return(NULL); |
| } |
| |
| /* Create the target surface */ |
| width = w; |
| w = (w+3)&~3; |
| textbuf = SDL_AllocSurface(SDL_SWSURFACE, w, h, 8, 0, 0, 0, 0); |
| if ( textbuf == NULL ) { |
| return(NULL); |
| } |
| |
| /* Fill the palette with 5 levels of shading from bg to fg */ |
| palette = textbuf->format->palette; |
| rdiff = fg.r - bg.r; |
| gdiff = fg.g - bg.g; |
| bdiff = fg.b - bg.b; |
| for ( index=0; index<5; ++index ) { |
| palette->colors[index].r = bg.r + (index*rdiff)/4; |
| palette->colors[index].g = bg.g + (index*gdiff)/4; |
| palette->colors[index].b = bg.b + (index*bdiff)/4; |
| } |
| /* The other 3 levels are used as overflow when ORing pixels */ |
| for ( ; index<8; ++index ) { |
| palette->colors[index] = palette->colors[4]; |
| } |
| |
| /* Load and render each character */ |
| xstart = 0; |
| for ( ch=text; *ch; ++ch ) { |
| error = Find_Glyph(font, *ch); |
| if ( ! error ) { |
| w = font->current->pixmap.width; |
| src = (Uint8 *)font->current->pixmap.bitmap; |
| for ( row = 0; row < h; ++row ) { |
| dst = (Uint8 *)textbuf->pixels + |
| row * textbuf->pitch + |
| xstart + font->current->minx; |
| for ( col=w; col>0; col -= 4 ) { |
| *dst++ |= *src++; |
| *dst++ |= *src++; |
| *dst++ |= *src++; |
| *dst++ |= *src++; |
| } |
| } |
| xstart += font->current->advance; |
| if ( font->style & TTF_STYLE_BOLD ) { |
| xstart += font->glyph_overhang; |
| } |
| } |
| } |
| /* Handle the underline style */ |
| if ( font->style & TTF_STYLE_UNDERLINE ) { |
| int row_offset; |
| |
| row_offset = round(font->ascent) + 1; |
| if ( row_offset > font->height ) { |
| row_offset = font->height-1; |
| } |
| memset((Uint8 *)textbuf->pixels+row_offset*textbuf->pitch, |
| 4, width); |
| } |
| return(textbuf); |
| } |
| |
| SDL_Surface *TTF_RenderGlyph_Shaded(TTF_Font *font, |
| Uint16 ch, SDL_Color fg, SDL_Color bg) |
| { |
| SDL_Surface *textbuf; |
| SDL_Palette *palette; |
| int index; |
| int rdiff, gdiff, bdiff; |
| Uint8 *src, *dst; |
| int row, col; |
| TT_Error error; |
| struct glyph *glyph; |
| |
| /* Get the glyph itself */ |
| error = Find_Glyph(font, ch); |
| if ( error ) { |
| return(NULL); |
| } |
| glyph = font->current; |
| |
| /* Create the target surface */ |
| textbuf = SDL_CreateRGBSurface(SDL_SWSURFACE, |
| glyph->pixmap.width, glyph->pixmap.rows, 8, 0, 0, 0, 0); |
| if ( ! textbuf ) { |
| return(NULL); |
| } |
| |
| /* Fill the palette with 5 levels of shading from bg to fg */ |
| palette = textbuf->format->palette; |
| rdiff = fg.r - bg.r; |
| gdiff = fg.g - bg.g; |
| bdiff = fg.b - bg.b; |
| for ( index=0; index<5; ++index ) { |
| palette->colors[index].r = bg.r + (index*rdiff)/4; |
| palette->colors[index].g = bg.g + (index*gdiff)/4; |
| palette->colors[index].b = bg.b + (index*bdiff)/4; |
| } |
| |
| /* Copy the character from the pixmap */ |
| for ( row=0; row<textbuf->h; ++row ) { |
| src = glyph->pixmap.bitmap + row * glyph->pixmap.cols; |
| dst = (Uint8 *)textbuf->pixels + row * textbuf->pitch; |
| memcpy(dst, src, glyph->pixmap.cols); |
| } |
| |
| /* Handle the underline style */ |
| if ( font->style & TTF_STYLE_UNDERLINE ) { |
| int row_offset; |
| |
| row_offset = round(font->ascent) + 1; |
| if ( row_offset > font->height ) { |
| row_offset = font->height-1; |
| } |
| memset((Uint8 *)textbuf->pixels+row_offset*textbuf->pitch, |
| 4, glyph->pixmap.cols); |
| } |
| return(textbuf); |
| } |
| |
| /* Convert the Latin-1 text to UNICODE and render it |
| */ |
| SDL_Surface *TTF_RenderText_Blended(TTF_Font *font, |
| const char *text, SDL_Color fg) |
| { |
| SDL_Surface *textbuf; |
| Uint16 *unicode_text; |
| int unicode_len; |
| |
| /* Copy the Latin-1 text to a UNICODE text buffer */ |
| unicode_len = strlen(text); |
| unicode_text = (Uint16 *)malloc((unicode_len+1)*(sizeof *unicode_text)); |
| if ( unicode_text == NULL ) { |
| SDL_SetError("Out of memory"); |
| return(NULL); |
| } |
| ASCII_to_UNICODE(unicode_text, text, unicode_len); |
| |
| /* Render the new text */ |
| textbuf = TTF_RenderUNICODE_Blended(font, unicode_text, fg); |
| |
| /* Free the text buffer and return */ |
| free(unicode_text); |
| return(textbuf); |
| } |
| |
| /* Convert the UTF-8 text to UNICODE and render it |
| */ |
| SDL_Surface *TTF_RenderUTF8_Blended(TTF_Font *font, |
| const char *text, SDL_Color fg) |
| { |
| SDL_Surface *textbuf; |
| Uint16 *unicode_text; |
| int unicode_len; |
| |
| /* Copy the UTF-8 text to a UNICODE text buffer */ |
| unicode_len = strlen(text); |
| unicode_text = (Uint16 *)malloc((unicode_len+1)*(sizeof *unicode_text)); |
| if ( unicode_text == NULL ) { |
| SDL_SetError("Out of memory"); |
| return(NULL); |
| } |
| UTF8_to_UNICODE(unicode_text, text, unicode_len); |
| |
| /* Render the new text */ |
| textbuf = TTF_RenderUNICODE_Blended(font, unicode_text, fg); |
| |
| /* Free the text buffer and return */ |
| free(unicode_text); |
| return(textbuf); |
| } |
| |
| SDL_Surface *TTF_RenderUNICODE_Blended(TTF_Font *font, |
| const Uint16 *text, SDL_Color fg) |
| { |
| int xstart, width; |
| int w, h; |
| SDL_Surface *textbuf; |
| #if SDL_VERSIONNUM(SDL_MAJOR_VERSION, SDL_MINOR_VERSION, SDL_PATCHLEVEL) >= \ |
| SDL_VERSIONNUM(1, 1, 5) /* The great alpha flip */ |
| Uint32 alpha_table[] = { |
| (0)<<24, (255-128)<<24, (255-64)<<24, (255-32)<<24, |
| (255)<<24, (255)<<24, (255)<<24, (255)<<24 |
| }; |
| #else |
| Uint32 alpha_table[] = { |
| (255<<24), (128<<24), (64<<24), (32<<24), 0, 0, 0, 0 |
| }; |
| #endif |
| Uint32 pixel; |
| const Uint16 *ch; |
| Uint8 *src; |
| Uint32 *dst; |
| int row, col; |
| TT_Error error; |
| |
| /* Get the dimensions of the text surface */ |
| if ( (TTF_SizeUNICODE(font, text, &w, &h) < 0) || !w ) { |
| TTF_SetError("Text has zero width"); |
| return(NULL); |
| } |
| |
| /* Create the target surface, 32-bit ARGB format */ |
| width = w; |
| w = (w+3)&~3; |
| textbuf = SDL_AllocSurface(SDL_SWSURFACE, w, h, 32, |
| 0x00FF0000, 0x0000FF00, 0x000000FF, |
| 0xFF000000); |
| if ( textbuf == NULL ) { |
| return(NULL); |
| } |
| |
| /* Load and render each character */ |
| xstart = 0; |
| for ( ch=text; *ch; ++ch ) { |
| error = Find_Glyph(font, *ch); |
| if ( ! error ) { |
| w = font->current->pixmap.width; |
| src = (Uint8 *)font->current->pixmap.bitmap; |
| for ( row = 0; row < h; ++row ) { |
| dst = (Uint32 *)textbuf->pixels + |
| row * textbuf->pitch/4 + |
| xstart + font->current->minx; |
| for ( col=w; col>0; col -= 4 ) { |
| *dst++ |= *src++; |
| *dst++ |= *src++; |
| *dst++ |= *src++; |
| *dst++ |= *src++; |
| } |
| } |
| xstart += font->current->advance; |
| if ( font->style & TTF_STYLE_BOLD ) { |
| xstart += font->glyph_overhang; |
| } |
| } |
| } |
| |
| /* Handle the underline style */ |
| if ( font->style & TTF_STYLE_UNDERLINE ) { |
| int row_offset; |
| |
| row_offset = round(font->ascent) + 1; |
| if ( row_offset > font->height ) { |
| row_offset = font->height-1; |
| } |
| dst = (Uint32 *)textbuf->pixels+row_offset*textbuf->pitch/4; |
| for ( col=width; col > 0; ++col ) { |
| *dst++ = 4; |
| } |
| } |
| |
| /* Build the alpha table */ |
| pixel = (fg.r<<16)|(fg.g<<8)|fg.b; |
| for ( xstart = 0; xstart < 8; ++xstart ) { |
| alpha_table[xstart] |= pixel; |
| } |
| |
| /* Transform the alpha values */ |
| for ( row = 0; row < textbuf->h; ++row ) { |
| dst = (Uint32 *)textbuf->pixels + row * textbuf->pitch/4; |
| for ( col=textbuf->w; col>0; col -= 4 ) { |
| *dst = alpha_table[*dst]; |
| ++dst; |
| *dst = alpha_table[*dst]; |
| ++dst; |
| *dst = alpha_table[*dst]; |
| ++dst; |
| *dst = alpha_table[*dst]; |
| ++dst; |
| } |
| } |
| return(textbuf); |
| } |
| |
| SDL_Surface *TTF_RenderGlyph_Blended(TTF_Font *font, Uint16 ch, SDL_Color fg) |
| { |
| SDL_Surface *textbuf; |
| #if SDL_VERSIONNUM(SDL_MAJOR_VERSION, SDL_MINOR_VERSION, SDL_PATCHLEVEL) >= \ |
| SDL_VERSIONNUM(1, 1, 5) /* The great alpha flip */ |
| Uint32 alpha_table[] = { |
| (0)<<24, (255-128)<<24, (255-64)<<24, (255-32)<<24, |
| (255)<<24, (255)<<24, (255)<<24, (255)<<24 |
| }; |
| #else |
| Uint32 alpha_table[] = { |
| (255<<24), (128<<24), (64<<24), (32<<24), 0, 0, 0, 0 |
| }; |
| #endif |
| Uint32 pixel; |
| Uint8 *src; |
| Uint32 *dst; |
| int row, col; |
| TT_Error error; |
| struct glyph *glyph; |
| |
| /* Get the glyph itself */ |
| error = Find_Glyph(font, ch); |
| if ( error ) { |
| return(NULL); |
| } |
| glyph = font->current; |
| |
| /* Create the target surface, 32-bit ARGB format */ |
| textbuf = SDL_CreateRGBSurface(SDL_SWSURFACE, |
| glyph->pixmap.width, glyph->pixmap.rows, 32, |
| 0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000); |
| if ( ! textbuf ) { |
| return(NULL); |
| } |
| |
| /* Copy the character from the pixmap */ |
| for ( row=0; row<textbuf->h; ++row ) { |
| src = glyph->pixmap.bitmap + row * glyph->pixmap.cols; |
| dst = (Uint32 *)textbuf->pixels + row * textbuf->pitch/4; |
| for ( col=0; col<glyph->pixmap.cols; ++col ) { |
| *dst++ = *src++; |
| } |
| } |
| |
| /* Handle the underline style */ |
| if ( font->style & TTF_STYLE_UNDERLINE ) { |
| int row_offset; |
| |
| row_offset = round(font->ascent) + 1; |
| if ( row_offset > font->height ) { |
| row_offset = font->height-1; |
| } |
| dst = (Uint32 *)textbuf->pixels+row_offset*textbuf->pitch/4; |
| for ( col=glyph->pixmap.cols; col > 0; ++col ) { |
| *dst++ = 4; |
| } |
| } |
| |
| /* Build the alpha table */ |
| pixel = (fg.r<<16)|(fg.g<<8)|fg.b; |
| for ( col = 0; col < 8; ++col ) { |
| alpha_table[col] |= pixel; |
| } |
| |
| /* Transform the alpha values */ |
| for ( row = 0; row < textbuf->h; ++row ) { |
| dst = (Uint32 *)textbuf->pixels + row * textbuf->pitch/4; |
| for ( col=textbuf->w; col>0; col -= 4 ) { |
| *dst = alpha_table[*dst]; |
| ++dst; |
| *dst = alpha_table[*dst]; |
| ++dst; |
| *dst = alpha_table[*dst]; |
| ++dst; |
| *dst = alpha_table[*dst]; |
| ++dst; |
| } |
| } |
| return(textbuf); |
| } |
| |
| void TTF_SetFontStyle(TTF_Font *font, int style) |
| { |
| font->style = style; |
| Flush_Cache(font); |
| } |
| |
| int TTF_GetFontStyle(TTF_Font *font) |
| { |
| return(font->style); |
| } |
| |
| void TTF_Quit(void) |
| { |
| TT_Done_FreeType(engine); |
| } |