Bitmaps.cpp

Go to the documentation of this file.

/*
 * Bitmaps.cpp
 *
 * Part of Fly! Legacy project
 *
 * Copyright 2003 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/Globals.h"
#include "../Include/FlyLegacy.h"
#include <vector>
using namespace std;


/*
 * Drawing Primitives
 *
 */

//
// Create a new drawing surface.  In Fly! II, drawing surfaces were RGB
//   arrays where one specific pixel colour value represented transparency,
//   usually <0, 0, 0>.  The xSpan field ensured that the first pixel
//   of each row was longword aligned, by padding each row of RGB values
//   to the next longword boundary.
//
// Legacy surfaces are RGBA arrays, so each pixel is assigned 
//   its transparency level.  This provides more flexibility for
//   implementing alpha-blended surfaces.  The xSpan field is not
//   really needed, but is kept for backwards compatibility with
//   Fly! II DLLs.
//
// Surface image data is oriented starting at the lower-left corner,
//   with pixels increasing towards the right, then row-wise towards
//   the top.
//
SSurface* CreateSurface(int width, int height)
{
  SSurface *surf = new SSurface;

  surf->xScreen = 0;
  surf->yScreen = 0;
  surf->xSize = width;
  surf->ySize = height;
  surf->xSpan = width;
  surf->drawBuffer = new unsigned int[width * height];

  return surf;
}

void  FreeSurface(SSurface *surface)
{
  if (surface != NULL) {
    if (surface->drawBuffer != NULL) delete surface->drawBuffer;
    delete surface;
  }
}

void  EraseSurface(SSurface *surface)
{
  EraseSurfaceRGBA (surface, 0);
}

void  EraseSurfaceRGB(SSurface *surface, unsigned int rgb)
{
  EraseSurfaceRGBA (surface, rgb | (0xff << 24));
}

void  EraseSurfaceRGBA(SSurface *surface, unsigned int rgba)
{
  if (surface != NULL) {
    int nPixels = (surface->xSpan * surface->ySize);
    for (int i=0; i<nPixels; i++) {
      surface->drawBuffer[i] = rgba;
    }
  }
}

GLuint TextureFromSurface (SSurface *s, bool mipmap)
{
  GLuint texid = 0;

  // Check that surface is square and a power of two in size
  if ((s->xSize) == (s->ySize)) {
    // Create a GL texture
    glGenTextures (1, &texid);
    glBindTexture (GL_TEXTURE_2D, texid);
    glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);

    GLenum format = GL_RGBA;
    int depth = 4;
    GLubyte *image = (unsigned char*)(s->drawBuffer);

    if (mipmap) {
      // Generate mipmapped texture
      glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
      glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);

      gluBuild2DMipmaps (GL_TEXTURE_2D, depth, s->xSize, s->ySize, format,
        GL_UNSIGNED_BYTE, image);
    } else {
      // Generate non-mipmapped texture
      glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
      glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

      glTexImage2D (GL_TEXTURE_2D, 0, format, s->xSize, s->ySize, 0,
        format, GL_UNSIGNED_BYTE, image);
    }
  }

  return texid;
}

//
// Draw a single pixel in the drawing surface to the specified colour
//   (x,y) are relative to the top-left corner of the surface, increasing
//   to the right and down
//
void  DrawDot(SSurface *surface, int x, int y, unsigned int rgba)
{
  if (surface != NULL) {
    // Clip to surface boundaries
    if ((x >= 0) &&
        (y >= 0) &&
        (x < (int)surface->xSize) &&
        (y < (int)surface->ySize))
    {
      y = surface->ySize - y - 1;
      int offset = ((y * surface->xSpan) + x);
      surface->drawBuffer[offset] = rgba;
    }
  }
}

