Fonts.cpp

Go to the documentation of this file.

/*
 * Fonts.cpp
 *
 * Part of Fly! Legacy project
 *
 * Copyright 2004 Chris Wallace
 *
 * Fly! Legacy is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 * Fly! Legacy is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 *   along with Fly! Legacy; if not, write to the Free Software
 *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include "../Include/FlyLegacy.h"
#include "../Include/Utility.h"
#include "../Include/Globals.h"
#include <vector>
using namespace std;

//
// CBitmappedFontChar
//
typedef struct {
  int     x, y;
} SFontCharBit;

class CBitmappedFontChar {
public:
  CBitmappedFontChar (void);
  ~CBitmappedFontChar (void);
  
  void SetBit (int x, int y);
  void Draw (SSurface *surface, int x, int y, unsigned int colour);
  int  GetWidth (void);
  int  GetHeight (void);

public:
  unsigned char         ascii;       
  int                   start, end;  
  int                   w, h;        
  vector<SFontCharBit*> bits;        
};

CBitmappedFontChar::CBitmappedFontChar (void)
{
  ascii = 0;
  start = end = 0;
  w = h = 0;
}

CBitmappedFontChar::~CBitmappedFontChar (void)
{
  vector<SFontCharBit*>::iterator i;
  for (i=bits.begin(); i!=bits.end(); i++) {
    SFontCharBit *bit = *i;
    delete bit;
  }
}

void CBitmappedFontChar::SetBit (int x, int y)
{
  SFontCharBit *bit = new SFontCharBit;
  bit->x = x;
  bit->y = y;
  bits.push_back (bit);
}

void CBitmappedFontChar::Draw (SSurface *surface, int x, int y, unsigned int colour)
{
  vector<SFontCharBit*>::iterator i;
  for (i=bits.begin(); i!=bits.end(); i++) {
    SFontCharBit *bit = *i;
    DrawDot (surface, (x + bit->x), (y + bit->y), colour);
  }
}

inline int CBitmappedFontChar::GetWidth (void) { return w; }
inline int CBitmappedFontChar::GetHeight (void) { return h; }



//
// CBitmappedFont
//
// This class represents a Fly! II bitmapped font.  Data members are public for a
//   couple of reasons:
//     - access needed by font utility functions
//     - some default fonts are not loaded from FNT control files, so function
//         init_default_fonts() in Main/Main.cpp initializes the members directly
//
class CBitmappedFont {
public:
  // Constructors
  CBitmappedFont (const char* fntFilename = NULL);
  ~CBitmappedFont (void);

  // CBitmappedFont methods
  int       Load (const char* fntFilename);
  int       LoadRaw (const char* rawFilename);
  bool      IsCharValid (unsigned char c);
  int       MaxCharHeight (void);
  int       MaxCharWidth (void);
  int       TextWidth (const char* text);
  int       TextHeight (const char* text);
  int       CharWidth (unsigned char c);
  int       CharHeight (unsigned char c);
  CBitmappedFontChar *GetAscii (unsigned char c);

public:
  bool   valid;                // Whether the font is valid for use

  char   rawFilename[64];      // Filename of .RAW image data
  int    w, h;                 // RAW image width/height
  int    start, end;           // ASCII character bounds of font data
  unsigned char   transparent;          // Palette index of background
  int    space;                // Width of a space character in pixels
  int    shadow_x, shadow_y;   // Shadow offset x, y

  int    maxCharHeight;
  int    maxCharWidth;
  CBitmappedFontChar  *chars;     // Array of font characters
};


//
// CBitmappedFont
//

CBitmappedFont::CBitmappedFont (const char* fntFilename)
{
  // Initialize
  valid = false;
  strcpy (rawFilename, "");
  w = h = 0;
  start = end = 0;
  transparent = 255;
  space = 0;
  shadow_x = shadow_y = 0;
  chars = NULL;
  maxCharHeight = maxCharWidth = 0;

  // If .FNT filename was supplied, re-initialize from it
  if (fntFilename && (strlen(fntFilename) > 0)) {
    Load (fntFilename);
  }
}

CBitmappedFont::~CBitmappedFont (void)
{
  delete[] chars;
}


/*
 * Load in the details of a bitmapped font from the specified FNT file
 *  Example .FNT file (ART\FTTINY7W.FNT in Startup.pod):

-------- font bitmap name --------
fttiny7w.raw
-------- width, height -----------
126,68
-------- start, end range --------
32,126
-------- transparency index ------
0
-------- space width -------------
2
-------- shadow offset x,y -------
0,0

  */
