RawImage.cpp

Go to the documentation of this file.

/*
 * RawImage.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/Utility.h"


//
// Define the following macro to have all RAW images flipped left-right
//   when loaded.
//
// #define RAW_FLIP_LEFT_RIGHT
// #define MASK_FLIP_LEFT_RIGHT


/*
 * CMaskImage
 *
 * A mask image is a special type of RAW file used to represent a bitmask for
 *   overlaying one texture on top of another.  There is no need for either the
 *   ACT or OPA files; the RAW image data represents an 8-bit grayscale mask.
 *
 */

//
// Constructor for creating a "blank" mask image
//
CMaskImage::CMaskImage (int width, int height)
{
  strcpy (this->name, "NoName");
  this->width = width;
  this->height = height;
  this->rawdata = new GLubyte[width * height];
  memset (this->rawdata, 0, width * height);
}

//
// This constructor accepts a predefined buffer containing the mask data
//
CMaskImage::CMaskImage (int width, int height, const GLubyte *data)
{
  strcpy (this->name, "NoName");
  this->width = width;
  this->height = height;
  this->rawdata = new GLubyte[width * height];
  memcpy (this->rawdata, data, width * height);
}

//
// This constructor accepts a RAW filename from which the mask data is loaded
//
CMaskImage::CMaskImage (int width, int height, const char* rawFilename)
{
  // Initialize data members
  strcpy (this->name, rawFilename);
  this->width = width;
  this->height = height;

  // Open RAW pod file
  PODFILE *pRaw = popen (&globals->pfs, rawFilename);
  if (!pRaw) {
    gtfo ("CMaskImage : Cannot open file %s", rawFilename);
    return;
  }

  // Load image data
  rawdata = new GLubyte[width * height];
  pread (rawdata, (width * height), 1, pRaw);
  pclose (pRaw);
}

CMaskImage::CMaskImage (const CMaskImage &src)
{
  width = src.width;
  height = src.height;

  // Copy data
  rawdata = new GLubyte[width * height];
  memcpy (rawdata, src.rawdata, width * height);
}

CMaskImage::~CMaskImage (void)
{
  delete rawdata;
}

int CMaskImage::GetWidth (void)
{
  return width;
}

int CMaskImage::GetHeight (void)
{
  return height;
}


/*
 * CRawImage
 */

CRawImage::CRawImage (const char* rawFilename,
                      const char* actFilename,
                      const char* opaFilename)
{
  Init ();

  // Open RAW file and get the file size
  PODFILE *pRaw = popen (&globals->pfs, rawFilename);
  if (!pRaw) {
    gtfo ("CRawImage : Cannot open file %s", rawFilename);
  }
  int rawSize = pRaw->size;
  pclose (pRaw);

  // Calculate side length and verify that the image is square
  int size = (int)(sqrt((double)rawSize));
  if ((size * size) != rawSize) {
    gtfo ("CRawImage : Image %s is not square; cannot auto-determine size", rawFilename);
    return;
  }

  // Initialize data members
  strcpy (name, rawFilename);
  width = height = size;

  // Load image data
  Load (rawFilename, actFilename, opaFilename);
}


CRawImage::CRawImage (int width,
                      int height,
                      const char* rawFilename,
                      const char* actFilename,
                      const char* opaFilename)
{
  Init ();

  // Initialize data members
  strcpy (name, rawFilename);
  this->width = width;
  this->height = height;
  
  // Load image data
  Load (rawFilename, actFilename, opaFilename);
}


void CRawImage::Init (void)
{
  actdata = rawdata = opadata = NULL;
  xferRed = xferGreen = xferBlue = xferAlpha = NULL;
  width = height = 0;
  texid = 0;
}


