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