//
// Draw a continuous line segment starting at (and including) (x1, y1) and
//   ending at (and including) (x2, y2).  This is an implementation of
//   Bresenham's algorithm.
//
void  DrawLine(SSurface *surface, int x1, int y1, int x2, int y2, unsigned int rgba)
{
  // First calculate delta in x and y endpoints
  int dx = x2 - x1;
  int dy = y2 - y1;

  // Check for special cases
  if ((dx == 0) && (dy == 0)) {
    // Coincident endpoints
    DrawDot (surface, x1, y1, rgba);
  } else if (dx == 0) {
    // Vertical line, draw from top to bottom
    int yStart, yEnd;
    if (dy > 0) {
      yStart = y1;
      yEnd = y2;
    } else {
      yStart = y2;
      yEnd = y1;
    }
    for (int y=yStart; y<=yEnd; y++) {
      DrawDot (surface, x1, y, rgba);
    }
  } else if (dy == 0) {
    // Horizontal line, draw left to right
    int xStart, xEnd;
    if (dx > 0) {
      xStart = x1;
      xEnd = x2;
    } else {
      xStart = x2;
      xEnd = x1;
    }
    for (int x=xStart; x<=xEnd; x++) {
      DrawDot (surface, x, y1, rgba);
    }
  } else {
    // Determine whether to step in x-direction or y-direction
    if (abs(dx) >= abs(dy)) {
      // Step in x direction
      // First endpoint must be the leftmost
      if (x1 > x2) {
        DrawLine (surface, x2, y2, x1, y1, rgba);
        return;
      }

      // Adjust y-increment for negatively sloped lines
      int slope;
      if (dy < 0) {
        slope = -1;
        dy = -dy;
      } else {
        slope = 1;
      }

      // Calculate constants for Bresenham's algorithm
      int incE = 2 * dy;
      int incNE = (2 * dy) - (2 * dx);
      int d = (2 * dy) - dx;
      int y = y1;
  
      // Step through each x-coordinate, drawing the appropriate pixels
      for (int x=x1; x<=x2; x++) {
        DrawDot (surface, x, y, rgba);
        if (d <= 0) {
          d += incE;
        } else {
          d += incNE;
          y += slope;
        }
      }
    } else {
      // Step in y direction
      // First endpoint must be the topmost
      if (y1 > y2) {
        DrawLine (surface, x2, y2, x1, y1, rgba);
        return;
      }

      // Adjust x-increment for negatively sloped lines
      int slope;
      if (dx < 0) {
        slope = -1;
        dx = -dx;
      } else {
        slope = 1;
      }

      // Calculate constants for Bresenham's algorithm
      int incE = 2 * dx;
      int incNE = (2 * dx) - (2 * dy);
      int d = (2 * dx) - dy;
      int x = x1;
  
      // Step through each y-coordinate, drawing the appropriate pixels
      for (int y=y1; y<=y2; y++) {
        DrawDot (surface, x, y, rgba);
        if (d <= 0) {
          d += incE;
        } else {
          d += incNE;
          x += slope;
        }
      }
    }
  }
}


//
// Draw an unfilled rectangle with corners (x1, y1) and (x2, y2).
//
void  DrawRect(SSurface *surface, int x1, int y1, int x2, int y2, unsigned int rgba)
{
  DrawLine (surface, x1, y1, x2, y1, rgba);     // Top
  DrawLine (surface, x2, y1, x2, y2, rgba);     // Right
  DrawLine (surface, x2, y2, x1, y2, rgba);     // Bottom
  DrawLine (surface, x1, y2, x1, y1, rgba);     // Left
}

//
// Draw a filled rectangle with corners (x1, y1) and (x2, y2).  The sides of
//   the rectangle must be parallel to the axes (sides) of the surface
//
void  FillRect(SSurface *surface, int x1, int y1, int x2, int y2, unsigned int rgba)
{
  // x1, y1 must be the top coordinate
  int height = (y2 - y1);
  if (height < 0) {
    FillRect (surface, x2, y2, x1, y1, rgba);
  } else {
    for (int row=0; row<height; row++) {
      DrawLine (surface, x1, y1 + row, x2, y1 + row, rgba);
    }
  }
}

void  DrawCircle(SSurface *surface, int xCenter, int yCenter, int radius, unsigned int rgba)
{
}

unsigned int  MakeRGB(unsigned int r, unsigned int g, unsigned int b)
{
  return (r << 0) + (g << 8) + (b << 16) + (0xff << 24);
}

unsigned int  MakeRGBA(unsigned int r, unsigned int g, unsigned int b, unsigned int a)
{
  return (r << 0) + (g << 8) + (b << 16) + (a << 24);
}

void UnmakeRGB (unsigned int rgb, unsigned int *r, unsigned int *g, unsigned int *b)
{
  *r =  rgb & 0x000000FF;
  *g = (rgb & 0x0000FF00) >> 8;
  *b = (rgb & 0x00FF0000) >> 16;
}


