TerrainManager.cpp

Go to the documentation of this file.

/*
 * TerrainManager.cpp
 *
 * Part of Fly! Legacy project
 *
 * Copyright 2003-2005 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/Ui.h"
#include "../Include/LogFile.h"

using namespace std;

//
// CTerrainManager
//
CTerrainManager::CTerrainManager (void)
{
  int i;

  // Instantiate SSG root for all terrain
  root = new ssgRoot;
  root->setName ("TerrainRoot");

  top = new ssgTransform;
  top->setName ("TerrainTop");
  root->addKid (top);

  // Open log file if INI setting is enabled
  log = NULL;
  i = 0;
  GetIniVar ("Logs", "logTerrainManager", &i);
  if (i != 0) {
    log = new CLogFile ("Logs\\TerrainManager.log", "w");
  }

  // Get terrain debug level
  debugLevel = 0;
  GetIniVar ("Debug", "terrainDebugLevel", &debugLevel);

  // Instantiate elevation database
  tedb = new CTileElevationDatabase;

  // Instantiate terrain type database
  ttdb = new CTerrainTypeDatabase;

  // Instantiate default texture database
  dtdb = new CDefaultTextureDatabase;

  // Instantiate scenery models database
  smdb = new CSceneryModelDatabase;

  // Instantiate transition mask database
  tmdb = new CTransitionMaskDatabase;

  // Instantiate water mask database
  wmdb = new CWaterMaskDatabase;

  // Instantiate scenery set database
  ssdb = new CScenerySetDatabase;

  // Update visibility settings from INI
  UpdateMaxVisibility ();
  UpdateMediumDetailRange ();
  UpdateHighDetailRange ();

  // WARNING : Cannot instantiate any terrain tile class instances here, since
  //   CTerrainManager must be instantiated and assigned to the globals in order
  //   for the tile classes to get the terrain debug level.

  // Set 'last' QGT indices so that first call to SetPosition will trigger a transition
  xLast = zLast = -1;
}


CTerrainManager::~CTerrainManager (void)
{
  Log ("TerrainManager destructor starting\n");

  root->removeAllKids();
  delete root;

  // Delete CQuarterGlobeTiles
  set<CQuarterGlobeTile*>::iterator i;
  for (i=qFree.begin(); i!=qFree.end(); i++) {
    CQuarterGlobeTile *qgt = *i;
    if (qgt != NULL) ssgDeRefDelete (qgt);
  }
  for (i=qBusy.begin(); i!=qBusy.end(); i++) {
    CQuarterGlobeTile *qgt = *i;
    if (qgt != NULL) ssgDeRefDelete (qgt);
  }

  // Delete elevation database
  delete tedb;
  tedb = NULL;

  // Delete terrain type database
  delete ttdb;
  ttdb = NULL;

  // Delete default texture database
  delete dtdb;
  dtdb = NULL;

  // Delete scenery models database
  delete smdb;
  smdb = NULL;

  // Delete transition mask database
  delete tmdb;
  tmdb = NULL;

  // Delete water mask database
  delete wmdb;
  wmdb = NULL;

  // Delete scenery set database
  delete ssdb;
  ssdb = NULL;

  // Shut down log file if created
  if (log != NULL) {
    delete log;
  }
}

void CTerrainManager::SetCamera (SPosition pos, SPosition lookat, SVector orient)
{
/*
  char debug[80];
  sprintf (debug, "Eye pos : lat=%f  lon=%f  alt=%f  scale=%f",
    pos.lat, pos.lon, pos.alt, scale);
  DrawNoticeToUser (debug, 1);
*/

  // Set eye position
  SVector v;
  v = PosToScaledFlatCartesianQgt (pos);
  sgVec3 eye;
  sgSetVec3 (eye, v.x, v.y, v.z);

  // Set lookat position
  v = PosToScaledFlatCartesianQgt (lookat);
  sgVec3 tgt;
  sgSetVec3 (tgt, v.x, v.y, v.z);

  // Set up vector
  sgVec3 up;
  sgSetVec3 (up, 0, 0, 1);

  ssgSetCameraLookAt (eye, tgt, up);

  // Set clipping distance to visibility limit
  float scale = TerrainScale (pos);
  float nearClip = 25.0f;
  float visScaled = vis_feet / scale;
