git.mutantstargoat.com Git - freeglut/blob - src/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 #include "../include/GL/freeglut.h"
  33 #include "freeglut_internal.h"
  34
  35 /*
  36  * TODO BEFORE THE STABLE RELEASE:
  37  *
  38  *  Test things out ...
  39  */
  40
  41 /* -- IMPORT DECLARATIONS -------------------------------------------------- */
  42
  43 /*
  44  * These are the font faces defined in freeglut_font_data.c file:
  45  */
  46 extern SFG_Font fgFontFixed8x13;
  47 extern SFG_Font fgFontFixed9x15;
  48 extern SFG_Font fgFontHelvetica10;
  49 extern SFG_Font fgFontHelvetica12;
  50 extern SFG_Font fgFontHelvetica18;
  51 extern SFG_Font fgFontTimesRoman10;
  52 extern SFG_Font fgFontTimesRoman24;
  53 extern SFG_StrokeFont fgStrokeRoman;
  54 extern SFG_StrokeFont fgStrokeMonoRoman;
  55
  56
  57 /* -- PRIVATE FUNCTIONS ---------------------------------------------------- */
  58
  59 /*
  60  * Matches a font ID with a SFG_Font structure pointer.
  61  * This was changed to match the GLUT header style.
  62  */
  63 static SFG_Font* fghFontByID( void* font )
  64 {
  65     /*
  66      * XXX Use a macro, a table of some kind, or else split these
  67      * XXX statements properly.  Jamming "return" on the end of an
  68      * XXX "if" is just bad style, IMHO.
  69      */
  70     if( font == GLUT_BITMAP_8_BY_13        ) return &fgFontFixed8x13;
  71     if( font == GLUT_BITMAP_9_BY_15        ) return &fgFontFixed9x15;
  72     if( font == GLUT_BITMAP_HELVETICA_10   ) return &fgFontHelvetica10;
  73     if( font == GLUT_BITMAP_HELVETICA_12   ) return &fgFontHelvetica12;
  74     if( font == GLUT_BITMAP_HELVETICA_18   ) return &fgFontHelvetica18;
  75     if( font == GLUT_BITMAP_TIMES_ROMAN_10 ) return &fgFontTimesRoman10;
  76     if( font == GLUT_BITMAP_TIMES_ROMAN_24 ) return &fgFontTimesRoman24;
  77     fgError( "font 0x%08x not found", font );
  78     return 0; /*** NOT REACHED ***/
  79 }
  80
  81 /*
  82  * Matches a font ID with a SFG_StrokeFont structure pointer.
  83  * This was changed to match the GLUT header style.
  84  */
  85 static SFG_StrokeFont* fghStrokeByID( void* font )
  86 {
  87     /*
  88      * XXX Same comment as above about jamming "return" in after an
  89      * XXX "if".
  90      */
  91     if( font == GLUT_STROKE_ROMAN      ) return &fgStrokeRoman;
  92     if( font == GLUT_STROKE_MONO_ROMAN ) return &fgStrokeMonoRoman;
  93     fgError( "stroke font 0x%08x not found", font );
  94     return 0; /*** NOT REACHED ***/
  95 }
  96
  97
  98 /* -- INTERFACE FUNCTIONS -------------------------------------------------- */
  99
 100 /*
 101  * Draw a bitmap character
 102  */
 103 void FGAPIENTRY glutBitmapCharacter( void* fontID, int character )
 104 {
 105     const GLubyte* face;
 106     SFG_Font* font = fghFontByID( fontID );
 107
 108     freeglut_return_if_fail( ( character >= 1 )&&( character < 256 ) );
 109
 110     /*
 111      * Find the character we want to draw (???)
 112      */
 113     face = font->Characters[ character - 1 ];
 114
 115     glPushClientAttrib( GL_CLIENT_PIXEL_STORE_BIT );
 116     glPixelStorei( GL_UNPACK_SWAP_BYTES,  GL_FALSE );
 117     glPixelStorei( GL_UNPACK_LSB_FIRST,   GL_FALSE );
 118     glPixelStorei( GL_UNPACK_ROW_LENGTH,  0        );
 119     glPixelStorei( GL_UNPACK_SKIP_ROWS,   0        );
 120     glPixelStorei( GL_UNPACK_SKIP_PIXELS, 0        );
 121     glPixelStorei( GL_UNPACK_ALIGNMENT,   1        );
 122     glBitmap(
 123         face[ 0 ], font->Height,      /* The bitmap's width and height  */
 124         font->xorig, font->yorig,     /* The origin in the font glyph   */
 125         ( float )( face[ 0 ] ), 0.0,  /* The raster advance -- inc. x,y */
 126         ( face + 1 )                  /* The packed bitmap data...      */
 127     );
 128     glPopClientAttrib( );
 129 }
 130
 131 void FGAPIENTRY glutBitmapString( void* fontID, const unsigned char *string )
 132 {
 133     int c;
 134     int numchar = strlen( string );
 135     SFG_Font* font = fghFontByID( fontID );
 136     float raster_position[ 4 ];
 137
 138     glGetFloatv ( GL_CURRENT_RASTER_POSITION, raster_position );
 139     glPushClientAttrib( GL_CLIENT_PIXEL_STORE_BIT );
 140     glPixelStorei( GL_UNPACK_SWAP_BYTES,  GL_FALSE );
 141     glPixelStorei( GL_UNPACK_LSB_FIRST,   GL_FALSE );
 142     glPixelStorei( GL_UNPACK_ROW_LENGTH,  0        );
 143     glPixelStorei( GL_UNPACK_SKIP_ROWS,   0        );
 144     glPixelStorei( GL_UNPACK_SKIP_PIXELS, 0        );
 145     glPixelStorei( GL_UNPACK_ALIGNMENT,   1        );
 146
 147     /*
 148      * Step through the string, drawing each character.
 149      * A newline will simply translate the next character's insertion
 150      * point back to the start of the line and down one line.
 151      */
 152     for( c = 0; c < numchar; c++ )
 153         if( string[c] == '\n' )
 154         {
 155             raster_position[ 1 ] -= ( float )font->Height;
 156             glRasterPos4fv( raster_position );
 157         }
 158         else  /* Not an EOL, draw the bitmap character */
 159         {
 160             const GLubyte* face = font->Characters[ string[ c ] - 1 ];
 161
 162             glBitmap(
 163                 face[ 0 ], font->Height,     /* Bitmap's width and height    */
 164                 font->xorig, font->yorig,    /* The origin in the font glyph */
 165                 ( float )( face[ 0 ] ), 0.0, /* The raster advance; inc. x,y */
 166                 ( face + 1 )                 /* The packed bitmap data...    */
 167             );
 168         }
 169     glPopClientAttrib( );
 170 }
 171
 172 /*
 173  * Returns the width in pixels of a font's character
 174  */
 175 int FGAPIENTRY glutBitmapWidth( void* fontID, int character )
 176 {
 177     SFG_Font* font = fghFontByID( fontID );
 178
 179     freeglut_return_val_if_fail( character > 0 && character < 256, 0 );
 180     return *( font->Characters[ character - 1 ] );
 181 }
 182
 183 /*
 184  * Return the width of a string drawn using a bitmap font
 185  */
 186 int FGAPIENTRY glutBitmapLength( void* fontID, const unsigned char* string )
 187 {
 188     int c, length = 0, this_line_length = 0;
 189     SFG_Font* font = fghFontByID( fontID );
 190     int numchar = strlen( string );
 191
 192     for( c = 0; c < numchar; c++ )
 193     {
 194         if( string[ c ] != '\n' )/* Not an EOL, increment length of line */
 195             this_line_length += *( font->Characters[ string[ c ] - 1 ]);
 196         else  /* EOL; reset the length of this line */
 197         {
 198             if( length < this_line_length )
 199                 length = this_line_length;
 200             this_line_length = 0;
 201         }
 202     }
 203     if ( length < this_line_length )
 204         length = this_line_length;
 205
 206     return length;
 207 }
 208
 209 /*
 210  * Returns the height of a bitmap font
 211  */
 212 int FGAPIENTRY glutBitmapHeight( void* fontID )
 213 {
 214     SFG_Font* font = fghFontByID( fontID );
 215     return font->Height;
 216 }
 217
 218 /*
 219  * Draw a stroke character
 220  */
 221 void FGAPIENTRY glutStrokeCharacter( void* fontID, int character )
 222 {
 223     const SFG_StrokeChar *schar;
 224     const SFG_StrokeStrip *strip;
 225     int i, j;
 226     SFG_StrokeFont* font = fghStrokeByID( fontID );
 227
 228     freeglut_return_if_fail( character >= 0 );
 229     freeglut_return_if_fail( character < font->Quantity );
 230
 231     schar = font->Characters[ character ];
 232     freeglut_return_if_fail( schar );
 233     strip = schar->Strips;
 234
 235     for( i = 0; i < schar->Number; i++, strip++ )
 236     {
 237         glBegin( GL_LINE_STRIP );
 238         for( j = 0; j < strip->Number; j++ )
 239             glVertex2f( strip->Vertices[ j ].X, strip->Vertices[ j ].Y );
 240         glEnd( );
 241     }
 242     glTranslatef( schar->Right, 0.0, 0.0 );
 243 }
 244
 245 void FGAPIENTRY glutStrokeString( void* fontID, const unsigned char *string )
 246 {
 247     int c, i, j;
 248     int numchar = strlen( string );
 249     float length = 0.0;
 250     SFG_StrokeFont* font = fghStrokeByID( fontID );
 251
 252     /*
 253      * Step through the string, drawing each character.
 254      * A newline will simply translate the next character's insertion
 255      * point back to the start of the line and down one line.
 256      */
 257     for( c = 0; c < numchar; c++ )
 258         if( string[ c ] < font->Quantity )
 259         {
 260             if( string[ c ] == '\n' )
 261             {
 262                 glTranslatef ( -length, -( float )( font->Height ), 0.0 );
 263                 length = 0.0;
 264             }
 265             else  /* Not an EOL, draw the bitmap character */
 266             {
 267                 const SFG_StrokeChar *schar = font->Characters[ string[ c ] ];
 268                 if( schar )
 269                 {
 270                     const SFG_StrokeStrip *strip = schar->Strips;
 271
 272                     for( i = 0; i < schar->Number; i++, strip++ )
 273                     {
 274                         glBegin( GL_LINE_STRIP );
 275                         for( j = 0; j < strip->Number; j++ )
 276                             glVertex2f( strip->Vertices[ j ].X,
 277                                         strip->Vertices[ j ].Y);
 278
 279                         glEnd( );
 280                     }
 281
 282                     length += schar->Right;
 283                     glTranslatef( schar->Right, 0.0, 0.0 );
 284                 }
 285             }
 286         }
 287 }
 288
 289 /*
 290  * Return the width in pixels of a stroke character
 291  */
 292 int FGAPIENTRY glutStrokeWidth( void* fontID, int character )
 293 {
 294     const SFG_StrokeChar *schar;
 295     SFG_StrokeFont* font = fghStrokeByID( fontID );
 296
 297     freeglut_return_val_if_fail( ( character >= 0 ) &&
 298                                  ( character < font->Quantity ),
 299                                  0
 300     );
 301     schar = font->Characters[ character ];
 302     freeglut_return_val_if_fail( schar, 0 );
 303
 304     return ( int )( schar->Right + 0.5 );
 305 }
 306
 307 /*
 308  * Return the width of a string drawn using a stroke font
 309  */
 310 int FGAPIENTRY glutStrokeLength( void* fontID, const unsigned char* string )
 311 {
 312     int c;
 313     float length = 0.0;
 314     float this_line_length = 0.0;
 315     SFG_StrokeFont* font = fghStrokeByID( fontID );
 316     int numchar = strlen( string );
 317
 318     for( c = 0; c < numchar; c++ )
 319         if( string[ c ] < font->Quantity )
 320         {
 321             if( string[ c ] == '\n' ) /* EOL; reset the length of this line */
 322             {
 323                 if( length < this_line_length )
 324                     length = this_line_length;
 325                 this_line_length = 0.0;
 326             }
 327             else  /* Not an EOL, increment the length of this line */
 328             {
 329                 const SFG_StrokeChar *schar = font->Characters[ string[ c ] ];
 330                 if( schar )
 331                     this_line_length += schar->Right;
 332             }
 333         }
 334     if( length < this_line_length )
 335         length = this_line_length;
 336     return ( int )( length + 0.5 );
 337 }
 338
 339 /*
 340  * Returns the height of a stroke font
 341  */
 342 GLfloat FGAPIENTRY glutStrokeHeight( void* fontID )
 343 {
 344     SFG_StrokeFont* font = fghStrokeByID( fontID );
 345     return( font->Height );
 346 }
 347
 348 /*** END OF FILE ***/