void  Blit(SSurface *surface)
{
  // Save alpha state and enable it
  glPushAttrib (GL_ENABLE_BIT);
  glDisable (GL_ALPHA_TEST);
  glDisable (GL_LIGHTING);

  glDrawBuffer (GL_BACK);
  glDrawPixels (surface->xSize, surface->ySize,
    GL_RGBA,
    GL_UNSIGNED_BYTE,
    surface->drawBuffer);

  // Restore alpha state
  glPopAttrib ();
}

void  BlitTransparent(SSurface *surface, unsigned int rgbTransparentColor)
{
  // Save alpha state and enable it
  glPushAttrib (GL_ENABLE_BIT);
  glEnable (GL_ALPHA_TEST);
  glDisable (GL_LIGHTING);

  glDrawBuffer (GL_BACK);
  glDrawPixels (surface->xSize, surface->ySize,
    GL_RGBA,
    GL_UNSIGNED_BYTE,
    surface->drawBuffer);

  // Restore alpha state
  glPopAttrib ();
}


/*
 * Font Primitives
 *

  int APILoadFont(SFont *font);
  void  APIFreeFont(SFont *font);
  void  APIDrawText(SSurface *surface, SFont *font, int x, int y, unsigned int rgbColor, const char *text);
  void  APIDrawTextC(SSurface *surface, SFont *font, int x, int y, unsigned int rgbColor, const char *text);
  void  APIDrawTextR(SSurface *surface, SFont *font, int x, int y, unsigned int rgbColor, const char *text);
  int APITextHeight(SFont *font, const char *text);
  int APITextWidth(SFont *font, const char *text);
  int APICharHeight(SFont *font, char c);
  int APICharWidth(SFont *font, char c);
  int APIMaxCharHeight(SFont *font);
  int APIMaxCharWidth(SFont *font);

 *
 */



//
// PBM (Single-frame) Bitmap
//

class CBitmapPBM {
public:
  // Constructors
  CBitmapPBM (const char* pbmFilename = NULL);
  ~CBitmapPBM (void);

  void Load (PODFILE *pbm, PODFILE *act);
  void GetSize (int *x_size, int *y_size);
  void Draw (SSurface *surface, int x, int y);
  void DrawPartial (SSurface *surface, int x, int y, int x1, int y1, int x2, int y2);

protected:
  char     pbmFilename[64];
  RGB      *palette;
  GLubyte  *image;
  int      width, height;
};


CBitmapPBM::CBitmapPBM (const char *pbmName)
{
  // Initialize
  image = NULL;
  width = height = 0;

  if (pbmName != NULL) {
    strcpy (pbmFilename, pbmName);

    // Construct full names for PBM and ACT files
    char pbmFilename[256];
    char actFilename[256];
    strcpy (pbmFilename, pbmName);

    strcpy (actFilename, pbmFilename);
    char *pExt = strrchr (actFilename, '.');
    if (pExt != NULL) {
      pExt++;
      strcpy (pExt, "ACT");
    } else {
      gtfo ("CBitmapPBM : Invalid PBM filename %s", pbmFilename);
    }

    // Open PBM and ACT files in default pod filesystem
    PODFILE* pbm = popen (&globals->pfs, pbmFilename);
    PODFILE* act = popen (&globals->pfs, actFilename);
    if ((pbm != NULL) && (act != NULL)) {
      Load (pbm, act);
      pclose (pbm);
      pclose (act);
    } else {
      gtfo ("CBitmapPBM : Could not open PBM or ACT file for %s", pbmName);
    }
  }
}

CBitmapPBM::~CBitmapPBM (void)
{
  delete palette;
  delete image;
}

void CBitmapPBM::GetSize (int *x_size, int *y_size)
{
  *x_size = width;
  *y_size = height;
}

