ElevationDatabase.cpp

Go to the documentation of this file.

/*
 * ElevationDatabase.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/Qtr.h"
#include "../Include/VTP.h"
#include "../Include/Endian.h"

//
// CElevationLookup
//
CElevationLookup::CElevationLookup (void)
{
  glType = 0;
  points = NULL;
}

CElevationLookup::~CElevationLookup (void)
{
  int i, n;

  if (points != NULL) {
    n = points->getNumEntities();
    for (i=0; i<n; i++) {
      SElevationLookupPoint *p = (SElevationLookupPoint *)points->getEntity(i);
      delete p;
    }
    points->removeAllEntities();
    delete points;
  }
}


//
// CElevationBlock
//
CElevationBlock::CElevationBlock (int x, int z, int size)
{
  this->x = x;
  this->z = z;
  this->size = size;
  type = ELEVATION_TYPE_UNKNOWN;
}

CElevationBlock::~CElevationBlock (void)
{
}

int CElevationBlock::GetSize (void)
{
  return size;
}

bool CElevationBlock::DetailTileInBlock (int x, int z)
{
  bool rc = false;

  // Find block bounds at the specified level
  int minX = this->x;
  int maxX = minX + size;
  int minZ = this->z;
  int maxZ = minZ + size;

  rc = ((x >= minX) && (x < maxX) && (z >= minZ) && (z < maxZ));

  return rc;
}

EElevationType CElevationBlock::GetElevationType (void)
{
  return type;
}


//
// CElevationBlockQTR
//
CElevationBlockQTR::CElevationBlockQTR (int x, int z, const char* qtrFilename)
: CElevationBlock (x, z, 512)
{
  type = ELEVATION_TYPE_CENTER;
  qtrFile = new CQTRFile (qtrFilename);
}

CElevationBlockQTR::~CElevationBlockQTR (void)
{
  delete qtrFile;
}

//
// Currently, the only supported resolution is 1 sample per detail tile
//   (512 x 512 per QTR).  This will be relaxed in the future
//
int CElevationBlockQTR::GetDetailTileResolution (void)
{
  return 1;
}

void CElevationBlockQTR::GetDetailTileElevations (int x, int z, float **data)
{
  // Search the QTR file for the desired elevation value.
  
  int gx = x % 512;
  int gz = 511 - (z % 512);
  if (qtrFile != NULL) {
    int depth = TERRAIN_SUBDIVISION_DETAIL_TILE - TERRAIN_SUBDIVISION_QTR;
    data[0][0] =
      qtrFile->Search (depth, 0, gx, gz);
  }
}

//
// CElevationBlockBT
//
CElevationBlockBT::CElevationBlockBT (int x, int z, const char* btFilename)
: CElevationBlock (x, z, 512)
{
  type = ELEVATION_TYPE_CENTER;

}

CElevationBlockBT::~CElevationBlockBT (void)
{
}

//
// Currently, the only supported resolution is 1 sample per detail tile
//   (512 x 512 per QTR).  This will be relaxed in the future
//
int CElevationBlockBT::GetDetailTileResolution (void)
{
  return 1;
}

void CElevationBlockBT::GetDetailTileElevations (int x, int z, float **data)
{
  data[0][0] = 0.0f;
}


void CElevationBlockBT::Load (const char* btFilename)
{
  // Open the .bt file for input
  PODFILE* pbt = popen (&globals->pfs, btFilename);
  if (!pbt) {
    globals->logWarning->Write ("ERROR reading %s\n", btFilename);
    return;
  }

  // Read BT header
  SBTHeader btHeader;
  pread (&btHeader, 1, SIZEOF_BT_HEADER, pbt);

  // Binary fields in BT header are little-Endian
  btHeader.columns = LittleEndian (btHeader.columns);
  btHeader.rows = LittleEndian (btHeader.rows);
  btHeader.size = LittleEndian (btHeader.size);
  btHeader.fp = LittleEndian (btHeader.fp);
  btHeader.space_units = LittleEndian (btHeader.space_units);
  btHeader.utm_zone = LittleEndian (btHeader.utm_zone);
  btHeader.datum = LittleEndian (btHeader.datum);
  btHeader.left = LittleEndian (btHeader.left);
  btHeader.right = LittleEndian (btHeader.right);
  btHeader.bottom = LittleEndian (btHeader.bottom);
  btHeader.top = LittleEndian (btHeader.top);
  btHeader.prj = LittleEndian (btHeader.prj);
  btHeader.scale = LittleEndian (btHeader.scale);

  // Sanity check on header fields
  if (btHeader.columns != btHeader.rows) {
    gtfo ("ERROR : BT is not square, cols=%d rows=%d\n",
      btHeader.columns, btHeader.rows);
    pclose (pbt);
    gtfo ();
  }

  if (btHeader.columns != 513) {
    gtfo ("ERROR : BT must be 513 elements square (not %d)\n",
      btHeader.columns);
    pclose (pbt);
    gtfo ();
  }

  int bt_size = btHeader.columns * btHeader.rows;
  int i;

  // Allocate array for short data
  short *bt_data = new short[bt_size];

  if (btHeader.fp) {
    // Values are floating point
    switch (btHeader.size) {
    case 2:
      {
        // Single-precision float
        float *fdata = new float[bt_size];
        pread (fdata, sizeof(float), bt_size, pbt);
        for (i=0; i<bt_size; i++) {
          bt_data[i] = (short)(fdata[i] * FEET_PER_METRE);
        }
        delete fdata;
      }
      break;
    case 4:
      {
        // Double-precision float
        double *ddata = new double[bt_size];
        pread (ddata, sizeof(double), bt_size, pbt);
        for (i=0; i<bt_size; i++) {
          bt_data[i] = (short)(ddata[i] * FEET_PER_METRE);
        }
        delete ddata;
      }
      break;
    }
  } else {
    // Values are integers
    switch (btHeader.size) {
    case 2:
      {
        // Short integer
        short *sdata = new short[bt_size];
        pread (sdata, sizeof(short), bt_size, pbt);
        for (i=0; i<bt_size; i++) {
          bt_data[i] = (short)(sdata[i] * FEET_PER_METRE);
        }
        delete sdata;
      }
      break;

    case 4:
      {
        // Integer
        int *idata = new int[bt_size];
        pread (idata, sizeof(int), bt_size, pbt);
        for (i=0; i<bt_size; i++) {
          bt_data[i] = (short)(idata[i] * FEET_PER_METRE);
        }
        delete idata;
      }
      break;
    }
  }

  // Close .bt file
  pclose (pbt);
/*
  // Calculate detail tile bounds for this QTR tile
  int qtrX = qtr % 32;
  int qtrZ = qtr / 32;

  int dtW = qtrX * 512;     // West
  int dtE = dtW + 511;      // East
  int dtS = (31 - qtrZ) * 512;  // South
  int dtN = dtS + 511;      // North

  // Create elevation block and add it to the database
  CElevationGrid *grid = new CElevationGrid (dtW, dtE, dtS, dtN, bt_span);

  // Copy .bt elevation data to the elevation grid object
  grid->FillElevationData (bt_data);

  // Add the grid to the elevation database
  db.addEntity (grid);
*/
  // Free temporary buffers
  delete bt_data;
}

