CursorManager.cpp

Go to the documentation of this file.

/*
 * CursorManager.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 "../Include/CursorManager.h"
#include "../Include/Utility.h"
#include "../Include/Ui.h"

using namespace std;


/***************************************************

  Fly! II Cursors

  Cursors are specified in a text file with extension .csr, stored in the
  \DATA folder.  The following example is \DATA\MPARROW.CSR in STARTUP.POD:

<bgno> ---- BEGIN CURSOR ----
<csid> ---- cursor id ----
arrw
<imag> ---- image file ----
mparrow.pbm
<hots> ---- cursor x,y hotspot ----
0
0
<endo> ---- END CURSOR ----

 ***************************************************/


//
// Constructor
//
CCursor::CCursor (const char* csrfilename)
{
  // Initialize fields
  strcpy (csr, csrfilename);
  strcpy (curs, "");
  csid = 0;
  strcpy (imag, "");
  hots_x = hots_y = 0;

  // Open .CSR file stream and parse tags
  SStream s;
  strcpy (s.filename, "DATA\\");
  strcat (s.filename, csrfilename);
  strcpy (s.mode, "r");
  if (OpenStream (&s)) {
    ReadFrom (this, &s);
    CloseStream (&s);
  }
}

//
// Destructor
//
CCursor::~CCursor (void)
{
  if (texid != 0) FreeTexture();
}


void CCursor::Load (const char* pbmName)
{
  int i, j;
  
  // Construct full names for PBM and ACT files
  char pbmFilename[256];
  char actFilename[256];
  strcpy (pbmFilename, "Art\\");
  strcat (pbmFilename, pbmName);

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

  // Load colormap from the ACT file
  PODFILE *act = popen (&globals->pfs, actFilename);
  RGB *actdata = new RGB[0x100];
  pread (actdata, 3, 0x100, act);
  pclose (act);

  // Read PBM header
  PODFILE* pbm = popen (&globals->pfs, pbmFilename);
  SPBMHeader h;
  pread (&h, sizeof(SPBMHeader), 1, pbm);
  if (h.magic != 0x1A4D4250) {    // 'PBM<Esc>' in Little-Endian format
    gtfo ("Invalid PBM magic value in %s", pbmName);
  }
  int width = h.width;
  int height = h.height;

  // Check that cursor size does not exceed maximum
  int texwidth = 32;
  int texheight = 32;
  if ((width > texwidth) || (height > texheight)) {
    gtfo ("Cursor image %s exceeds maximum size of 32x32 pixels", pbmName);
  }

  // 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);

  // Allocate an array containing the length in bytes of each row data
  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 row data into memory for faster processing
  int rowDataSize = rowOffset[height];
  unsigned char *rowData = new unsigned char[rowDataSize];
  pread (rowData, 1, rowDataSize, pbm);
  pclose (pbm);

  // Allocate storage for 32x32 RGBA texture image
  GLubyte *teximage = new GLubyte[texwidth * texheight * 4];
  memset (teximage, 0, texwidth*texheight * 4);

  for (i=0; i<height; i++) {
    unsigned char *p = &rowData[rowOffset[i]];

    // 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 for this chunk
      short count;
      count = *((short*)p);
      p += sizeof(short);
      iRow += sizeof(short);

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

        // Flip image vertically
        unsigned int offset = (((texheight - i - 1) * texwidth) + column + j) * 4;
        
        // Assign texel RGBA values
        if (iCmap == 0) {
          // This is a transparent pixel
          teximage[offset + 0] = 0;
          teximage[offset + 1] = 0;
          teximage[offset + 2] = 0;
          teximage[offset + 3] = 0;
        } else {
          // Non-transparent pixel, transfer colour data from palette
          teximage[offset + 0] = actdata[iCmap].r;
          teximage[offset + 1] = actdata[iCmap].g;
          teximage[offset + 2] = actdata[iCmap].b;
          teximage[offset + 3] = 0xff;
        }
      }

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

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

  // Generate non-mipmapped OpenGL texture
  glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
  glGenTextures (1, &texid);
  glBindTexture (GL_TEXTURE_2D, texid);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
  glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
  glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
  glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
  GLenum format = GL_RGBA;
  glTexImage2D (GL_TEXTURE_2D, 0, format, texwidth, texheight, 0,
        format, GL_UNSIGNED_BYTE, teximage);

  // Clean up dynamically allocated data
  delete teximage;
}

void CCursor::FreeTexture (void)
{
  glDeleteTextures (1, &texid);
  texid = 0;
}

int CCursor::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  switch (tag) {
  case 'csid':
    // Read unique ID
    ReadTag (&csid, stream);
    rc = TAG_READ;
    break;

  case 'imag':
    // Read .PBM image filename
    ReadString (imag, 64, stream);
    rc = TAG_READ;
    break;

  case 'curs':
    // Read OS cursor resource name (not currently used)
    ReadString (curs, 64, stream);
    rc = TAG_READ;
    break;

  case 'hots':
    // Read hotspot offsets
    ReadInt (&hots_x, stream);
    ReadInt (&hots_y, stream);
    rc = TAG_READ;
    break;

  default:
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CCursor::Read : Unknown tag <%s>", s);
  }

  return rc;
}