int CBitmappedFont::Load (const char* fntFilename)
{
  int rc = 0;

  return rc;
}

//
// This method loads the bitmapped font image data from the specified .RAW
//   file.  All relevant members of the class instance must have been
//   initialized before calling this method.
//
int CBitmappedFont::LoadRaw (const char* rawFilename)
{
  int i, j, k, m;
  int rc = 0;

  // Load RAW image data
  PODFILE *pRaw = popen (&globals->pfs, rawFilename);
  if (pRaw != NULL) {
    // Allocate array of font characters
    int nChars = end - start + 1;
    chars = new CBitmappedFontChar[nChars];

    // Declare temporary storage for raw image data
    unsigned char *rawdata = new unsigned char[w * h];
    pread (rawdata, 1, (w * h), pRaw);
    pclose (pRaw);

    int iChar = 0;                // Index of current bitmapped font char
    int iRowStart = 0;            // Index to first char in a pixel row
    int iRowEnd = 0;              // Index to last char in a pixel row
    int iRowCount = 0;            // Pixel row count for each char
    unsigned char *p = rawdata;   // Pointer to next byte of RAW image data
    unsigned char ciHighlight = 0;          // Colour index value for highlight
    bool highlightSet = false;    // Whether highlight colour has been determined yet
    bool done = false;
    for (i=0; (i<h) && !done; i++) {
      // At start of each row, initialize:
      //    - previous colour index to background
      //    - start of char range for row to current char index
      //    - flag to indicate that the next character (if found) is first in the row
      unsigned char ciPrev = transparent;
      bool firstCharInRow = true;
      iChar = iRowStart;

      for (j=0; (j<w) && !done; j++) {
        // Get pixel colour index from raw data
        unsigned char ci = *p;
        p++;

        // Start tests against colour index
        if (ci != transparent) {
          // First check to see if highlight colour has been set.  If not, then
          //   this colour is the highlight colour
          if (!highlightSet) {
            ciHighlight = ci;
            highlightSet = true;
          }

          // Check if this colour is the highlight
          if (ci == ciHighlight) {
            // If the previous colour was background then this is the start of a new
            //   character marker
            if (ciPrev == transparent) {
              if (firstCharInRow) {
                // Start of a new row of highlights.  Set heights of all chars
                //   in the previous row (if applicable) and reset the row
                //   control variables
                for (m=iRowStart; m<iRowEnd; m++) {
                  chars[m].h = iRowCount;
                }

                // Check if all characters have been read
                if (iRowEnd >= nChars) {
                  done = true;
                  break;
                }

                // Initialize control variables for this row of chars
                iRowStart = iRowEnd;
                iRowCount = 0;
                iChar = iRowStart;
                firstCharInRow = false;
              }
              // Set current column as starting column for this character
              chars[iChar].ascii = start + iChar;
              chars[iChar].start = j;
              iRowEnd++;
            }
          } else {
            // Neither background nor highlight, this is a font image bit
            // Check for transition to subsequent char
            for (k = iRowStart; k < iRowEnd; k++) {
              if (j >= chars[k].start) iChar = k;
            }

            // Add bit to char
            if (j > chars[iChar].end) {
              globals->logWarning->Write ("Font bit out of range : %s @ (%d,%d), char=%d",
                rawFilename, j, i, iChar);
            } else {
              chars[iChar].SetBit (j - chars[iChar].start, iRowCount);
            }
          }
        } else {
          // Pixel is transparent (background colour).  If previous pixel was
          //   highlight, then we have just transitioned out of a character marker,
          //   otherwise ignore
          if (ciPrev == ciHighlight) {
            chars[iChar].end = j-1;
            chars[iChar].w = chars[iChar].end - chars[iChar].start + 1;
            iChar++;
            if (iChar > nChars) {
              gtfo ("CBitmappedFont : Font character %d out of range for %s",
                iChar, rawFilename);
            }
          }
        }
        ciPrev = ci;
      } // for j = 0..w

      // Check for highlight that ends at right hand side of image
      if ((ciPrev == ciHighlight) && (iChar < nChars)) {
        chars[iChar].end = j-1;
        chars[iChar].w = chars[iChar].end - chars[iChar].start + 1;
        iChar++;
      }

      if (iRowEnd > nChars) {
        gtfo ("CBitmappedFont : Font character %d out of range for %s",
          iChar, rawFilename);
      }

      iRowCount++;
    } // for i = 0..h

/*
    // DEBUG : Dump font contents to text file
    if (stricmp (rawFilename, "Art\\ftthin24.raw") == 0) {
      FILE *f = fopen ("Debug\\fontdebug.txt", "w");
      for (i=0; i<nChars; i++) {
        CBitmappedFontChar *c = &(chars[i]);
        fprintf (f, "Char : %d\n", c->ascii);
        fprintf (f, "  Columns   :  start=%d\tend=%d\n", c->start, c->end);
        fprintf (f, "  Extents   :  W = %d\tH=%d\n", c->w, c->h);
        fprintf (f, "  Bits (%d) :\n", c->bits.size());
        fprintf (f, "\n");
      }
      fprintf (f, "Rawdata (first 16 bytes) :\n");
      for (j=0; j<16; j++) {
        fprintf (f, "  %02X", rawdata[j]);
      }
      fclose (f);
    }
*/

    delete rawdata;

    rc = 1;
  }

  return rc;
}