//
// CElevationBlockGrid
//
// The Grid elevation block contains a square array of 2^n+1 x 2^n+1
//   elevation samples representing the corners of an arbitrarily
//   subdivided area of detail tiles.
//
// The 'size' parameter indicates the size in detail tiles of the area.
// The 'subdivision' parameter indicates the level of subdivision per
//   detail tile:
//        AreaSize     SubdivisionLevel    ArraySize
//         4x4 DT             1              5 x 5    <elev> in SuperTile object
//         1x1 DT             4              5 x 5    <hdtl> object with <dimn>=4
//         1x1 DT             8              9 x 9    <hdtl> object with <dimn>=8
//
// In general, elevation array is n x n where n = [(size * subdivision) + 1]
//
CElevationBlockGrid::CElevationBlockGrid (int x, int z,
                                          int size, int subdivision,
                                          float** data)
: CElevationBlock (x, z, size)
{
  type = ELEVATION_TYPE_CORNER;

  this->subdivision = subdivision;
  this->data = data;
}

CElevationBlockGrid::~CElevationBlockGrid (void)
{
}

int CElevationBlockGrid::GetDetailTileResolution (void)
{
  return subdivision+1;
}

//
// Extracts elevations for a single Detail Tile.  The application is
//   responsible for determining the required array size by calling
//   GetDetailTileResolution(), allocating the float array and freeing
//   the data when it is no longer needed.
//
//       AreaSize     SubdivisionLevel     ArraySize
//        4x4 DT             1                2x2
//        1x1 DT             4                5x5
//        1x1 DT             8                9x9
//
// In general, detail tile array is n x n where n = (subdivision + 1)
//
void CElevationBlockGrid::GetDetailTileElevations (int x, int z, float **data)
{
  // Calculate detail tile offsets
  int dx = x - this->x;
  int dz = z - this->z;

  // Allocate storage for elevations
  int dimn = GetDetailTileResolution();
  for (int i=0; i<dimn; i++) {
    for (int j=0; j<dimn; j++) {
      data[i][j] = this->data[i + dz][j + dx];
    }
  }
}


//
// CElevationTRNSuperTile
//
CElevationTRNSuperTile::CElevationTRNSuperTile (int x, int z, int subdivision)
{
  this->x = x;
  this->z = z;
  this->subdivision = subdivision;
  elev = NULL;
  dtArray = new CElevationBlockGrid**[subdivision];
  for (int i=0; i<subdivision; i++) {
    dtArray[i] = new CElevationBlockGrid*[subdivision];
    for (int j=0; j<subdivision; j++) {
      dtArray[i][j] = NULL;
    }
  }
}

CElevationTRNSuperTile::~CElevationTRNSuperTile (void)
{
  if (elev != NULL) delete elev;
  for (int i=0; i<subdivision; i++) {
    for (int j=0; j<subdivision; j++) {
      delete dtArray[i][j];
    }
    delete[] dtArray[i];
  }
  delete[] dtArray;
}


//
// CElevationTRNQuarterGlobeTile
//
CElevationTRNQuarterGlobeTile::CElevationTRNQuarterGlobeTile (int x, int z, int subdivision)
{
  this->x = x;
  this->z = z;
  this->subdivision = subdivision;
  stArray = new CElevationTRNSuperTile**[subdivision];
  for (int i=0; i<subdivision; i++) {
    stArray[i] = new CElevationTRNSuperTile*[subdivision];
    for (int j=0; j<subdivision; j++) {
      stArray[i][j] = NULL;
    }
  }
}

CElevationTRNQuarterGlobeTile::~CElevationTRNQuarterGlobeTile (void)
{
  for (int i=0; i<subdivision; i++) {
    for (int j=0; j<subdivision; j++) {
      delete stArray[i][j];
    }
    delete[] stArray[i];
  }
  delete[] stArray;
}


//
// CTileElevationDatabase
//
CTileElevationDatabase::CTileElevationDatabase (void)
{
  qtrList = new ulList (8);
  trnList = new ulList (64);

  btList = NULL;
}