void CCursor::ReadFinished (void)
{
  // Load image bitmap
  if (strlen (imag) > 0) {
    Load (imag);
  }
/*
    // Successfully loaded.  Create a surface and draw the bitmap onto it
    // The surface will actually be blitted to the screen when this cursor
    // is active
    int w, h;
    GetBitmapSize (&bmImage, &w, &h);
    surf = CreateSurface (w, h);
    DrawBitmap (surf, &bmImage, 0, 0, 0);
*/
}


//
// CursorManager
//
CCursorManager::CCursorManager (void)
{
  x = y = 0;
  crsrCurrent = NULL;
}

CCursorManager::~CCursorManager (void)
{
  map<Tag,CCursor*>::iterator iter;
  for (iter=cache.begin(); iter!=cache.end(); iter++) {
    delete iter->second;
  }
}

//
// MouseMotion
//
void CCursorManager::MouseMotion (int mouse_x, int mouse_y)
{
  if (crsrCurrent != NULL) {
//  int w, h;
//  GetBitmapSize (&crsrCurrent->bmImage, &w, &h);
    x = mouse_x - crsrCurrent->hots_x;
    y = globals->screenHeight - mouse_y - 1 - 32 + crsrCurrent->hots_y;
  }

/*
  char sTag[8];
  strcpy (sTag, "----");
  if (crsrCurrent != NULL) {
    TagToString (sTag, crsrCurrent->csid);
  }
  char debug[80];
  sprintf (debug, "MouseMotion : tag=%s x=%d y=%d", sTag, x, y);
  DrawNoticeToUser (debug, 1);
*/
}


CCursor *CCursorManager::FindCursor (const char *csrfilename)
{
  CCursor *rc = NULL;

  map<Tag,CCursor*>::iterator iter;
  for (iter=cache.begin(); iter!=cache.end() && (rc == NULL); iter++) {
    CCursor *crsr = iter->second;
    if (strcmp (crsr->csr, csrfilename) == 0) {
      rc = crsr;
    }
  }

  return rc;
}

CCursor *CCursorManager::FindCursor (Tag tag)
{
  CCursor *rc = NULL;

  map<Tag,CCursor*>::iterator iter = cache.find(tag);
  if (iter != cache.end()) {
    rc = iter->second;
  }

  return rc;
}


//
// BindCursor
//
// Applications call this method to load the specified cursor bitmap into cache.
//   The method returns a handle to the cursor that is used in SetCursor().
//
Tag CCursorManager::BindCursor (const char *csrfilename)
{
  Tag rc = 0;

  CCursor *crsr = FindCursor (csrfilename);
  if (crsr == NULL) {
    // Try to load it
    crsr = new CCursor (csrfilename);
    cache[crsr->csid] = crsr;
  }

  // Set return code to cursor unique identifier
  if (crsr != NULL) {
    rc = crsr->csid;
  }

  return rc;
}


int CCursorManager::GetNumBoundCursors (void)
{
  return cache.size();
}


void CCursorManager::SetCursor (Tag tag)
{
  crsrCurrent = FindCursor (tag);
}

Tag CCursorManager::GetCursor (void)
{
  Tag rc = 0;

  if (crsrCurrent != NULL) {
    rc = crsrCurrent->csid;
  }

  return rc;
}


void CCursorManager::Draw (void)
{
  if (crsrCurrent != NULL) {
    // Set projection matrix to 2D screen size
    glMatrixMode(GL_PROJECTION);
    glPushMatrix();
    glLoadIdentity ();
    gluOrtho2D (0, globals->screenWidth, 0, globals->screenHeight);

    // Position cursor onscreen
    glMatrixMode (GL_MODELVIEW);
    glPushMatrix ();
    glLoadIdentity ();
    glTranslatef (x, y, 0);

    glPushAttrib (GL_ENABLE_BIT);
    glDisable (GL_LIGHTING);
    glEnable (GL_ALPHA_TEST);
    glDisable (GL_DEPTH_TEST);

    glEnable (GL_TEXTURE_2D);
    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
    glBindTexture (GL_TEXTURE_2D, crsrCurrent->texid);

    // Draw a 32x32 quad, textured with the current cursor texture id
    glBegin (GL_QUADS);
      glTexCoord2f (0.0, 0.0);
      glVertex2f (0,   0);

      glTexCoord2f (1.0, 0.0);
      glVertex2f (32,  0);

      glTexCoord2f (1.0, 1.0);
      glVertex2f (32, 32);

      glTexCoord2f (0.0, 1.0);
      glVertex2f (0,  32);
    glEnd ();
    glFlush ();

    // Restore original settings
    glPopAttrib ();
    glMatrixMode (GL_MODELVIEW);
    glPopMatrix ();
    glMatrixMode (GL_PROJECTION);
    glPopMatrix ();

    // Check for an OpenGL error
    GLenum e = glGetError ();
    if (e != GL_NO_ERROR) {
      gtfo ("CCursorManager::Draw : GL Error 0x%04X", e);
    }
/*
    char sTag[8];
    strcpy (sTag, "----");
    if (crsrCurrent != NULL) {
      TagToString (sTag, crsrCurrent->csid);
    }
    char debug[80];
    sprintf (debug, "Draw: tag=%s x=%d y=%d", sTag, x, y);
    DrawNoticeToUser (debug, 1);
*/
  }
}

Documentation generated by