source/blender/blenfont/intern/blf_font.c

   1 /**
   2  * $Id:
   3  *
   4  * ***** BEGIN GPL LICENSE BLOCK *****
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version 2
   9  * of the License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software Foundation,
  18  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  19  *
  20  * The Original Code is Copyright (C) 2009 Blender Foundation.
  21  * All rights reserved.
  22  *
  23  *
  24  * Contributor(s): Blender Foundation
  25  *
  26  * ***** END GPL LICENSE BLOCK *****
  27  */
  28
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31 #include <string.h>
  32 #include <math.h>
  33
  34 #include <ft2build.h>
  35
  36 #include FT_FREETYPE_H
  37 #include FT_GLYPH_H
  38
  39 #include "MEM_guardedalloc.h"
  40
  41 #include "DNA_listBase.h"
  42 #include "DNA_vec_types.h"
  43
  44 #include "BKE_utildefines.h"
  45
  46 #include "BLI_blenlib.h"
  47 #include "BLI_linklist.h"       /* linknode */
  48 #include "BLI_string.h"
  49 #include "BLI_arithb.h"
  50
  51 #include "BIF_gl.h"
  52 #include "BLF_api.h"
  53
  54 #include "blf_internal_types.h"
  55 #include "blf_internal.h"
  56
  57
  58 /* freetype2 handle. */
  59 FT_Library global_ft_lib;
  60
  61 int blf_font_init(void)
  62 {
  63         return(FT_Init_FreeType(&global_ft_lib));
  64 }
  65
  66 void blf_font_exit(void)
  67 {
  68         FT_Done_FreeType(global_ft_lib);
  69 }
  70
  71 void blf_font_size(FontBLF *font, int size, int dpi)
  72 {
  73         GlyphCacheBLF *gc;
  74         FT_Error err;
  75
  76         err= FT_Set_Char_Size(font->face, 0, (size * 64), dpi, dpi);
  77         if (err) {
  78                 /* FIXME: here we can go through the fixed size and choice a close one */
  79                 printf("The current font don't support the size, %d and dpi, %d\n", size, dpi);
  80                 return;
  81         }
  82
  83         font->size= size;
  84         font->dpi= dpi;
  85
  86         gc= blf_glyph_cache_find(font, size, dpi);
  87         if (gc)
  88                 font->glyph_cache= gc;
  89         else {
  90                 gc= blf_glyph_cache_new(font);
  91                 if (gc)
  92                         font->glyph_cache= gc;
  93                 else
  94                         font->glyph_cache= NULL;
  95         }
  96 }
  97
  98 void blf_font_draw(FontBLF *font, char *str)
  99 {
 100         unsigned int c;
 101         GlyphBLF *g, *g_prev;
 102         FT_Vector delta;
 103         FT_UInt glyph_index, g_prev_index;
 104         float pen_x, pen_y, old_pen_x;
 105         int i, has_kerning;
 106
 107         if (!font->glyph_cache)
 108                 return;
 109
 110         i= 0;
 111         pen_x= 0;
 112         pen_y= 0;
 113         has_kerning= FT_HAS_KERNING(font->face);
 114         g_prev= NULL;
 115         g_prev_index= 0;
 116
 117         while (str[i]) {
 118                 c= blf_utf8_next((unsigned char *)str, &i);
 119                 if (c == 0)
 120                         break;
 121
 122                 glyph_index= FT_Get_Char_Index(font->face, c);
 123                 g= blf_glyph_search(font->glyph_cache, c);
 124                 if (!g)
 125                         g= blf_glyph_add(font, glyph_index, c);
 126
 127                 /* if we don't found a glyph, skip it. */
 128                 if (!g)
 129                         continue;
 130
 131                 /*
 132                  * This happen if we change the mode of the
 133                  * font, we don't drop the glyph cache, so it's
 134                  * possible that some glyph don't have the
 135                  * bitmap or texture information.
 136                  */
 137                 if (font->mode == BLF_MODE_BITMAP && (!g->bitmap_data))
 138                         g= blf_glyph_add(font, glyph_index, c);
 139                 else if (font->mode == BLF_MODE_TEXTURE && (!g->tex_data))
 140                         g= blf_glyph_add(font, glyph_index, c);
 141
 142                 if ((font->flags & BLF_FONT_KERNING) && has_kerning && g_prev) {
 143                         old_pen_x= pen_x;
 144                         delta.x= 0;
 145                         delta.y= 0;
 146
 147                         if (FT_Get_Kerning(font->face, g_prev_index, glyph_index, FT_KERNING_UNFITTED, &delta) == 0) {
 148                                 pen_x += delta.x >> 6;
 149 /*
 150                                 if (pen_x < old_pen_x)
 151                                         pen_x= old_pen_x;
 152 */
 153                         }
 154                 }
 155
 156                 if (font->flags & BLF_USER_KERNING) {
 157                         old_pen_x= pen_x;
 158                         pen_x += font->kerning;
 159 /*
 160                         if (pen_x < old_pen_x)
 161                                 pen_x= old_pen_x;
 162 */
 163                 }
 164
 165                 /* do not return this loop if clipped, we want every character tested */
 166                 blf_glyph_render(font, g, pen_x, pen_y);
 167
 168                 pen_x += g->advance;
 169                 g_prev= g;
 170                 g_prev_index= glyph_index;
 171         }
 172 }
 173
 174 void blf_font_boundbox(FontBLF *font, char *str, rctf *box)
 175 {
 176         unsigned int c;
 177         GlyphBLF *g, *g_prev;
 178         FT_Vector delta;
 179         FT_UInt glyph_index, g_prev_index;
 180         rctf gbox;
 181         float pen_x, pen_y, old_pen_x;
 182         int i, has_kerning;
 183
 184         if (!font->glyph_cache)
 185                 return;
 186
 187         box->xmin= 32000.0f;
 188         box->xmax= -32000.0f;
 189         box->ymin= 32000.0f;
 190         box->ymax= -32000.0f;
 191
 192         i= 0;
 193         pen_x= 0;
 194         pen_y= 0;
 195         has_kerning= FT_HAS_KERNING(font->face);
 196         g_prev= NULL;
 197         g_prev_index= 0;
 198
 199         while (str[i]) {
 200                 c= blf_utf8_next((unsigned char *)str, &i);
 201                 if (c == 0)
 202                         break;
 203
 204                 glyph_index= FT_Get_Char_Index(font->face, c);
 205                 g= blf_glyph_search(font->glyph_cache, c);
 206                 if (!g)
 207                         g= blf_glyph_add(font, glyph_index, c);
 208
 209                 /* if we don't found a glyph, skip it. */
 210                 if (!g)
 211                         continue;
 212
 213                 /*
 214                  * This happen if we change the mode of the
 215                  * font, we don't drop the glyph cache, so it's
 216                  * possible that some glyph don't have the
 217                  * bitmap or texture information.
 218                  */
 219                 if (font->mode == BLF_MODE_BITMAP && (!g->bitmap_data))
 220                         g= blf_glyph_add(font, glyph_index, c);
 221                 else if (font->mode == BLF_MODE_TEXTURE && (!g->tex_data))
 222                         g= blf_glyph_add(font, glyph_index, c);
 223
 224                 if ((font->flags & BLF_FONT_KERNING) && has_kerning && g_prev) {
 225                         old_pen_x= pen_x;
 226                         delta.x= 0;
 227                         delta.y= 0;
 228
 229                         if (FT_Get_Kerning(font->face, g_prev_index, glyph_index, FT_KERNING_UNFITTED, &delta) == 0) {
 230                                 pen_x += delta.x >> 6;
 231 /*
 232                                 if (pen_x < old_pen_x)
 233                                         old_pen_x= pen_x;
 234 */
 235                         }
 236                 }
 237
 238                 if (font->flags & BLF_USER_KERNING) {
 239                         old_pen_x= pen_x;
 240                         pen_x += font->kerning;
 241 /*
 242                         if (pen_x < old_pen_x)
 243                                 old_pen_x= pen_x;
 244 */
 245                 }
 246
 247                 gbox.xmin= g->box.xmin + pen_x;
 248                 gbox.xmax= g->box.xmax + pen_x;
 249                 gbox.ymin= g->box.ymin + pen_y;
 250                 gbox.ymax= g->box.ymax + pen_y;
 251
 252                 if (gbox.xmin < box->xmin)
 253                         box->xmin= gbox.xmin;
 254                 if (gbox.ymin < box->ymin)
 255                         box->ymin= gbox.ymin;
 256
 257                 if (gbox.xmax > box->xmax)
 258                         box->xmax= gbox.xmax;
 259                 if (gbox.ymax > box->ymax)
 260                         box->ymax= gbox.ymax;
 261
 262                 pen_x += g->advance;
 263                 g_prev= g;
 264                 g_prev_index= glyph_index;
 265         }
 266
 267         if (box->xmin > box->xmax) {
 268                 box->xmin= 0.0f;
 269                 box->ymin= 0.0f;
 270                 box->xmax= 0.0f;
 271                 box->ymax= 0.0f;
 272         }
 273 }
 274
 275 float blf_font_width(FontBLF *font, char *str)
 276 {
 277         rctf box;
 278
 279         if (!font->glyph_cache)
 280                 return(0.0f);
 281
 282         blf_font_boundbox(font, str, &box);
 283         return((box.xmax - box.xmin) * font->aspect);
 284 }
 285
 286 float blf_font_height(FontBLF *font, char *str)
 287 {
 288         rctf box;
 289
 290         if (!font->glyph_cache)
 291                 return(0.0f);
 292
 293         blf_font_boundbox(font, str, &box);
 294         return((box.ymax - box.ymin) * font->aspect);
 295 }
 296
 297 void blf_font_free(FontBLF *font)
 298 {
 299         GlyphCacheBLF *gc;
 300
 301         font->glyph_cache= NULL;
 302         while (font->cache.first) {
 303                 gc= font->cache.first;
 304                 BLI_remlink(&font->cache, gc);
 305                 blf_glyph_cache_free(gc);
 306         }
 307
 308         FT_Done_Face(font->face);
 309         if (font->filename)
 310                 MEM_freeN(font->filename);
 311         if (font->name)
 312                 MEM_freeN(font->name);
 313         MEM_freeN(font);
 314 }
 315
 316 void blf_font_fill(FontBLF *font)
 317 {
 318         font->mode= BLF_MODE_TEXTURE;
 319         font->aspect= 1.0f;
 320         font->pos[0]= 0.0f;
 321         font->pos[1]= 0.0f;
 322         font->angle= 0.0f;
 323         Mat4One(font->mat);
 324         font->clip_rec.xmin= 0.0f;
 325         font->clip_rec.xmax= 0.0f;
 326         font->clip_rec.ymin= 0.0f;
 327         font->clip_rec.ymax= 0.0f;
 328         font->flags= BLF_USER_KERNING | BLF_FONT_KERNING;
 329         font->dpi= 0;
 330         font->size= 0;
 331         font->kerning= 0.0f;
 332         font->cache.first= NULL;
 333         font->cache.last= NULL;
 334         font->glyph_cache= NULL;
 335         font->blur= 0;
 336         glGetIntegerv(GL_MAX_TEXTURE_SIZE, (GLint *)&font->max_tex_size);
 337 }
 338
 339 FontBLF *blf_font_new(char *name, char *filename)
 340 {
 341         FontBLF *font;
 342         FT_Error err;
 343         char *mfile;
 344
 345         font= (FontBLF *)MEM_mallocN(sizeof(FontBLF), "blf_font_new");
 346         err= FT_New_Face(global_ft_lib, filename, 0, &font->face);
 347         if (err) {
 348                 MEM_freeN(font);
 349                 return(NULL);
 350         }
 351
 352         err= FT_Select_Charmap(font->face, ft_encoding_unicode);
 353         if (err) {
 354                 printf("Can't set the unicode character map!\n");
 355                 FT_Done_Face(font->face);
 356                 MEM_freeN(font);
 357                 return(NULL);
 358         }
 359
 360         mfile= blf_dir_metrics_search(filename);
 361         if (mfile) {
 362                 err= FT_Attach_File(font->face, mfile);
 363                 MEM_freeN(mfile);
 364         }
 365
 366         font->name= BLI_strdup(name);
 367         font->filename= BLI_strdup(filename);
 368         blf_font_fill(font);
 369         return(font);
 370 }
 371
 372 void blf_font_attach_from_mem(FontBLF *font, const unsigned char *mem, int mem_size)
 373 {
 374         FT_Open_Args open;
 375
 376         open.flags= FT_OPEN_MEMORY;
 377         open.memory_base= (FT_Byte *)mem;
 378         open.memory_size= mem_size;
 379         FT_Attach_Stream(font->face, &open);
 380 }
 381
 382 FontBLF *blf_font_new_from_mem(char *name, unsigned char *mem, int mem_size)
 383 {
 384         FontBLF *font;
 385         FT_Error err;
 386
 387         font= (FontBLF *)MEM_mallocN(sizeof(FontBLF), "blf_font_new_from_mem");
 388         err= FT_New_Memory_Face(global_ft_lib, mem, mem_size, 0, &font->face);
 389         if (err) {
 390                 MEM_freeN(font);
 391                 return(NULL);
 392         }
 393
 394         err= FT_Select_Charmap(font->face, ft_encoding_unicode);
 395         if (err) {
 396                 printf("Can't set the unicode character map!\n");
 397                 FT_Done_Face(font->face);
 398                 MEM_freeN(font);
 399                 return(NULL);
 400         }
 401
 402         font->name= BLI_strdup(name);
 403         font->filename= NULL;
 404         blf_font_fill(font);
 405         return(font);
 406 }