Terrain.cpp

Go to the documentation of this file.

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


//
// CGenericTileType
//
CGenericTileType::CGenericTileType (void)
{
  pixl = 0;
  txti = 0;
  tilc = 0;

  strcpy (texture, "");
}

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

  switch (tag) {
  case 'pixl':
    ReadInt (&pixl, stream);
    rc = TAG_READ;
    break;

  case 'txti':
    ReadInt (&txti, stream);
    rc = TAG_READ;
    break;

  case 'tilc':
    ReadInt (&tilc, stream);
    rc = TAG_READ;
    break;
  }

  return rc;
}

void CGenericTileType::ReadFinished (void)
{
}


//
// CGenericTileDatabase
//
CGenericTileDatabase::CGenericTileDatabase (const char* gentiles)
{
  strcpy (schm, "");

  // Open stream
  SStream s;
  strcpy (s.filename, "Data\\");
  strcat (s.filename, gentiles);
  strcpy (s.mode, "r");
  if (OpenStream (&s)) {
    ReadFrom (this, &s);
  } else {
    // Could not open generic tile database
    globals->logWarning->Write ("CGenericTileDatabase : Could not open file %s", gentiles);
  }

}

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

  switch (tag) {
  case 'schm':
    // Texture file naming scheme template
    ReadString (schm, 64, stream);
    rc = TAG_READ;
    break;

  case 'tile':
    // Generic tile type
    {
      CGenericTileType* newtile = new CGenericTileType;
      ReadFrom (newtile, stream);
      tile.addEntity (newtile);
    }
    rc = TAG_READ;
    break;
  }

  return rc;
}



//
// CTerrainTypeDatabase
//
// This class implements an interface to the terrain type database encoded in the
//   file tiletype.img.  The database is a 16K x 16K grid of 8-bit ground type
//   values, one for each default detail tile

CTerrainTypeDatabase::CTerrainTypeDatabase (void)
: img(NULL)
{
  // Open tiletype.img
  img = popen (&globals->pfs, "DATA\\TILETYPE.IMG");
  if (img == NULL) {
    gtfo ("CTerrainTypeDatabase : Cannot open TILETYPE.IMG");
  }
}

CTerrainTypeDatabase::~CTerrainTypeDatabase ()
{
  // Close tiletype.img
  if (img != NULL) {
    pclose (img);
  }
}

ETerrainType CTerrainTypeDatabase::GetTerrainType (int x, int z)
{
  // Calculate offset in tiletype.img for this tile.
  // The top-left entry in the image is x=0, z=16383
  long offset = ((16383 - z) * 16384) + x;

  pseek (img, offset, SEEK_SET);
  unsigned char c;
  pread (&c, 1, 1, img);

  ETerrainType t = (ETerrainType) c;

  // DEBUG : Set all tiles to use the same terrain type to test tiling
//  t = TERRAIN_CITY_USA;

  return t;
}


// Declare terrain type database, extern in Terrain.h
CTerrainTypeDatabase *ttdb = NULL;


//
// CDefaultTextureDatabase
//
// This class implements an interface to the set of detail tile textures for
//   default terrain
//
CDefaultTextureDatabase::CDefaultTextureDatabase (void)
{
  Init ();

  // Load .act (palette) for relief shading
  PODFILE *pAct = popen (&globals->pfs, "Art\\Topographic.act");
  if (pAct != NULL) {
    // Read palette data and close the POD file
    unsigned char data[256][3];
    pread (data, 256 * 3, 1, pAct);
    pclose (pAct);

    // Convert to float and copy to relief array
    for (int i=0; i<256; i++) {
      for (int j=0; j<3; j++) {
        relief[i][j] = (float)(data[i][j]) / 256;
      }
    }

    // Initialize relief mapping controls
    negativeIndex = 0;      // Palette index for negative elevations
    zeroIndex = 1;          // Palette index corresponding to zero elev
    maxElevation = 15000;   // Maximum positive elevation in feet
    baseIndex = 48;         // Palette index of lowest positive elevation
    maxIndex = 256;         // Palette index of highest elevation
  } else {
    gtfo ("DTDB : Cannot load relief shading texture");
  }
}

