SFontLoader.cpp

//Licence:   LGPL
//Copyright: Visti Andresen

#include "SFontLoader.h"

#include <iostream>
#include <fstream>

using namespace std;


SFontLoader::SFontLoader()
{
  fontData_ = 0;
  alphaR_ = 0;
  alphaG_ = 0;
  alphaB_ = 0;
  alphaType_ = GREY_COLOUR;
  seperatorR_ = 255;
  seperatorG_ = 0;
  seperatorB_ = 255;
  fontDefinition_ = "!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~";
  for (int i=0; i<256; i++){
    fontGfxTiles[i] = 0;
    charWidth_[i] = -1;
  }
}

SFontLoader::~SFontLoader()
{
  unloadGfx();
}


void SFontLoader::loadFont(const string &name)
{
  unloadGfx();
  
  fontData_ = loadPpm(name, fontDataWidth_, fontDataHeight_);
 
  for (int i=0; i<256; i++){
    fontGfxTiles[i] = 0;
    charWidth_[i] = -1;
  }
  
  
        if (fontData_ !=0){
                findCellSizes();
   
    numberOfCharsInFont_ = fontDefinition_.size();
    
    unsigned char *fontDataBuffer = fontData_;

    while(isSpaceColour(fontDataBuffer)){
      fontDataBuffer+=4;
    }
     findCharWidths(fontDataBuffer);
  
    for (unsigned int i = 0; i!=fontDefinition_.size(); i++){
      unsigned char character = (unsigned char)fontDefinition_[i];
      charWidth_[character] = definitionFontWidths_[i];
      
      fontGfxTiles[character] = 
              (unsigned char*)malloc(fontCellWidth_*fontCellHeight_*4);
      if (fontGfxTiles[character]==0) throw 
                      string("Failed to reserve memory for font data buffer");  
      
      loadCharacter(i, fontDataBuffer, fontGfxTiles[character]);
      
    }
        }
        else throw string("Failed to open font image: ")+name;

}

void SFontLoader::findCharWidths(unsigned char *result)
{
  for (int i = 0; i != numberOfCharsInFont_; i++){
    definitionFontWidths_[i] = 0;
    while(!isSpaceColour(result)){
      result+=4;
      definitionFontWidths_[i]++;
    }
    while(isSpaceColour(result)){
      result+=4;
    }
    definitionFontWidths_[i]--;
  
  }
  
}

void SFontLoader::loadCharacter(unsigned char number,
                                unsigned char *inputData,
                                unsigned char *outputData)
{

  for (int i = 0; i != number; i++){
    while(!isSpaceColour(inputData)){
      inputData+=4;
    }
    while(isSpaceColour(inputData)){
      inputData+=4;
    }
  }
        inputData += fontDataWidth_*4;
        
  memset(outputData, 0, fontCellHeight_*fontCellWidth_*4);
        
        
        unsigned char *inputBuffer = inputData;
        unsigned char *outputBuffer = outputData;
        int width = (int)definitionFontWidths_[number];
  //cout << "p" << fontDataHeight_ << "O" << width << endl;
        for (int y=0; y != fontDataHeight_-1; y++){
                for (int x=0; x != width; x++){
                        *outputBuffer = inputBuffer[0];
                        outputBuffer++;
                        *outputBuffer = inputBuffer[1];
                        outputBuffer++;
                        *outputBuffer = inputBuffer[2];
                        outputBuffer++;
                        *outputBuffer = inputBuffer[3];
                        outputBuffer++;
                        inputBuffer+=4;                 
                }
                inputData += fontDataWidth_*4;
                inputBuffer = inputData;
                outputBuffer = outputData + fontCellWidth_*4*(y+1);
        }
}

void SFontLoader::readNumber(ifstream &file, int &number)
{
        char c[1];
 
        file.read((char*)c,1);
        while ((*c<'0' || *c>'9') && !file.bad()){
                file.read((char*)c,1);
        }
        number =0;
        while ((*c>='0' && *c<='9') && !file.bad()){
                number = number *10 +*c-'0';
                file.read((char*)c,1);
        }
}

unsigned char *SFontLoader::loadPpm(const string &fileName, int &width,
                                    int &height)
{
        unsigned char *result=0, *buf;
        unsigned char id[5];
        int scale=0;
        long count;
        ifstream infile (fileName.c_str(), ifstream::binary);
        if (!infile) throw string("File IO error, could not open ppm file: ")
                      +fileName;
        infile.read((char*)id,2);
        //cout << "starting load of " <<id[0]<<id[1]<<endl;
        if (id[0]=='P' || id[1]=='6') {
                readNumber(infile, width);
                readNumber(infile, height); 
                readNumber(infile, scale);
                cout <<"'"<< width <<"'"<< height<<"'"<<scale<<endl;
    
                if (scale==255){
                        result = (unsigned char*)malloc(width*height*4);
                        if (result!=0){
                                buf=result;
                                for (count=0; count != width*height; count++){
                                        if (infile.bad()) throw string("File IO error");
         
        id[0] =10;
        id[1] =10;
        id[2] =10;
        
                                infile.read((char*)id,3);
          if(infile.gcount() != 3 || infile.eof())
            throw string("Read error in PPM file."); 
                                        buf[0] = id[0];
                                        buf[1] = id[1];
                                        buf[2] = id[2];

          switch (alphaType_){
          case NONE:
            buf[3] = 255;
            break;
          case BLACK_MASK:
            if (id[0] == 0 && id[1] == 0 && id[2] == 0){
              buf[3] = 0;
            }
            else {
              buf[3]= 255;
            }
            break;
          case GREY_COLOUR:
            unsigned int alpha;
            alpha = id[0] + id[1] + id[2];
            alpha /= 3;
            buf[3] = (unsigned char)alpha;
          }
          buf+=4;
            
                                }
                        }
      else throw string ("Out of memory");
                }
    else {
      throw string (
    "SFontloader ppm load only supports ppm images with 256 colours per channel"
      );
    }
        }
        infile.close();
                //memset(result, 255, 64*64*4);
        return result;
}


void SFontLoader::findCellSizes()
{
        int largestWidth=0;
        int currentWidth=0;
        unsigned char *fontData = fontData_+4;
        for (int i=1; i<fontDataWidth_-1; i++){
                if (!isSpaceColour(fontData)){
                        currentWidth++;
                        if (currentWidth > largestWidth){
                                largestWidth = currentWidth;
                        }
                }
                else currentWidth=0;
                fontData+=4;    
        }
        
        fontCellHeight_ = 1;
        while (fontCellHeight_ < fontDataHeight_-1){
                fontCellHeight_*=2;
        }
        fontCellWidth_ = 1;
        while (fontCellWidth_ < largestWidth){
                fontCellWidth_*=2;
        }
}

void SFontLoader::unloadGfx()
{
  if (fontData_ != 0){
    free (fontData_);
    fontData_ = 0;
  }
  
  for (int i=0; i<256; i++){
    if (fontGfxTiles[i] != 0){
      free (fontGfxTiles[i]);
      fontGfxTiles[i] = 0;
    }
    charWidth_[i] = -1;
  }
}

unsigned char *SFontLoader::getDataForCharacter(char character)
{
  return fontGfxTiles[(unsigned char) character];
}

int SFontLoader::getCharacterWidth(char character)
{
  return charWidth_[(unsigned char) character];
}

---