CTileElevationDatabase::~CTileElevationDatabase (void)
{
  int i, n;

  // Delete all entries in the TRN elevation block list
  if (trnList != NULL) {
    n = trnList->getNumEntities();
    for (i=0; i<n; i++) {
      CElevationTRNQuarterGlobeTile *trn =
        (CElevationTRNQuarterGlobeTile *)trnList->getEntity(i);
      delete trn;
    }
    delete trnList;
  }

  // Delete all entries in the BT elevation block list
  if (btList != NULL) {
    n = btList->getNumEntities();
    for (i=0; i<n; i++) {
      CElevationBlock *block = (CElevationBlock *)btList->getEntity(i);
      delete block;
    }
    delete btList;
  }

  // Delete all entries in the QTR elevation block list
  if (qtrList != NULL) {
    n = qtrList->getNumEntities();
    for (i=0; i<n; i++) {
      CElevationBlock *block = (CElevationBlock *)qtrList->getEntity(i);
      delete block;
    }
    delete qtrList;
  }
}

//
// Add the specified elevation block to the database
//
void CTileElevationDatabase::AddQTRBlock (CElevationBlockQTR *block)
{
  qtrList->addEntity (block);
}

//
// Create a new placeholder for TRN elevation data.  A TRN covers an entire QGT
//
CElevationTRNQuarterGlobeTile *CTileElevationDatabase::AddTRN (int x, int z, 
                                                               int subdivision)
{
  CElevationTRNQuarterGlobeTile *rc = new CElevationTRNQuarterGlobeTile (x, z, subdivision);
  trnList->addEntity (rc);
  return rc;
}

//
// Remove a TRN elevation data placeholder, including all embedded super tile blocks
//
void CTileElevationDatabase::RemoveTRN (int x, int z)
{
  CElevationTRNQuarterGlobeTile *trn = SearchTRN (x, z);
  if (trn != NULL) {
    delete trn;
    trnList->removeEntity (trn);
  }
}

CElevationTRNQuarterGlobeTile *CTileElevationDatabase::SearchTRN (int x, int z)
{
  CElevationTRNQuarterGlobeTile *rc = NULL;

  int i, n;
  n = trnList->getNumEntities();
  for (i=0; (i<n) && (rc==NULL); i++) {
    CElevationTRNQuarterGlobeTile *trn =
      (CElevationTRNQuarterGlobeTile *)trnList->getEntity(i);
    if ((trn->x == x) && (trn->z == z)) {
      rc = trn;
    }
  }

  return rc;
}

//
// Remove the specified elevation block from the database
//
bool CTileElevationDatabase::RemoveQTRBlock (CElevationBlockQTR *block)
{
  bool found = false;
  int i, n;
  n = qtrList->getNumEntities();
  for (i=0; i<n && !found; i++) {
    CElevationBlockQTR *b = (CElevationBlockQTR *)qtrList->getEntity(i);
    found = (block == b);
  }
  
  if (found) {
    qtrList->removeEntity (i);
  }

  return found;
}

//
// Convert detail tile x,z indices into the corresponding QTR tile index
//
int CTileElevationDatabase::DetailTileToQtrTile (int x, int z)
{
  int qtr_x = x / 512;
  int qtr_z = 31 - (z / 512);
  return (qtr_z * 32) + qtr_x;
}

//
// Find the lower-left (south-west) detail tile in the given QTR tile
//
void CTileElevationDatabase::QtrBaseDetailTile (int qtr, int *x, int *z)
{
  int qtr_x = qtr % 32;
  int qtr_z = 31 - (qtr / 32);
  *x = qtr_x * 512;
  *z = qtr_z * 512;
}

//
// Load one QTR of elevations from an Enviro .bt format file
//
CElevationBlockBT *CTileElevationDatabase::LoadBT (int qtr)
{
  CElevationBlockBT *rc = NULL;

  // Get lower-left detail tile indices for this qtr
  int x, z;
  QtrBaseDetailTile (qtr, &x, &z);

  // If the .bt file exists, instantiate a new CElevationBlockBT and
  //   add it to the database list
  char btFilename[64];
  sprintf (btFilename, "BT\\FMQTR%03X.BT", qtr);
  if (pexists (&globals->pfs, btFilename)) {
    rc = new CElevationBlockBT (x, z, btFilename);
  }

  return rc;
}

//
// Load one QTR of elevations from a Fly! II QTR format file
//
CElevationBlockQTR *CTileElevationDatabase::LoadQTR (int qtr)
{
  CElevationBlockQTR *rc = NULL;

  // Get lower-left detail tile indices for this qtr
  int x, z;
  QtrBaseDetailTile (qtr, &x, &z);

  // If the .qtr file exists, instantiate a new CElevationBlockQTR and
  //   add it to the database list
  char qtrFilename[64];
  sprintf (qtrFilename, "DATA\\%03X.QTR", qtr);
  if (pexists (&globals->pfs, qtrFilename)) {
    rc = new CElevationBlockQTR (x, z, qtrFilename);
  }

  return rc;
}

//
// Search for smallest cached elevation block that contains the desired detail tile
//
CElevationBlock *CTileElevationDatabase::Search (int x, int z)
{
  CElevationBlock *block = NULL;
  int i, n;

  // First check TRN elevation list
  int qx = x / 32;
  int qz = z / 32;
  CElevationTRNQuarterGlobeTile *trn = SearchTRN (qx, qz);
  if (trn != NULL) {
    // TRN data exists for the quarter globe tile
    int sx = (x / 4) % 8;
    int sz = (z / 4) % 8;
    CElevationTRNSuperTile *stTrn = trn->stArray[sx][sz];
    if (stTrn != NULL) {
      // TRN data exists for the super tile
      int dx = x % 4;
      int dz = z % 4;
      if (stTrn->dtArray[dx][dz] != NULL) {
        // High-detail elevations exists for the detail tile
        block = stTrn->dtArray[dx][dz];
      } else {
        // Use base resolution block from the super tile
        block = stTrn->elev;
      }
    }
  }


  // Finally search QTR list
  if (block == NULL) {
    n = qtrList->getNumEntities();
    for (i=0; i<n; i++) {
      CElevationBlock *testBlock = (CElevationBlock *)qtrList->getEntity(i);
      if (testBlock->DetailTileInBlock(x, z)) {
        // Found a QTR block that contains this detail tile
        block = testBlock;
        break;
      }
    }
  }

  // If no block was found, load the default QTR elevation block
  if (block == NULL) {
    block = LoadQTR (DetailTileToQtrTile (x, z));
    qtrList->addEntity (block);
  }

  return block;
}