CDefaultTextureDatabase::~CDefaultTextureDatabase ()
{
  // Delete any cached base textures
  CRawImage *raw;
  for (int type=0; type<256; type++) {
    raw = low[type];
    if (raw != NULL) delete raw;

    for (int j=0; j<4; j++) {
      for (int k=0; k<4; k++) {
        raw = med[type][j][k];
        if (raw != NULL) delete raw;

        raw = high[type][j][k];
        if (raw != NULL) delete raw;
      }
    }
  }

  // Clean up any cached composite textures
  int n = composite.getNumEntities();
  for (int i=0; i<n; i++) {
    CRawImage *raw = (CRawImage *)composite.getEntity(i);
    delete raw;
  }
  composite.removeAllEntities();
}

void CDefaultTextureDatabase::Init (void)
{
  for (int type=0; type<256; type++) {
    // Preload all low-detail textures
    low[type] = NULL;

    /*  Low resolution textures should not even be used.  Comment out until
        until optimizations enable use of medium detail without constraints

    char raw[64];
    sprintf (raw, "SYSTEM\\GLOBE\\%02XFF1.RAW", type);
    char act[64];
    sprintf (act, "SYSTEM\\GLOBE\\%02XFF1.ACT", type);
    if (pexists (&globals->pfs, raw)) {
      low[type] = NULL;
    }
    */

    for (int j=0; j<4; j++) {
      for (int k=0; k<4; k++) {
        med[type][j][k] = NULL;
        high[type][j][k] = NULL;
      }
    }
  }

  // Initialize relief shading array
  memset (relief, 0, 256 * 3);
}


//
// Purge all medium- and high-detail textures to recover memory
//
void CDefaultTextureDatabase::Purge (void)
{
  for (int i=0; i<256; i++) {
    for (int j=0; j<4; j++) {
      for (int k=0; k<4; k++) {
        if (med[i][j][k] != NULL) {
          delete med[i][j][k];
        }
        med[i][j][k] = NULL;

        if (high[i][j][k] != NULL) {
          delete high[i][j][k];
        }
        high[i][j][k] = NULL;
      }
    }
  }
}


//
// Return a pointer to the base texture for the given subtile, terrain type
//   and resolution (tile detail level).  If the base texture is not already
//   cached then it will be loaded into the cache.  Calling applications should
//   not delete the returned object.
//
CRawImage* CDefaultTextureDatabase::GetBaseTexture (int x, int z,
                                                    ETerrainType type,
                                                    ETileDetail level)
{
  CRawImage *image = NULL;

  // Invert order of z subtiles
  z = 3 - z;

  switch (level) {
  case TILE_DETAIL_LOW:
    {
      // All low-detail textures should always be loaded
      if (low[type] == NULL) {
        char raw[64];
        sprintf (raw, "SYSTEM\\GLOBE\\%02XFF1.RAW", type);
        char act[64];
        sprintf (act, "SYSTEM\\GLOBE\\%02XFF1.ACT", type);
        if (pexists (&globals->pfs, raw) && pexists (&globals->pfs, act)) {
          low[type] = new CRawImage (64, 64, raw, act);
          image = low[type];
        }
      } else {
        // Texture has already been loaded
        image = low[type];
      }
    }
    break;

  case TILE_DETAIL_MEDIUM:
    {
      // Check to see if this texture has already been loaded
      if (med[type][x][z] == NULL) {
        // No, it has not been loaded yet
        char raw[64];
        sprintf (raw, "SYSTEM\\GLOBE\\%02X%d%d4D.RAW", type, x, z);
        char act[64];
        sprintf (act, "SYSTEM\\GLOBE\\%02X%d%d4D.ACT", type, x, z);
        if (pexists (&globals->pfs, raw) && pexists (&globals->pfs, act)) {
          image = new CRawImage (128, 128, raw, act);
          med[type][x][z] = image;
        } else {
          gtfo ("Cannot open medium-detail texture for terrain type 0x%02X", type);
        }
      } else {
        // Texture has already been loaded
        image = med[type][x][z];
      }
    }
    break;

  case TILE_DETAIL_HIGH:
    {
      // Check to see if this texture has already been loaded
      if (high[type][x][z] == NULL) {
        // No, it has not been loaded yet
        char raw[64];
        sprintf (raw, "SYSTEM\\GLOBE\\%02X%d%d5D.RAW", type, x, z);
        char act[64];
        sprintf (act, "SYSTEM\\GLOBE\\%02X%d%d5D.ACT", type, x, z);

        if (pexists (&globals->pfs, raw) && pexists (&globals->pfs, act)) {
          image = new CRawImage (256, 256, raw, act);
          high[type][x][z] = image;
        } else {
          gtfo ("Cannot open high-detail texture for terrain type 0x%02X", type);
        }
      } else {
        // Texture has already been loaded
        image = high[type][x][z];
      }
    }
    break;
  }

  return image;
}

