nevrax.org : docs

00001 
00007 /* Copyright, 2000 Nevrax Ltd.
00008  *
00009  * This file is part of NEVRAX NEL.
00010  * NEVRAX NEL is free software; you can redistribute it and/or modify
00011  * it under the terms of the GNU General Public License as published by
00012  * the Free Software Foundation; either version 2, or (at your option)
00013  * any later version.
00014 
00015  * NEVRAX NEL is distributed in the hope that it will be useful, but
00016  * WITHOUT ANY WARRANTY; without even the implied warranty of
00017  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
00018  * General Public License for more details.
00019 
00020  * You should have received a copy of the GNU General Public License
00021  * along with NEVRAX NEL; see the file COPYING. If not, write to the
00022  * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
00023  * MA 02111-1307, USA.
00024  */
00025 
00026 #include "std3d.h"
00027 
00028 #include <string>
00029 
00030 #include "nel/misc/types_nl.h"
00031 #include "nel/misc/debug.h"
00032 #include "nel/misc/common.h"
00033 #include "nel/misc/path.h"
00034 
00035 #include "3d/font_generator.h"
00036 
00037 using namespace std;
00038 
00039 #ifndef NL_DONT_USE_EXTERNAL_CODE
00040 
00041 #include <freetype/freetype.h>
00042 
00043 // for freetype 2.0
00044 #ifdef FTERRORS_H
00045 #undef FTERRORS_H
00046 #endif
00047 
00048 // for freetype 2.0.1
00049 #ifdef __FTERRORS_H__
00050 #undef __FTERRORS_H__
00051 #endif
00052 
00053 #define FT_ERRORDEF( e, v, s )  { e, s },
00054 #define FT_ERROR_START_LIST  {
00055 #define FT_ERROR_END_LIST    { 0, 0 } };
00056 
00057 const struct
00058 {
00059 int          err_code;
00060 const char*  err_msg;
00061 } ft_errors[] = 
00062 
00063 #include <freetype/fterrors.h>
00064 
00065 using namespace NLMISC;
00066 
00067 namespace NL3D {
00068 
00069 FT_Library      CFontGenerator::_Library;
00070 bool            CFontGenerator::_LibraryInit = false;
00071 
00072 
00073 const char *CFontGenerator::getFT2Error(FT_Error fte)
00074 {
00075         NL_ALLOC_CONTEXT (FreeTyp);
00076 
00077         static char ukn[1024];
00078 
00079         for (uint32 i = 0; ft_errors[i].err_code != 0 || ft_errors[i].err_msg != 0; i++)
00080         {
00081                 if (ft_errors[i].err_code == fte)
00082                         return ft_errors[i].err_msg;
00083         }
00084         smprintf (ukn, 1024, "Unknown freetype2 error, errcode: 0x%x", fte);
00085         return ukn;
00086 }
00087 
00088 
00089  
00090 /*
00091  * Constructor
00092  */
00093 CFontGenerator::CFontGenerator (const std::string &fontFileName, const std::string &fontExFileName)
00094 {
00095         NL_ALLOC_CONTEXT (FreeTyp);
00096 
00097         FT_Error error;
00098 
00099         if (!_LibraryInit)
00100         {
00101                 error = FT_Init_FreeType (&_Library);
00102                 if (error)
00103                 {
00104                         nlerror ("FT_Init_FreeType() failed: %s", getFT2Error(error));
00105                 }
00106                 _LibraryInit = true;
00107         }
00108 
00109         error = FT_New_Face (_Library, fontFileName.c_str (), 0, &_Face);
00110         if (error)
00111         {
00112                 nlerror ("FT_New_Face() failed with file '%s': %s", fontFileName.c_str(), getFT2Error(error));
00113         }
00114 
00115         string fontEx = fontExFileName;
00116         if (fontEx == "")
00117         {
00118                 // try to see if the ex filename exists based on the fontExFileName
00119                 fontEx = CPath::lookup(CFile::getFilenameWithoutExtension (fontFileName)+".afm", false, false);
00120         }
00121 
00122         if (fontEx != "")
00123         {
00124                 error = FT_Attach_File (_Face, fontEx.c_str ());
00125                 if (error)
00126                 {
00127                         nlwarning ("FT_Attach_File() failed with file '%s': %s", fontEx.c_str(), getFT2Error(error));
00128                 }
00129         }
00130 
00131         error = FT_Select_Charmap (_Face, ft_encoding_unicode);
00132         if (error)
00133         {
00134                 nlerror ("FT_Select_Charmap() failed with file '%s': %s", fontFileName.c_str(), getFT2Error(error));
00135         }
00136 }
00137 
00138 CFontGenerator::~CFontGenerator ()
00139 {
00140 }
00141 
00142 void CFontGenerator::getSizes (ucchar c, uint32 size, uint32 &width, uint32 &height)
00143 {
00144         NL_ALLOC_CONTEXT (FreeTyp);
00145 
00146         FT_Error error;
00147 
00148         error = FT_Set_Pixel_Sizes (_Face, size, size);
00149         if (error)
00150         {
00151                 nlerror ("FT_Set_Pixel_Sizes() failed: %s", getFT2Error(error));
00152         }
00153 
00154         // retrieve glyph index from character code
00155         FT_UInt glyph_index = FT_Get_Char_Index (_Face, c);
00156 
00157         // load glyph image into the slot (erase previous one)
00158         error = FT_Load_Glyph (_Face, glyph_index, FT_LOAD_DEFAULT);
00159         if (error)
00160         {
00161                 nlerror ("FT_Load_Glyph() failed: %s", getFT2Error(error));
00162         }
00163 
00164         // convert 24.6 fixed point into integer
00165         width = _Face->glyph->metrics.width >> 6;
00166         height = _Face->glyph->metrics.height >> 6;
00167 }
00168 
00169 uint8 *CFontGenerator::getBitmap (ucchar c, uint32 size, uint32 &width, uint32 &height, uint32 &pitch, sint32 &left, sint32 &top, sint32 &advx, uint32 &glyphIndex)
00170 {
00171         NL_ALLOC_CONTEXT (FreeTyp);
00172 
00173         FT_Error error;
00174 
00175         error = FT_Set_Pixel_Sizes (_Face, size, size);
00176         if (error)
00177         {
00178                 nlerror ("FT_Set_Pixel_Sizes() failed: %s", getFT2Error(error));
00179         }
00180 
00181         // retrieve glyph index from character code
00182         FT_UInt glyph_index = FT_Get_Char_Index (_Face, c);
00183 
00184         // load glyph image into the slot (erase previous one)
00185         error = FT_Load_Glyph (_Face, glyph_index, FT_LOAD_DEFAULT);
00186         if (error)
00187         {
00188                 nlerror ("FT_Load_Glyph() failed: %s", getFT2Error(error));
00189         }
00190 
00191         if (size == 0)
00192         {
00193                 width = 0;
00194                 height = 0;
00195                 pitch = 0;
00196                 left = 0;
00197                 top = 0;
00198                 advx = 0;
00199                 glyphIndex = glyph_index;
00200                 return NULL;
00201         }
00202 
00203         // convert to an anti-aliased bitmap
00204         error = FT_Render_Glyph (_Face->glyph, ft_render_mode_normal);
00205         if (error)
00206         {
00207                 nlerror ("FT_Render_Glyph() failed: %s", getFT2Error(error));
00208         }
00209 
00210         width = _Face->glyph->bitmap.width;
00211         height = _Face->glyph->bitmap.rows;
00212         pitch = _Face->glyph->bitmap.pitch;
00213 
00214         left = _Face->glyph->bitmap_left;
00215         top = _Face->glyph->bitmap_top;
00216 
00217         advx = _Face->glyph->advance.x >> 6;
00218 
00219         glyphIndex = glyph_index;
00220 
00221         return (uint8 *) _Face->glyph->bitmap.buffer;
00222 }
00223 
00224 
00225 
00226 void CFontGenerator::getKerning (ucchar left, ucchar right, sint32 &kernx)
00227 {
00228         NL_ALLOC_CONTEXT (FreeTyp);
00229 
00230         if (!FT_HAS_KERNING(_Face))
00231         {
00232                 kernx = 0;
00233         }
00234         else
00235         {
00236                 FT_Vector  kerning;
00237                 FT_Error error = FT_Get_Kerning (_Face, left, right, ft_kerning_default, &kerning);
00238                 if (error)
00239                 {
00240                         nlerror ("FT_Get_Kerning() failed: %s", getFT2Error(error));
00241                 }
00242                 kernx = kerning.x;
00243         }
00244 }
00245 
00246 
00247 
00248 uint32   CFontGenerator::getCharIndex (ucchar c)
00249 {
00250         NL_ALLOC_CONTEXT (FreeTyp);
00251 
00252         return FT_Get_Char_Index (_Face, c);
00253 }
00254 
00255 } // NL3D
00256 
00257 #else // NL_DONT_USE_EXTERNAL_CODE
00258 
00259 #include <windows.h>
00260 
00261 using namespace NLMISC;
00262 
00263 namespace NL3D {
00264  
00265 HBITMAP Dib;
00266 uint32 *Buffer;
00267 HDC hdcDib;
00268 int Width = 100;
00269 int Height = 100;
00270 
00271 /*
00272  * Constructor
00273  */
00274 CFontGenerator::CFontGenerator (const std::string &fontFileName, const std::string &fontExFileName)
00275 {
00276 
00277 //      HWND win=(HWND)winHack;
00278 //      WindowHandle = win;
00279 //      Format = format;
00280 //      RECT rect;
00281 //      BOOL ret = GetClientRect( WindowHandle, &rect);
00282 //      assert (ret);
00283 
00284 //      uint f = AddFontResource ("");
00285 //      nlassert (f);
00286 
00287         BITMAPINFO info;
00288         info.bmiHeader.biWidth = Width;
00289         info.bmiHeader.biHeight= -Height;
00290         info.bmiHeader.biSize = sizeof (BITMAPINFOHEADER);
00291         info.bmiHeader.biPlanes = 1; 
00292         info.bmiHeader.biBitCount = 32;
00293         info.bmiHeader.biCompression = BI_RGB;
00294         info.bmiHeader.biSizeImage = 4*Width*Height;
00295         info.bmiHeader.biXPelsPerMeter = 1;
00296         info.bmiHeader.biYPelsPerMeter = 1;
00297         info.bmiHeader.biClrUsed = 0;
00298         info.bmiHeader.biClrImportant = 0;
00299 
00300         HDC hdc = GetDC (NULL);
00301         nlassert (hdc);
00302         Dib = CreateDIBSection (hdc, &info, DIB_RGB_COLORS, (void**)&Buffer, NULL, NULL);
00303 
00304         hdcDib = CreateCompatibleDC (hdc);
00305         nlassert (hdcDib);
00306 
00307 
00308         ReleaseDC (NULL, hdc);
00309 
00310         SetTextAlign (hdcDib, TA_TOP | TA_LEFT | TA_NOUPDATECP);
00311         SetBkColor (hdcDib, RGB (0,0,0));
00312         SetTextColor (hdcDib, RGB (255, 255, 255));
00313         
00314         /*FT_Error error;
00315 
00316         if (!_LibraryInit)
00317         {
00318                 error = FT_Init_FreeType (&_Library);
00319                 if (error)
00320                 {
00321                         nlerror ("FT_Init_FreeType() failed: %s", getFT2Error(error));
00322                 }
00323                 _LibraryInit = true;
00324         }
00325 
00326         error = FT_New_Face (_Library, fontFileName.c_str (), 0, &_Face);
00327         if (error)
00328         {
00329                 nlerror ("FT_New_Face() failed with file '%s': %s", fontFileName.c_str(), getFT2Error(error));
00330         }
00331 
00332         if (fontExFileName != "")
00333         {
00334                 error = FT_Attach_File (_Face, fontExFileName.c_str ());
00335                 if (error)
00336                 {
00337                         nlwarning ("FT_Attach_File() failed with file '%s': %s", fontExFileName.c_str(), getFT2Error(error));
00338                 }
00339         }*/
00340 }
00341 
00342 CFontGenerator::~CFontGenerator ()
00343 {
00344         DeleteObject (Dib);
00345 
00346         DeleteDC (hdcDib);
00347 }
00348 
00349 void CFontGenerator::getSizes (ucchar c, uint32 size, uint32 &width, uint32 &height)
00350 {
00351 /*      FT_Error error;
00352 
00353         error = FT_Set_Pixel_Sizes (_Face, size, size);
00354         if (error)
00355         {
00356                 nlerror ("FT_Set_Pixel_Sizes() failed: %s", getFT2Error(error));
00357         }
00358 
00359         // retrieve glyph index from character code
00360         FT_UInt glyph_index = FT_Get_Char_Index (_Face, c);
00361 
00362         // load glyph image into the slot (erase previous one)
00363         error = FT_Load_Glyph (_Face, glyph_index, FT_LOAD_DEFAULT);
00364         if (error)
00365         {
00366                 nlerror ("FT_Load_Glyph() failed: %s", getFT2Error(error));
00367         }
00368 
00369         // convert 24.6 fixed point into integer
00370         width = _Face->glyph->metrics.width >> 6;
00371         height = _Face->glyph->metrics.height >> 6;
00372         */
00373 }
00374 
00375 HFONT hFont = NULL;
00376 uint32 CurrentFontSize = 0;
00377 
00378 uint8 *CFontGenerator::getBitmap (ucchar c, uint32 size, uint32 &width, uint32 &height, uint32 &pitch, sint32 &left, sint32 &top, sint32 &advx, uint32 &glyphIndex)
00379 {
00380 /*      FT_Error error;
00381 
00382         error = FT_Set_Pixel_Sizes (_Face, size, size);
00383         if (error)
00384         {
00385                 nlerror ("FT_Set_Pixel_Sizes() failed: %s", getFT2Error(error));
00386         }
00387 
00388         // retrieve glyph index from character code
00389         FT_UInt glyph_index = FT_Get_Char_Index (_Face, c);
00390 
00391         // load glyph image into the slot (erase previous one)
00392         error = FT_Load_Glyph (_Face, glyph_index, FT_LOAD_DEFAULT);
00393         if (error)
00394         {
00395                 nlerror ("FT_Load_Glyph() failed: %s", getFT2Error(error));
00396         }
00397 
00398         if (size == 0)
00399         {
00400                 width = 0;
00401                 height = 0;
00402                 pitch = 0;
00403                 left = 0;
00404                 top = 0;
00405                 advx = 0;
00406                 glyphIndex = glyph_index;
00407                 return NULL;
00408         }
00409 
00410         // convert to an anti-aliased bitmap
00411         error = FT_Render_Glyph (_Face->glyph, ft_render_mode_normal);
00412         if (error)
00413         {
00414                 nlerror ("FT_Render_Glyph() failed: %s", getFT2Error(error));
00415         }
00416 
00417         width = _Face->glyph->bitmap.width;
00418         height = _Face->glyph->bitmap.rows;
00419         pitch = _Face->glyph->bitmap.pitch;
00420 
00421         left = _Face->glyph->bitmap_left;
00422         top = _Face->glyph->bitmap_top;
00423 
00424         advx = _Face->glyph->advance.x >> 6;
00425 
00426         glyphIndex = glyph_index;
00427 
00428         return (uint8 *) _Face->glyph->bitmap.buffer;
00429 */
00430 
00431         if (size == 0)
00432         {
00433                 width = 0;
00434                 height = 0;
00435                 pitch = 0;
00436                 left = 0;
00437                 top = 0;
00438                 advx = 0;
00439                 glyphIndex = 0;
00440                 return NULL;
00441         }
00442 
00443         // Create the font
00444         if (hFont ==  NULL || CurrentFontSize != size)
00445         {
00446                 if (hFont !=  NULL)
00447                 {
00448                         DeleteObject (hFont);
00449                 }
00450 
00451                 hFont=CreateFont
00452                 (
00453                         size,                                   // logical height of font
00454                         0,                                      // logical average character width
00455                         0,                                      // angle of escapement
00456                         0,                                      // base-line orientation angle
00457                         FW_DONTCARE, //FW_NORMAL,                       // font weight
00458                         FALSE,                          // italic attribute flag
00459                         FALSE,                          // underline attribute flag
00460                         FALSE,                          // strikeout attribute flag
00461                         DEFAULT_CHARSET,        // character set identifier
00462                         OUT_DEVICE_PRECIS,  // output precision
00463                         CLIP_DEFAULT_PRECIS,    // clipping precision
00464                         DEFAULT_QUALITY,        // output quality
00465                         DEFAULT_PITCH|FF_DONTCARE,  // pitch and family
00466                         "Arial Unicode MS Normal"         // pointer to typeface name string
00467                 );
00468                 nlassert (hFont);
00469 
00470                 CurrentFontSize = size;
00471         }
00472 
00473         SelectObject (hdcDib, hFont);
00474         SelectObject (hdcDib, Dib);
00475         
00476         const char cc = (char) c;
00477 
00478         RECT rect;
00479         rect.bottom = Height;
00480         rect.top = 0;
00481         rect.left = 0;
00482         rect.right = Width;
00483 
00484         int res = DrawText (hdcDib, &cc, 1, &rect, DT_LEFT | DT_TOP);
00485 
00486         POINT point;
00487         point.y = res;
00488 
00489         int w = res;
00490         BOOL rey = GetCharWidth32 (hdcDib, (uint8) cc,  (uint8) cc, &w);
00491         nlassert (rey);
00492         point.x = w;
00493 
00494 //      ABC abc;
00495 //      BOOL rey = GetCharABCWidths (hdcDib, (uint8) cc, (uint8) cc, &abc);
00496 //      nlassert (rey);
00497 //      point.x = abc.abcA;
00498 
00499         SIZE s;
00500         GetTextExtentPoint32 (hdcDib, &cc, 1, &s);
00501         
00502         BOOL ret = LPtoDP (hdcDib, &point, 1);
00503         nlassert (ret);
00504 
00505         static uint8 buf[100*100];
00506 
00507         sint32 _top = 0, _left = point.x;
00508         sint32 right = 0, bottom = point.y;
00509         bool emptyLine;
00510         for (sint y = 0; y < point.y; y++)
00511         {
00512                 emptyLine = true;
00513                 for (sint x = 0; x < point.x; x++)
00514                 {
00515                         buf[y*100+x] = (uint8) Buffer[y*100+x];
00516                         if (buf[y*100+x])
00517                         {
00518                                 emptyLine = false;
00519                                 if (x < _left)
00520                                         _left = x;
00521                                 if (x > right)
00522                                         right = x;
00523                         }
00524 
00525 //                      printf (buf[y*100+x]?"*":".");
00526                 }
00527                 if (!emptyLine)
00528                 {
00529                         if (_top == 0)
00530                                 _top = y;
00531 
00532                         bottom = y;
00533                 }
00534 
00535 //              printf ("\n");
00536         }
00537         width = right - _left + 1;
00538         if (right - _left + 1 < 0) width = 0;
00539         height = bottom - _top + 1;
00540         if (bottom - _top + 1 < 0) height = 0;
00541         pitch = 100;
00542         advx = point.x;
00543         
00544         WORD ag = 0;
00545         /*uint t = GetGlyphIndices (hdcDib, &cc, 1, &ag, 0);
00546         if (t == GDI_ERROR)
00547         {
00548                 nlstop;
00549         }
00550 */
00551         glyphIndex = ag;
00552 
00553         top = -_top;
00554         left = -_left;
00555 
00556 /*      {
00557                 for (sint y = _top; y < _top + height; y++)
00558                 {
00559                         for (sint x = _left; x < _left + width; x++)
00560                         {
00561                                 printf (buf[y*100+x]?"*":".");
00562                         }
00563                         printf ("\n");
00564                 }
00565                 printf ("w: %d h: %d s: %d a: %d l: %d t: %d", width, height, size, advx, left, top);
00566                 getchar();
00567         }
00568 */
00569         _top = _left = top = left = 0;
00570         top = s.cy;
00571         width = s.cx;
00572         height = s.cy;
00573 
00574         return buf + _top * 100 + _left;
00575 }
00576 
00577 
00578 
00579 
00580 void CFontGenerator::getKerning (ucchar left, ucchar right, sint32 &kernx)
00581 {
00582 /*      if (!FT_HAS_KERNING(_Face))
00583         {
00584                 kernx = 0;
00585         }
00586         else
00587         {
00588                 FT_Vector  kerning;
00589                 FT_Error error = FT_Get_Kerning (_Face, left, right, ft_kerning_default, &kerning);
00590                 if (error)
00591                 {
00592                         nlerror ("FT_Get_Kerning() failed: %s", getFT2Error(error));
00593                 }
00594                 kernx = kerning.x;
00595         }*/
00596 }
00597 
00598 
00599 
00600 uint32   CFontGenerator::getCharIndex (ucchar c)
00601 {
00602 //      return FT_Get_Char_Index (_Face, c);
00603         return 0;
00604 }
00605 
00606 
00607 } // NL3D
00608 
00609 #endif // NL_DONT_USE_EXTERNAL_CODE
00610
font_generator.cpp