//
// Get the type of elevation data that is available for the desired tile
//
EElevationType CTileElevationDatabase::GetElevationType (int x, int z)
{
  EElevationType rc = ELEVATION_TYPE_UNKNOWN;
  CElevationBlock *block = Search (x, z);
  if (block != NULL) rc = block->GetElevationType();
  return rc;
}

int CTileElevationDatabase::GetDetailTileResolution (int x, int z)
{
  int rc = 0;

  CElevationBlock *block = Search (x, z);
  if (block != NULL) {
    rc = block->GetDetailTileResolution();
  }

  return rc;
}

static void AllocateElevationArray (int dimn, float ***array)
{
  *array = new float*[dimn];
  for (int i=0; i<dimn; i++) {
    (*array)[i] = new float[dimn];
  }
}

static void FreeElevationArray (int dimn, float **array)
{
  for (int i=0; i<dimn; i++) {
    delete[] array[i];
  }
  delete[] array;
}

static float max3 (float f1, float f2, float f3)
{
  float rc = f1;

  if (f2 > rc) rc = f2;
  if (f3 > rc) rc = f3;

  return rc;
}

//
// Return an interpolated elevation from the specified grid.
//
// See http://www.geovista.psu.edu/sites/geocomp99/Gc99/082/gc_082.htm
//   for details re: bilinear interpolation function (and others)
//
float InterpolatedData (float x, float z, int res, float **data)
{
  float rc = 0.0f;

  float fres = (float)(res-1);

  // Calculate indices of the interpolation points in the tile data
  int ix0, ix1, iz0, iz1;

  if (z == 0.0f) {
    iz0 = iz1 = 0;
  } else if (z == 1.0f) {
    iz0 = iz1 = res-1;
  } else {
    iz0 = (int)(floorf(fres * z));
    iz1 = iz0 + 1;
  }

  if (x == 0.0f) {
    ix0 = ix1 = 0;
  } else if (x == 1.0f) {
    ix0 = ix1 = res-1;
  } else {
    ix0 = (int)(floorf(fres * x));
    ix1 = ix0 + 1;
  }

  // Get the four height (elevation) values to be interpolated
  //
  //   h3  ----------  h4
  //      |          |
  //      |          |
  //      |          |
  //      |          |
  //   h1  ----------  h2
  //
  float h1 = data[iz0][ix0];
  float h2 = data[iz0][ix1];
  float h3 = data[iz1][ix0];
  float h4 = data[iz1][ix1];

  // Adjust x, z distance by distance to h1
  float delta = 1.0f / fres;
  x -= ix0 * delta;
  z -= iz0 * delta;

  // Interpolate
  rc = h1 + ((h2 - h1) * x) + ((h3 - h1) * z) + ((h1 - h2 - h3 + h4) * x * z);

  return rc;
}