//
// This function creates the generic texture name for a given detail tile.
//   The texture name identifies the unique combination of default terrain
//   types that are merged to form the texture for the tile.
//
void CDefaultTextureDatabase::GetCompositeTextureName (unsigned int x,
                                                       unsigned int z,
                                                       char *textureName)
{
  if (ttdb == NULL) return;

  // Calculate tile indices for all relevant tiles:
  //   A = Tile being looked up
  //   B = South bordering tile
  //   X = East bordering tile
  //   Y = South-East bordering tile

  unsigned int Xx = (x + 1) % 16384;
  unsigned int Xz = z;

  unsigned int Bx = x;
  unsigned int Bz = z - 1;   if (Bz < 0) Bz = 0;

  unsigned int Yx = (x + 1) % 16384;
  unsigned int Yz = z - 1;   if (Yz < 0) Yz = 0;

  // Get terrain types for all tiles
  ETerrainType Atype = ttdb->GetTerrainType (x, z);
  ETerrainType Xtype = ttdb->GetTerrainType (Xx, Xz);
  ETerrainType Btype = ttdb->GetTerrainType (Bx, Bz);
  ETerrainType Ytype = ttdb->GetTerrainType (Yx, Yz);

  // Calculate medium- and high-detail tile offset
  unsigned int xSubtile = x % 4;
  unsigned int zSubtile = z % 4;

  // Format texture name
  sprintf (textureName, "%02X%02X%02X%02X%1d%1d",
    Atype, Xtype, Btype, Ytype, xSubtile, zSubtile);
}