//
// Load the image data from the specified pod files.  Class members 'width' and 'height'
//   must already have been initialized
//
void CRawImage::Load (const char *rawFilename,
                      const char *actFilename,
                      const char *opaFilename)
{
  // Initialize data buffer pointers
  actdata = NULL;
  rawdata = NULL;
  opadata = NULL;

  // Validate that width and height have been initialized
  if ((width == 0) || (height == 0)) {
    return;
  }

  // Open ACT pod file
  PODFILE *pAct = NULL;
  if (actFilename == NULL) {
    // Derive ACT filename from RAW file
    char actName[64];
    strcpy (actName, rawFilename);
    char *p = strrchr (actName, '.');
    if (p) {
      strcpy (p, ".ACT");
      pAct = popen (&globals->pfs, actName);
    } else {
      gtfo ("CRawImage : Could not derive ACT filename for %s", rawFilename);
    }
  } else {
    // ACT filename was supplied
    pAct = popen (&globals->pfs, actFilename);
  }
  if (!pAct) {
    gtfo ("CRawImage : Cannot open file %s", actFilename);
    return;
  }

  // Load colour map from ACT file
  actdata = new GLubyte[0x300];
  pread (actdata, 0x300, 1, pAct);
  pclose (pAct);

  // Open RAW pod file
  PODFILE *pRaw = popen (&globals->pfs, rawFilename);
  if (!pRaw) {
    gtfo ("CRawImage : Cannot open file %s", rawFilename);
    return;
  }

  // Load image data from RAW file
  rawdata = new GLubyte[width * height];
  pread (rawdata, (width * height), 1, pRaw);
  pclose (pRaw);

  // Open OPA data file if the filename has been specified
  PODFILE *pOpa = NULL;
  if (opaFilename != NULL) {
    pOpa = popen (&globals->pfs, opaFilename);
    if (!pOpa) {
      gtfo ("CRawImage : Cannot open file %s", opaFilename);
    }

    opadata = new GLubyte [width * height];
    pread (opadata, (width * height), 1, pOpa);
    pclose (pOpa);
  }
}


CRawImage::CRawImage (const CRawImage &src)
{
  Init ();
  Copy (src);
}

CRawImage::~CRawImage (void)
{
  delete actdata;
  delete rawdata;
  delete opadata;
  delete xferRed;
  delete xferGreen;
  delete xferBlue;
  delete xferAlpha;
}

int CRawImage::GetWidth (void)
{
  return width;
}

int CRawImage::GetHeight (void)
{
  return height;
}

void CRawImage::SetName (const char* name)
{
  strcpy (this->name, name);
}

void CRawImage::Copy (const CRawImage &src)
{
  width = src.width;
  height = src.height;
  strcpy (name, src.name);
  actdata = NULL;
  rawdata = NULL;
  opadata = NULL;

  // Copy all data
  if (src.actdata != NULL) {
    actdata = new GLubyte[0x300];
    memcpy (actdata, src.actdata, 0x300);
  }

  if (src.rawdata != NULL) {
    rawdata = new GLubyte[width * height];
    memcpy (rawdata, src.rawdata, (width * height));
  }

  if (src.opadata != NULL) {
    opadata = new GLubyte[width * height];
    memcpy (opadata, src.opadata, (width * height));
  }
}


//
// Create pixel transfer maps to be used when texture is created
//
void CRawImage::CreateTransferMaps (void)
{
  // Transfer ACT data into floating-point pixel transfer arrays
  xferRed = new GLfloat[0x100];
  xferGreen = new GLfloat[0x100];
  xferBlue = new GLfloat[0x100];
  GLubyte *p = actdata;
  for (int i=0; i<0x100; i++) {
    xferRed[i] = (float)(*p++) / 256.0f;
    xferGreen[i] = (float)(*p++) / 256.0f;
    xferBlue[i] = (float)(*p++) / 256.0f;
  }

  if (opadata != NULL) {
    // Transfer OPA data into floating-point alpha pixel transfer array
    xferAlpha = new GLfloat[0x100];
    GLubyte *p = opadata;
    for (int i=0; i<0x100; i++) {
      xferAlpha[i] = (float)(*p++) / 256.0f;
    }
  }
}