//
// Primary lookup method for the tile elevation database.  Given a tile
//   subdivision level and the x,z coordinates, returns an array of
//   elevation points for the tile, in feet.
//
// The returned CElevationLookup instance must be deleted by the calling application.
//
CElevationLookup *CTileElevationDatabase::GetDetailTileElevations (int x, int z)
{
  int i, j;

  CElevationLookup *rc = NULL;

  // Declare locals for surrounding corner elevations required for interpolation
  float **nwTile = NULL;
  float **wTile = NULL;
  float **swTile = NULL;
  float **sTile = NULL;
  float **seTile = NULL;
  float **eTile = NULL;
  float **neTile = NULL;
  float **nTile = NULL;

  int nwResolution = 0;
  int wResolution = 0;
  int swResolution = 0;
  int sResolution = 0;
  int seResolution = 0;
  int eResolution = 0;
  int neResolution = 0;
  int nResolution = 0;

  CElevationBlock *nwBlock = NULL;
  CElevationBlock *wBlock = NULL;
  CElevationBlock *swBlock = NULL;
  CElevationBlock *sBlock = NULL;
  CElevationBlock *seBlock = NULL;
  CElevationBlock *eBlock = NULL;
  CElevationBlock *neBlock = NULL;
  CElevationBlock *nBlock = NULL;

  // Search for elevation block for this tile
  CElevationBlock *thisBlock = Search (x, z);
  float **thisTile = NULL;
  int thisResolution;

  // Finally search the elevation block for the data
  if (thisBlock != NULL) {
    // Determine type of elevation data for this detail tile
    thisResolution = thisBlock->GetDetailTileResolution();
    EElevationType type = thisBlock->GetElevationType();
    switch (type) {
    case ELEVATION_TYPE_CENTER:
      {
        // Elevation lookup will be in the form of a fan, consisting of a center
        //   elevation plus a minimum of four other vertices, one for each corner.
        //   Additional vertices may be present along the borders to align with
        //   adjacent high-detail tiles

        bool nwDone = false, swDone = false, seDone = false, neDone = false;
        int nWest = 0, nSouth = 0, nEast = 0, nNorth = 0;
        float westEdge[7], southEdge[7], eastEdge[7], northEdge[7];
        float centerElev = 0, nwElev = 0, swElev = 0, seElev = 0, neElev = 0;

        // Get center elevation for this tile
        AllocateElevationArray (thisResolution, &thisTile);
        thisBlock->GetDetailTileElevations (x, z, thisTile);
        centerElev = thisTile[0][0];
        FreeElevationArray (thisResolution, thisTile);

        // Check if W adjacent tile has corner elevations in database
        wBlock = Search (x-1, z);
        wResolution = wBlock->GetDetailTileResolution();
        if (wBlock->GetElevationType () == ELEVATION_TYPE_CORNER) {
          // Get tile elevations
          AllocateElevationArray (wBlock->GetDetailTileResolution(), &wTile);
          wBlock->GetDetailTileElevations (x-1, z, wTile);

          // NW corner of this tile is NE corner of W tile
          nwElev = wTile[wResolution-1][wResolution-1];
          nwDone = true;
          // SW corner of this tile is SE corner of W tile
          swElev = wTile[0][wResolution-1];
          swDone = true;

          // Extract intermediate edge vertices if resolution is higher than 2x2
          if (wResolution > 2) {
            nWest = wResolution - 2;

            // Copy edges from E edge of tile , N->S, into edge array
            for (int i=0; i<nWest; i++) {
              westEdge[i] = wTile[wResolution-2-i][wResolution-1];
            }
          }
        }

        // Check if E adjacent tile has corner elevations in database
        eBlock = Search (x+1, z);
        eResolution = eBlock->GetDetailTileResolution();
        if (eBlock->GetElevationType () == ELEVATION_TYPE_CORNER) {
          // Get tile elevations, extract corners
          AllocateElevationArray (eResolution, &eTile);
          eBlock->GetDetailTileElevations (x+1, z, eTile);

          // NE corner of this tile is NW corner of E tile
          neElev = eTile[eResolution-1][0];
          neDone = true;
          // SE corner of this tile is SW corner of E tile
          seElev = eTile[0][0];
          seDone = true;

          // Extract intermediate edge vertices if resolution is higher than 2x2
          if (eResolution > 2) {
            nEast = eResolution - 2;

            // Copy edges from W edge of tile , S->N, into edge array
            for (int i=0; i<nEast; i++) {
              eastEdge[i] = eTile[i+1][0];
            }
          }
        }

        // Check N adjacent tile for corner elevations higher than 2x2 resolution
        nBlock = Search (x, z+1);
        nResolution = nBlock->GetDetailTileResolution();
        if (nBlock->GetElevationType () == ELEVATION_TYPE_CORNER) {
          // Get tile elevations, extract corners
          AllocateElevationArray (nBlock->GetDetailTileResolution(), &nTile);
          nBlock->GetDetailTileElevations (x, z+1, nTile);

          // NE corner of this tile is SE corner of N tile
          neElev = nTile[0][nResolution-1];
          neDone = true;
          // NW corner of this tile is SW corner of N tile
          nwElev = nTile[0][0];
          nwDone = true;

          // Extract intermediate edge vertices if resolution is higher than 2x2
          if (nResolution > 2) {
            nNorth = nResolution - 2;

            // Copy edges from S edge of tile , E->W, into edge array
            for (int i=0; i<nNorth; i++) {
              northEdge[i] = nTile[0][nResolution-2-i];
            }
          }
        }

        // Check S adjacent tile for corner elevations higher than 2x2 resolution
        sBlock = Search (x, z-1);
        sResolution = sBlock->GetDetailTileResolution();
        if (sBlock->GetElevationType () == ELEVATION_TYPE_CORNER) {
          // Get tile elevations, extract corners
          AllocateElevationArray (sResolution, &sTile);
          sBlock->GetDetailTileElevations (x, z-1, sTile);

          // SE corner of this tile is NE corner of S tile
          seElev = sTile[sResolution-1][sResolution-1];
          seDone = true;
          // SW corner of this tile is NW corner of S tile
          swElev = sTile[sResolution-1][0];
          swDone = true;

          // Extract intermediate edge vertices if resolution is higher than 2x2
          if (sResolution > 2) {
            nSouth = sResolution - 2;

            // Copy edges from N edge of tile , W->E, into edge array
            for (int i=0; i<nSouth; i++) {
              southEdge[i] = sTile[sResolution-1][i+1];
            }
          }
        }

        // Determine NW corner if it has not already been done
        if (!nwDone) {
          // Check NW adjacent tile to see if it has corner vertices
          if (nwBlock == NULL) {
            nwBlock = Search (x-1, z+1);
            nwResolution = nwBlock->GetDetailTileResolution();
          }
          switch (nwBlock->GetElevationType()) {
          case ELEVATION_TYPE_CORNER:
            {
              // Get elevations for NW corner tile
              AllocateElevationArray (nwResolution, &nwTile);
              nwBlock->GetDetailTileElevations (x-1, z+1, nwTile);

              // Extract SE corner from elevation block
              nwElev = nwTile[0][nwResolution-1];
              nwDone = true;
            }
            break;

          case ELEVATION_TYPE_CENTER:
            // All surrounding tiles have center elevations only
            if (nTile == NULL) {
              nBlock = Search (x, z+1);
              nResolution = nBlock->GetDetailTileResolution();
              AllocateElevationArray (nResolution, &nTile);
              nBlock->GetDetailTileElevations (x, z+1, nTile);
            }
            if (nwTile == NULL) {
              nwBlock = Search (x-1, z+1);
              nwResolution = nwBlock->GetDetailTileResolution();
              AllocateElevationArray (nwResolution, &nwTile);
              nwBlock->GetDetailTileElevations (x-1, z+1, nwTile);
            }
            if (wTile == NULL) {
              wBlock = Search (x-1, z);
              wResolution = wBlock->GetDetailTileResolution();
              AllocateElevationArray (wResolution, &wTile);
              wBlock->GetDetailTileElevations (x-1, z, wTile);
            }
            nwElev = (centerElev + nTile[0][0] + nwTile[0][0] + wTile[0][0]) / 4.0f;
            nwDone = true;
            break;

          default:
            globals->logWarning->Write ("No elevation data for NW corner of %d,%d", x, z);
            nwElev = centerElev;
          }
        }

        // Determine SW corner if it has not already been done
        if (!swDone) {
          // Check SW adjacent tile to see if it has corner vertices
          if (swBlock == NULL) {
            swBlock = Search (x-1, z-1);
          }
          switch (swBlock->GetElevationType()) {
          case ELEVATION_TYPE_CORNER:
            {
              // Get elevations for SW corner tile
              swResolution = swBlock->GetDetailTileResolution();
              AllocateElevationArray (swResolution, &swTile);
              swBlock->GetDetailTileElevations (x-1, z-1, swTile);

              // Extract NE corner from elevation block
              swElev = swTile[swResolution-1][swResolution-1];
              swDone = true;
            }
            break;

          case ELEVATION_TYPE_CENTER:
            // All surrounding tiles have center elevations only
            if (wTile == NULL) {
              wBlock = Search (x-1, z);
              wResolution = wBlock->GetDetailTileResolution();
              AllocateElevationArray (wResolution, &wTile);
              wBlock->GetDetailTileElevations (x-1, z, wTile);
            }
            if (swTile == NULL) {
              swBlock = Search (x-1, z-1);
              swResolution = swBlock->GetDetailTileResolution();
              AllocateElevationArray (swResolution, &swTile);
              swBlock->GetDetailTileElevations (x-1, z-1, swTile);
            }
            if (sTile == NULL) {
              sBlock = Search (x, z-1);
              sResolution = sBlock->GetDetailTileResolution();
              AllocateElevationArray (sResolution, &sTile);
              sBlock->GetDetailTileElevations (x, z-1, sTile);
            }
            swElev = (centerElev + wTile[0][0] + swTile[0][0] + sTile[0][0]) / 4.0f;
            swDone = true;
            break;

          default:
            globals->logWarning->Write ("No elevation data for SW corner of %d,%d", x, z);
            swElev = centerElev;
          }
        }

        // Determine SE corner if it has not already been done
        if (!seDone) {
          // Check SE adjacent tile to see if it has corner vertices
          if (seBlock == NULL) {
            seBlock = Search (x+1, z-1);
          }
          switch (seBlock->GetElevationType()) {
          case ELEVATION_TYPE_CORNER:
            {
              // Get elevations for SE corner tile
              seResolution = seBlock->GetDetailTileResolution();
              AllocateElevationArray (seResolution, &seTile);
              seBlock->GetDetailTileElevations (x+1, z-1, seTile);

              // Extract NW corner from elevation block
              seElev = seTile[seResolution-1][0];
              seDone = true;
            }
            break;

          case ELEVATION_TYPE_CENTER:
            // All surrounding tiles have center elevations only
            if (sTile == NULL) {
              sBlock = Search (x, z-1);
              sResolution = sBlock->GetDetailTileResolution();
              AllocateElevationArray (sResolution, &sTile);
              sBlock->GetDetailTileElevations (x, z-1, sTile);
            }
            if (seTile == NULL) {
              seBlock = Search (x+1, z-1);
              seResolution = seBlock->GetDetailTileResolution();
              AllocateElevationArray (seResolution, &seTile);
              seBlock->GetDetailTileElevations (x+1, z-1, seTile);
            }
            if (eTile == NULL) {
              eBlock = Search (x+1, z);
              eResolution = eBlock->GetDetailTileResolution();
              AllocateElevationArray (eResolution, &eTile);
              eBlock->GetDetailTileElevations (x+1, z, eTile);
            }
            seElev = (centerElev + sTile[0][0] + seTile[0][0] + eTile[0][0]) / 4.0f;
            seDone = true;
            break;

          default:
            globals->logWarning->Write ("No elevation data for SE corner of %d,%d", x, z);
            seElev = centerElev;
          }
        }

        // Determine NE corner if it has not already been done
        if (!neDone) {
          if (neBlock == NULL) {
            neBlock = Search (x+1, z+1);
          }
          switch (neBlock->GetElevationType()) {
          case ELEVATION_TYPE_CORNER:
            {
              // Get elevations for NE corner tile
              neResolution = neBlock->GetDetailTileResolution();
              AllocateElevationArray (neResolution, &neTile);
              neBlock->GetDetailTileElevations (x+1, z+1, neTile);

              // Extract SW corner from elevation block
              neElev = neTile[0][0];
              neDone = true;
            }
            break;

          case ELEVATION_TYPE_CENTER:
            // All surrounding tiles have center elevations only
            if (eTile == NULL) {
              eBlock = Search (x+1, z);
              eResolution = eBlock->GetDetailTileResolution();
              AllocateElevationArray (eResolution, &eTile);
              eBlock->GetDetailTileElevations (x+1, z, eTile);
            }
            if (neTile == NULL) {
              neBlock = Search (x+1, z+1);
              neResolution = neBlock->GetDetailTileResolution();
              AllocateElevationArray (neResolution, &neTile);
              neBlock->GetDetailTileElevations (x+1, z+1, neTile);
            }
            if (nTile == NULL) {
              nBlock = Search (x, z+1);
              nResolution = nBlock->GetDetailTileResolution();
              AllocateElevationArray (nResolution, &nTile);
              nBlock->GetDetailTileElevations (x, z+1, nTile);
            }
            neElev = (centerElev + eTile[0][0] + neTile[0][0] + nTile[0][0]) / 4.0f;
            neDone = true;
            break;

          default:
            globals->logWarning->Write ("No elevation data for NE corner of %d,%d", x, z);
            neElev = centerElev;
          }
        }

        // Clean up surrounding tile data
        if (nwTile != NULL) FreeElevationArray (nwResolution, nwTile);
        if (wTile != NULL)  FreeElevationArray (wResolution,   wTile);
        if (swTile != NULL) FreeElevationArray (swResolution, swTile);
        if (sTile != NULL)  FreeElevationArray (sResolution,   sTile);
        if (seTile != NULL) FreeElevationArray (seResolution, seTile);
        if (eTile != NULL)  FreeElevationArray (eResolution,   eTile);
        if (neTile != NULL) FreeElevationArray (neResolution, neTile);
        if (nTile != NULL)  FreeElevationArray (nResolution,   nTile);

        // Combine all elevation values into triangle fan lookup class instance
        int i;
        float dx, dz;
        int nPoints = 6 + nWest + nSouth + nEast + nNorth;
        rc = new CElevationLookup;
        rc->glType = GL_TRIANGLE_FAN;
        rc->u.fanData.nPoints = nPoints;
        rc->points = new ulList(nPoints);

        SElevationLookupPoint *p;

        // Add center
        p = new SElevationLookupPoint;
        p->x = 0.5f;
        p->z = 0.5f;
        p->elevation = centerElev;
        rc->points->addEntity(p);

        // Add NW corner
        p = new SElevationLookupPoint;
        p->x = 0.0f;
        p->z = 0.0f;
        p->elevation = nwElev;
        rc->points->addEntity(p);

        // Add W intermediate points, from N->S
        dz = 1.0f / (nWest + 1);
        for (i=0; i<nWest; i++) {
          p = new SElevationLookupPoint;
          p->x = 0.0f;
          p->z = (float)(i+1) * dz;
          p->elevation = westEdge[i];
          rc->points->addEntity(p);
        }

        // Add SW corner
        p = new SElevationLookupPoint;
        p->x = 0.0f;
        p->z = 1.0f;
        p->elevation = swElev;
        rc->points->addEntity(p);

        // Add S intermediate points, from W->E
        dx = 1.0f / (nSouth + 1);
        for (i=0; i<nSouth; i++) {
          p = new SElevationLookupPoint;
          p->x = (float)(i+1) * dx;
          p->z = 1.0f;
          p->elevation = southEdge[i];
          rc->points->addEntity(p);
        }

        // Add SE corner
        p = new SElevationLookupPoint;
        p->x = 1.0f;
        p->z = 1.0f;
        p->elevation = seElev;
        rc->points->addEntity(p);

        // Add E intermediate points, S->N
        dz = 1.0f / (nEast + 1);
        for (i=0; i<nEast; i++) {
          p = new SElevationLookupPoint;
          p->x = 1.0f;
          p->z = 1.0f - ((float)(i+1) * dz);
          p->elevation = eastEdge[i];
          rc->points->addEntity(p);
        }

        // Add NE corner
        p = new SElevationLookupPoint;
        p->x = 1.0f;
        p->z = 0.0f;
        p->elevation = neElev;
        rc->points->addEntity(p);

        // Add N intermediate points, from E->W
        dx = 1.0f / (nNorth + 1);
        for (i=0; i<nNorth; i++) {
          p = new SElevationLookupPoint;
          p->x = 1.0f - ((float)(i+1) * dx);
          p->z = 0.0f;
          p->elevation = northEdge[i];
          rc->points->addEntity(p);
        }

        // Add NW corner again to close the fan
        p = new SElevationLookupPoint;
        p->x = 0.0f;
        p->z = 0.0f;
        p->elevation = nwElev;
        rc->points->addEntity(p);
      }
      break;

    case ELEVATION_TYPE_CORNER:
      {
        // Determine overall resolution required to hold all elevation samples
        //   for this tile.  In each direction, the dimension of the array
        //   is the maximum of this tile's resolution and those of the adjoining
        //   tiles.

        int tileResolution = thisBlock->GetDetailTileResolution();

        int northResolution = 0;
        CElevationBlock *northBlock = Search (x, z+1);
        if (northBlock->GetElevationType() == ELEVATION_TYPE_CORNER) {
          northResolution = northBlock->GetDetailTileResolution();
        }

        int southResolution = 0;
        CElevationBlock *southBlock = Search (x, z-1);
        if (southBlock->GetElevationType() == ELEVATION_TYPE_CORNER) {
          southResolution = southBlock->GetDetailTileResolution();
        }

        int westResolution = 0;
        CElevationBlock *westBlock = Search (x-1, z);
        if (westBlock->GetElevationType() == ELEVATION_TYPE_CORNER) {
          westResolution = westBlock->GetDetailTileResolution();
        }

        int eastResolution = 0;
        CElevationBlock *eastBlock = Search (x+1, z);
        if (eastBlock->GetElevationType() == ELEVATION_TYPE_CORNER) {
          eastResolution = eastBlock->GetDetailTileResolution();
        }

        // Allocate overall elevation array for this tile
        int xTile = max3 (tileResolution, northResolution, southResolution);
        int zTile = max3 (tileResolution, westResolution, eastResolution);
        float **overallData;
        overallData = new float*[zTile];
        for (i=0; i<zTile; i++) {
          overallData[i] = new float[xTile];
        }

        // Get detail tile elevations and copy to overall array
        if ((xTile > tileResolution) || (zTile > tileResolution)) {
          // Overall array is larger than tile array; initialize the overall array
          //   with elevations interpolated from the tile's elevations
          float **tileData;
          AllocateElevationArray (tileResolution, &tileData);
          thisBlock->GetDetailTileElevations (x, z, tileData);
          float dx = 1.0f / (float)(xTile - 1);
          float dz = 1.0f / (float)(zTile - 1);
          for (i=0; i<zTile; i++) {
            for (j=0; j<xTile; j++) {
              float xInt = j * dx;
              float zInt = i * dz;
              overallData[i][j] = InterpolatedData (xInt, zInt, tileResolution, tileData);
            }
          }
          FreeElevationArray (tileResolution, tileData);

          // Override N border if required
          if (northResolution > tileResolution) {
            // North tile is higher resolution than this tile, so the border
            //   must be overridden
            float **northData;
            AllocateElevationArray (northResolution, &northData);
            northBlock->GetDetailTileElevations(x, z+1, northData);
            if (xTile > northResolution) {
              // North tile is lower resolution than overall data; interpolate
              //   elevations from southern edge of the north tile
              for (j=0; j<xTile; j++) {
                overallData[zTile-1][j] = InterpolatedData (0.0f, (float)j * dx,
                                                            northResolution, northData);
              }
            } else {
              // North tile is same resolution as overall data, simply copy
              //   southern elevations to northern border of overall data
              for (j=0; j<xTile; j++) {
                overallData[zTile-1][j] = northData[0][j];
              }
            }
            FreeElevationArray (northResolution, northData);
          }

          // Override S border if required
          if (southResolution > tileResolution) {
            // South tile is higher resolution than this tile, so the border
            //   must be overridden
            float **southData;
            AllocateElevationArray (southResolution, &southData);
            southBlock->GetDetailTileElevations(x, z-1, southData);
            if (xTile > southResolution) {
              // South tile is lower resolution than overall data; interpolate
              //   elevations from northern edge of the south tile
              for (j=0; j<xTile; j++) {
                overallData[0][j] = InterpolatedData (1.0f, (float)j * dx,
                                                      southResolution, southData);
              }
            } else {
              // South tile is same resolution as overall data, simply copy
              //   northern elevations to southern border of overall data
              for (j=0; j<xTile; j++) {
                overallData[0][j] = southData[southResolution-1][j];
              }
            }
            FreeElevationArray (southResolution, southData);
          }

          // Override W border if required
          if (westResolution > tileResolution) {
            // West tile is higher resolution than this tile, so the border
            //   must be overridden
            float **westData;
            AllocateElevationArray (westResolution, &westData);
            westBlock->GetDetailTileElevations(x-1, z, westData);
            if (zTile > westResolution) {
              // West tile is lower resolution than overall data; interpolate
              //   elevations from eastern edge of the west tile
              for (i=0; i<zTile; i++) {
                overallData[i][0] = InterpolatedData ((float)i * dz, 1.0f,
                                                            westResolution, westData);
              }
            } else {
              // West tile is same resolution as overall data, simply copy
              //   eastern elevations to western border of overall data
              for (i=0; i<zTile; i++) {
                overallData[i][0] = westData[i][westResolution-1];
              }
            }
            FreeElevationArray (westResolution, westData);
          }

          // Override E border if required
          if (eastResolution > tileResolution) {
            // East tile is higher resolution than this tile, so the border
            //   must be overridden
            float **eastData;
            AllocateElevationArray (eastResolution, &eastData);
            eastBlock->GetDetailTileElevations(x+1, z, eastData);
            if (zTile > eastResolution) {
              // East tile is lower resolution than overall data; interpolate
              //   elevations from eastern edge of the west tile
              for (i=0; i<zTile; i++) {
                overallData[i][xTile-1] = InterpolatedData ((float)i * dz, 0.0f,
                                                            eastResolution, eastData);
              }
            } else {
              // East tile is same resolution as overall data, simply copy
              //   western elevations to eastern border of overall data
              for (i=0; i<zTile; i++) {
                overallData[i][xTile-1] = eastData[i][0];
              }
            }
            FreeElevationArray (eastResolution, eastData);
          }
        } else {
          // Overall array is same size as tile array; simply populate the
          //   overall array with this tile's elevations
          thisBlock->GetDetailTileElevations (x, z, overallData);
        }

        // Instantiate database lookup results
        rc = new CElevationLookup;
        rc->glType = GL_TRIANGLE_STRIP;
        int nStrips = zTile - 1;
        int stripSize = 2 * xTile;
        rc->u.stripData.nStrips = nStrips;
        rc->u.stripData.stripSize = stripSize;
        rc->points = new ulList(nStrips * stripSize);

        float dx = 1.0f / (float)(xTile - 1);
        float dz = 1.0f / (float)(zTile - 1);
        SElevationLookupPoint *p;
        for (i=0; i<nStrips; i++) {
          for (j=0; j<xTile; j++) {
            // Add northern point
            p = new SElevationLookupPoint;
            p->x = (float)j * dx;
            p->z = (float)(nStrips-i-1) * dz;
            p->elevation = overallData[i+1][j];
            rc->points->addEntity(p);

            // Add southern point
            p = new SElevationLookupPoint;
            p->x = (float)j * dx;
            p->z = (float)(nStrips-i) * dz;
            p->elevation = overallData[i][j];
            rc->points->addEntity(p);
          }
        }

        // Free overall elevation data for tile
        for (i=0; i<zTile; i++) {
          delete[] overallData[i];
        }
        delete[] overallData;
      }
      break;
    }
  } else {
    globals->logWarning->Write ("TEDB : Could not find elevations for DT %d,%d", x, z);
  }

  // Return pointer to CElevationLookup; this must be deleted by the application
  return rc;
}

// Declare tile elevation database (extern in Terrain.h)
CTileElevationDatabase *tedb = NULL;

Documentation generated by