//
// This function compiles a customized generic detail tile texture.
//   The composite texture is composed of up to four generic detail
//   tile textures, properly transitioned based on the terrain type
//   of the tile in question, and the terrain types of the tiles to
//   the east, south and south-east.
//
// Composite textures are cached in case of re-use
//
CRawImage* CDefaultTextureDatabase::GetCompositeTexture (const char *textureName,
                                                         ETileDetail level)
{
  CRawImage *aRaw = NULL;

  // Parse texture name into base texture types
  ETerrainType Atype, Btype, Xtype, Ytype;
  unsigned int xSubtile, zSubtile;
  if (sscanf (textureName, "%02X%02X%02X%02X%1d%1d",
              &Atype, &Xtype, &Btype, &Ytype, &xSubtile, &zSubtile) == 6)
  {
    // Create the composite texture as a copy of base texture A
    aRaw = new CRawImage (*(dtdb->GetBaseTexture (xSubtile, zSubtile, Atype, level)));
    aRaw->SetName (textureName);

    CRawImage *bRaw = NULL;
    CRawImage *xRaw = NULL;
    CRawImage *yRaw = NULL;
    CMaskImage *bMask = NULL;
    CMaskImage *xMask = NULL;
    CMaskImage *yMask = NULL;

// Single preprocessor macro to enable/disable detail tile texture transitioning
#define DO_TRANSITIONS
#ifdef DO_TRANSITIONS

    // Don't transition to/from ocean tiles; these transitions are handled
    //   with the default water masks
    if (Atype != TERRAIN_WATER_OCEAN)
    {
      // Check for bottom-side transition first

      if ((Atype != Btype) && (Btype != TERRAIN_WATER_OCEAN)) {
        // Bottom-side transition applies
        bMask = tmdb->GetBottomTransition(level);
        bRaw = dtdb->GetBaseTexture (xSubtile, zSubtile, Btype, level);
      }

      // Check for right-side transition next
      if ((Atype != Xtype) && (Xtype != TERRAIN_WATER_OCEAN)) {
        // Right-side transition applies
        xMask = tmdb->GetRightTransition(level);
        xRaw = dtdb->GetBaseTexture (xSubtile, zSubtile, Xtype, level);
      }

      // Check for corner transition
      bool case1 = (Atype != Xtype) && (Atype == Ytype);
      bool case2 = (Atype == Xtype) && (Atype != Ytype);
      bool case3 = (Atype != Xtype) && (Atype != Ytype);
      if ((case1 || case2 || case3) && (Ytype != TERRAIN_WATER_OCEAN))
      {
        // Corner transition applies
        yMask = tmdb->GetCornerTransition(level);
        yRaw = dtdb->GetBaseTexture (xSubtile, zSubtile, Ytype, level);
      }

      // Merge all of the transition tiles together
      aRaw->MergeTransitions (bRaw, bMask,
                              xRaw, xMask,
                              yRaw, yMask);
    } else {
  /*
      // Check for watermask
      CMaskImage *wMask = wmdb->GetWaterMask (x, z, detail);
      if (wMask != NULL) {
        // Get water texture for this tile
        CRawImage *w = dtdb->GetRawImage (x, z, TERRAIN_WATER_OCEAN, detail);
      }
  */
    }
#endif // DO_TRANSITIONS
  }

  return aRaw;
}

//
// This function compiles a customized generic detail tile texture.
//   The composite texture is composed of up to four generic detail
//   tile textures, properly transitioned based on the terrain type
//   of the tile in question, and the terrain types of the tiles to
//   the east, south and south-east.
//
// Composite textures are cached in case of re-use
//
CRawImage* CDefaultTextureDatabase::GetCompositeTexture (unsigned int x,
                                                         unsigned int z,
                                                         ETileDetail level)
{
  char textureName[64];
  GetCompositeTextureName (x, z, textureName);

  return GetCompositeTexture (textureName, level);
}

//
// This function returns an RGB colour corresponding to the given elevation
//   for terrain relief shading
//
void CDefaultTextureDatabase::GetReliefShadingRGB (const float elev,
                                                   float &r, float &g, float &b)
{
  static const float zeroEpsilon = 3.0;

  // Calculate index
  int i = 0;
  if ((elev <= zeroEpsilon) && (elev >= -zeroEpsilon)) {
    // Elevation is considered to be zero
    i = zeroIndex;
  } else if (elev < 0) {
    // Negative elevations use a single colour
    i = negativeIndex;
  } else if (elev > maxElevation) {
    i = maxIndex;
  } else {
    // Positive elevation
    float d = 1 - ((maxElevation - elev) / maxElevation);
    int offset = (int)((float)(maxIndex - baseIndex) * d);
    i = baseIndex + offset;
  }

  // Assign colours
  r = relief[i][0];
  g = relief[i][1];
  b = relief[i][2];

  // DEBUG
//  float x = elev / 10000;
//  r = g = b = x;
}


// Declare default texture database, extern in Terrain.h
CDefaultTextureDatabase *dtdb = NULL;



//
// Scenery Model Database
//
// This class implements a centralized database for scenery models (BIN and SMF formats).
//

CSceneryModelDatabase::~CSceneryModelDatabase ()
{
  int n = model.getNumEntities();
  for (int i=0; i<n; i++) {
    SSceneryModel *m = (SSceneryModel *)model.getEntity(i);
    ssgEntity *ssge = m->smf->GetSSGEntity();
    ssge->deRef();
    delete m->smf;
    delete m;
  }
  model.removeAllEntities ();
}