//  float farClip = sqrt ((visScaled * visScaled) + (pos.alt * pos.alt));
  float farClip = visScaled * 1.2f;
  ssgSetNearFar (nearClip, farClip); 
}

/*
void CTerrainManager::LoadQuarterGlobeTile (int x, int z, SPosition base)
{
  bool loaded = false;

  // Check to see if QGT is already instantiated

  // If so, then reset the translation matrix for the new base position

  // Instantiate the QGT

  // Check QGT is already loaded
  vector<CQuarterGlobeTile*>::iterator i;
  for (i=qgtPool.begin(); i!=qgtPool.end(); i++) {
    CQuarterGlobeTile *qgt = *i;
    if (qgt->IsAssigned ()) {
      qgt->GetIndices (&qx, &qz);
      if (
      qgt->AssignIndices (x, z);
    }
  }
  int n = qgtList->getNumEntities();
  for (int i=0; i<n; i++) {
    CGlobeTile *globetile = (CGlobeTile *) gtList->getEntity(i);
    if ((globetile->GetX() == x) && (globetile->GetZ() == z)) {
      // Reset translation matrix of the GT for the new base position
      loaded = true;
      break;
    }
  }

  // Instantiate new globe tile
  if (!loaded) {
    CGlobeTile *globetile = new CGlobeTile (x, z);
    if (globetile != NULL) {
      // Translate from base coordinates
      gtList->addEntity (globetile);
//      top->addKid (globetile->GetSSGEntity());
    } else {
      gtfo ("CTerrainManager::LoadGlobeTile : Bad globe tile %d,%d", x, z);
    }
  }
}
*/


void CTerrainManager::Prepare (void)
{
  // Instantiate pool of QGTs
  int i;
  for (i=0; i<25; i++) {
    CQuarterGlobeTile *qgt = new CQuarterGlobeTile;
    qFree.insert (qgt);
  }

  // Set initial user position
  SPosition pos = globals->sit->GetUserVehicle()->GetPosition();
  SetPosition (pos);
}

#define QGT_INDEX(x,z)    (unsigned long)(x << 16 | z)

