SFontLoader.h

#ifndef MOD_SFONTLOADER_H
#define MOD_SFONTLOADER_H

//Licence:   LGPL
//Copyright: Visti Andresen

#include <string>

using namespace std;
/**A class for loading a SFont stored in a .ppm image.*/
class SFontLoader
{
  public:
  /**An enum defining the way to obtain alpha data from the ppm image*/
  enum AlphaLoadingType{
  /**Don't fake an alpha channel.*/
  NONE,
  /**Every thing black is transparent (colour is actually definable).*/
  BLACK_MASK,
  /**Use the grey (r+g+b)/3 value as alpha 0 is 100% transparent.*/
  GREY_COLOUR
  };

  SFontLoader();
  ~SFontLoader();

  /**Load a font .ppm file (may contain path).*/
  void loadFont(const string &name);

  /**Sets the way to get the alpha channel when load is called, default is 
  GREY_COLOUR.*/
  void setAlphaLoadingType(AlphaLoadingType type){alphaType_ = type;}
  /**Sets the alpha colour to use with alphaType=BLACK_MASK, default 0,0,0.*/
  void setAlpha(unsigned char r, unsigned char g, unsigned char b);
  /**Sets the colour used to separate characters in the SFont file, default
  255,0,255.*/
  void setSeperatorColour(unsigned char r, unsigned char g, unsigned char b);

  /**Sets the fontDefinition to use for the next loadFont

  fontDefinition is a string containing the letters in the SFont.*/
  void setFontDefinition(const string &definition)
                                            {fontDefinition_ = definition;}

  /**Returns a pointer to a raw image of a character, the format is
  RBGA and the width and height can be found using
  getFontWidth() and getFontHeight().*/
  unsigned char *getDataForCharacter(char character);

  /**Returns the width of a specific character  <=getFontWidth() (in pixels).*/
  int getCharacterWidth(char character);
  /**Returns the height of the font  <=getFontHeight() (in pixels).*/
  int getCharacterHeight(){return fontDataHeight_-1;}
  /**Returns the height of a character data image (in pixels). Always = 2^n*/
  int getFontHeight(){return fontCellHeight_;}
  /**Returns the width of a character data image (in pixels).  Always = 2^m*/
  int getFontWidth(){return fontCellWidth_;}
  
  private:
  void findCharWidths(unsigned char *result);
  void unloadGfx();
  void loadCharacter(unsigned char number, unsigned char *inputData,
                     unsigned char *outputData);
  void readNumber(ifstream &file, int &number);
  unsigned char *loadPpm(const string &fileName, int &width, int &height);
  void findCellSizes();
  inline bool isSpaceColour(unsigned char* data);
  
  unsigned char alphaR_, alphaG_, alphaB_;
  unsigned char seperatorR_, seperatorG_, seperatorB_;
  AlphaLoadingType alphaType_;
  string fontDefinition_;
  
  unsigned char *fontData_;
  int fontCellHeight_;
  int fontDataHeight_;
  int fontCellWidth_;
  int fontDataWidth_;
  
  unsigned char * fontGfxTiles[256];
  int charWidth_[256];
  int definitionFontWidths_[256];
  int numberOfCharsInFont_;
};

bool SFontLoader::isSpaceColour(unsigned char* data)
{
        return (seperatorR_ == data[0] && seperatorG_ == data[1] &&
          seperatorB_ == data[2]);
}



#endif

---