From 0ea5fc66924303d1bf73ba283a383e2aadee02f2 Mon Sep 17 00:00:00 2001 From: neodarz Date: Sat, 11 Aug 2018 20:21:34 +0200 Subject: Initial commit --- docs/doxygen/nel/a02542.html | 890 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 890 insertions(+) create mode 100644 docs/doxygen/nel/a02542.html (limited to 'docs/doxygen/nel/a02542.html') diff --git a/docs/doxygen/nel/a02542.html b/docs/doxygen/nel/a02542.html new file mode 100644 index 00000000..f76d6a1e --- /dev/null +++ b/docs/doxygen/nel/a02542.html @@ -0,0 +1,890 @@ + + +NeL: NL3D::CFontManager class Reference + + + +
+Main Page | Namespace List | Class Hierarchy | Alphabetical List | Data Structures | File List | Namespace Members | Data Fields | Globals | Related Pages | Search for 
+

NL3D::CFontManager Class Reference

#include <font_manager.h> +

+

Detailed Description

+Font manager The font manager manages CMaterial pointers through a list of CSmartPtr. When the user asks for the texture font representing a character(font/size), it generates and stores this pointer in the list. If this character has already been generated, and lies in the list, it increments its reference count. If the memory used by generated textures exceeds the max memory, then the useless character/pointer is erased from the list. Max memory is set to 0 by default, so this value should be set to non-zero before generating textures to prevent immediate memory deletion.
Author:
Stephane Coutelas

+Nevrax France

+
Date:
2000
+ +

+ +

+Definition at line 62 of file font_manager.h. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Public Member Functions

 CFontManager ()
void computeString (const ucstring &s, CFontGenerator *fontGen, const NLMISC::CRGBA &color, uint32 fontSize, IDriver *driver, CComputedString &output, bool keep800x600Ratio=true)
void computeString (const std::string &s, CFontGenerator *fontGen, const NLMISC::CRGBA &color, uint32 fontSize, IDriver *driver, CComputedString &output, bool keep800x600Ratio=true)
void computeStringInfo (const ucstring &s, CFontGenerator *fontGen, const NLMISC::CRGBA &color, uint32 fontSize, IDriver *driver, CComputedString &output, bool keep800x600Ratio=true)
void dumpCache (const char *filename)
std::string getCacheInformation () const
CMaterial * getFontMaterial ()
uint32 getMaxMemory () const
void setMaxMemory (uint32 mem)

Private Attributes

CMaterial * _MatFont
uint32 _MaxMemory
uint32 _MemSize
uint32 _NbChar
CTextureFont * _TexFont
+

Constructor & Destructor Documentation

+

+ + + + +
+ + + + + + + + + +
NL3D::CFontManager::CFontManager (   )  [inline]
+
+ + + + + +
+   + + +

+Default constructor +

+Definition at line 76 of file font_manager.h. +

+References _MatFont, _MaxMemory, _MemSize, _NbChar, and _TexFont. +

+

00077         {
+00078                 _MemSize = 0;
+00079                 _MaxMemory = 1000000;
+00080                 _NbChar = 0;
+00081                 _MatFont = NULL;
+00082                 _TexFont = NULL;
+00083         }
+
+

Member Function Documentation

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void NL3D::CFontManager::computeString ( const ucstring &  s,
CFontGenerator *  fontGen,
const NLMISC::CRGBA &  color,
uint32  fontSize,
IDriver *  driver,
CComputedString &  output,
bool  keep800x600Ratio = true
) 
+
+ + + + + +
+   + + +

+Same as computeString but works with a unicode string (ucstring) +

+Definition at line 88 of file font_manager.cpp. +