void CTerrainManager::SetPosition (SPosition pos)
{
  DEBUGLOG ("CTerrainManager::SetPosition lat=%f lon=%f", pos.lat, pos.lon);

  // Get QGT indices for new position
  int x, z;
  lat_lon_to_qgt (pos.lat, pos.lon, x, z);

  // If current QGT has changed, update QGT array pointers
  if ((x != xLast) || (z != zLast)) {
    set<unsigned long> setVisible;
    xLast = x;
    zLast = z;

    // Determine set of visible QGT indices
    int i, j;
    for (i=0; i<5; i++) {
      for (j=0; j<5; j++) {
        unsigned int qx = x + i - 2;
        unsigned int qz = z + j - 2;
        unsigned long index = QGT_INDEX (qx, qz);
        setVisible.insert (index);
      }
    }

    // Iterate over all loaded QGTs, removing any which are not potentially
    //   visible, and removing from the visible set any which are already loaded
    set<CQuarterGlobeTile*>::iterator qIter = qBusy.begin();
    while (qIter != qBusy.end()) {
      CQuarterGlobeTile *qgt = *qIter;
      unsigned int qx, qz;
      qgt->GetIndices (qx, qz);
      unsigned long index = QGT_INDEX (qx, qz);
      set<unsigned long>::iterator sIter = setVisible.find(index);
      if (sIter == setVisible.end()) {
        // This QGT is not in the potentially visible set; destroy it
        qgt->Destroy();
        qgt->UnassignIndices ();
        set<CQuarterGlobeTile*>::iterator eraseIter = qIter;
        qIter++;
        qBusy.erase (eraseIter);
        qFree.insert (qgt);
//        top->removeKid (qgt);
      } else {
        // This QGT is already in the potentially visible set.  Remove the indices
        //   from the visible set since we don't need to check for it anymore
        setVisible.erase (sIter);
        qIter++;
      }
    }

    // All remaining members of the visible set must be loaded
    set<unsigned long>::iterator sIter;
    for (sIter=setVisible.begin(); sIter!=setVisible.end(); sIter++) {
      unsigned long index = *sIter;
      unsigned int qx = (index & 0xFFFF0000) >> 16;
      unsigned int qz = index & 0x0000FFFF;

      // Get a QTR from the free set and move it to the busy set
      if (qFree.size() == 0) {
        gtfo ("CTerrainManager::SetPosition : No free QGT available");
      }
      set<CQuarterGlobeTile*>::iterator qIter = qFree.begin();
      CQuarterGlobeTile *qgt = *qIter;
      qFree.erase (qIter);
      qBusy.insert (qgt);

      // Assign new indices and create geometry
      qgt->AssignIndices (qx, qz);
      qgt->Create();
      top->addKid (qgt);
    }
  }

  // Update position for all loaded QGTs
  set<CQuarterGlobeTile*>::iterator i;
  for (i=qBusy.begin(); i!=qBusy.end(); i++) {
    CQuarterGlobeTile *qgt = *i;
    if (qgt->IsAssigned()) qgt->UpdatePosition (pos);
  }

  // Update top-level scaling
  float scale = TerrainScale (pos);
  sgMat4 S;
  sgMakeIdentMat4 (S);
  S[0][0] = scale;
  S[1][1] = scale;
  top->setTransform (S);
}


//
// Return the maximum terrain range in statute miles
//
float CTerrainManager::GetMaxVisibility (void)
{
  return (visibility);
}

//
// Return the range for medium-detail terrain textures in statute miles
//
float CTerrainManager::GetMediumDetailRange (void)
{
  return (medium_detail);
}

//
// Return the range for high-detail terrain textures in statute miles
//
float CTerrainManager::GetHighDetailRange (void)
{
  return (high_detail);
}

void CTerrainManager::UpdateMaxVisibility (void)
{
  // Get maximum visibility from INI setting
  float miles = 20;
  GetIniFloat ("Graphics", "maxUserVisibility", &miles);

  // Store visibility in feet
  visibility = miles;
  vis_feet = visibility * FEET_PER_MILE;
  vis_check = vis_feet * 1.5f;
}

void CTerrainManager::UpdateMediumDetailRange (void)
{
  // Get medium detail texture range from INI setting
  float miles = 0;
  GetIniFloat ("Graphics", "medDetailRadius", &miles);

  // Store medium detail radius in feet
  medium_detail = miles;
}

void CTerrainManager::UpdateHighDetailRange (void)
{
  // Get high detail texture range from INI setting
  float miles = 0;
  GetIniFloat ("Graphics", "highDetailRadius", &miles);

  // Store medium detail radius in feet
  high_detail = miles;
}