inline bool CBitmappedFont::IsCharValid (unsigned char c)
{
  return ((c >= start) && (c <= end));
}

inline int CBitmappedFont::MaxCharHeight (void)
{
  return maxCharHeight;
}

inline int CBitmappedFont::MaxCharWidth (void)
{
  return maxCharWidth;
}

int CBitmappedFont::TextWidth (const char* text)
{
  int rc = 0;

  for (unsigned int i=0; i<strlen(text); i++) {
    // Increment by char length (plus 1 for inter-char space)
    rc += CharWidth (text[i]) + 1;
  }

  return rc;
}

int CBitmappedFont::TextHeight (const char* text)
{
  int rc = 0;

  for (unsigned int i=0; i<strlen(text); i++) {
    int height = CharHeight (text[i]);
    if (height > rc) { rc = height; }
  }

  return rc;
}

int CBitmappedFont::CharWidth (unsigned char c)
{
  int rc = 0;

  if (c == ' ') {
    rc = space;
  } else if (IsCharValid (c)) {
    rc = chars[c - start].w;
  }

  return rc;
}

int CBitmappedFont::CharHeight (unsigned char c)
{
  int rc = 0;

  if (IsCharValid (c)) {
    rc = chars[c - start].h;
  }

  return rc;
}

CBitmappedFontChar *CBitmappedFont::GetAscii (unsigned char c)
{
  CBitmappedFontChar *rc = NULL;

  if (IsCharValid (c)) {
    rc = &(chars[c - start]);
  }

  return rc;
}




typedef struct {
  char      rawFilename[64];
  int       w, h;
  int       start, end;
  int       space;
} SDefaultFont;