ssgEntity* CSceneryModelDatabase::GetSceneryModel (const char* filename)
{
  ssgEntity *rc = NULL;

  // Search models already loaded
  for (int i=0; i<model.getNumEntities (); i++) {
    SSceneryModel *s = (SSceneryModel *) model.getEntity (i);
    if (stricmp (s->filename, filename) == 0) {
      // Found a match!
      rc = s->smf->GetSSGEntity();
      break;
    }
  }

  // If model is not already in the list, then load it
  if (rc == NULL) {
    // Load the model
    SSceneryModel *s = new SSceneryModel;
    strcpy (s->filename, filename);
    s->smf = new CModelSMF (filename);
    rc = s->smf->GetSSGEntity();

    // Add a superfluous reference to the model so it isn't deleted automatically
    rc->ref();

    // Add the model to the database cache
    model.addEntity (s);
  }

  return rc;
}


// Declare scenery model database, extern in Terrain.h
CSceneryModelDatabase *smdb = NULL;



//
// Transition Mask Database
//

CTransitionMaskDatabase::CTransitionMaskDatabase (void)
{
  // Load right-side transition masks
  high_right = new CMaskImage (256, 256, "Art\\TransRightHigh.raw");
  med_right = new CMaskImage (128, 128, "Art\\TransRightMed.raw");
  low_right = new CMaskImage (64, 64, "Art\\TransRightLow.raw");

  // Load bottom-side transition masks
  high_bottom = new CMaskImage (256, 256, "Art\\TransBottomHigh.raw");
  med_bottom = new CMaskImage (128, 128, "Art\\TransBottomMed.raw");
  low_bottom = new CMaskImage (64, 64, "Art\\TransBottomLow.raw");

  // Load corner transition masks
  high_corner = new CMaskImage (256, 256, "Art\\TransCornerHigh.raw");
  med_corner = new CMaskImage (128, 128, "Art\\TransCornerMed.raw");
  low_corner = new CMaskImage (64, 64, "Art\\TransCornerLow.raw");
}

CTransitionMaskDatabase::~CTransitionMaskDatabase (void)
{
  delete high_right;
  delete med_right;
  delete low_right;
  delete high_bottom;
  delete med_bottom;
  delete low_bottom;
  delete high_corner;
  delete med_corner;
  delete low_corner;
}

CMaskImage *CTransitionMaskDatabase::GetBottomTransition (ETileDetail detail)
{
  CMaskImage *rc = NULL;

  switch (detail) {
  case TILE_DETAIL_LOW:
    rc = low_bottom;
    break;

  case TILE_DETAIL_MEDIUM:
    rc = med_bottom;
    break;

  case TILE_DETAIL_HIGH:
    rc = high_bottom;
    break;
  }

  return rc;
}


CMaskImage *CTransitionMaskDatabase::GetRightTransition (ETileDetail detail)
{
  CMaskImage *rc = NULL;

  switch (detail) {
  case TILE_DETAIL_LOW:
    rc = low_right;
    break;

  case TILE_DETAIL_MEDIUM:
    rc = med_right;
    break;

  case TILE_DETAIL_HIGH:
    rc = high_right;
    break;
  }

  return rc;
}


CMaskImage *CTransitionMaskDatabase::GetCornerTransition (ETileDetail detail)
{
  CMaskImage *rc = NULL;

  switch (detail) {
  case TILE_DETAIL_LOW:
    rc = low_corner;
    break;

  case TILE_DETAIL_MEDIUM:
    rc = med_corner;
    break;

  case TILE_DETAIL_HIGH:
    rc = high_corner;
    break;
  }

  return rc;
}


// Declare transition mask database (extern in Terrain.h)
CTransitionMaskDatabase *tmdb = NULL;


//
// CGtpTile
//
void CGtpTile::Print (FILE *f)
{
}


//
// CGtpFile
//
CGtpFile::CGtpFile (void)
{
  nTiles = 0;
//  header = NULL;
//  data = NULL;
}

CGtpFile::~CGtpFile (void)
{
//  if (header) {
//    delete header;
//  }

//  if (data) {
//    delete data;
//  }
}