void CTerrainManager::Draw (void)
{
  // Get user position, this is the origin point for the rendered world
  SPosition pos = globals->sit->GetUserVehicle()->GetPosition();
  float scale = TerrainScale (pos);
  SetPosition (pos);

  // Wireframe mode for testing
  if (globals->settings->terrainWireframe) {
    glPushAttrib (GL_ENABLE_BIT | GL_FOG_BIT | GL_TRANSFORM_BIT | GL_POLYGON_BIT);
    glPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
  } else {
    glPushAttrib (GL_ENABLE_BIT | GL_FOG_BIT | GL_TRANSFORM_BIT);
  }

  // Enable fog

  
  
  glEnable (GL_FOG);
  GLint fogMode = GL_EXP;
  glFogi (GL_FOG_MODE, fogMode);
  GLfloat fogColour[4] = {1.0, 1.0, 1.0, 1.0};
  glFogfv (GL_FOG_COLOR, fogColour);
  glFogf (GL_FOG_DENSITY, 5.0E-6);
  glHint (GL_FOG_HINT, GL_DONT_CARE);
  glFogf (GL_FOG_START, 20.0);
  glFogf (GL_FOG_END, (vis_feet / scale) * 1.2f);

  glEnable (GL_DEPTH_TEST);


  // Draw terrain root
  ssgCullAndDraw (root);

  // Restore GL attributes
  glPopAttrib ();
}

void CTerrainManager::Log (const char *fmt, ...)
{
  if (log) {
    va_list argp;
    va_start(argp, fmt);
    log->Write (fmt, argp);
    va_end(argp);
  }
}

void CTerrainManager::Print (FILE* f)
{
  root->print (f, " ", 4);
}