+References NL3D::CTextureFont::SLetterInfo::AdvX, NL3D::CTextureFont::SLetterKey::Char, NL3D::CTextureFont::SLetterInfo::CharHeight, NL3D::CTextureFont::SLetterInfo::CharWidth, NL3D::CComputedString::Color, NL3D::CTextureFont::SLetterKey::FontGenerator, getFontMaterial(), NLMISC::CBitmap::getHeight(), NL3D::CTextureFont::getLetterInfo(), NL3D::CMaterial::getTexture(), NLMISC::CBitmap::getWidth(), NL3D::IDriver::getWindowSize(), height, NL3D::CTextureFont::SLetterInfo::Left, NL3D::CComputedString::Material, min, s, NL3D::CVertexBuffer::setNumVertices(), NL3D::CVertexBuffer::setTexCoord(), NL3D::CVertexBuffer::setVertexCoord(), sint32, NL3D::CTextureFont::SLetterKey::Size, NL3D::CComputedString::StringHeight, NL3D::CComputedString::StringLine, NL3D::CComputedString::StringWidth, NL3D::CTextureFont::SLetterInfo::Top, NL3D::CTextureFont::SLetterInfo::U, uint, uint32, NL3D::CTextureFont::SLetterInfo::V, NL3D::CComputedString::Vertices, width, NL3D::CComputedString::XMax, NL3D::CComputedString::XMin, NL3D::CComputedString::ZMax, and NL3D::CComputedString::ZMin. +

+