void CBitmapPBM::Load (PODFILE *pbm, PODFILE *act)
{
  int i;

  if ((pbm == NULL) || (act == NULL)) {
    return;
  }

  // Load colormap from the ACT file
  palette = new RGB[0x100];
  pread (palette, 3, 0x100, act);

  // Read PBM header
  SPBMHeader h;
  pread (&h, sizeof(SPBMHeader), 1, pbm);
  if (h.magic != 0x1A4D4250) {    // 'PBM<Esc>' in Little-Endian format
    gtfo ("CBitmapPBM : Invalid magic value, %s", pbm->filename);
  }
  width = h.width;
  height = h.height;

  // Read PBM row offset table. This is a list of (height+1) offsets to the
  //   start of each row's data.  The last element is the size of the entire
  //   data area, which allows for simple calculation of the last row's size
  unsigned long *rowOffset = new unsigned long[height+1];
  pread (rowOffset, sizeof(unsigned long), height+1, pbm);

  unsigned long *rowLength = new unsigned long[height];
  for (i=0; i<height; i++) {
    // Calculate data length for this row
    rowLength[i] = rowOffset[i+1] - rowOffset[i];
  }

  // Pre-load all image data into memory for faster processing
  int rowDataSize = rowOffset[height];
  unsigned char *rowData = new unsigned char[rowDataSize];
  pread (rowData, 1, rowDataSize, pbm);

  // Allocate storage for the 32bpp image
  image = new GLubyte[width*height];

  // Initialize entire image to palette index 0 (transparent)
  memset (image, 0, width*height);

  for (i=0; i<height; i++) {

    unsigned char *p = &rowData[rowOffset[i]];

    // Each row consists of a series of data chunks, each chunk representing
    //   a non-transparent series of pixels.

    // Continue reading data chunks until finished this row
    unsigned long iRow = 0;
    while (iRow < rowLength[i]) {
      // Read pixel colum
      short column;
      column = *((short*)p);
      p += sizeof(short);
      iRow += sizeof(short);

      // Read pixel count
      short count;
      count = *((short*)p);
      p += sizeof(short);
      iRow += sizeof(short);

      // Read data (palette index) for each pixel in the chunk
      for (short j=0; j<count; j++) {
        unsigned char iCmap;
        iCmap = *p;
        p++;
        iRow++;

        // Flip image vertically
        unsigned int offset = (((height - i - 1) * width) + column + j);

        // Set pixel colour, and transparency to fully opaque
        image[offset] = iCmap;
      }

      // Pad to next long boundary
      while ((iRow % 4) != 0) {
        p++;
        iRow++;
      }
    }
  }

  // Clean up allocated data
  delete rowOffset;
  delete rowLength;
  delete rowData;
}


void CBitmapPBM::Draw (SSurface *surface, int x, int y)
{
  if (image == NULL) {
    WARNINGLOG ("CBitmapPBM::Draw : Drawing NULL bitmap image for %s", pbmFilename);
    return;
  }

  // Check that rendered bitmap will fit in the surface
  if ((x < 0) || ((unsigned int)(x + width) > surface->xSize)) {
//    gtfo ("CBitmapPBM::Draw outside surface x bounds");
  }

  if ((y < 0) || ((unsigned int)(y + height) > surface->ySize)) {
//    gtfo ("CBitmapPBM::Draw outside surface y bounds");
  }

  // Copy bitmap pixels to surface image buffer
//  int sybase = surface->ySize - y;
  int sybase = surface->ySize - y - height;
  for (int i=0; i<height; i++) {
    for (int j=0; j<width; j++) {
      long bmOffset = ((i * width) + j);
      int iCmap = image[bmOffset];

      // Copy only non-transparent pixels to the surface
      if (iCmap != 0) {
        GLubyte r = palette[iCmap].r;
        GLubyte g = palette[iCmap].g;
        GLubyte b = palette[iCmap].b;
        GLubyte a = 0xFF;
        unsigned int rgba = MakeRGBA (r, g, b, a);

        // Copy pixel value to surface buffer, clipping against edges
        int sx = x+j;
        int sy = sybase+i;
        if ((sx >= 0) && (sx <= (int)surface->xSize) &&
            (sy >= 0) && (sy <= (int)surface->ySize))
        {
          int surfOffset = (sy * surface->xSpan) + sx;
          surface->drawBuffer[surfOffset] = rgba;
        }
      }
    }
  }
}