SDefaultFont defaultFonts[] =
{
  //     RAW Filename      w       h     start   end    space
  {"ART\\FTASCI10.RAW",   272,    188,    33,    255,     5},
  {"ART\\FTASCM10.RAW",   224,    224,    33,    255,     5},
  {"ART\\FTDIGI9.RAW",     72,    110,    33,    133,     6},
  {"ART\\FTDIGI9B.RAW",    69,     41,    45,     90,     6},
  {"ART\\FTDIGI9D.RAW",    69,     41,    45,     90,     6},
  {"ART\\FTDIGI13.RAW",    97,    130,    33,    134,     8},
  {"ART\\FTDOS12.RAW",    221,     79,    33,    126,     7},
  {"ART\\FTMICRO5.RAW",   100,    100,    33,    126,     4},
  {"ART\\FTMNO14B.RAW",   193,     97,    33,    126,    12},
  {"ART\\FTMONO12.RAW",   222,     79,    33,    126,     7},
  {"ART\\FTNORM14.RAW",   275,    147,    33,    126,    14},
  {"ART\\FTNORM28.RAW",   463,    238,    33,    126,    22},
  {"ART\\FTSMAL10.RAW",   162,     73,    33,    127,     8},
  {"ART\\FTTHIN24.RAW",   215,    151,    33,    126,     6},
  {"ART\\FTTINY7.RAW",    126,     68,   33,     126,     5},
  {"ART\\FTTINY7W.RAW",   126,     68,   33,     126,     5},
};


//
// Load the bitmapped font.  The font->fontName attribute of the SFont struct
//   must be populated with the name of the .RAW font image data, including
//   the pod filesystem path name (typically ART\\)
//
// Return code:
//  0 (false) = Error encountered during font loading
//  1 (true)  = Font loaded successfully
//
int LoadFont (SFont *font)
{
  int i;
  int rc = 0;

  if (font == NULL) return rc;

  // Initialize *font member of SFont class
  font->font = NULL;

  // If this is a default font, create "empty" CBitmappedFont class instance,
  //   populate the members from the predefined table above, and load
  //   the RAW data.
  int nDefaultFonts = sizeof(defaultFonts) / sizeof (SDefaultFont);
  for (i=0; i<nDefaultFonts; i++) {
    SDefaultFont *d = &(defaultFonts[i]);
    if (stricmp (d->rawFilename, font->fontName) == 0) {
      // Instantiate blank SBitmappedFont
      CBitmappedFont *newfont = new CBitmappedFont ();

      // Populate with required data
      strcpy (newfont->rawFilename, font->fontName);
      newfont->w = d->w;
      newfont->h = d->h;
      newfont->start = d->start;
      newfont->end = d->end;
      newfont->space = d->space;

      // Store CBitmappedFont pointer in return struct
      font->font = newfont;
      
      // Load image data for font
      newfont->LoadRaw (font->fontName);
      rc = 1;
      break;
    }
  }

  if (font->font == NULL) {
  }

  return rc;
}


//
// Unload (free) a font when it is no longer needed
//
void FreeFont (SFont *font)
{
  if (font == NULL) return;
  CBitmappedFont *f = (CBitmappedFont *)font->font;
  delete f;
  font->font = NULL;
}

void DrawChar (SSurface *surface, SFont *font,
               int x, int y, unsigned int rgbColour,
               char ascii)
{
  if (font == NULL) return;
  if (font->font == NULL) return;

  CBitmappedFont *f = (CBitmappedFont *)(font->font);
  CBitmappedFontChar *fc = f->GetAscii (ascii);
  if (fc != NULL) {
    fc->Draw (surface, x, y, rgbColour);
  }
}

