3fe559a75b08ea1a71ac356a7cfc2934377183ec
[freeglut] / 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 #define  G_LOG_DOMAIN  "freeglut-font"
33
34 #include "../include/GL/freeglut.h"
35 #include "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   struct _GLUTstrokeFont {
63     const char *name;
64     int num_chars;
65     void *ch;
66     float top;
67     float bottom;
68   };
69
70   struct _GLUTbitmapFont {
71     const char *name;
72     const int num_chars;
73     const int first;
74     const void *ch;
75   };
76
77   struct _GLUTstrokeFont glutStrokeRoman;
78   struct _GLUTstrokeFont glutStrokeMonoRoman;
79   struct _GLUTbitmapFont glutBitmap9By15;
80   struct _GLUTbitmapFont glutBitmap8By13;
81   struct _GLUTbitmapFont glutBitmapTimesRoman10;
82   struct _GLUTbitmapFont glutBitmapTimesRoman24;
83   struct _GLUTbitmapFont glutBitmapHelvetica10;
84   struct _GLUTbitmapFont glutBitmapHelvetica12;
85   struct _GLUTbitmapFont glutBitmapHelvetica18;
86 #endif
87
88
89 /* -- PRIVATE FUNCTIONS ---------------------------------------------------- */
90
91 /*
92  * Matches a font ID with a SFG_Font structure pointer.
93  * This was changed to match the GLUT header style.
94  */
95 static SFG_Font* fghFontByID( void* font )
96 {
97   /*
98    * Try matching the font ID and the font data structure
99    */
100   if( font == GLUT_BITMAP_8_BY_13        ) return( &fgFontFixed8x13    );
101   if( font == GLUT_BITMAP_9_BY_15        ) return( &fgFontFixed9x15    );
102   if( font == GLUT_BITMAP_HELVETICA_10   ) return( &fgFontHelvetica10  );
103   if( font == GLUT_BITMAP_HELVETICA_12   ) return( &fgFontHelvetica12  );
104   if( font == GLUT_BITMAP_HELVETICA_18   ) return( &fgFontHelvetica18  );
105   if( font == GLUT_BITMAP_TIMES_ROMAN_10 ) return( &fgFontTimesRoman10 );
106   if( font == GLUT_BITMAP_TIMES_ROMAN_24 ) return( &fgFontTimesRoman24 );
107
108   /*
109    * This probably is the library user's fault
110    */
111   fgError( "font 0x%08x not found", font );
112
113   return 0;
114 }
115
116 /*
117  * Matches a font ID with a SFG_StrokeFont structure pointer.
118  * This was changed to match the GLUT header style.
119  */
120 static SFG_StrokeFont* fghStrokeByID( void* font )
121 {
122   /*
123    * Try matching the font ID and the font data structure
124    */
125   if( font == GLUT_STROKE_ROMAN      ) return( &fgStrokeRoman     );
126   if( font == GLUT_STROKE_MONO_ROMAN ) return( &fgStrokeMonoRoman );
127
128   /*
129    * This probably is the library user's fault
130    */
131   fgError( "stroke font 0x%08x not found", font );
132
133   return 0;
134 }
135
136
137 /* -- INTERFACE FUNCTIONS -------------------------------------------------- */
138
139 /*
140  * Draw a bitmap character
141  */
142 void FGAPIENTRY glutBitmapCharacter( void* fontID, int character )
143 {
144   const GLubyte* face;
145
146   /*
147    * First of all we'll need a font to use
148    */
149   SFG_Font* font = fghFontByID( fontID );
150
151   /*
152    * Make sure the character we want to output is valid
153    */
154   freeglut_return_if_fail( character >= 0 && character < 256 );
155
156   /*
157    * Then find the character we want to draw
158    */
159   face = font->Characters[ character - 1 ];
160
161   /*
162    * Save the old pixel store settings
163    */
164   glPushClientAttrib( GL_CLIENT_PIXEL_STORE_BIT );
165
166   /*
167    * Set up the pixel unpacking ways
168    */
169   glPixelStorei( GL_UNPACK_SWAP_BYTES,  GL_FALSE );
170   glPixelStorei( GL_UNPACK_LSB_FIRST,   GL_FALSE );
171   glPixelStorei( GL_UNPACK_ROW_LENGTH,  0        );
172   glPixelStorei( GL_UNPACK_SKIP_ROWS,   0        );
173   glPixelStorei( GL_UNPACK_SKIP_PIXELS, 0        );
174   glPixelStorei( GL_UNPACK_ALIGNMENT,   1        );
175
176   /*
177    * We'll use a glBitmap call to draw the font.
178    */
179   glBitmap(
180       face[ 0 ], font->Height,      /* The bitmap's width and height */
181       font->xorig, font->yorig,     /* The origin -- what on earth?  */
182       (float)(face[ 0 ]), 0.0,      /* The raster advance -- inc. x  */
183       (face + 1)                    /* The packed bitmap data...     */
184   );
185
186   /*
187    * Restore the old pixel store settings
188    */
189   glPopClientAttrib();
190 }
191
192 void FGAPIENTRY glutBitmapString( void* fontID, const char *string )
193 {
194   int c;
195   int numchar = strlen ( string ) ;
196
197   /*
198    * First of all we'll need a font to use
199    */
200   SFG_Font* font = fghFontByID( fontID );
201
202   float raster_position[4] ;
203   glGetFloatv ( GL_CURRENT_RASTER_POSITION, raster_position ) ;
204
205   /*
206    * Save the old pixel store settings
207    */
208   glPushClientAttrib( GL_CLIENT_PIXEL_STORE_BIT );
209
210   /*
211    * Set up the pixel unpacking ways
212    */
213   glPixelStorei( GL_UNPACK_SWAP_BYTES,  GL_FALSE );
214   glPixelStorei( GL_UNPACK_LSB_FIRST,   GL_FALSE );
215   glPixelStorei( GL_UNPACK_ROW_LENGTH,  0        );
216   glPixelStorei( GL_UNPACK_SKIP_ROWS,   0        );
217   glPixelStorei( GL_UNPACK_SKIP_PIXELS, 0        );
218   glPixelStorei( GL_UNPACK_ALIGNMENT,   1        );
219
220   /*
221    * Step through the string, drawing each character.
222    * A carriage return will simply translate the next character's insertion point back to the
223    * start of the line and down one line.
224    */
225   for( c = 0; c < numchar; c++ )
226   {
227     if ( string[c] == '\n' )
228     {
229       raster_position[1] -= (float)font->Height ;
230       glRasterPos4fv ( raster_position ) ;
231     }
232     else  /* Not a carriage return, draw the bitmap character */
233     {
234       const GLubyte* face = font->Characters[ string[ c ] - 1 ] ;
235
236       /*
237        * We'll use a glBitmap call to draw the font.
238        */
239       glBitmap(
240           face[ 0 ], font->Height,      /* The bitmap's width and height */
241           font->xorig, font->yorig,     /* The origin -- what on earth?  */
242           (float)(face[ 0 ]), 0.0,      /* The raster advance -- inc. x  */
243           (face + 1)                    /* The packed bitmap data...     */
244       ) ;
245     }
246   }
247
248   /*
249    * Restore the old pixel store settings
250    */
251   glPopClientAttrib();
252 }
253
254 /*
255  * Returns the width in pixels of a font's character
256  */
257 int FGAPIENTRY glutBitmapWidth( void* fontID, int character )
258 {
259   /*
260    * First of all, grab the font we need
261    */
262   SFG_Font* font = fghFontByID( fontID );
263
264   /*
265    * Make sure the character we want to output is valid
266    */
267   freeglut_return_val_if_fail( character > 0 && character < 256, 0 );
268
269   /*
270        * Scan the font looking for the specified character
271    */
272   return( *(font->Characters[ character - 1 ]) );
273 }
274
275 /*
276  * Return the width of a string drawn using a bitmap font
277  */
278 int FGAPIENTRY glutBitmapLength( void* fontID, const char* string )
279 {
280   int c, length = 0, this_line_length = 0;
281
282   /*
283    * First of all, grab the font we need
284    */
285   SFG_Font* font = fghFontByID( fontID );
286
287   /*
288    * Step through the characters in the string, adding up the width of each one
289    */
290   int numchar = strlen ( string ) ;
291   for( c = 0; c < numchar; c++ )
292   {
293     if ( string[ c ] == '\n' )  /* Carriage return, reset the length of this line */
294     {
295       if ( length < this_line_length ) length = this_line_length ;
296       this_line_length = 0 ;
297     }
298     else  /* Not a carriage return, increment the length of this line */
299       this_line_length += *(font->Characters[ string[ c ] - 1 ]) ;
300   }
301
302   if ( length < this_line_length ) length = this_line_length ;
303
304   /*
305    * Return the result now
306    */
307   return( length );
308 }
309
310 /*
311  * Returns the height of a bitmap font
312  */
313 int FGAPIENTRY glutBitmapHeight( void* fontID )
314 {
315   /*
316    * See which font are we queried about
317    */
318   SFG_Font* font = fghFontByID( fontID );
319
320   /*
321    * Return the character set's height
322    */
323   return( font->Height );
324 }
325
326 /*
327  * Draw a stroke character
328  */
329 void FGAPIENTRY glutStrokeCharacter( void* fontID, int character )
330 {
331   const SFG_StrokeChar *schar;
332   const SFG_StrokeStrip *strip;
333   int i, j;
334
335   /*
336    * First of all we'll need a font to use
337    */
338   SFG_StrokeFont* font = fghStrokeByID( fontID );
339
340   /*
341    * Make sure the character we want to output is valid
342    */
343   freeglut_return_if_fail( character >= 0 && character < font->Quantity );
344
345   schar = font->Characters[character];
346
347   freeglut_return_if_fail( schar );
348
349   strip = schar->Strips;
350
351   for (i = 0; i < schar->Number; i++, strip++)
352   {
353     glBegin(GL_LINE_STRIP);
354     for(j = 0; j < strip->Number; j++)
355     {
356       glVertex2f(strip->Vertices[j].X, strip->Vertices[j].Y);
357     }
358     glEnd();
359   }
360   glTranslatef(schar->Right, 0.0, 0.0);
361 }
362
363 void FGAPIENTRY glutStrokeString( void* fontID, const char *string )
364 {
365   int c, i, j;
366   int numchar = strlen ( string ) ;
367   float length = 0.0 ;
368
369   /*
370    * First of all we'll need a font to use
371    */
372   SFG_StrokeFont* font = fghStrokeByID( fontID );
373
374   /*
375    * Step through the string, drawing each character.
376    * A carriage return will simply translate the next character's insertion point back to the
377    * start of the line and down one line.
378    */
379   for( c = 0; c < numchar; c++ )
380   {
381     if ( ( string[ c ] >= 0 ) && ( string[ c ] < font->Quantity ) )
382     {
383       if ( string[c] == '\n' )
384       {
385         glTranslatef ( -length, -(float)(font->Height), 0.0 ) ;
386         length = 0.0 ;
387       }
388       else  /* Not a carriage return, draw the bitmap character */
389       {
390         const SFG_StrokeChar *schar = font->Characters[string[c]];
391         if ( schar != NULL )
392         {
393           const SFG_StrokeStrip *strip = schar->Strips;
394
395           for (i = 0; i < schar->Number; i++, strip++)
396           {
397             glBegin(GL_LINE_STRIP);
398             for(j = 0; j < strip->Number; j++)
399               glVertex2f(strip->Vertices[j].X, strip->Vertices[j].Y);
400
401             glEnd();
402           }
403
404           length += schar->Right ;
405           glTranslatef(schar->Right, 0.0, 0.0);
406         }
407       }
408     }
409   }
410 }
411
412 /*
413  * Return the width in pixels of a stroke character
414  */
415 int FGAPIENTRY glutStrokeWidth( void* fontID, int character )
416 {
417   const SFG_StrokeChar *schar;
418   /*
419    * First of all we'll need a font to use
420    */
421   SFG_StrokeFont* font = fghStrokeByID( fontID );
422
423   /*
424    * Make sure the character we want to output is valid
425    */
426   freeglut_return_val_if_fail( character >= 0 && character < font->Quantity, 0 );
427
428   schar = font->Characters[character];
429
430   freeglut_return_val_if_fail( schar, 0 );
431
432   return ((int)(schar->Right + 0.5));
433 }
434
435 /*
436  * Return the width of a string drawn using a stroke font
437  */
438 int FGAPIENTRY glutStrokeLength( void* fontID, const char* string )
439 {
440   int c;
441   float length = 0.0;
442   float this_line_length = 0.0 ;
443
444   /*
445    * First of all we'll need a font to use
446    */
447   SFG_StrokeFont* font = fghStrokeByID( fontID );
448
449   /*
450    * Step through the characters in the string, adding up the width of each one
451    */
452   int numchar = strlen ( string ) ;
453   for( c = 0; c < numchar; c++ )
454   {
455     if ( ( string[ c ] >= 0 ) && ( string[ c ] < font->Quantity ) )
456     {
457       if ( string[ c ] == '\n' )  /* Carriage return, reset the length of this line */
458       {
459         if ( length < this_line_length ) length = this_line_length ;
460         this_line_length = 0.0 ;
461       }
462       else  /* Not a carriage return, increment the length of this line */
463       {
464         const SFG_StrokeChar *schar = font->Characters[string[c]];
465         if ( schar != NULL )
466           this_line_length += schar->Right ;
467       }
468     }
469   }
470
471   if ( length < this_line_length ) length = this_line_length ;
472
473   /*
474    * Return the result now
475    */
476   return( (int)(length+0.5) );
477 }
478
479 /*
480  * Returns the height of a stroke font
481  */
482 GLfloat FGAPIENTRY glutStrokeHeight( void* fontID )
483 {
484     /*
485      * See which font are we queried about
486      */
487     SFG_StrokeFont* font = fghStrokeByID( fontID );
488
489     /*
490      * Return the character set's height
491      */
492     return( font->Height );
493 }
494
495 /*** END OF FILE ***/