void CBitmapPBM::DrawPartial (SSurface *surface, int x, int y,
                              int x1, int y1, int x2, int y2)
{
  // Check that rendered bitmap will fit in the surface
  int wDraw = x2 - x1;
  int hDraw = y2 - y1;

  if ((x < 0) || ((unsigned int)(x + wDraw) > surface->xSize)) {
//    gtfo ("CBitmapPBM::Draw outside surface x bounds");
  }

  if ((y < 0) || ((unsigned int)(y + hDraw) > surface->ySize)) {
//    gtfo ("CBitmapPBM::Draw outside surface y bounds");
  }

  // Copy bitmap pixels to surface image buffer
  int sybase = surface->ySize - y - hDraw;
  for (int i=0; i<hDraw; i++) {
    for (int j=0; j<wDraw; j++) {
      long bmOffset = (((y1 + i) * width) + (x1 + j));
      int iCmap = image[bmOffset];

      // Copy only non-transparent pixels to the surface
      if (iCmap != 0) {
        GLubyte r = palette[iCmap].r;
        GLubyte g = palette[iCmap].g;
        GLubyte b = palette[iCmap].b;
        GLubyte a = 0xFF;
        unsigned int rgba = MakeRGBA (r, g, b, a);

        // Copy pixel value to surface buffer, clipping against edges
        int sx = x+j;
        int sy = sybase+i;
        if ((sx >= 0) && (sx < (int)surface->xSize) &&
            (sy >= 0) && (sy < (int)surface->ySize))
        {
          int surfOffset = (sy * surface->xSpan) + sx;
          surface->drawBuffer[surfOffset] = rgba;
        }
      }
    }
  }
}


//
// PBG (Multi-frame) Bitmap
//

class CBitmapPBG {
public:
  // Constructor
  CBitmapPBG (const char* pbgFilename);
  ~CBitmapPBG (void);

  // CBitmapPBG methods
  void  Load (PODFILE *pbm, PODFILE *act);
  void  GetSize (int *x_size, int *y_size);
  int   GetNumFrames (void);
  void  Draw (SSurface *surface, int x, int y, int frame);
  void  DrawPartial (SSurface *surface, int x, int y,
                     int x1, int y1, int x2, int y2, int frame);

protected:
  int                 nFrames;  
  vector<CBitmapPBM*> pbm;      
};

CBitmapPBG::CBitmapPBG (const char *pbgName)
{
  // Initialize
  nFrames = 0;

  if (pbgName != NULL) {
    // Construct full names for PBG and ACT files
    char pbgFilename[256];
    char actFilename[256];
    strcpy (pbgFilename, pbgName);

    strcpy (actFilename, pbgFilename);
    char *pExt = strrchr (actFilename, '.');
    if (pExt != NULL) {
      pExt++;
      strcpy (pExt, "ACT");
    } else {
      gtfo ("CBitmapPBG : Invalid PBG filename %s", pbgFilename);
    }

    // Open PBM and ACT files in default pod filesystem
    PODFILE* pbg = popen (&globals->pfs, pbgFilename);
    PODFILE* act = popen (&globals->pfs, actFilename);
    Load (pbg, act);
    pclose (pbg);
    pclose (act);
  }   
}

CBitmapPBG::~CBitmapPBG (void)
{
  vector<CBitmapPBM*>::iterator i;
  for (i=pbm.begin(); i!=pbm.end(); i++) {
    CBitmapPBM *bm = *i;
    delete bm;
  }
}

int CBitmapPBG::GetNumFrames (void)
{
  return nFrames;
}

typedef struct {
  unsigned long magic;
  unsigned long nFrames;
} SPBGHeader;

void CBitmapPBG::Load (PODFILE *pbg, PODFILE *act)
{
  if ((pbg == NULL) || (act == NULL)) {
    return;
  }

  // Read PBG header
  SPBGHeader h;
  pread (&h, sizeof(SPBGHeader), 1, pbg);
  if (h.magic != 0x1A474250) {    // 'PBG<Esc>' in Little-Endian format
    gtfo ("CBitmapPBG : Invalid magic value, %s", pbg->filename);
  }
  nFrames = h.nFrames;

  for (int i=0; i<nFrames; i++) {
    CBitmapPBM *bm = new CBitmapPBM;
    prewind (act);
    bm->Load (pbg, act);
    pbm.push_back (bm);
  }
}


void CBitmapPBG::GetSize (int *x, int *y)
{
  if (pbm.size() > 0) {
    // Get size of first PBM entry (assume they are all the same size!)
    pbm[0]->GetSize (x, y);
  } else {
    // Zero frames ?
    *x = 0;
    *y = 0;
  }
}


void CBitmapPBG::Draw (SSurface *surface, int x, int y, int frame)
{
  if (frame < nFrames) {
    CBitmapPBM *bm = pbm[frame];
    bm->Draw (surface, x, y);
  }
}