00095 {
+00096         output.Color = color;
+00097 
+00098         // resize fontSize if window not of 800x600.
+00099         if (keep800x600Ratio)
+00100         {
+00101                 uint32 width, height;
+00102                 driver->getWindowSize (width, height);
+00103                 if ((height == 0) || (width == 0))
+00104                         return;
+00105                 
+00106                 // keep the 800*600 ratio
+00107                 fontSize = (uint32)floor(fontSize*height/600.f);
+00108                 fontSize = max(fontSize, (uint32)2);
+00109         }
+00110 
+00111         // Setting vertices format
+00112         output.Vertices.setNumVertices (4 * s.size());
+00113 
+00114         // 1 character <-> 1 quad
+00115         sint32 penx = 0, dx;
+00116         sint32 penz = 0, dz;
+00117         float x1, z1, x2, z2;
+00118         float u1, v1, u2, v2;
+00119         CMaterial               *pMatFont = getFontMaterial();
+00120         CTextureFont    *pTexFont = (CTextureFont*)(pMatFont->getTexture (0));
+00121         float TexRatioW = 1.0f / pTexFont->getWidth();
+00122         float TexRatioH = 1.0f / pTexFont->getHeight();
+00123         /*float hlfPixTexW = 0.5f * TexRatioW;
+00124         float hlfPixTexH = 0.5f * TexRatioH;
+00125         float hlfPixScrW = 0.5f;
+00126         float hlfPixScrH = 0.5f;*/
+00127         // Yoyo: Do not need Half Pixel/Texel displacement!!
+00128         float hlfPixTexW = 0;
+00129         float hlfPixTexH = 0;
+00130         float hlfPixScrW = 0;
+00131         float hlfPixScrH = 0;
+00132 
+00133 
+00134         CTextureFont::SLetterKey k;
+00135 
+00136         // string bound.
+00137         output.XMin= FLT_MAX;
+00138         output.XMax= -FLT_MAX;
+00139         output.ZMin= FLT_MAX;
+00140         output.ZMax= -FLT_MAX;
+00141 
+00142         // string info.
+00143         sint32 nMaxZ = -1000000, nMinZ = 1000000;
+00144         output.StringHeight = 0;
+00145 
+00146         // For all chats
+00147         uint j = 0;
+00148         for (uint i = 0; i < s.size(); i++)
+00149         {
+00150                 // Creating font
+00151                 k.Char = s[i];
+00152                 k.FontGenerator = fontGen;
+00153                 k.Size = fontSize;
+00154                 CTextureFont::SLetterInfo *pLI = pTexFont->getLetterInfo (k);
+00155                 if(pLI != NULL)
+00156                 {
+00157                         if ((pLI->CharWidth > 0) && (pLI->CharHeight > 0))
+00158                         {
+00159                                 // Creating vertices
+00160                                 dx = pLI->Left;
+00161                                 dz = -((sint32)pLI->CharHeight-(sint32)(pLI->Top));
+00162                                 u1 = pLI->U - hlfPixTexW;
+00163                                 v1 = pLI->V - hlfPixTexH;
+00164                                 u2 = pLI->U + ((float)pLI->CharWidth) * TexRatioW + hlfPixTexW;
+00165                                 v2 = pLI->V + ((float)pLI->CharHeight) * TexRatioH + hlfPixTexH;
+00166 
+00167                                 x1 = (penx + dx) - hlfPixScrW;
+00168                                 z1 = (penz + dz) - hlfPixScrH;
+00169                                 x2 = (penx + dx + (sint32)pLI->CharWidth)  + hlfPixScrW;
+00170                                 z2 = (penz + dz + (sint32)pLI->CharHeight) + hlfPixScrH;
+00171 
+00172                                 output.Vertices.setVertexCoord  (j, x1, 0, z1);
+00173                                 output.Vertices.setTexCoord             (j, 0, u1, v2);
+00174                                 ++j;
+00175 
+00176                                 output.Vertices.setVertexCoord  (j, x2, 0, z1);
+00177                                 output.Vertices.setTexCoord             (j, 0, u2, v2);
+00178                                 ++j;
+00179 
+00180                                 output.Vertices.setVertexCoord  (j, x2, 0, z2); 
+00181                                 output.Vertices.setTexCoord             (j, 0, u2, v1);
+00182                                 ++j;
+00183 
+00184                                 output.Vertices.setVertexCoord  (j, x1, 0, z2); 
+00185                                 output.Vertices.setTexCoord             (j, 0, u1, v1);
+00186                                 ++j;
+00187                                 
+00188                                 // String Bound
+00189                                 output.XMin= min(output.XMin, x1);
+00190                                 output.XMin= min(output.XMin, x2);
+00191                                 output.XMax= max(output.XMax, x1);
+00192                                 output.XMax= max(output.XMax, x2);
+00193                                 output.ZMin= min(output.ZMin, z1);
+00194                                 output.ZMin= min(output.ZMin, z2);
+00195                                 output.ZMax= max(output.ZMax, z1);
+00196                                 output.ZMax= max(output.ZMax, z2);
+00197 
+00198                                 // String info
+00199                                 sint32  nZ1 = (sint32)pLI->Top-(sint32)pLI->CharHeight;
+00200                                 sint32  nZ2 = pLI->Top;
+00201                                 
+00202                                 if (nZ1 < nMinZ) nMinZ = nZ1;
+00203                                 if (nZ2 > nMaxZ) nMaxZ = nZ2;
+00204                         }
+00205                         penx += pLI->AdvX;
+00206                 }
+00207 
+00208                 // Building Material
+00209                 output.Material = pMatFont;
+00210         }
+00211         output.Vertices.setNumVertices (j);
+00212 
+00213         // compile string info
+00214         output.StringWidth = (float)penx;
+00215         if(nMaxZ>nMinZ)
+00216         {
+00217                 output.StringHeight = (float)(nMaxZ - nMinZ);
+00218                 output.StringLine = -(float)nMinZ;
+00219         }
+00220         else
+00221         {
+00222                 output.StringHeight = 0;
+00223                 output.StringLine = 0;
+00224         }
+00225 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void NL3D::CFontManager::computeString ( const std::string &  s,
CFontGenerator *  fontGen,
const NLMISC::CRGBA &  color,
uint32  fontSize,
IDriver *  driver,
CComputedString &  output,
bool  keep800x600Ratio = true
) 
+
+ + + + + +
+   + + +

+Compute primitive blocks and materials of each character of the string.

Parameters:
+ + + + + + + + +
s string to compute
fontGen font generator
color primitive blocks color
fontSize font size
desc display descriptor (screen size, font ratio)
output computed string
keep800x600Ratio true if you want that CFontManager look at Driver window size, and resize fontSize so it keeps same size...
+
+ +

+Definition at line 72 of file font_manager.cpp. +

+References s, and uint32. +

+Referenced by NL3D::CTextContext::computeString(), NL3D::CTextContext::printAt(), NL3D::CTextContext::printfAt(), and NL3D::CTextContext::textPush(). +

+

00079 {
+00080         // static to avoid reallocation
+00081         static ucstring ucs;
+00082         ucs= s;
+00083         computeString(ucs, fontGen, color, fontSize, driver, output, keep800x600Ratio);
+00084 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void NL3D::CFontManager::computeStringInfo ( const ucstring &  s,
CFontGenerator *  fontGen,
const NLMISC::CRGBA &  color,
uint32  fontSize,
IDriver *  driver,
CComputedString &  output,
bool  keep800x600Ratio = true
) 
+
+ + + + + +
+   + + +

+Same as computeString but do not make vertex buffers and primitives +

+Definition at line 229 of file font_manager.cpp. +

+References NL3D::CTextureFont::SLetterInfo::AdvX, NL3D::CTextureFont::SLetterKey::Char, NL3D::CTextureFont::SLetterInfo::CharHeight, NL3D::CTextureFont::SLetterInfo::CharWidth, NL3D::CComputedString::Color, NL3D::CTextureFont::SLetterKey::FontGenerator, getFontMaterial(), NL3D::CTextureFont::getLetterInfo(), NL3D::CMaterial::getTexture(), NL3D::IDriver::getWindowSize(), height, s, sint32, NL3D::CTextureFont::SLetterKey::Size, NL3D::CComputedString::StringHeight, NL3D::CComputedString::StringLine, NL3D::CComputedString::StringWidth, NL3D::CTextureFont::SLetterInfo::Top, uint, uint32, and width. +

+Referenced by NL3D::CTextContext::computeStringInfo(). +

+

00236 {
+00237         output.Color = color;
+00238 
+00239         // resize fontSize if window not of 800x600.
+00240         if (keep800x600Ratio)
+00241         {
+00242                 uint32 width, height;
+00243                 driver->getWindowSize (width, height);
+00244                 if ((height == 0) || (width == 0))
+00245                         return;
+00246                 // keep the 800*600 ratio
+00247                 fontSize = (uint32)floor(fontSize*height/600.f);
+00248                 fontSize = max(fontSize, (uint32)2);
+00249         }
+00250         
+00251         sint32 penx = 0;
+00252         sint32 nMaxZ = -1000000, nMinZ = 1000000;
+00253         CMaterial               *pMatFont = getFontMaterial();
+00254         CTextureFont    *pTexFont = (CTextureFont*)(pMatFont->getTexture (0));
+00255 
+00256         CTextureFont::SLetterKey k;
+00257         CTextureFont::SLetterInfo *pLI;
+00258 
+00259         for (uint i = 0; i < s.size(); i++)
+00260         {
+00261                 // Creating font
+00262                 k.Char = s[i];
+00263                 k.FontGenerator = fontGen;
+00264                 k.Size = fontSize;
+00265                 pLI = pTexFont->getLetterInfo (k);
+00266                 if(pLI != NULL)
+00267                 {
+00268                         if ((pLI->CharWidth > 0) && (pLI->CharHeight > 0))
+00269                         {
+00270                                 // String info
+00271                                 sint32  nZ1 = (sint32)pLI->Top-(sint32)pLI->CharHeight;
+00272                                 sint32  nZ2 = pLI->Top;
+00273                                 
+00274                                 if (nZ1 < nMinZ) nMinZ = nZ1;
+00275                                 if (nZ2 > nMaxZ) nMaxZ = nZ2;
+00276                         }
+00277                         penx += pLI->AdvX;
+00278                 }
+00279         }
+00280 
+00281         // compile string info
+00282         output.StringWidth = (float)penx;
+00283         if(nMaxZ>nMinZ)
+00284         {
+00285                 output.StringHeight = (float)(nMaxZ - nMinZ);
+00286                 output.StringLine = -(float)nMinZ;
+00287         }
+00288         else
+00289         {
+00290                 output.StringHeight = 0;
+00291                 output.StringLine = 0;
+00292         }
+00293 
+00294 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CFontManager::dumpCache ( const char *  filename  )  [inline]
+
+ + + + + +
+   + + +

+ +

+Definition at line 154 of file font_manager.h. +

+References _TexFont, and NL3D::CTextureFont::dumpTextureFont(). +

+Referenced by NL3D::CTextContext::dumpCache(). +

+

00155         {
+00156                 _TexFont->dumpTextureFont (filename);
+00157         }
+
+

+ + + + +
+ + + + + + + + + +
string NL3D::CFontManager::getCacheInformation (   )  const
+
+ + + + + +
+   + + +

+return a string given information about the cache +

+Definition at line 298 of file font_manager.cpp. +

+References _MaxMemory, _MemSize, _NbChar, and NLMISC::toString(). +

+Referenced by NL3D::CDriverUser::getFontManagerCacheInformation(). +

+

00299 {
+00300 //      stringstream ss;
+00301 //      ss << "MaxMemory: " << (uint) _MaxMemory << " MemSize: " << (uint) _MemSize << " NbChar: " << (uint) _NbChar;
+00302 //      return ss.str();
+00303         string str;
+00304         str = "MaxMemory: " + NLMISC::toString(_MaxMemory) + " MemSize: " + NLMISC::toString(_MemSize) + " NbChar: " + NLMISC::toString(_NbChar);
+00305         return str;
+00306 }
+
+

+ + + + +
+ + + + + + + + + +
CMaterial * NL3D::CFontManager::getFontMaterial (   ) 
+
+ + + + + +
+   + + +

+manages fonts in memory using CSmartPtr

Parameters:
+ + +
character descriptor
+
+
Returns:
CSmartPtr to a font texture
+ +

+Definition at line 49 of file font_manager.cpp. +

+References _MatFont, _TexFont, NL3D::CMaterial::initUnlit(), NL3D::CMaterial::setBlend(), NL3D::CMaterial::setDstBlend(), NL3D::CMaterial::setSrcBlend(), NL3D::CMaterial::setTexture(), NL3D::CMaterial::texEnvArg0RGB(), and NL3D::CMaterial::texEnvOpRGB(). +

+Referenced by computeString(), computeStringInfo(), NL3D::CTextContextUser::flushRenderBuffer(), and NL3D::CTextContextUser::flushRenderBufferUnProjected(). +

+

00050 {
+00051         if (_TexFont == NULL)
+00052         {
+00053                 _TexFont = new CTextureFont;
+00054         }
+00055 
+00056         if (_MatFont == NULL)
+00057         {
+00058                 _MatFont= new CMaterial;
+00059                 _MatFont->initUnlit();
+00060                 _MatFont->setSrcBlend(CMaterial::srcalpha);
+00061                 _MatFont->setDstBlend(CMaterial::invsrcalpha);
+00062                 _MatFont->setBlend(true);
+00063                 _MatFont->setTexture(0, _TexFont);
+00064                 _MatFont->texEnvOpRGB(0, CMaterial::Replace);
+00065                 _MatFont->texEnvArg0RGB(0, CMaterial::Diffuse, CMaterial::SrcColor);
+00066         }
+00067         return _MatFont;
+00068 }
+
+

+ + + + +
+ + + + + + + + + +
uint32 NL3D::CFontManager::getMaxMemory (   )  const [inline]
+
+ + + + + +
+   + + +

+gives maximum memory allowed

Returns:
maximum memory
+ +

+Definition at line 97 of file font_manager.h. +

+References _MaxMemory, and uint32. +

+

00097 { return _MaxMemory; }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CFontManager::setMaxMemory ( uint32  mem  )  [inline]
+
+ + + + + +
+   + + +

+define maximum memory allowed

Parameters:
+ + +
maximum memory
+
+ +

+Definition at line 90 of file font_manager.h. +

+References _MaxMemory, and uint32. +

+Referenced by NL3D::CDriverUser::setFontManagerMaxMemory(). +

+

00090 { _MaxMemory = mem; }
+
+

Field Documentation

+

+ + + + +
+ + +
CMaterial* NL3D::CFontManager::_MatFont [private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 68 of file font_manager.h. +

+Referenced by CFontManager(), and getFontMaterial().

+

+ + + + +
+ + +
uint32 NL3D::CFontManager::_MaxMemory [private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 65 of file font_manager.h. +

+Referenced by CFontManager(), getCacheInformation(), getMaxMemory(), and setMaxMemory().

+

+ + + + +
+ + +
uint32 NL3D::CFontManager::_MemSize [private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 64 of file font_manager.h. +

+Referenced by CFontManager(), and getCacheInformation().

+

+ + + + +
+ + +
uint32 NL3D::CFontManager::_NbChar [private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 66 of file font_manager.h. +

+Referenced by CFontManager(), and getCacheInformation().

+

+ + + + +
+ + +
CTextureFont* NL3D::CFontManager::_TexFont [private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 69 of file font_manager.h. +

+Referenced by CFontManager(), dumpCache(), and getFontMaterial().

+

The documentation for this class was generated from the following files: +
Generated on Tue Mar 16 06:46:58 2004 for NeL by + +doxygen +1.3.6
+ + -- cgit v1.2.1