void CRawImage::Merge (const CRawImage *raw, const CMaskImage *mask, int actOffset)
{
  if ((raw != NULL) && (mask != NULL)) {
    // Copy palette
    memcpy (&actdata[actOffset * 3], &raw->actdata[0], 0x40 * 3);

    // Overwrite current image data when corresponding mask bit is non-zero
    int offset = 0;
    for (int i=0; i<height; i++) {
      for (int j=0; j<width; j++, offset++) {
        if (mask->rawdata[offset] != 0) {
          this->rawdata[offset] = raw->rawdata[offset] + actOffset;
        }
      }
    }
  }
}


//
// This function merges a total of four terrain detail tile textures ('this'
//   image plus the three specified in the arguments) using the supplied masks.
//   The current implementation relies on the fact that original Fly! II
//   detail tile textures use only 0x40 palette indices each.
//
void CRawImage::MergeTransitions (const CRawImage *bRaw, const CMaskImage *bMask,
                                  const CRawImage *xRaw, const CMaskImage *xMask,
                                  const CRawImage *yRaw, const CMaskImage *yMask)
{
  // Merge bottom transition
  Merge (bRaw, bMask, 0x40);

  // Merge right-side transition
  Merge (xRaw, xMask, 0x80);

  // Merge corner transition
  Merge (yRaw, yMask, 0xC0);
}

void CRawImage::CopyMasked (const CRawImage *src, const CMaskImage *mask)
{
/*
  for (int i=0; i<height; i++) {
    for (int j=0; j<width; j++) {
      // Calculate offsets
      int image_offset = ((i * width) + j) * depth;
      int mask_offset = (i * width) + j;

      float weight = (float)(mask->image[mask_offset] / 255);
      for (int k=0; k<3; k++) {
        char this_c = image[image_offset + k];
        char src_c = src->image[image_offset + k];
        char new_c = (char)((weight * (float)src_c) +
                          ((1.0 - weight) * (float)this_c));
        image[image_offset + k] = new_c;
      }
    }
  }
*/
}


GLubyte *CRawImage::GetRGBImageData (void)
{
  int depth = 3;
  GLubyte *image = new GLubyte [width * height * depth];

  for (int i=0; i<height; i++) {
    for (int j=0; j<width; j++) {

#ifdef RAW_FLIP_LEFT_RIGHT
      long iRaw = (i * width) + j;
      long iImg = ((i * width) + (width - j - 1)) * depth;
#else
      long iSrc = (i * width) + j;
      long iImg = ((i * width) + j) * depth;
#endif
      // Read colormap index from the raw image data
      GLubyte iCmap = rawdata[iSrc];

      image[iImg + 0] = actdata[iCmap * 3 + 0];
      image[iImg + 1] = actdata[iCmap * 3 + 1];
      image[iImg + 2] = actdata[iCmap * 3 + 2];
    }
  }

  return image;
}

GLubyte *CRawImage::GetRGBAImageData (void)
{
  int depth = 4;
  GLubyte *image = new GLubyte [width * height * depth];

  for (int i=0; i<height; i++) {
    for (int j=0; j<width; j++) {

#ifdef RAW_FLIP_LEFT_RIGHT
      long iRaw = (i * width) + j;
      long iImg = ((i * width) + (width - j - 1)) * depth;
#else
      long iSrc = (i * width) + j;
      long iImg = ((i * width) + j) * depth;
#endif
      // Read colormap index from the raw image data
      GLubyte iCmap = rawdata[iSrc];

      image[iImg + 0] = actdata[iCmap * 3 + 0];
      image[iImg + 1] = actdata[iCmap * 3 + 1];
      image[iImg + 2] = actdata[iCmap * 3 + 2];

      // Read opacity from OPA file, or default to 0xFF (opaque)
      GLubyte opa = (GLubyte)0xFF;
      if (opadata != NULL) {
        opa = opadata [(i * width) + j];
      }
      image[iImg + 3] = opa;
    }
  }

  return image;
}

