OgreMain/src/OgreFontManager.cpp

   1 /*-------------------------------------------------------------------------
   2 This source file is a part of OGRE
   3 (Object-oriented Graphics Rendering Engine)
   4
   5 For the latest info, see http://www.ogre3d.org/
   6
   7 Copyright (c) 2000-2006 Torus Knot Software Ltd
   8 Also see acknowledgements in Readme.html
   9
  10 This library is free software; you can redistribute it and/or modify it
  11 under the terms of the GNU Lesser General Public License (LGPL) as
  12 published by the Free Software Foundation; either version 2.1 of the
  13 License, or (at your option) any later version.
  14
  15 This library is distributed in the hope that it will be useful, but
  16 WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  17 or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
  18 License for more details.
  19
  20 You should have received a copy of the GNU Lesser General Public License
  21 along with this library; if not, write to the Free Software Foundation,
  22 Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA or go to
  23 http://www.gnu.org/copyleft/lesser.txt
  24 -------------------------------------------------------------------------*/
  25 #include "OgreStableHeaders.h"
  26
  27 #include "OgreFontManager.h"
  28 #include "OgreLogManager.h"
  29 #include "OgreStringConverter.h"
  30 #include "OgreStringVector.h"
  31 #include "OgreException.h"
  32 #include "OgreResourceGroupManager.h"
  33
  34 namespace Ogre
  35 {
  36     //---------------------------------------------------------------------
  37     template<> FontManager * Singleton< FontManager >::ms_Singleton = 0;
  38     FontManager* FontManager::getSingletonPtr(void)
  39     {
  40         return ms_Singleton;
  41     }
  42     FontManager& FontManager::getSingleton(void)
  43     {
  44         assert( ms_Singleton );  return ( *ms_Singleton );
  45     }
  46     //---------------------------------------------------------------------
  47         FontManager::FontManager() : ResourceManager()
  48         {
  49         // Loading order
  50         mLoadOrder = 200.0f;
  51                 // Scripting is supported by this manager
  52                 mScriptPatterns.push_back("*.fontdef");
  53                 // Register scripting with resource group manager
  54                 ResourceGroupManager::getSingleton()._registerScriptLoader(this);
  55
  56                 // Resource type
  57                 mResourceType = "Font";
  58
  59                 // Register with resource group manager
  60                 ResourceGroupManager::getSingleton()._registerResourceManager(mResourceType, this);
  61
  62
  63         }
  64         //---------------------------------------------------------------------
  65         FontManager::~FontManager()
  66         {
  67                 // Unregister with resource group manager
  68                 ResourceGroupManager::getSingleton()._unregisterResourceManager(mResourceType);
  69                 // Unegister scripting with resource group manager
  70                 ResourceGroupManager::getSingleton()._unregisterScriptLoader(this);
  71
  72         }
  73         //---------------------------------------------------------------------
  74         Resource* FontManager::createImpl(const String& name, ResourceHandle handle,
  75                 const String& group, bool isManual, ManualResourceLoader* loader,
  76         const NameValuePairList* params)
  77         {
  78                 return OGRE_NEW Font(this, name, handle, group, isManual, loader);
  79         }
  80         //---------------------------------------------------------------------
  81     void FontManager::parseScript(DataStreamPtr& stream, const String& groupName)
  82     {
  83         String line;
  84         FontPtr pFont;
  85
  86         while( !stream->eof() )
  87         {
  88             line = stream->getLine();
  89             // Ignore blanks & comments
  90             if( !line.length() || line.substr( 0, 2 ) == "//" )
  91             {
  92                 continue;
  93             }
  94             else
  95             {
  96                             if (pFont.isNull())
  97                             {
  98                                     // No current font
  99                                     // So first valid data should be font name
 100                                         if (StringUtil::startsWith(line, "font "))
 101                                         {
 102                                                 // chop off the 'particle_system ' needed by new compilers
 103                                                 line = line.substr(5);
 104                                         }
 105                                     pFont = create(line, groupName);
 106                                         pFont->_notifyOrigin(stream->getName());
 107                                     // Skip to and over next {
 108                     stream->skipLine("{");
 109                             }
 110                             else
 111                             {
 112                                     // Already in font
 113                                     if (line == "}")
 114                                     {
 115                                             // Finished
 116                                             pFont.setNull();
 117                         // NB font isn't loaded until required
 118                                     }
 119                     else
 120                     {
 121                         parseAttribute(line, pFont);
 122                     }
 123                 }
 124             }
 125         }
 126     }
 127     //---------------------------------------------------------------------
 128     void FontManager::parseAttribute(const String& line, FontPtr& pFont)
 129     {
 130         vector<String>::type params = StringUtil::split(line);
 131         String& attrib = params[0];
 132                 StringUtil::toLowerCase(attrib);
 133         if (attrib == "type")
 134         {
 135             // Check params
 136             if (params.size() != 2)
 137             {
 138                 logBadAttrib(line, pFont);
 139                 return;
 140             }
 141             // Set
 142                         StringUtil::toLowerCase(params[1]);
 143             if (params[1] == "truetype")
 144             {
 145                 pFont->setType(FT_TRUETYPE);
 146             }
 147             else
 148             {
 149                 pFont->setType(FT_IMAGE);
 150             }
 151
 152         }
 153         else if (attrib == "source")
 154         {
 155             // Check params
 156             if (params.size() != 2)
 157             {
 158                 logBadAttrib(line, pFont);
 159                 return;
 160             }
 161             // Set
 162             pFont->setSource(params[1]);
 163         }
 164         else if (attrib == "glyph")
 165         {
 166             // Check params
 167             if (params.size() != 6)
 168             {
 169                 logBadAttrib(line, pFont);
 170                 return;
 171             }
 172             // Set
 173                         // Support numeric and character glyph specification
 174                         Font::CodePoint cp;
 175                         if (params[1].at(0) == 'u' && params[1].size() > 1)
 176                         {
 177                                 // Unicode glyph spec
 178                                 String trimmed = params[1].substr(1);
 179                                 cp = StringConverter::parseUnsignedInt(trimmed);
 180                         }
 181                         else
 182                         {
 183                                 // Direct character
 184                                 cp = params[1].at(0);
 185                         }
 186             pFont->setGlyphTexCoords(
 187                 cp,
 188                 StringConverter::parseReal(params[2]),
 189                 StringConverter::parseReal(params[3]),
 190                 StringConverter::parseReal(params[4]),
 191                 StringConverter::parseReal(params[5]), 1.0 ); // assume image is square
 192         }
 193         else if (attrib == "size")
 194         {
 195             // Check params
 196             if (params.size() != 2)
 197             {
 198                 logBadAttrib(line, pFont);
 199                 return;
 200             }
 201             // Set
 202             pFont->setTrueTypeSize(
 203                 StringConverter::parseReal(params[1]) );
 204         }
 205         else if (attrib == "resolution")
 206         {
 207             // Check params
 208             if (params.size() != 2)
 209             {
 210                 logBadAttrib(line, pFont);
 211                 return;
 212             }
 213             // Set
 214             pFont->setTrueTypeResolution(
 215                 (uint)StringConverter::parseReal(params[1]) );
 216         }
 217         else if (attrib == "antialias_colour")
 218         {
 219                 // Check params
 220                 if (params.size() != 2)
 221                 {
 222                 logBadAttrib(line, pFont);
 223                 return;
 224                 }
 225                 // Set
 226             pFont->setAntialiasColour(StringConverter::parseBool(params[1]));
 227         }
 228                 else if (attrib == "code_points")
 229                 {
 230                         for (size_t c = 1; c < params.size(); ++c)
 231                         {
 232                                 String& item = params[c];
 233                                 StringVector itemVec = StringUtil::split(item, "-");
 234                                 if (itemVec.size() == 2)
 235                                 {
 236                                         pFont->addCodePointRange(Font::CodePointRange(
 237                                                 StringConverter::parseLong(itemVec[0]),
 238                                                 StringConverter::parseLong(itemVec[1])));
 239                                 }
 240                         }
 241                 }
 242
 243
 244
 245     }
 246     //---------------------------------------------------------------------
 247     void FontManager::logBadAttrib(const String& line, FontPtr& pFont)
 248     {
 249         LogManager::getSingleton().logMessage("Bad attribute line: " + line +
 250             " in font " + pFont->getName());
 251
 252     }
 253
 254 }