TerrainTile.cpp

Go to the documentation of this file.

/*
 * TerrainTile.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"


//
// CTerrainTile
//
CTerrainTile::CTerrainTile (void)
{
  memset (&sw, 0, sizeof(SPosition));
  memset (&nw, 0, sizeof(SPosition));
  memset (&ne, 0, sizeof(SPosition));
  memset (&se, 0, sizeof(SPosition));
  memset (&c, 0, sizeof(SPosition));
  strcpy (swBound, "");
  strcpy (nwBound, "");
  strcpy (neBound, "");
  strcpy (seBound, "");
  texid = 0;
  created = false;
}

CTerrainTile::~CTerrainTile (void)
{
  if (texid != 0) {
    glDeleteTextures (1, &texid);
  }
}

//
// Calculate center latitude/longitude position for the tile by simply
//   dividing the lat and lon size of the tile in half
//
// For this function to be meaningful, the boundary positions must have been
//   set already
//
void CTerrainTile::CalculateCenter (void)
{
  // Calculate center position
  c.lat = sw.lat + (ne.lat - sw.lat) / 2;
  c.lon = sw.lon + (ne.lon - sw.lon) / 2;
  c.alt = 0;
}

//
// Set the corner bounds of the tile
//
void CTerrainTile::SetBounds (SPosition sw, SPosition nw, SPosition ne, SPosition se)
{
  this->sw = sw;
  this->nw = nw;
  this->ne = ne;
  this->se = se;

  CalculateCenter ();
  FormatBounds ();
}

//
// Set tile bounds by specifying only the SW and NE corner latitude/longitude values
//
void CTerrainTile::SetCorners (double sw_lat, double sw_lon,
                               double ne_lat, double ne_lon)
{
  sw.lon = sw_lon;
  sw.lat = sw_lat;

  ne.lon = ne_lon;
  ne.lat = ne_lat;

  nw.lon = sw.lon;
  nw.lat = ne.lat;

  se.lon = ne.lon;
  se.lat = sw.lat;

  CalculateCenter ();
  FormatBounds ();
}

//
// Format the corner positions into human-readable text strings for debugging
//
// For this function to be meaningful, the boundary positions must have been
//   set already
//
void CTerrainTile::FormatBounds (void)
{
  FormatPosition (sw, swBound);
  FormatPosition (nw, nwBound);
  FormatPosition (ne, neBound);
  FormatPosition (se, seBound);
}

//
// Determine if tile is visible from the given position.  This is only a rough,
//   fast check against the corners.
//
// Parameters:
//   from     Position from which tile distance is measured
//   vis      Visibility in feet
//
// Return code:
//   bool     true if the tile is within visibility range of the position
//
/*bool CTerrainTile::CheckVisibility (SPosition from, float vis)
{
  bool rc = false;

  // Check distance to closest edges of tile
  bool nsInRange = false;
  bool ewInRange = false;
  float distance;

  // Check viewing position relative to tile edges
  if (from.lat > nw.lat) {
    // Viewing position is north of the tile
    distance = NmToFeet ((from.lat - nw.lat) / 60.0);
    nsInRange = distance <= vis;
  } else if (from.lat < sw.lat) {
    // Viewing position is south of the tile
    distance = NmToFeet ((sw.lat - from.lat) / 60.0);
    nsInRange = distance <= vis;
  } else {
    // Viewing position is within latitude bounds of tile
    nsInRange = true;
  }

  if (from.lon > ne.lon) {
    // Viewing position is east of the tile
    distance = (from.lon - ne.lon) * FeetPerLonArcsec (from.lat);
    ewInRange = distance <= vis;
  } else if (from.lon < nw.lon) {
    // Viewing position is west of the tile
    distance = (nw.lon - from.lon) * FeetPerLonArcsec (from.lat);
    ewInRange = distance <= vis;
  } else {
    // Viewing position is within longitude bounds of tile
    ewInRange = true;
  }

  // Tile is in range if both N/S and E/W distances are in range
  rc = nsInRange && ewInRange;

  return rc;
}
*/

void CTerrainTile::Create (void)
{
  created = true;
}

void CTerrainTile::Destroy (void)
{
  created = false;
}

bool CTerrainTile::IsCreated (void)
{
  return created;
}

//
// Debug print
//
void CTerrainTile::print (FILE *fd, char *indent, int how_much)
{
  ssgTransform::print (fd, indent, how_much);

  // Print 
  FormatBounds();
  fprintf (fd, "%s  CTerrainTile:\n", indent);
  fprintf (fd, "%s    SW Extent = %s\n", indent, swBound);
  fprintf (fd, "%s    NW Extent = %s\n", indent, nwBound);
  fprintf (fd, "%s    NE Extent = %s\n", indent, neBound);
  fprintf (fd, "%s    SE Extent = %s\n", indent, seBound);
}

Documentation generated by