void CBitmapPBG::DrawPartial (SSurface *surface, int x, int y,
                              int x1, int y1, int x2, int y2, int frame)
{
  if (frame < nFrames) {
    CBitmapPBM *bm = pbm[frame];
    bm->DrawPartial (surface, x, y, x1, y1, x2, y2);
  }
}


/*
 * Bitmap primitives
 */

int   LoadBitmap(SBitmap *bm)
{
  int rc = false;

  bm->type = TYPE_INVALID;
  bm->bitmap = NULL;

  char *p = strrchr (bm->bitmapName, '.');
  if (p) {
    // File has an extension, now check for valid bitmaps
    if (stricmp (p, ".PBM") == 0) {
      bm->type = TYPE_SINGLE;
      bm->bitmap = new CBitmapPBM (bm->bitmapName);
      rc = true;
    } else if (stricmp (p, ".PBG") == 0) {
      bm->type = TYPE_FRAMES;
      bm->bitmap = new CBitmapPBG (bm->bitmapName);
      rc = true;
    } else {
      gtfo ("LoadBitmap : Invalid bitmap name %s", bm->bitmapName);
    }
  }

  return rc;
}


//
// Draw a PBM/PBG bitmap onto the specified surface.  The 'frame' parameter is
//  only relevant for multi-frame PBG bitmaps.  The 'x' and 'y' parameters
//  indicate the location of the top-left corner of the bitmap relative to
//  the top-left corner of the surface
//
void  DrawBitmap (SSurface *surface, SBitmap *bm, int x, int y, int frame)
{
  // PBM/PBG draw methods copy pixels from bottom-up to match the orientation
  //   of the SSurface.  Adjust the supplied x,y coordinates from top-left to
  //   bottom-left of the bitmap relative to bottom-left of the surface
  switch (bm->type) {
  case TYPE_SINGLE:
    ((CBitmapPBM*)(bm->bitmap))->Draw (surface, x, y);
    break;

  case TYPE_FRAMES:
    ((CBitmapPBG*)(bm->bitmap))->Draw (surface, x, y, frame);
    break;
    
  default:
    // Invalid bitmap type
    gtfo ("DrawBitmap : Invalid bitmap type %d", bm->type);
  }
}


void  DrawBitmapPartial (SSurface *surf, SBitmap *bm, int x, int y,
                         int x1, int y1, int x2, int y2, int frame)
{
  // PBM/PBG draw methods copy pixels from bottom-up to match the orientation
  //   of the SSurface.  Adjust the supplied x,y coordinates from top-left to
  //   bottom-left of the bitmap relative to bottom-left of the surface
  switch (bm->type) {
  case TYPE_SINGLE:
    ((CBitmapPBM*)(bm->bitmap))->DrawPartial (surf, x, y, x1, y1, x2, y2);
    break;

  case TYPE_FRAMES:
    ((CBitmapPBG*)(bm->bitmap))->DrawPartial (surf, x, y, x1, y1, x2, y2, frame);
    break;

  default:
    // Invalid bitmap type
    gtfo ("DrawBitmapPartial : Invalid bitmap type %d", bm->type);
  }
}


void  GetBitmapSize(SBitmap *bm, int *xSize, int *ySize)
{
  switch (bm->type) {
  case TYPE_SINGLE:
    ((CBitmapPBM*)(bm->bitmap))->GetSize (xSize, ySize);
    break;

  case TYPE_FRAMES:
    ((CBitmapPBG*)(bm->bitmap))->GetSize (xSize, ySize);
    break;

  default:
    // Invalid bitmap type
    gtfo ("GetBitmapSize : Invalid bitmap type %d", bm->type);
  }
}


int NumBitmapFrames(SBitmap *bm)
{
  int rc = 0;

  switch (bm->type) {
  case TYPE_SINGLE:
    rc = 1;
    break;

  case TYPE_FRAMES:
    rc = ((CBitmapPBG*)(bm->bitmap))->GetNumFrames ();
    break;

  default:
    rc = 0;
  }

  return rc;
}

void FreeBitmap(SBitmap *bm)
{
  switch (bm->type) {
  case TYPE_SINGLE:
    delete (CBitmapPBM *)(bm->bitmap);
    break;

  case TYPE_FRAMES:
    delete (CBitmapPBG *)(bm->bitmap);
    break;

  default:
    // Invalid bitmap type
    gtfo ("FreeBitmap : Invalid bitmap type %d", bm->type);
  }
  bm->bitmap = NULL;
  bm->type = TYPE_INVALID;
}

Documentation generated by