//
// Render bitmapped text onto the drawing surface using the specified font.
//   The text is left-justified with the upper-left corner at surface offset (x,y)
//
void DrawText (SSurface *surface, SFont *font,
               int x, int y, unsigned int rgbColour,
               const char* text)
{
  if (font == NULL) return;
  if (font->font == NULL) return;

  CBitmappedFont *f = (CBitmappedFont *)(font->font);
  for (unsigned int i=0; i<strlen(text); i++) {
    unsigned char ascii = text[i];
    if (ascii == 0x20) {
      x += f->space;
    } else {
      CBitmappedFontChar *fc = f->GetAscii (ascii);
      if (fc != NULL) {
        fc->Draw (surface, x, y, rgbColour);
        x += fc->GetWidth () + 1;
      }
    }
  }
}

//
// Render bitmapped text onto the drawing surface using the specified font.
//   The text is centered with the top-center at surface offset (x,y)
//
void DrawTextC (SSurface *surface, SFont *font,
                int x, int y, unsigned int rgbColour,
                const char* text)
{
  if (font == NULL) return;
  if (font->font == NULL) return;

  // Adjust x-offset by half of string length and call DrawText
  CBitmappedFont *f = (CBitmappedFont *)(font->font);
  int offset = f->TextWidth (text) / 2;
  DrawText (surface, font, (x - offset), y, rgbColour, text);
}

//
// Render bitmapped text onto the drawing surface using the specified font.
//   The text is left-justified with the top-right corner at surface offset (x,y)
//
void DrawTextR (SSurface *surface, SFont *font,
                int x, int y, unsigned int rgbColour,
                const char* text)
{
  if (font == NULL) return;
  if (font->font == NULL) return;

  // Adjust x-offset for string length and call DrawText
  CBitmappedFont *f = (CBitmappedFont *)(font->font);
  int offset = f->TextWidth (text);
  DrawText (surface, font, (x - offset), y, rgbColour, text);
}


//
// Returns the height (in pixels) of the specified character string (i.e. the
//   height of the tallest character in the string)
//
int TextHeight(SFont *font, const char *text)
{
  int rc = 0;

  if (font != NULL) {
    if (font->font != NULL) {
      CBitmappedFont *f = (CBitmappedFont *)(font->font);
      rc = f->TextHeight (text);
    }
  }

  return rc;
}


//
// Return the width (in pixels) of the specified character string
//
int TextWidth(SFont *font, const char *text)
{
  int rc = 0;

  if (font != NULL) {
    if (font->font != NULL) {
      CBitmappedFont *f = (CBitmappedFont *)(font->font);
      rc = f->TextWidth (text);
    }
  }
  return rc;
}

//
// Return the height of the specified character in the bitmapped font
//
int CharHeight(SFont *font, char c)
{
  int rc = 0;

  if (font != NULL) {
    if (font->font != NULL) {
      CBitmappedFont *f = (CBitmappedFont *)(font->font);
      rc = f->CharHeight (c);
    }
  }
  return rc;
}


//
// Return the width (in pixels) of the specified character in the bitmapped font
//
int CharWidth(SFont *font, char c)
{
  int rc = 0;

  if (font != NULL) {
    if (font->font != NULL) {
      CBitmappedFont *f = (CBitmappedFont *)(font->font);
      rc = f->CharWidth (c);
    }
  }
  return rc;
}


//
// Return the maximum character height (in pixels) for all defined characters
//   in the bitmapped font
//
int MaxCharHeight(SFont *font)
{
  int rc = 0;

  if (font != NULL) {
    if (font->font != NULL) {
      CBitmappedFont *f = (CBitmappedFont *)(font->font);
      rc = f->MaxCharHeight();
    }
  }

  return rc;
}


//
// Return the maximum character width (in pixels) for all defined characters
//   in the bitmapped font
//
int MaxCharWidth(SFont *font)
{
  int rc = 0;

  if (font != NULL) {
    if (font->font != NULL) {
      CBitmappedFont *f = (CBitmappedFont *)(font->font);
      rc = f->MaxCharWidth ();
    }
  }

  return rc;
}

Documentation generated by