void CGtpFile::Print (FILE *f)
{
  fprintf (f, "  Globe Tile : %d,%d\n", x, z);
  fprintf (f, "    nTiles = %d\n", nTiles);
  for (int i=0; i<nTiles; i++) {
    CGtpTile *t = &tile[i];
    t->Print (f);
  }
}


//
// Water Mask Database
//

CWaterMaskDatabase::CWaterMaskDatabase (void)
{
}


CWaterMaskDatabase::~CWaterMaskDatabase (void)
{
}


void CWaterMaskDatabase::AddGlobeTile (int x, int z)
{
  int i, j;
  
  // Instantiate a new structure representing the coastlines in this globe tile
  CGtpFile *gt = new CGtpFile;
  gt->nTiles = 0;
  gt->x = x;
  gt->z = z;

  // Attempt to open GTP file for this globe tile.  If the file does not exist
  //   then there are no coastline tiles in the globe tile, but the empty
  //   CGtpFile instance should still be added to the database
  char gtpFilename[64];
  sprintf (gtpFilename, "Coast\\V%03d%03d.GTP", x, z);
  PODFILE *pGtp = popen (&globals->pfs, gtpFilename);
  if (pGtp != NULL) {
    // Read the entire GTP file into memory for parsing
    int gtpSize = pGtp->size;
    char *data = new char[gtpSize];
    pread (data, gtpSize, 1, pGtp);
    pclose (pGtp);

    // Get number of ground tiles for which there is coastline data
    char *p = data;
    gt->nTiles = LittleEndian (*((short*)p));
    p += sizeof(short);

    // Parse the header data for each tile
    SGtpHeader *header = new SGtpHeader [gt->nTiles];
    for (i=0; i<gt->nTiles; i++) {
      SGtpHeader *h = &header[i];
      short index;
      index = LittleEndian (*((short*)p));    p += sizeof(short);
      h->z = index / 64;
      h->x = index % 64;

      unsigned long offset;
      offset = LittleEndian (*((long*)p));    p += sizeof(long);
      h->offset = offset;
    }

    // Parse vertex and polygon data for each tile
    gt->tile = new CGtpTile[gt->nTiles];
    for (i=0; i<gt->nTiles; i++) {
      SGtpHeader *h = &header[i];

      // Instantiate new SGtpTile
      CGtpTile *tile = &(gt->tile[i]);
      tile->x = h->x;
      tile->z = h->z;

      // Reset data pointer to beginning of this tile
      p = &(data[h->offset]);

      // Read vertex data
      tile->nVertices = LittleEndian (*((short*)p));    p += sizeof(short);
      tile->vlist = new SGtpVertex[tile->nVertices];
      for (j=0; j<tile->nVertices; j++) {
        SGtpVertex *v = &(tile->vlist[j]);
        v->x = LittleEndian (*((float*)p));     p += sizeof(float);
        v->z = LittleEndian (*((float*)p));     p += sizeof(float);
      }

      // Read polygon data
      tile->nPolygons = LittleEndian (*((short*)p));    p += sizeof(short);
      tile->plist = new SGtpPolygon[tile->nPolygons];
      for (i=0; i<tile->nPolygons; i++) {
        // Get polygon vertex indices
        SGtpPolygon *poly = &(tile->plist[i]);
        poly->nPolyVerts = LittleEndian (*((short*)p)); p += sizeof(short);

        poly->pvlist = new short[poly->nPolyVerts];
        for (int j=0; j<poly->nPolyVerts; j++) {
          poly->pvlist[j] = LittleEndian (*((short*)p));  p += sizeof(short);
        }
      }
    }
  } else {
    globals->logWarning->Write ("Could not open default coastline file %s", gtpFilename);
  }

  // Add the watermask struct to the list
  gtlist.addEntity (gt);
}


int CWaterMaskDatabase::FindGlobeTile (int x, int z)
{
  int rc = -1;

  for (int i=0; i<gtlist.getNumEntities (); i++) {
    CGtpFile *gt = (CGtpFile*) gtlist.getEntity (i);
    if ((gt->x == x) && (gt->z == z)) {
      rc = i;
      break;
    }
  }

  return rc;
}


