git.mutantstargoat.com Git - freeglut/blob - freeglut-1.3/freeglut_font.c

   1 /*
   2  * freeglut_font.c
   3  *
   4  * Bitmap and stroke fonts displaying.
   5  *
   6  * Copyright (c) 1999-2000 Pawel W. Olszta. All Rights Reserved.
   7  * Written by Pawel W. Olszta, <olszta@sourceforge.net>
   8  * Creation date: Thu Dec 16 1999
   9  *
  10  * Permission is hereby granted, free of charge, to any person obtaining a
  11  * copy of this software and associated documentation files (the "Software"),
  12  * to deal in the Software without restriction, including without limitation
  13  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  14  * and/or sell copies of the Software, and to permit persons to whom the
  15  * Software is furnished to do so, subject to the following conditions:
  16  *
  17  * The above copyright notice and this permission notice shall be included
  18  * in all copies or substantial portions of the Software.
  19  *
  20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  21  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  23  * PAWEL W. OLSZTA BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
  24  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  25  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  26  */
  27
  28 #ifdef HAVE_CONFIG_H
  29 #include "config.h"
  30 #endif
  31
  32 #define  G_LOG_DOMAIN  "freeglut-font"
  33
  34 #include "../include/GL/freeglut.h"
  35 #include "../include/GL/freeglut_internal.h"
  36
  37 /*
  38  * TODO BEFORE THE STABLE RELEASE:
  39  *
  40  *  Test things out ...
  41  */
  42
  43 /* -- IMPORT DECLARATIONS -------------------------------------------------- */
  44
  45 /*
  46  * These are the font faces defined in freeglut_font_data.c file:
  47  */
  48 extern SFG_Font fgFontFixed8x13;
  49 extern SFG_Font fgFontFixed9x15;
  50 extern SFG_Font fgFontHelvetica10;
  51 extern SFG_Font fgFontHelvetica12;
  52 extern SFG_Font fgFontHelvetica18;
  53 extern SFG_Font fgFontTimesRoman10;
  54 extern SFG_Font fgFontTimesRoman24;
  55 extern SFG_StrokeFont fgStrokeRoman;
  56 extern SFG_StrokeFont fgStrokeMonoRoman;
  57
  58 /*
  59  * This is for GLUT binary compatibility, as suggested by Steve Baker
  60  */
  61 #if TARGET_HOST_UNIX_X11
  62   void* glutStrokeRoman;
  63   void* glutStrokeMonoRoman;
  64   void* glutBitmap9By15;
  65   void* glutBitmap8By13;
  66   void* glutBitmapTimesRoman10;
  67   void* glutBitmapTimesRoman24;
  68   void* glutBitmapHelvetica10;
  69   void* glutBitmapHelvetica12;
  70   void* glutBitmapHelvetica18;
  71 #endif
  72
  73
  74 /* -- PRIVATE FUNCTIONS ---------------------------------------------------- */
  75
  76 /*
  77  * Matches a font ID with a SFG_Font structure pointer.
  78  * This was changed to match the GLUT header style.
  79  */
  80 static SFG_Font* fghFontByID( void* font )
  81 {
  82   /*
  83    * Try matching the font ID and the font data structure
  84    */
  85   if( font == GLUT_BITMAP_8_BY_13        ) return( &fgFontFixed8x13    );
  86   if( font == GLUT_BITMAP_9_BY_15        ) return( &fgFontFixed9x15    );
  87   if( font == GLUT_BITMAP_HELVETICA_10   ) return( &fgFontHelvetica10  );
  88   if( font == GLUT_BITMAP_HELVETICA_12   ) return( &fgFontHelvetica12  );
  89   if( font == GLUT_BITMAP_HELVETICA_18   ) return( &fgFontHelvetica18  );
  90   if( font == GLUT_BITMAP_TIMES_ROMAN_10 ) return( &fgFontTimesRoman10 );
  91   if( font == GLUT_BITMAP_TIMES_ROMAN_24 ) return( &fgFontTimesRoman24 );
  92
  93   /*
  94    * This probably is the library user's fault
  95    */
  96   fgError( "font 0x%08x not found", font );
  97
  98   return 0;
  99 }
 100
 101 /*
 102  * Matches a font ID with a SFG_StrokeFont structure pointer.
 103  * This was changed to match the GLUT header style.
 104  */
 105 static SFG_StrokeFont* fghStrokeByID( void* font )
 106 {
 107   /*
 108    * Try matching the font ID and the font data structure
 109    */
 110   if( font == GLUT_STROKE_ROMAN      ) return( &fgStrokeRoman     );
 111   if( font == GLUT_STROKE_MONO_ROMAN ) return( &fgStrokeMonoRoman );
 112
 113   /*
 114    * This probably is the library user's fault
 115    */
 116   fgError( "stroke font 0x%08x not found", font );
 117
 118   return 0;
 119 }
 120
 121
 122 /* -- INTERFACE FUNCTIONS -------------------------------------------------- */
 123
 124 /*
 125  * Draw a bitmap character
 126  */
 127 void FGAPIENTRY glutBitmapCharacter( void* fontID, int character )
 128 {
 129   const GLubyte* face;
 130
 131   /*
 132    * First of all we'll need a font to use
 133    */
 134   SFG_Font* font = fghFontByID( fontID );
 135
 136   /*
 137    * Make sure the character we want to output is valid
 138    */
 139   freeglut_return_if_fail( character >= 0 && character < 256 );
 140
 141   /*
 142    * Then find the character we want to draw
 143    */
 144   face = font->Characters[ character - 1 ];
 145
 146   /*
 147    * Save the old pixel store settings
 148    */
 149   glPushClientAttrib( GL_CLIENT_PIXEL_STORE_BIT );
 150
 151   /*
 152    * Set up the pixel unpacking ways
 153    */
 154   glPixelStorei( GL_UNPACK_SWAP_BYTES,  GL_FALSE );
 155   glPixelStorei( GL_UNPACK_LSB_FIRST,   GL_FALSE );
 156   glPixelStorei( GL_UNPACK_ROW_LENGTH,  0        );
 157   glPixelStorei( GL_UNPACK_SKIP_ROWS,   0        );
 158   glPixelStorei( GL_UNPACK_SKIP_PIXELS, 0        );
 159   glPixelStorei( GL_UNPACK_ALIGNMENT,   1        );
 160
 161   /*
 162    * We'll use a glBitmap call to draw the font.
 163    */
 164   glBitmap(
 165       face[ 0 ], font->Height,      /* The bitmap's width and height */
 166       font->xorig, font->yorig,     /* The origin -- what on earth?  */
 167       (float)(face[ 0 ] + 1), 0.0,  /* The raster advance -- inc. x  */
 168       (face + 1)                    /* The packed bitmap data...     */
 169   );
 170
 171   /*
 172    * Restore the old pixel store settings
 173    */
 174   glPopClientAttrib();
 175 }
 176
 177 void FGAPIENTRY glutBitmapString( void* fontID, const char *string )
 178 {
 179   int c;
 180   int numchar = strlen ( string ) ;
 181
 182   /*
 183    * First of all we'll need a font to use
 184    */
 185   SFG_Font* font = fghFontByID( fontID );
 186
 187   float raster_position[4] ;
 188   glGetFloatv ( GL_CURRENT_RASTER_POSITION, raster_position ) ;
 189
 190   /*
 191    * Save the old pixel store settings
 192    */
 193   glPushClientAttrib( GL_CLIENT_PIXEL_STORE_BIT );
 194
 195   /*
 196    * Set up the pixel unpacking ways
 197    */
 198   glPixelStorei( GL_UNPACK_SWAP_BYTES,  GL_FALSE );
 199   glPixelStorei( GL_UNPACK_LSB_FIRST,   GL_FALSE );
 200   glPixelStorei( GL_UNPACK_ROW_LENGTH,  0        );
 201   glPixelStorei( GL_UNPACK_SKIP_ROWS,   0        );
 202   glPixelStorei( GL_UNPACK_SKIP_PIXELS, 0        );
 203   glPixelStorei( GL_UNPACK_ALIGNMENT,   1        );
 204
 205   /*
 206    * Step through the string, drawing each character.
 207    * A carriage return will simply translate the next character's insertion point back to the
 208    * start of the line and down one line.
 209    */
 210   for( c = 0; c < numchar; c++ )
 211   {
 212     if ( ( string[ c ] >= 0 ) && ( string[ c ] < 256 ) )
 213     {
 214       if ( string[c] == '\n' )
 215       {
 216         raster_position[1] -= (float)font->Height ;
 217         glRasterPos4fv ( raster_position ) ;
 218       }
 219       else  /* Not a carriage return, draw the bitmap character */
 220       {
 221         const GLubyte* face = font->Characters[ string[ c ] - 1 ] ;
 222
 223         /*
 224          * We'll use a glBitmap call to draw the font.
 225          */
 226         glBitmap(
 227             face[ 0 ], font->Height,      /* The bitmap's width and height */
 228             font->xorig, font->yorig,     /* The origin -- what on earth?  */
 229             (float)(face[ 0 ] + 1), 0.0,  /* The raster advance -- inc. x  */
 230             (face + 1)                    /* The packed bitmap data...     */
 231         ) ;
 232       }
 233     }
 234   }
 235
 236   /*
 237    * Restore the old pixel store settings
 238    */
 239   glPopClientAttrib();
 240 }
 241
 242 /*
 243  * Returns the width in pixels of a font's character
 244  */
 245 int FGAPIENTRY glutBitmapWidth( void* fontID, int character )
 246 {
 247   /*
 248    * First of all, grab the font we need
 249    */
 250   SFG_Font* font = fghFontByID( fontID );
 251
 252   /*
 253    * Make sure the character we want to output is valid
 254    */
 255   freeglut_return_val_if_fail( character > 0 && character < 256, 0 );
 256
 257   /*
 258        * Scan the font looking for the specified character
 259    */
 260   return( *(font->Characters[ character - 1 ]) + 1 );
 261 }
 262
 263 /*
 264  * Return the width of a string drawn using a bitmap font
 265  */
 266 int FGAPIENTRY glutBitmapLength( void* fontID, const char* string )
 267 {
 268   int c, length = 0, this_line_length = 0;
 269
 270   /*
 271    * First of all, grab the font we need
 272    */
 273   SFG_Font* font = fghFontByID( fontID );
 274
 275   /*
 276    * Step through the characters in the string, adding up the width of each one
 277    */
 278   int numchar = strlen ( string ) ;
 279   for( c = 0; c < numchar; c++ )
 280   {
 281     if ( ( string[ c ] >= 0 ) && ( string[ c ] < 256 ) )
 282     {
 283       if ( string[ c ] == '\n' )  /* Carriage return, reset the length of this line */
 284       {
 285         if ( length < this_line_length ) length = this_line_length ;
 286         this_line_length = 0 ;
 287       }
 288       else  /* Not a carriage return, increment the length of this line */
 289         this_line_length += *(font->Characters[ string[ c ] - 1 ]) + 1 ;
 290     }
 291   }
 292
 293   if ( length < this_line_length ) length = this_line_length ;
 294
 295   /*
 296    * Return the result now
 297    */
 298   return( length );
 299 }
 300
 301 /*
 302  * Returns the height of a bitmap font
 303  */
 304 int FGAPIENTRY glutBitmapHeight( void* fontID )
 305 {
 306   /*
 307    * See which font are we queried about
 308    */
 309   SFG_Font* font = fghFontByID( fontID );
 310
 311   /*
 312    * Return the character set's height
 313    */
 314   return( font->Height );
 315 }
 316
 317 /*
 318  * Draw a stroke character
 319  */
 320 void FGAPIENTRY glutStrokeCharacter( void* fontID, int character )
 321 {
 322   const SFG_StrokeChar *schar;
 323   const SFG_StrokeStrip *strip;
 324   int i, j;
 325
 326   /*
 327    * First of all we'll need a font to use
 328    */
 329   SFG_StrokeFont* font = fghStrokeByID( fontID );
 330
 331   /*
 332    * Make sure the character we want to output is valid
 333    */
 334   freeglut_return_if_fail( character >= 0 && character < font->Quantity );
 335
 336   schar = font->Characters[character];
 337
 338   freeglut_return_if_fail( schar );
 339
 340   strip = schar->Strips;
 341
 342   for (i = 0; i < schar->Number; i++, strip++)
 343   {
 344     glBegin(GL_LINE_STRIP);
 345     for(j = 0; j < strip->Number; j++)
 346     {
 347       glVertex2f(strip->Vertices[j].X, strip->Vertices[j].Y);
 348     }
 349     glEnd();
 350   }
 351   glTranslatef(schar->Right, 0.0, 0.0);
 352 }
 353
 354 void FGAPIENTRY glutStrokeString( void* fontID, const char *string )
 355 {
 356   int c, i, j;
 357   int numchar = strlen ( string ) ;
 358   float length = 0.0 ;
 359
 360   /*
 361    * First of all we'll need a font to use
 362    */
 363   SFG_StrokeFont* font = fghStrokeByID( fontID );
 364
 365   /*
 366    * Step through the string, drawing each character.
 367    * A carriage return will simply translate the next character's insertion point back to the
 368    * start of the line and down one line.
 369    */
 370   for( c = 0; c < numchar; c++ )
 371   {
 372     if ( ( string[ c ] >= 0 ) && ( string[ c ] < font->Quantity ) )
 373     {
 374       if ( string[c] == '\n' )
 375       {
 376         glTranslatef ( -length, -(float)(font->Height), 0.0 ) ;
 377         length = 0.0 ;
 378       }
 379       else  /* Not a carriage return, draw the bitmap character */
 380       {
 381         const SFG_StrokeChar *schar = font->Characters[string[c]];
 382         if ( schar != NULL )
 383         {
 384           const SFG_StrokeStrip *strip = schar->Strips;
 385
 386           for (i = 0; i < schar->Number; i++, strip++)
 387           {
 388             glBegin(GL_LINE_STRIP);
 389             for(j = 0; j < strip->Number; j++)
 390               glVertex2f(strip->Vertices[j].X, strip->Vertices[j].Y);
 391
 392             glEnd();
 393           }
 394
 395           length += schar->Right ;
 396           glTranslatef(schar->Right, 0.0, 0.0);
 397         }
 398       }
 399     }
 400   }
 401 }
 402
 403 /*
 404  * Return the width in pixels of a stroke character
 405  */
 406 int FGAPIENTRY glutStrokeWidth( void* fontID, int character )
 407 {
 408   const SFG_StrokeChar *schar;
 409   /*
 410    * First of all we'll need a font to use
 411    */
 412   SFG_StrokeFont* font = fghStrokeByID( fontID );
 413
 414   /*
 415    * Make sure the character we want to output is valid
 416    */
 417   freeglut_return_val_if_fail( character >= 0 && character < font->Quantity, 0 );
 418
 419   schar = font->Characters[character];
 420
 421   freeglut_return_val_if_fail( schar, 0 );
 422
 423   return ((int)(schar->Right + 0.5));
 424 }
 425
 426 /*
 427  * Return the width of a string drawn using a stroke font
 428  */
 429 int FGAPIENTRY glutStrokeLength( void* fontID, const char* string )
 430 {
 431   int c;
 432   float length = 0.0;
 433   float this_line_length = 0.0 ;
 434
 435   /*
 436    * First of all we'll need a font to use
 437    */
 438   SFG_StrokeFont* font = fghStrokeByID( fontID );
 439
 440   /*
 441    * Step through the characters in the string, adding up the width of each one
 442    */
 443   int numchar = strlen ( string ) ;
 444   for( c = 0; c < numchar; c++ )
 445   {
 446     if ( ( string[ c ] >= 0 ) && ( string[ c ] < font->Quantity ) )
 447     {
 448       if ( string[ c ] == '\n' )  /* Carriage return, reset the length of this line */
 449       {
 450         if ( length < this_line_length ) length = this_line_length ;
 451         this_line_length = 0.0 ;
 452       }
 453       else  /* Not a carriage return, increment the length of this line */
 454       {
 455         const SFG_StrokeChar *schar = font->Characters[string[c]];
 456         if ( schar != NULL )
 457           this_line_length += schar->Right ;
 458       }
 459     }
 460   }
 461
 462   if ( length < this_line_length ) length = this_line_length ;
 463
 464   /*
 465    * Return the result now
 466    */
 467   return( (int)(length+0.5) );
 468 }
 469
 470 /*
 471  * Returns the height of a stroke font
 472  */
 473 GLfloat FGAPIENTRY glutStrokeHeight( void* fontID )
 474 {
 475     /*
 476      * See which font are we queried about
 477      */
 478     SFG_StrokeFont* font = fghStrokeByID( fontID );
 479
 480     /*
 481      * Return the character set's height
 482      */
 483     return( font->Height );
 484 }
 485
 486 /*** END OF FILE ***/