/*********************************************************
 * Experimental code to export very large terrain area
 *   textures for debugging of algorithms.  These are not
 *   currently being used, they are candidates for eventual
 *   removal.
 
//
// Custom error handling for JPEG library routines
//
struct my_error_mgr {
  struct jpeg_error_mgr pub;
  jmp_buf setjmp_buffer;
};

typedef struct my_error_mgr * my_error_ptr;

METHODDEF(void)
my_error_exit (j_common_ptr cinfo)
{
  // cinfo->err really points to a my_error_mgr struct, so coerce pointer
  my_error_ptr myerr = (my_error_ptr) cinfo->err;

  //  Always display the message.
  // We could postpone this until after returning, if we chose.
  (*cinfo->err->output_message) (cinfo);

  // Return control to the setjmp point
  longjmp(myerr->setjmp_buffer, 1);
}


void CTerrainManager::ExportElevationTileTexture (int tile)
{
  int resolution = 8192;

  // Determine globe tile x, z indices of south-west corner in elevation tile
  int base_gt_x = (tile & 0x1F) * 8;
  int base_gt_z = (32 - ((tile >> 5) & 0x1F) - 1) * 8;

  // Declare storage for the complete bitmap...192 MB!!
  GLubyte *image = new GLubyte[resolution * resolution * 3];

  // Loop over the 8x8 globe tile grid
  for (int gz = 7; gz >= 0; gz--) {
    int gt_z = base_gt_z + gz;
    for (int gx = 0; gx < 8; gx++) {
      int gt_x = base_gt_x + gx;

      // Loop over the 64x64 grid of detail tiles in the globe tile
      for (int z = 63; z >= 0; z--) {
        int dt_z = (gt_z * 64) + z;
        for (int x = 0; x < 64; x++) {
          int dt_x = (gt_x * 64) + x;
          // Get raw image data for the detail tile

          // TEMP : Comment out code to get fully transitioned detail tile
//          CRawImage *r = GetDetailTileTexture (dt_x, dt_z, TILE_DETAIL_LOW);

          // TEMP : Just get basic terrain tile without transitioning
          ETerrainType tt = ttdb->GetTerrainType (dt_x, dt_z);
          CRawImage *r = new CRawImage (*(dtdb->GetRawImage (dt_x, dt_z, tt, TILE_DETAIL_LOW)));

          GLubyte *dt_image = r->GetRGBImageData();
          int dt_span = (64 * 3);

          // Transfer/compress detail tile to elevation tile texture images
          // Don't invert z-loop since we are copying from north-up image
          //   data in the detail tile texture to north-up image data
          //   in the elevation texture
          int scale = 16;
          for (int sz = 0; sz < scale; sz++) {
            for (int sx = 0; sx < scale; sx++) {
              // Calculate pixel colour by averaging detail tile texels
              int pixelscale = sqrt(scale);
              GLuint r = 0;
              GLuint g = 0;
              GLuint b = 0;

              // TEMP, just take one pixel for testing
              int detailRow = (sz * 4);
              int detailCol = (sx * 4);
              int iDetail;
//              int iDetail = ((detailRow * 64) + detailCol) * 3;
//              r = dt_image[iDetail + 0];
//              g = dt_image[iDetail + 1];
//              b = dt_image[iDetail + 2];

              for (int pz = 0; pz < pixelscale; pz++) {
                for (int px = 0; px < pixelscale; px++) {
                  iDetail = ((detailRow * 64) + detailCol) * 3;
                  r += dt_image[iDetail + 0];
                  g += dt_image[iDetail + 1];
                  b += dt_image[iDetail + 2];
                  detailCol++;
                }
                detailRow++;
              }

              r /= scale;
              g /= scale;
              b /= scale;

              // Store in elevation tile texel
              int imageRow = ((7 - gz) * 1024) + ((63 - z) * 16) + (15 - sz);
              int imageCol = (gx * 1024) + (x * 16) + sx;
              int iImage = ((imageRow * resolution) + imageCol) * 3;
              image[iImage + 0] = r;
              image[iImage + 1] = g;
              image[iImage + 2] = b;
            }
          }

          // Free detail tile image data
          delete dt_image;
          delete r;
        }
      }

      // Purge detail tile database to free memory
      dtdb->Purge ();
    }
  }

  // Create the JPG context
  struct jpeg_compress_struct cinfo;

  // Set error handler
  struct my_error_mgr     jerr;

  // Format the .jpg filename
  char jpgFilename[80];
  sprintf (jpgFilename, "ET%03X.jpg", tile);

  // Open the .jpg file for writing as a binary file
  FILE *fJpg = fopen (jpgFilename, "wb");
  if (!fJpg) {
    // File open failed...display error message to user
    DrawNoticeToUser ("ExportElevationTileTexture : Could not open output .jpg file", 5);
    return;
  }

  // We set up the normal JPEG error routines, then override error_exit.
  cinfo.err = jpeg_std_error(&jerr.pub);
  jerr.pub.error_exit = my_error_exit;
  // Establish the setjmp return context for my_error_exit to use.
  if (setjmp(jerr.setjmp_buffer)) {
    // If we get here, the JPEG code has signaled an error.
    // We need to clean up the JPEG object, close the input file, and return.
    jpeg_destroy_compress(&cinfo);
    fclose(fJpg);
    return;
  }

  // Create compress context
  jpeg_create_compress (&cinfo);

  // Assign the file as the output target for the compress context
  jpeg_stdio_dest (&cinfo, fJpg);

  // Set parameters for compression
  cinfo.image_width = resolution;
  cinfo.image_height = resolution;
  cinfo.input_components = 3;
  cinfo.in_color_space = JCS_RGB;
  jpeg_set_defaults (&cinfo);
  cinfo.dct_method = JDCT_ISLOW;
  jpeg_set_quality (&cinfo, 50, TRUE);
  jpeg_start_compress (&cinfo, TRUE);

  for (int i=0; i<resolution; i++) {
    JSAMPROW pRow[1];
    pRow[0] = &image[i * resolution * 3];
    jpeg_write_scanlines (&cinfo, pRow, 1);
  }

  // Finish and clean up
  jpeg_finish_compress (&cinfo);
  jpeg_destroy_compress (&cinfo);
  fclose (fJpg);

  delete image;
}


void CTerrainManager::ExportGlobeTileTexture (int x, int z, ETileDetail detail)
{
  int tile_resolution;
  int tile_overlap;
  switch (detail) {
  case TILE_DETAIL_LOW:
    tile_resolution = 64;
    tile_overlap = 0;
    break;

  case TILE_DETAIL_MEDIUM:
    tile_resolution = 128;
    tile_overlap = 8;
    break;
    
  case TILE_DETAIL_HIGH:
    tile_resolution = 256;
    tile_overlap = 4;
    break;

  default:
    tile_resolution = 64;
    tile_overlap = 0;
    break;
  }

  int extract_resolution = tile_resolution - (2 * tile_overlap);
  int resolution = extract_resolution * 64;

  // Create the JPG context
  struct jpeg_compress_struct cinfo;

  // Set error handler
  struct my_error_mgr     jerr;

  // Format the .jpg filename
  char jpgFilename[80];
  sprintf (jpgFilename, "GT%03d%03d_%d.jpg", x, z, resolution);

  // Open the .jpg file for writing as a binary file
  FILE *fJpg = fopen (jpgFilename, "wb");
  if (!fJpg) {
    // File open failed...display error message to user
    DrawNoticeToUser ("Export Globe Tile Texture : Could not open output .jpg file", 5);
    return;
  }

  // We set up the normal JPEG error routines, then override error_exit.
  cinfo.err = jpeg_std_error(&jerr.pub);
  jerr.pub.error_exit = my_error_exit;
  // Establish the setjmp return context for my_error_exit to use.
  if (setjmp(jerr.setjmp_buffer)) {
    // If we get here, the JPEG code has signaled an error.
    // We need to clean up the JPEG object, close the input file, and return.
    jpeg_destroy_compress(&cinfo);
    fclose(fJpg);
    return;
  }

  // Create compress context
  jpeg_create_compress (&cinfo);

  // Assign the file as the output target for the compress context
  jpeg_stdio_dest (&cinfo, fJpg);

  // Set parameters for compression
  cinfo.image_width = resolution;
  cinfo.image_height = resolution;
  cinfo.input_components = 3;
  cinfo.in_color_space = JCS_RGB;
  jpeg_set_defaults (&cinfo);
  cinfo.dct_method = JDCT_ISLOW;
  jpeg_set_quality (&cinfo, 50, TRUE);
  jpeg_start_compress (&cinfo, TRUE);

  // Allocate storage for a single scan line
  int rowStride = resolution * 3;
  BYTE *row = new BYTE[rowStride];

  // Each GT consists of a 64x64 grid of detail tiles, processed row by row
  //   from north to south.
  CRawImage* raw[64][64];
  GLubyte* rowImage[64][64];
  int xCount, zCount;
  for (zCount = 63; zCount >= 0; zCount--) {
    // Get first row of 64 detail tiles
    int dt_z = (z * 64) + zCount;

    for (xCount = 0; xCount < 64; xCount++) {
      int dt_x = (x * 64) + xCount;
      CRawImage *r = GetDetailTileTexture (dt_x, dt_z, detail);
      raw[xCount][zCount] = r;
      rowImage[xCount][zCount] = r->GetRGBImageData();
    }

    // Construct data for each scan line and send to JPEG compressor
    for (int rowCount = 0; rowCount < extract_resolution; rowCount++)
    {
      int extract_stride = extract_resolution * 3;
      int iImage = (rowCount * tile_resolution + tile_overlap) * 3;

      // Extract row data from each of the detail textures
      for (xCount=0; xCount<64; xCount++) {
        GLubyte *image = rowImage[xCount][zCount];
        int iRow = xCount * extract_stride;
        memcpy (&row[iRow], &image[iImage], extract_stride);
      }

      // Send scan line data to JPEG compressor
      JSAMPROW pRow[1];
      pRow[0] = row;
      jpeg_write_scanlines (&cinfo, pRow, 1);
    }
  }

  // Finish and clean up
  jpeg_finish_compress (&cinfo);
  jpeg_destroy_compress (&cinfo);
  fclose (fJpg);
  delete row;

  for (zCount=0; zCount<64; zCount++) {
    for (xCount=0; xCount<64; xCount++) {
      delete rowImage[xCount][zCount];
      delete raw[xCount][zCount];
    }
  }
}

*/

Documentation generated by