/*
GLuint CRawImage::GetTexture (bool mipmap)
{
  // 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_RGB;
  int depth = 3;
  GLubyte *image = NULL;
  if (opadata == NULL) {
    // OPA data does not exist, texture is in RGB format
    format = GL_RGB;
    depth = 3;
    image = GetRGBImageData ();
  } else {
    // OPA data exists, get RGBA format data
    format = GL_RGBA;
    depth = 4;
    image = GetRGBAImageData ();
  }

  if (image != NULL) {
    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, width, height, 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, width, height, 0,
        format, GL_UNSIGNED_BYTE, image);
    }

    // Free image data
    free (image);

  } else {
    // Error, could not generate image data
    globals->logWarning->Write ("CRawImage : Could not generate image data");
  }   

  return texid;
}
*/

static int nTextures = 0;

GLuint CRawImage::GetTexture (bool mipmap)
{
  // Check that texture has not already been generated for this image
  if (texid != 0) {
    gtfo ("CRawImage::GetTexture : Multiple texture generation");
  }

  CreateTransferMaps ();

  glPushAttrib (GL_PIXEL_MODE_BIT);

  // 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_COLOR_INDEX;
  GLint depth = 3;

  // Set up pixel transfer functions for RGB colours
  glPixelMapfv (GL_PIXEL_MAP_I_TO_R, 0x100, xferRed);
  glPixelMapfv (GL_PIXEL_MAP_I_TO_G, 0x100, xferGreen);
  glPixelMapfv (GL_PIXEL_MAP_I_TO_B, 0x100, xferBlue);
  if (xferAlpha != NULL) {
    glPixelMapfv (GL_PIXEL_MAP_I_TO_A, 0x100, xferAlpha);
    depth = 4;
  }
  glPixelTransferi (GL_MAP_COLOR, true);

  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, width, height, format, GL_UNSIGNED_BYTE, rawdata);
    GLenum e = glGetError();
    if (e != GL_NO_ERROR) {
      gtfo ("GL Error 0x%08X building 2D mipmaps for %s", e, name);
    }
  } 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, depth, width, height, 0, format, GL_UNSIGNED_BYTE, rawdata);
    GLenum e = glGetError();
    if (e != GL_NO_ERROR) {
      gtfo ("GL Error 0x%08X building 2D texture for %s", e, name);
    }
  }

  nTextures++;

  glPopAttrib ();

  return texid;
}


void CRawImage::FreeTexture (void)
{
  glDeleteTextures (1, &texid);
}


//
// CSunRawImage
//
// RAW textures used to display the sun are special in that the transparency
//   is implied by the RAW image itself.  That is, there are no OPA files yet
//   the texture is supposed to be transparent.
//
// Try using the pixel colour index as the transparency value
//
CSunRawImage::CSunRawImage (int width,
              int height,
              const char* rawFilename,
              const char* actFilename)
              : CRawImage (width, height, rawFilename, actFilename)
{
/*
  // Initialize data members
  strcpy (name, rawFilename);
  this->width = width;
  this->height = height;
  
  actdata = NULL;
  rawdata = NULL;
  opadata = NULL;

  // Open ACT pod file
  PODFILE *pAct = popen (&globals->pfs, actFilename);
  if (!pAct) {
    gtfo ("CSunRawImage : Cannot open file %s", actFilename);
    return;
  }

  // Load colour map from ACT file
  actdata = new GLubyte[0x300];
  pread (actdata, 0x300, 1, pAct);
  pclose (pAct);

  // Open RAW pod file
  PODFILE *pRaw = popen (&globals->pfs, rawFilename);
  if (!pRaw) {
    globals->logWarning->Write ("CRawImage : Cannot open file %s", rawFilename);
    return;
  }

  // Load image data
  rawdata = new GLubyte[width * height];
  pread (rawdata, (width * height), 1, pRaw);
  pclose (pRaw);
*/
  opadata = new GLubyte [width * height];
  memcpy (opadata, rawdata, (width * height));
}

Documentation generated by