void CWaterMaskDatabase::DeleteGlobeTile (int x, int z)
{
  int i = FindGlobeTile (x, z);
  if (i != -1) {
    // Globe tile exists, delete it from the list and destroy
    CGtpFile *gt = (CGtpFile*) gtlist.getEntity (i);
    gtlist.removeEntity (i);
    delete gt;
  }
}

/*
//
// Determine the offset of the start of GTP polygon data for the specified detail tile
//
// Inputs:
//  dx      Detail tile x-index
//  dz      Detail tile z-index
//
// Outputs:
//  offset    Offset to start of polygon data for this detail tile
//  index   Index into watermask database globe tile list
//
// Returns:
//  bool    true if the offset is defined, i.e. watermask data exists for this tile
//
CGtpTile *CWaterMaskDatabase::FindDetailTile (int dx, int dz)
//bool CWaterMaskDatabase::DetailTileOffset (int dx, int dz, unsigned long *offset, int *index)
{
  CGtpTile *rc = NULL;

  // Convert absolute detail tile indices into globe tile and relative detail tile
  int x = dx / 64;
  int z = dz / 64;
  dx %= 64;
  dz %= 64;


  int index = FindGlobeTile (x, z);
  if (index != -1) {
    // The globe tile exists in the database
    CGtpFile *gt = (CGtpFile*) gtlist.getEntity (index);

    for (int i=0; i<gt->nTiles; i++) {
//      SGtpHeader *header = &gt->header[i];
      CGtpTile *tile = &(gt->tile[i]);

//      if ((header->x == dx) && (header->z == dz)) {
      if ((tile->x == dx) && (tile->z == dz)) {
        // Found a match
        rc = tile;
//        *offset = header->offset;
        break;
      }
    }
  }

  return rc;
}
*/

CMaskImage *CWaterMaskDatabase::GetWaterMask (int dx, int dz, ETileDetail detail)
{
  CMaskImage *rc = NULL;

  int x = dx / 64;
  int z = dz / 64;
  int i = FindGlobeTile (x, z);
  if (i != -1) {
    // Globe tile exists, search for detail tile
    CGtpFile *gt = (CGtpFile*) gtlist.getEntity (i);
    dx %= 64;
    dz %= 64;
    int nTiles = gt->nTiles;
    for (int j=0; j<nTiles; j++) {
      CGtpTile* tile = &(gt->tile[j]);

      if ((tile->x == dx) && (tile->z == dz)) {

        // Coastline data exists for this detail tile
        int mask_x = 0;
        int mask_z = 0;

        switch (detail) {
        case TILE_DETAIL_LOW:
          mask_x = mask_z = 64;
          break;

        case TILE_DETAIL_MEDIUM:
          mask_x = mask_z = 128;
          break;

        case TILE_DETAIL_HIGH:
          mask_x = mask_z = 256;
          break;

        default:
          gtfo ("CWaterMaskDatabase::GetWaterMask() : Invalid detail level");
        }

        // TEMP : Fill mask image with dummy checkerboard pattern
        GLubyte *data = new GLubyte[mask_x * mask_z];
        for (int m=0; m<mask_z; m++) {
          for (int n=0; n<mask_x; n++) {
            data[m * mask_x + n] = 0x80;
          }
        }

        // Create the watermask image
        char name[64];
        sprintf (name, "WaterMask %d,%d", dx, dz);
        rc = new CMaskImage (mask_x, mask_z, name);
      }
    }

    // "Draw" polygons in mask image bitmap
  }
  return rc;
}

void CWaterMaskDatabase::Print (FILE *f)
{
  fprintf (f, "Water Mask Database :\n");
  for (int i=0; i<gtlist.getNumEntities(); i++) {
    CGtpFile *g = (CGtpFile *)gtlist.getEntity (i);
    g->Print (f);
  }
}


// Declare watermask database (extern in Terrain.h)
CWaterMaskDatabase *wmdb = NULL;

Documentation generated by