git.mutantstargoat.com Git - freeglut/blob - src/Common/freeglut_font.c

   1 /*\r
   2  * freeglut_font.c\r
   3  *\r
   4  * Bitmap and stroke fonts displaying.\r
   5  *\r
   6  * Copyright (c) 1999-2000 Pawel W. Olszta. All Rights Reserved.\r
   7  * Written by Pawel W. Olszta, <olszta@sourceforge.net>\r
   8  * Creation date: Thu Dec 16 1999\r
   9  *\r
  10  * Permission is hereby granted, free of charge, to any person obtaining a\r
  11  * copy of this software and associated documentation files (the "Software"),\r
  12  * to deal in the Software without restriction, including without limitation\r
  13  * the rights to use, copy, modify, merge, publish, distribute, sublicense,\r
  14  * and/or sell copies of the Software, and to permit persons to whom the\r
  15  * Software is furnished to do so, subject to the following conditions:\r
  16  *\r
  17  * The above copyright notice and this permission notice shall be included\r
  18  * in all copies or substantial portions of the Software.\r
  19  *\r
  20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS\r
  21  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r
  22  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL\r
  23  * PAWEL W. OLSZTA BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\r
  24  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
  25  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r
  26  */\r
  27 \r
  28 #include <GL/freeglut.h>\r
  29 #include "freeglut_internal.h"\r
  30 \r
  31 /*\r
  32  * TODO BEFORE THE STABLE RELEASE:\r
  33  *\r
  34  *  Test things out ...\r
  35  */\r
  36 \r
  37 /* -- IMPORT DECLARATIONS -------------------------------------------------- */\r
  38 \r
  39 /*\r
  40  * These are the font faces defined in freeglut_font_data.c file:\r
  41  */\r
  42 extern SFG_Font fgFontFixed8x13;\r
  43 extern SFG_Font fgFontFixed9x15;\r
  44 extern SFG_Font fgFontHelvetica10;\r
  45 extern SFG_Font fgFontHelvetica12;\r
  46 extern SFG_Font fgFontHelvetica18;\r
  47 extern SFG_Font fgFontTimesRoman10;\r
  48 extern SFG_Font fgFontTimesRoman24;\r
  49 extern SFG_StrokeFont fgStrokeRoman;\r
  50 extern SFG_StrokeFont fgStrokeMonoRoman;\r
  51 \r
  52 \r
  53 /* -- PRIVATE FUNCTIONS ---------------------------------------------------- */\r
  54 \r
  55 /*\r
  56  * Matches a font ID with a SFG_Font structure pointer.\r
  57  * This was changed to match the GLUT header style.\r
  58  */\r
  59 static SFG_Font* fghFontByID( void* font )\r
  60 {\r
  61     if( font == GLUT_BITMAP_8_BY_13        )\r
  62         return &fgFontFixed8x13;\r
  63     if( font == GLUT_BITMAP_9_BY_15        )\r
  64         return &fgFontFixed9x15;\r
  65     if( font == GLUT_BITMAP_HELVETICA_10   )\r
  66         return &fgFontHelvetica10;\r
  67     if( font == GLUT_BITMAP_HELVETICA_12   )\r
  68         return &fgFontHelvetica12;\r
  69     if( font == GLUT_BITMAP_HELVETICA_18   )\r
  70         return &fgFontHelvetica18;\r
  71     if( font == GLUT_BITMAP_TIMES_ROMAN_10 )\r
  72         return &fgFontTimesRoman10;\r
  73     if( font == GLUT_BITMAP_TIMES_ROMAN_24 )\r
  74         return &fgFontTimesRoman24;\r
  75 \r
  76     fgWarning( "font 0x%08x not found", font );\r
  77     return 0;\r
  78 }\r
  79 \r
  80 /*\r
  81  * Matches a font ID with a SFG_StrokeFont structure pointer.\r
  82  * This was changed to match the GLUT header style.\r
  83  */\r
  84 static SFG_StrokeFont* fghStrokeByID( void* font )\r
  85 {\r
  86     if( font == GLUT_STROKE_ROMAN      )\r
  87         return &fgStrokeRoman;\r
  88     if( font == GLUT_STROKE_MONO_ROMAN )\r
  89         return &fgStrokeMonoRoman;\r
  90 \r
  91     fgWarning( "stroke font 0x%08x not found", font );\r
  92     return 0;\r
  93 }\r
  94 \r
  95 \r
  96 /* -- INTERFACE FUNCTIONS -------------------------------------------------- */\r
  97 \r
  98 /*\r
  99  * Draw a bitmap character\r
 100  */\r
 101 void FGAPIENTRY glutBitmapCharacter( void* fontID, int character )\r
 102 {\r
 103     const GLubyte* face;\r
 104     SFG_Font* font;\r
 105     FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutBitmapCharacter" );\r
 106     font = fghFontByID( fontID );\r
 107     freeglut_return_if_fail( ( character >= 1 )&&( character < 256 ) );\r
 108     freeglut_return_if_fail( font );\r
 109 \r
 110     /*\r
 111      * Find the character we want to draw (???)\r
 112      */\r
 113     face = font->Characters[ character ];\r
 114 \r
 115     glPushClientAttrib( GL_CLIENT_PIXEL_STORE_BIT );\r
 116     glPixelStorei( GL_UNPACK_SWAP_BYTES,  GL_FALSE );\r
 117     glPixelStorei( GL_UNPACK_LSB_FIRST,   GL_FALSE );\r
 118     glPixelStorei( GL_UNPACK_ROW_LENGTH,  0        );\r
 119     glPixelStorei( GL_UNPACK_SKIP_ROWS,   0        );\r
 120     glPixelStorei( GL_UNPACK_SKIP_PIXELS, 0        );\r
 121     glPixelStorei( GL_UNPACK_ALIGNMENT,   1        );\r
 122     glBitmap(\r
 123         face[ 0 ], font->Height,      /* The bitmap's width and height  */\r
 124         font->xorig, font->yorig,     /* The origin in the font glyph   */\r
 125         ( float )( face[ 0 ] ), 0.0,  /* The raster advance -- inc. x,y */\r
 126         ( face + 1 )                  /* The packed bitmap data...      */\r
 127     );\r
 128     glPopClientAttrib( );\r
 129 }\r
 130 \r
 131 void FGAPIENTRY glutBitmapString( void* fontID, const unsigned char *string )\r
 132 {\r
 133     unsigned char c;\r
 134     float x = 0.0f ;\r
 135     SFG_Font* font;\r
 136     FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutBitmapString" );\r
 137     font = fghFontByID( fontID );\r
 138     freeglut_return_if_fail( font );\r
 139     if ( !string || ! *string )\r
 140         return;\r
 141 \r
 142     glPushClientAttrib( GL_CLIENT_PIXEL_STORE_BIT );\r
 143     glPixelStorei( GL_UNPACK_SWAP_BYTES,  GL_FALSE );\r
 144     glPixelStorei( GL_UNPACK_LSB_FIRST,   GL_FALSE );\r
 145     glPixelStorei( GL_UNPACK_ROW_LENGTH,  0        );\r
 146     glPixelStorei( GL_UNPACK_SKIP_ROWS,   0        );\r
 147     glPixelStorei( GL_UNPACK_SKIP_PIXELS, 0        );\r
 148     glPixelStorei( GL_UNPACK_ALIGNMENT,   1        );\r
 149 \r
 150     /*\r
 151      * Step through the string, drawing each character.\r
 152      * A newline will simply translate the next character's insertion\r
 153      * point back to the start of the line and down one line.\r
 154      */\r
 155     while( ( c = *string++) )\r
 156         if( c == '\n' )\r
 157         {\r
 158             glBitmap ( 0, 0, 0, 0, -x, (float) -font->Height, NULL );\r
 159             x = 0.0f;\r
 160         }\r
 161         else  /* Not an EOL, draw the bitmap character */\r
 162         {\r
 163             const GLubyte* face = font->Characters[ c ];\r
 164 \r
 165             glBitmap(\r
 166                 face[ 0 ], font->Height,     /* Bitmap's width and height    */\r
 167                 font->xorig, font->yorig,    /* The origin in the font glyph */\r
 168                 ( float )( face[ 0 ] ), 0.0, /* The raster advance; inc. x,y */\r
 169                 ( face + 1 )                 /* The packed bitmap data...    */\r
 170             );\r
 171 \r
 172             x += ( float )( face[ 0 ] );\r
 173         }\r
 174 \r
 175     glPopClientAttrib( );\r
 176 }\r
 177 \r
 178 /*\r
 179  * Returns the width in pixels of a font's character\r
 180  */\r
 181 int FGAPIENTRY glutBitmapWidth( void* fontID, int character )\r
 182 {\r
 183     SFG_Font* font;\r
 184     FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutBitmapWidth" );\r
 185     font = fghFontByID( fontID );\r
 186     freeglut_return_val_if_fail( character > 0 && character < 256, 0 );\r
 187     freeglut_return_val_if_fail( font, 0 );\r
 188     return *( font->Characters[ character ] );\r
 189 }\r
 190 \r
 191 /*\r
 192  * Return the width of a string drawn using a bitmap font\r
 193  */\r
 194 int FGAPIENTRY glutBitmapLength( void* fontID, const unsigned char* string )\r
 195 {\r
 196     unsigned char c;\r
 197     int length = 0, this_line_length = 0;\r
 198     SFG_Font* font;\r
 199     FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutBitmapLength" );\r
 200     font = fghFontByID( fontID );\r
 201     freeglut_return_val_if_fail( font, 0 );\r
 202     if ( !string || ! *string )\r
 203         return 0;\r
 204 \r
 205     while( ( c = *string++) )\r
 206     {\r
 207         if( c != '\n' )/* Not an EOL, increment length of line */\r
 208             this_line_length += *( font->Characters[ c ]);\r
 209         else  /* EOL; reset the length of this line */\r
 210         {\r
 211             if( length < this_line_length )\r
 212                 length = this_line_length;\r
 213             this_line_length = 0;\r
 214         }\r
 215     }\r
 216     if ( length < this_line_length )\r
 217         length = this_line_length;\r
 218 \r
 219     return length;\r
 220 }\r
 221 \r
 222 /*\r
 223  * Returns the height of a bitmap font\r
 224  */\r
 225 int FGAPIENTRY glutBitmapHeight( void* fontID )\r
 226 {\r
 227     SFG_Font* font;\r
 228     FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutBitmapHeight" );\r
 229     font = fghFontByID( fontID );\r
 230     freeglut_return_val_if_fail( font, 0 );\r
 231     return font->Height;\r
 232 }\r
 233 \r
 234 /*\r
 235  * Draw a stroke character\r
 236  */\r
 237 void FGAPIENTRY glutStrokeCharacter( void* fontID, int character )\r
 238 {\r
 239     const SFG_StrokeChar *schar;\r
 240     const SFG_StrokeStrip *strip;\r
 241     int i, j;\r
 242     SFG_StrokeFont* font;\r
 243     FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutStrokeCharacter" );\r
 244     font = fghStrokeByID( fontID );\r
 245     freeglut_return_if_fail( character >= 0 );\r
 246     freeglut_return_if_fail( character < font->Quantity );\r
 247     freeglut_return_if_fail( font );\r
 248 \r
 249     schar = font->Characters[ character ];\r
 250     freeglut_return_if_fail( schar );\r
 251     strip = schar->Strips;\r
 252 \r
 253     for( i = 0; i < schar->Number; i++, strip++ )\r
 254     {\r
 255         glBegin( GL_LINE_STRIP );\r
 256         for( j = 0; j < strip->Number; j++ )\r
 257             glVertex2f( strip->Vertices[ j ].X, strip->Vertices[ j ].Y );\r
 258         glEnd( );\r
 259                                 glBegin( GL_POINTS );\r
 260         for( j = 0; j < strip->Number; j++ )\r
 261             glVertex2f( strip->Vertices[ j ].X, strip->Vertices[ j ].Y );\r
 262                                 glEnd( );\r
 263     }\r
 264     glTranslatef( schar->Right, 0.0, 0.0 );\r
 265 }\r
 266 \r
 267 void FGAPIENTRY glutStrokeString( void* fontID, const unsigned char *string )\r
 268 {\r
 269     unsigned char c;\r
 270     int i, j;\r
 271     float length = 0.0;\r
 272     SFG_StrokeFont* font;\r
 273     FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutStrokeString" );\r
 274     font = fghStrokeByID( fontID );\r
 275     freeglut_return_if_fail( font );\r
 276     if ( !string || ! *string )\r
 277         return;\r
 278 \r
 279     /*\r
 280      * Step through the string, drawing each character.\r
 281      * A newline will simply translate the next character's insertion\r
 282      * point back to the start of the line and down one line.\r
 283      */\r
 284     while( ( c = *string++) )\r
 285         if( c < font->Quantity )\r
 286         {\r
 287             if( c == '\n' )\r
 288             {\r
 289                 glTranslatef ( -length, -( float )( font->Height ), 0.0 );\r
 290                 length = 0.0;\r
 291             }\r
 292             else  /* Not an EOL, draw the bitmap character */\r
 293             {\r
 294                 const SFG_StrokeChar *schar = font->Characters[ c ];\r
 295                 if( schar )\r
 296                 {\r
 297                     const SFG_StrokeStrip *strip = schar->Strips;\r
 298 \r
 299                     for( i = 0; i < schar->Number; i++, strip++ )\r
 300                     {\r
 301                         glBegin( GL_LINE_STRIP );\r
 302                         for( j = 0; j < strip->Number; j++ )\r
 303                             glVertex2f( strip->Vertices[ j ].X,\r
 304                                         strip->Vertices[ j ].Y);\r
 305 \r
 306                         glEnd( );\r
 307                     }\r
 308 \r
 309                     length += schar->Right;\r
 310                     glTranslatef( schar->Right, 0.0, 0.0 );\r
 311                 }\r
 312             }\r
 313         }\r
 314 }\r
 315 \r
 316 /*\r
 317  * Return the width in pixels of a stroke character\r
 318  */\r
 319 int FGAPIENTRY glutStrokeWidth( void* fontID, int character )\r
 320 {\r
 321     const SFG_StrokeChar *schar;\r
 322     SFG_StrokeFont* font;\r
 323     FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutStrokeWidth" );\r
 324     font = fghStrokeByID( fontID );\r
 325     freeglut_return_val_if_fail( ( character >= 0 ) &&\r
 326                                  ( character < font->Quantity ),\r
 327                                  0\r
 328     );\r
 329     freeglut_return_val_if_fail( font, 0 );\r
 330     schar = font->Characters[ character ];\r
 331     freeglut_return_val_if_fail( schar, 0 );\r
 332 \r
 333     return ( int )( schar->Right + 0.5 );\r
 334 }\r
 335 \r
 336 /*\r
 337  * Return the width of a string drawn using a stroke font\r
 338  */\r
 339 int FGAPIENTRY glutStrokeLength( void* fontID, const unsigned char* string )\r
 340 {\r
 341     unsigned char c;\r
 342     float length = 0.0;\r
 343     float this_line_length = 0.0;\r
 344     SFG_StrokeFont* font;\r
 345     FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutStrokeLength" );\r
 346     font = fghStrokeByID( fontID );\r
 347     freeglut_return_val_if_fail( font, 0 );\r
 348     if ( !string || ! *string )\r
 349         return 0;\r
 350 \r
 351     while( ( c = *string++) )\r
 352         if( c < font->Quantity )\r
 353         {\r
 354             if( c == '\n' ) /* EOL; reset the length of this line */\r
 355             {\r
 356                 if( length < this_line_length )\r
 357                     length = this_line_length;\r
 358                 this_line_length = 0.0;\r
 359             }\r
 360             else  /* Not an EOL, increment the length of this line */\r
 361             {\r
 362                 const SFG_StrokeChar *schar = font->Characters[ c ];\r
 363                 if( schar )\r
 364                     this_line_length += schar->Right;\r
 365             }\r
 366         }\r
 367     if( length < this_line_length )\r
 368         length = this_line_length;\r
 369     return( int )( length + 0.5 );\r
 370 }\r
 371 \r
 372 /*\r
 373  * Returns the height of a stroke font\r
 374  */\r
 375 GLfloat FGAPIENTRY glutStrokeHeight( void* fontID )\r
 376 {\r
 377     SFG_StrokeFont* font;\r
 378     FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutStrokeHeight" );\r
 379     font = fghStrokeByID( fontID );\r
 380     freeglut_return_val_if_fail( font, 0.0 );\r
 381     return font->Height;\r
 382 }\r
 383 \r
 384 /*** END OF FILE ***/\r