src/fonttool/fontkern.cpp

   1 /*
   2  * Copyright (C) Volition, Inc. 1999.  All rights reserved.
   3  *
   4  * All source code herein is the property of Volition, Inc. You may not sell
   5  * or otherwise commercially exploit the source or things you created based on
   6  * the source.
   7  */
   8
   9 /*
  10  * $Logfile: /Freespace2/code/Fonttool/FontKern.cpp $
  11  * $Revision$
  12  * $Date$
  13  * $Author$
  14  *
  15  * Tool for interactively kerning fonts
  16  *
  17  * $Log$
  18  * Revision 1.4  2006/04/26 19:38:36  taylor
  19  * fix some minor fonttool compile errors
  20  *
  21  * Revision 1.3  2003/01/30 20:03:48  relnev
  22  * various files ported needed for fonttool.  There is a bug where on exit it segfaults in SDL_GL_SwapBuffers, I'm probably missing something (don't know what) but it works fine otherwise (Taylor Richards)
  23  *
  24  * Revision 1.2  2002/06/09 04:41:16  relnev
  25  * added copyright header
  26  *
  27  * Revision 1.1.1.1  2002/05/03 03:28:08  root
  28  * Initial import.
  29  *
  30  *
  31  * 6     5/19/99 4:07p Dave
  32  * Moved versioning code into a nice isolated common place. Fixed up
  33  * updating code on the pxo screen. Fixed several stub problems.
  34  *
  35  * 5     12/18/98 1:14a Dave
  36  * Rough 1024x768 support for Direct3D. Proper detection and usage through
  37  * the launcher.
  38  *
  39  * 4     12/02/98 9:58a Dave
  40  * Got fonttool working under glide/direct3d.
  41  *
  42  * 3     11/30/98 1:09p Dave
  43  *
  44  * 2     10/24/98 5:15p Dave
  45  *
  46  * 1     10/24/98 4:58p Dave
  47  *
  48  * 14    5/06/98 5:30p John
  49  * Removed unused cfilearchiver.  Removed/replaced some unused/little used
  50  * graphics functions, namely gradient_h and _v and pixel_sp.   Put in new
  51  * DirectX header files and libs that fixed the Direct3D alpha blending
  52  * problems.
  53  *
  54  * 13    4/13/98 10:11a John
  55  * Made timer functions thread safe.  Made timer_init be called in all
  56  * projects.
  57  *
  58  * 12    3/10/98 4:18p John
  59  * Cleaned up graphics lib.  Took out most unused gr functions.   Made D3D
  60  * & Glide have popups and print screen.  Took out all >8bpp software
  61  * support.  Made Fred zbuffer.  Made zbuffer allocate dynamically to
  62  * support Fred.  Made zbuffering key off of functions rather than one
  63  * global variable.
  64  *
  65  * 11    3/05/98 11:15p Hoffoss
  66  * Changed non-game key checking to use game_check_key() instead of
  67  * game_poll().
  68  *
  69  * 10    10/30/97 4:56p John
  70  * Fixed up font stuff to build.  Fixed bug where it didn't show the last
  71  * 3 characters in kerning table.
  72  *
  73  * 9     9/03/97 4:32p John
  74  * changed bmpman to only accept ani and pcx's.  made passing .pcx or .ani
  75  * to bm_load functions not needed.   Made bmpman keep track of palettes
  76  * for bitmaps not mapped into game palettes.
  77  *
  78  * 8     6/06/97 6:47p John
  79  * Fixed bug
  80  *
  81  * 7     6/06/97 4:41p John
  82  * Fixed alpha colors to be smoothly integrated into gr_set_color_fast
  83  * code.
  84  *
  85  * 6     6/06/97 11:10a John
  86  * made scrolling kern pair box.
  87  *
  88  * 5     6/06/97 9:21a John
  89  * added some kerning pairs
  90  *
  91  * 4     6/06/97 9:18a John
  92  * Added capital hamburger.
  93  *
  94  * 3     6/05/97 5:00p John
  95  * used fonttool.pcx
  96  *
  97  * 2     6/05/97 4:53p John
  98  * First rev of new antialiased font stuff.
  99  *
 100  * 1     6/02/97 4:04p John
 101  *
 102  * $NoKeywords: $
 103  */
 104
 105 #ifndef PLAT_UNIX
 106 #include <windows.h>
 107 #endif
 108 #include <stdlib.h>
 109 #include <stdio.h>
 110 #include <time.h>
 111 #ifndef PLAT_UNIX
 112 #include <io.h>
 113 #include <conio.h>
 114 #endif
 115
 116 #include "pstypes.h"
 117 #include "osapi.h"
 118 #include "cfile.h"
 119 #include "2d.h"
 120 #include "key.h"
 121 #include "mouse.h"
 122 #include "palman.h"
 123 #include "timer.h"
 124 #include "bmpman.h"
 125 #include "osregistry.h"
 126 #include "cmdline.h"
 127
 128 #include "fonttool.h"
 129
 130 const char *SampleText = "This is some sample text that is here to\n" \
 131 "Show you how the antialiasing will\n"  \
 132 "look over different color backgrounds\n" \
 133 "KERN PAIRS: VaWaVeWeVAV-LyT.T,TyTvTcYe\n";
 134
 135 static void myexit(int value)
 136 {
 137 #ifdef WIN32
 138         getch();
 139 #endif
 140         exit(value);
 141 }
 142
 143 int game_check_key()
 144 {
 145         return key_inkey();
 146 }
 147
 148 int game_poll()
 149 {
 150         return key_inkey();
 151 }
 152
 153 int os_done = 0;
 154
 155 void os_close()
 156 {
 157         os_done = 1;
 158 }
 159
 160 int fonttool_get_kerning( font *fnt, int c1, int c2, int *pairnum )
 161 {
 162         int i;
 163
 164         int l1 = c1 - fnt->first_ascii;
 165         int l2 = c2 - fnt->first_ascii;
 166
 167         for (i=0; i<fnt->num_kern_pairs; i++ )  {
 168                 if ( (fnt->kern_data[i].c1 == l1) && (fnt->kern_data[i].c2 == l2) )     {
 169                         if (pairnum) *pairnum = i;
 170                         return fnt->kern_data[i].offset;
 171                 }
 172         }
 173         return 0;
 174 }
 175
 176 void fonttool_resync_kerning( font *fnt )
 177 {
 178         int i;
 179
 180         // update all the font into
 181         for (i=0; i<fnt->num_chars; i++ )       {
 182                 fnt->char_data[i].kerning_entry = -1;
 183         }
 184
 185         for (i=0; i<fnt->num_kern_pairs; i++ )  {
 186                 int c = fnt->kern_data[i].c1;
 187                 if ( fnt->char_data[c].kerning_entry == -1 )
 188                         fnt->char_data[c].kerning_entry = (short)i;
 189         }
 190 }
 191
 192 void fonttool_remove_kern_pair( font *fnt, int index )
 193 {
 194         // not found, add it
 195         int i, n, new_num_pairs;
 196
 197         new_num_pairs = fnt->num_kern_pairs - 1;
 198
 199         if ( new_num_pairs < 1 )        {
 200                 fonttool_remove_kerning(fnt);
 201                 return;
 202         }
 203
 204         font_kernpair *new_kern_data = (font_kernpair *)malloc( new_num_pairs*sizeof(font_kernpair) );
 205         if (!new_kern_data)     {
 206                 printf( "Out of memory!\n" );
 207                 myexit(1);
 208         }
 209
 210
 211         n=0;
 212         for (i=0; i<fnt->num_kern_pairs; i++ )  {
 213                 if ( i != index )       {
 214                         new_kern_data[n] = fnt->kern_data[i];
 215                         n++;
 216                 }
 217         }
 218
 219         if ( fnt->kern_data ) free( fnt->kern_data );
 220         fnt->kern_data = new_kern_data;
 221         fnt->kern_data_size = sizeof(font_kernpair)*new_num_pairs;
 222         fnt->num_kern_pairs = new_num_pairs;
 223
 224         fonttool_resync_kerning(fnt);
 225
 226         mprintf(( "Font has %d kern pairs\n", fnt->num_kern_pairs ));
 227 }
 228
 229 void fonttool_set_kerning( font *fnt, int c1, int c2, int dist )
 230 {
 231         int i;
 232
 233         int l1 = c1 - fnt->first_ascii;
 234         int l2 = c2 - fnt->first_ascii;
 235
 236         for (i=0; i<fnt->num_kern_pairs; i++ )  {
 237                 if ( (fnt->kern_data[i].c1 == l1) && (fnt->kern_data[i].c2 == l2) )     {
 238                         fnt->kern_data[i].offset = (signed char)dist;
 239                         if ( dist == 0 )        {
 240                                 fonttool_remove_kern_pair( fnt, i );
 241                         }
 242                         return;
 243                 }
 244         }
 245         if ( dist == 0 )        return;
 246
 247         // not found, add it
 248         int new_num_pairs;
 249
 250         new_num_pairs = fnt->num_kern_pairs+1;
 251
 252         font_kernpair *new_kern_data = (font_kernpair *)malloc( new_num_pairs*sizeof(font_kernpair) );
 253         if (!new_kern_data)     {
 254                 printf( "Out of memory!\n" );
 255                 myexit(1);
 256         }
 257
 258
 259         int n=0;
 260         uint newcode = l1*256+l2;
 261
 262         for (i=0; i<fnt->num_kern_pairs; i++ )  {
 263                 uint code = fnt->kern_data[i].c1*256 + fnt->kern_data[i].c2;
 264                 if ( code < newcode )   {
 265                         new_kern_data[n] = fnt->kern_data[i];
 266                         n++;
 267                 } else {
 268                         break;
 269                 }
 270         }
 271
 272
 273         new_kern_data[n].c1 = (char)l1;
 274         new_kern_data[n].c2 = (char)l2;
 275         new_kern_data[n].offset = (signed char)dist;
 276         n++;
 277
 278
 279         for (; i<fnt->num_kern_pairs; i++ )     {
 280                 new_kern_data[n] = fnt->kern_data[i];
 281                 n++;
 282         }
 283
 284
 285         if ( fnt->kern_data ) free( fnt->kern_data );
 286         fnt->kern_data = new_kern_data;
 287         fnt->kern_data_size +=  sizeof(font_kernpair);
 288         fnt->num_kern_pairs++;
 289
 290         fonttool_resync_kerning(fnt);
 291
 292         mprintf(( "Font has %d kern pairs\n", fnt->num_kern_pairs ));
 293
 294 }
 295
 296
 297 void fonttool_remove_kerning( font *fnt )
 298 {
 299         int i;
 300
 301         for (i=0; i<fnt->num_chars; i++ )       {
 302                 fnt->char_data[i].kerning_entry = -1;
 303         }
 304
 305         fnt->kern_data_size = 0;
 306         if (fnt->kern_data)
 307                 free( fnt->kern_data );
 308         fnt->kern_data = NULL;
 309         fnt->num_kern_pairs = 0;
 310 }
 311
 312
 313 void fonttool_edit_kerning(char *fname1, char *extras_dir)
 314 {
 315         int i, k,x;
 316         int done;
 317         int bkg;
 318         font KernFont, tmpfont;
 319         int alpha = 16;
 320         int cr=16, cb=16, cg=16;
 321         int c1 = 'b', c2 = 'u';
 322         char kerntext[128];
 323         int current_pair = -1;
 324         int first_item = 0;
 325         int current_item = 0;
 326         int num_items_displayed = 1;
 327         int last_good_pair = -1;
 328         color ac;
 329
 330         printf( "Editing kerning data for %s\n", fname1 );
 331         fonttool_read( fname1, &KernFont );
 332
 333         timer_init();
 334
 335         // setup the fred exe directory so CFILE can init properly
 336         //char *c = GetCommandLine();
 337         //SDL_assert(c != NULL);
 338         //char *tok = strtok(c, " ");
 339         //SDL_assert(tok != NULL);
 340
 341         cfile_init(extras_dir);
 342
 343         os_init( "FontTool", "FontTool - Kerning Table Editor" );
 344
 345         // always run this thing in a window
 346         Cmdline_fullscreen = 0;
 347         Cmdline_window = 1;
 348
 349         gr_init(GR_640, GR_OPENGL);
 350
 351         gr_set_palette("none",NULL);
 352
 353         char fonttool_pcx[128];
 354         sprintf(fonttool_pcx, "src%sfonttool%sfonttool", DIR_SEPARATOR_STR, DIR_SEPARATOR_STR);
 355
 356         bkg = bm_load( fonttool_pcx );
 357
 358         if ( bkg < 0 )  {
 359                 printf("Error loading FontTool\n" );
 360                 myexit(1);
 361         }
 362         palette_use_bm_palette(bkg);
 363
 364         key_init();
 365         mouse_init();
 366
 367         gr_init_alphacolor( &ac, cr*16,cg*16,cb*16,alpha*16,AC_TYPE_HUD );
 368
 369
 370         {
 371                 extern font *Current_font;
 372                 Current_font = &KernFont;
 373         }
 374
 375         done = 0;
 376         while (!done)   {
 377
 378                 os_poll();
 379                 k = key_inkey();
 380                 switch(k)       {
 381                 case SDLK_F5:
 382                         fonttool_read( fname1, &tmpfont );
 383                         fonttool_copy_kern( &tmpfont, &KernFont );
 384                         break;
 385
 386                 case SDLK_F6:
 387                         fonttool_remove_kerning( &KernFont );
 388                         break;
 389
 390                 case SDLK_F10:
 391                         fonttool_dump( fname1, &KernFont );
 392                         done=1;
 393                         break;
 394
 395                 case SDLK_COMMA:
 396                         if ( alpha > 1 )        {
 397                                 alpha--;
 398                                 gr_init_alphacolor(&ac,cr*16,cg*16,cb*16,alpha*16,AC_TYPE_HUD);
 399                         }
 400                         break;
 401
 402                 case SDLK_PERIOD:
 403                         if ( alpha < 17 )       {
 404                                 alpha++;
 405                                 gr_init_alphacolor(&ac,cr*16,cg*16,cb*16,alpha*16,AC_TYPE_HUD);
 406                         }
 407                         break;
 408
 409                 case SDLK_r:
 410                         if ( cr == 16 ) cr = 1; else cr = 16;
 411                         gr_init_alphacolor(&ac,cr*16,cg*16,cb*16,alpha*16,AC_TYPE_HUD);
 412                         break;
 413
 414                 case SDLK_g:
 415                         if ( cg == 16 ) cg = 1; else cg = 16;
 416                         gr_init_alphacolor(&ac,cr*16,cg*16,cb*16,alpha*16,AC_TYPE_HUD);
 417                         break;
 418
 419                 case SDLK_b:
 420                         if ( cb == 16 ) cb = 1; else cb = 16;
 421                         gr_init_alphacolor(&ac,cr*16,cg*16,cb*16,alpha*16,AC_TYPE_HUD);
 422                         break;
 423
 424                 case SDLK_KP_6:
 425                         x = fonttool_get_kerning( &KernFont, c1, c2, NULL );
 426                         fonttool_set_kerning( &KernFont, c1, c2, x+1 );
 427                         break;
 428
 429                 case SDLK_KP_4:
 430                         x = fonttool_get_kerning( &KernFont, c1, c2, NULL );
 431                         fonttool_set_kerning( &KernFont, c1, c2, x-1 );
 432                         break;
 433
 434                 case SDLK_KP_5:
 435                         fonttool_set_kerning( &KernFont, c1, c2, 0 );
 436                         break;
 437
 438                 case SDLK_KP_7:
 439                         if ( c1 < KernFont.first_ascii + KernFont.num_chars-1 ) c1++;
 440                         break;
 441
 442                 case SDLK_KP_1:
 443                         if ( c1 > KernFont.first_ascii ) c1--;
 444                         break;
 445
 446                 case SDLK_KP_9:
 447                         if ( c2 < KernFont.first_ascii + KernFont.num_chars-1 ) c2++;
 448                         mprintf(( "C2 = %d\n", c2 ));
 449                         break;
 450
 451                 case SDLK_KP_3:
 452                         if ( c2 > KernFont.first_ascii ) c2--;
 453                         mprintf(( "C2 = %d\n", c2 ));
 454                         break;
 455
 456                 case SDLK_KP_2:
 457                         if ( current_pair < 0 )
 458                                 current_pair = last_good_pair;
 459                         else
 460                                 current_pair++;
 461                         if ( current_pair >= KernFont.num_kern_pairs )  {
 462                                 current_pair = KernFont.num_kern_pairs-1;
 463                         }
 464                         if ( (current_pair < KernFont.num_kern_pairs) && (current_pair > -1) )  {
 465                                 c1 = KernFont.kern_data[current_pair].c1 + KernFont.first_ascii;
 466                                 c2 = KernFont.kern_data[current_pair].c2 + KernFont.first_ascii;
 467                         }
 468                         break;
 469
 470                 case SDLK_KP_8:
 471                         if ( current_pair < 0 )
 472                                 current_pair = last_good_pair;
 473                         else
 474                                 current_pair--;
 475                         if ( current_pair < 0 ) {
 476                                 current_pair = 0;
 477                         }
 478                         if ( (current_pair < KernFont.num_kern_pairs) && (current_pair > -1) )  {
 479                                 c1 = KernFont.kern_data[current_pair].c1 + KernFont.first_ascii;
 480                                 c2 = KernFont.kern_data[current_pair].c2 + KernFont.first_ascii;
 481                         }
 482                         break;
 483
 484                 case SDLK_ESCAPE:
 485                         done=1;
 486                         break;
 487                 }
 488
 489                 if ( current_pair >= KernFont.num_kern_pairs )  {
 490                         current_pair = -1;
 491                 }
 492
 493                 int tmpp=-1;
 494                 fonttool_get_kerning( &KernFont, c1, c2, &tmpp );
 495
 496                 if ( tmpp != -1 )       {
 497                         current_pair = tmpp;
 498                 } else  {
 499                         if ( current_pair > -1 )
 500                                 last_good_pair = current_pair;
 501                         current_pair = -1;
 502                 }
 503
 504                 gr_reset_clip();
 505                 gr_set_bitmap(bkg);
 506                 gr_bitmap(0,0);
 507                 gr_set_color_fast(&ac);
 508
 509                 sprintf( kerntext, "%c (%d)", c1, c1 );
 510                 gr_string( 240, 210, kerntext );
 511                 sprintf( kerntext, "%c (%d)", c2, c2 );
 512                 gr_string( 340, 210, kerntext );
 513
 514                 sprintf( kerntext, "Ham%c%crger", c1, c2 );
 515                 gr_string( 0x8000, 240, kerntext );
 516
 517                 sprintf( kerntext, "HAM%c%cRGER", c1, c2 );
 518                 gr_string( 0x8000, 270, kerntext );
 519
 520                 sprintf( kerntext, "Offset: %d pixels", fonttool_get_kerning( &KernFont, c1, c2, NULL ) );
 521                 gr_string( 0x8000, 300, kerntext );
 522
 523                 {
 524                         int tw, th;
 525                         gr_get_string_size( &tw, &th, kerntext );
 526
 527                         gr_string( 0x8000, 360, SampleText );
 528                         gr_string( 20, 360+th+20, SampleText );
 529                 }
 530
 531                 int x = 5, y = 200;
 532                 int widest = 0;
 533
 534                  //= ( 330 - 200 ) / KernFont.h;
 535                 int num_items = KernFont.num_kern_pairs;
 536
 537                 if ( current_pair > -1 )
 538                         current_item = current_pair;
 539
 540                 if (current_item <0 )
 541                         current_item = 0;
 542
 543                 if (current_item >= num_items )
 544                         current_item = num_items-1;
 545
 546                 if (current_item<first_item)
 547                         first_item = current_item;
 548
 549                 if (current_item>=(first_item+num_items_displayed))
 550                         first_item = current_item-num_items_displayed+1;
 551
 552                 if (num_items <= num_items_displayed )
 553                         first_item = 0;
 554
 555                 int stop = first_item+num_items_displayed;
 556                 if (stop>num_items) stop = num_items;
 557
 558                 int n = 0;
 559                 for (i=first_item; i<stop; i++ )        {
 560                         int tw, th;
 561
 562                         sprintf( kerntext, "%c%c", KernFont.kern_data[i].c1 + KernFont.first_ascii, KernFont.kern_data[i].c2 + KernFont.first_ascii );
 563                         if ( i==current_pair )  {
 564                                 gr_set_color( 255, 0, 0 );
 565                                 //hud_tri( i2fl(x),i2fl(y), i2fl(x+6), i2fl(y+5), i2fl(x), i2fl(y+8) );
 566
 567                                 int x1 = x;
 568                                 int y1 = y;
 569                                 int x2 = x+6;
 570                                 int y2 = y+5;
 571                                 int x3 = x;
 572                                 int y3 = y+8;
 573
 574                                 gr_line(x1,y1,x2,y2);
 575                                 gr_line(x2,y2,x3,y3);
 576                                 gr_line(x3,y3,x1,y1);
 577
 578                                 gr_set_color_fast(&ac);
 579                         }
 580                         gr_string( x+8, y, kerntext );
 581                         n++;
 582                         gr_get_string_size( &tw, &th, kerntext );
 583                         tw += 8;
 584                         if ( tw > widest )
 585                                 widest = tw;
 586                         y += KernFont.h;
 587                         if ( y > 330 ) {
 588                                 y = 200;
 589                                 x += widest + 5;
 590                                 if ( x > 150 ) {
 591                                         num_items_displayed=n;
 592                                         break;
 593                                 }
 594                                 widest = 0;
 595                         }
 596                 }
 597                 if (i==stop)
 598                         num_items_displayed++;
 599
 600                 if (num_items_displayed < 1 )
 601                         num_items_displayed = 1;
 602
 603                 if (num_items_displayed > num_items )
 604                         num_items_displayed = num_items;
 605
 606                 //mprintf(( "Num items = %d\n", num_items_displayed ));
 607
 608
 609                 gr_flip();
 610
 611                 // sleep a little bit, don't need high framerate here
 612                 SDL_Delay(10);
 613         }
 614
 615         // cleanup
 616         if (bkg > -1) {
 617                 bm_unload(bkg);
 618         }
 619
 620
 621         exit(0);
 622 }
 623