GlobeTile.cpp

Go to the documentation of this file.

/*
 * GlobeTile.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
 *
 *
 * Implementation of class CGlobeTile, the first level of terrain tile division
 *
 */

#include "../Include/Globals.h"
#include "../Include/Terrain.h"
#include "../Include/Utility.h"
#include "../Include/Ui.h"

/*
//
// CGlobeTile
//

CGlobeTile::CGlobeTile (unsigned int x, unsigned int z)
{
  int i, j;

  globals->terrainmgr->Log ("Instantiating Globe Tile %d,%d", x, z);

  // Range check parameters
  if ((x < 0) || (x > 255) || (z < 0) || (z > 255)) {
    gtfo ("CGlobeTile : Illegal indices %d,%d", x, z);
  }
  this->x = x;
  this->z = z;

  level = TERRAIN_SUBDIVISION_GLOBE_TILE;
  navaidList = NULL;

  // Initialize quarter globe tile array.
  for (i=0; i<2; i++) {
    for (j=0; j<2; j++) {
      qtArray[i][j] = NULL;
    }
  }

  // Construct scenery folder base name for this globe tile
  sprintf (dataFolder, "DATA\\D%03d%03d", x, z);

  //
  // Compute lat/lon boundaries for the globe tile
  //

  // Get SW and NE lat/lon boundaries for the globe tile
  double sw_lat, sw_lon, ne_lat, ne_lon;
  globe_tile_lon_bounds (x, sw_lon, ne_lon);
  globe_tile_lat_bounds (z, sw_lat, ne_lat);

  // Convert degrees to arcseconds
  sw_lat *= 3600;
  sw_lon *= 3600;
  ne_lat *= 3600;
  ne_lon *= 3600;

  // Create SPosition structs for all corners
  SetCorners (sw_lat, sw_lon, ne_lat, ne_lon);

  //
  // In order to reduce the floating point roundoff error for tile vertices,
  //   each globe tile has its own local coordinate system, with origin at
  //   the center of the globe tile.  The appropriate transform is applied to
  //   the top-level ssgTransform for the globe tile, and all sub-tile vertices
  //   are relative to this local center.
  //

  // Top-level SSG entity is controlled by Create()/Destroy()
  top = NULL;
}

CGlobeTile::~CGlobeTile (void)
{
  // Ensure globe tile contents are destroyed
  if (IsCreated()) Destroy ();
}

int CGlobeTile::GetX (void)
{
  return x;
}

int CGlobeTile::GetZ (void)
{
  return z;
}
*/

/*
void CGlobeTile::Create (void)
{
  globals->terrainmgr->Log ("Creating Globe Tile %d,%d", x, z);

  // Instantiate top-level SSG entity for the globe tile
  top = new ssgTransform;
  char name[64];
  sprintf (name, "GT %d,%d", x, z);
  top->setName (name);

  if (globals->terrainmgr->debugLevel == GLOBE_TILES) {
    // Debug mode that creates globe tiles only
    DEBUGLOG ("GT %d,%d : Creating debug tile");

    // Calculate cartesian coordinates for tile corners
    SVector vsw, vnw, vse, vne;
    vsw = PosToFlatCartesian (sw, x, z);
    vnw = PosToFlatCartesian (nw, x, z);
    vse = PosToFlatCartesian (se, x, z);
    vne = PosToFlatCartesian (ne, x, z);

    // Load default globe tile debugging texture 
    SSurface *surface = CreateSurface (64, 64);
    unsigned int bg = MakeRGB (128, 128, 128);    // Medium grey
    unsigned int fg = MakeRGB (255, 255, 255);    // White
    surface->xScreen = surface->yScreen = 0;
    EraseSurfaceRGB (surface, bg);
    DrawLine (surface, 0, 0, 63, 0, fg);
    DrawLine (surface, 63, 0, 63, 63, fg);
    DrawLine (surface, 63, 63, 0, 63, fg);
    DrawLine (surface, 63, 0, 0, 0, fg);
    char label[16];
    sprintf (label, "%03d,%03d", x, z);
    DrawTextC (surface, &globals->fonts.ftthin24, 32, 20, fg, label);
    texid = TextureFromSurface (surface, true);
    FreeSurface (surface);

    // Initialize state information for the detail tile
    ssgSimpleState *state = new ssgSimpleState ();
    state->setShadeModel (GL_SMOOTH);
    state->disable (GL_LIGHTING);
    state->enable (GL_CULL_FACE);
    state->enable (GL_BLEND);
    state->disable (GL_ALPHA_TEST);
    state->setColourMaterial (GL_AMBIENT_AND_DIFFUSE);
    state->setMaterial (GL_EMISSION, 0, 0, 0, 1);
    state->setMaterial (GL_SPECULAR, 0, 0, 0, 1);

    // Terrain is textured with globe tile default debug texture
    state->enable (GL_TEXTURE_2D);
    state->setTexture (texid);
    state->disable (GL_COLOR_MATERIAL);

    // Set vertices
    sgVec3 v1, v2, v3, v4;
    sgSetVec3 (v1, vnw.x, vnw.y, vnw.z);
    sgSetVec3 (v2, vsw.x, vsw.y, vsw.z);
    sgSetVec3 (v3, vne.x, vne.y, vne.z);
    sgSetVec3 (v4, vse.x, vse.y, vse.z);

    // Define arrays for face data
    ssgVertexArray *va = new ssgVertexArray(4);
    va->add (v1);
    va->add (v2);
    va->add (v3);
    va->add (v4);

    // Allocate texture coordinates
    sgVec2 t1, t2, t3, t4;
    sgSetVec2 (t1, 0.0, 1.0);   // Upper-left  NW
    sgSetVec2 (t2, 0.0, 0.0);   // Lower-left  SW
    sgSetVec2 (t3, 1.0, 1.0);   // Upper-right NE
    sgSetVec2 (t4, 1.0, 0.0);   // Lower-right SE

    ssgTexCoordArray *ta = new ssgTexCoordArray(4);
    ta->add (t1);
    ta->add (t2);
    ta->add (t3);
    ta->add (t4);

    ssgVtxTable *vtab = new ssgVtxTable (GL_TRIANGLE_STRIP, va, NULL, ta, NULL);
    vtab->setState (state);
    vtab->setName ("TriStrip");

    top->addKid (vtab);

  } else {

    DEBUGLOG ("GT %d,%d : Creating quarter globe tiles");

    // Register the globe tile corner positions with the sliced scenery database
    //   This ensures that pods containing relevant .SCF scenery areas are 
    //   loaded prior to creating the quarter globe tiles
    ssdb->Register (nw);
    ssdb->Register (ne);
    ssdb->Register (sw);
    ssdb->Register (se);

    // Instantiate each of the four quarter globe tiles
    for (int i=0; i<2; i++) {
      for (int j=0; j<2; j++) {
        // Calculate quarter globe tile indices
        int qx = (x * 2) + i;
        int qz = (z * 2) + j;

        // Construct TRN filename for this quarter globe tile
        char trnFilename[64];
        sprintf (trnFilename, "G%1d%1d.TRN", i, j);

        char trnFullname[64];
        strcpy (trnFullname, dataFolder);
        strcat (trnFullname, "\\");
        strcat (trnFullname, trnFilename);

        // Attempt to open TRN stream file
        SStream s;
        strcpy (s.filename, trnFullname);
        strcpy (s.mode, "r");
        if (OpenStream (&s)) {
          // TRN file could be opened, create a sliced quarter globe tile
          CSlicedQuarterGlobeTile *q = new CSlicedQuarterGlobeTile (qx, qz, dataFolder);
          ReadFrom (q, &s);
          CloseStream (&s);
          qtArray[i][j] = q;
        } else {
          // TRN file could not be opened, create a generic quarter globe tile
          CDefaultQuarterGlobeTile *q = new CDefaultQuarterGlobeTile (qx, qz);
          qtArray[i][j] = q;
        }
      }
    }
  }
*/
/*
  // Search for navaids in this globe tile
  SearchNavaidsByGlobeTile (x, z, &navaidList);

  // Instantiate VOR model and add to globe tile
  if (smdb != NULL) {
    ssgEntity *vor = smdb->GetSceneryModel ("Models\\Vor.smf");

    if (vor) {
      SNavaid *next = navaidList;
      while (next != NULL) {
        if (next->type & NAVAID_TYPE_VOR) {
          // Create a transform for the VOR model instance
          ssgTransform *transform = new ssgTransform;
          char name[64];
          sprintf (name, "VOR %s %s", next->id, next->name);
          transform->setName (name);
          transform->addKid (vor);

          next->pos.alt = 100.0;

          // Set model translation relative to globe tile center
          SVector v = PosToFlatCartesian (next->pos, x, z);
          sgVec3 t;
          sgSetVec3 (t, v.x, v.y, v.z);
          sgMat4 T;
          sgMakeTransMat4 (T, t);
          transform->setTransform (T);
          
          // Add the transformed VOR model to the globe tile SSG tree
          top->addKid (transform);
        }

        // Go to next navaid in the list
        next = next->next;
      }
    } else {
      globals->terrainmgr->Log ("CGlobeTile : Could not load model Vor.smf");
    }
  }
*/
/*
  // DEBUG : Dump navaid list to file
//  FILE *f = fopen ("gtnavaid.txt", "w");
//  if (f) {
//    SNavaid *next = navaidList;
//    while (next != NULL) {
//      char pos[64];
//      FormatPosition (next->pos, pos);
//      fprintf (f, "%5s %s\n", next->id, pos);
//      next = next->next;
//    }
//    fclose (f);
//  }

  CTerrainTile::Create ();
}
*/
/*
void CGlobeTile::Destroy (void)
{
  globals->terrainmgr->Log ("Destroying Globe Tile %d,%d", x, z);

  int i, j;

  // Destroy and delete child quarter globe tiles
  for (i=0; i<2; i++) {
    for (j=0; j<2; j++) {
      CQuarterGlobeTile *q = qtArray[i][j];
      if (q != NULL) {
        if (q->IsCreated()) {
          q->Destroy();
          top->removeKid (q->GetSSGEntity());
        }
        delete q;
        qtArray[i][j] = NULL;
      }
    }
  }

  // Free navaids
  FreeNavaid (navaidList);

  // De-register this globe tile with the sliced scenery database
  ssdb->Deregister (nw);
  ssdb->Deregister (ne);
  ssdb->Deregister (sw);
  ssdb->Deregister (se);

  CTerrainTile::Destroy ();
}

void CGlobeTile::TranslateFrom (int xbase, int zbase)
{
  float distance = GlobeTileDistance();
  int xtiles = x - xbase;
  int ztiles = z - zbase;
  float dx = xtiles * distance;
  float dy = ztiles * distance;
  sgVec3 t;
  sgSetVec3 (t, dx, dy, 0);

  sgMat4 T;
  sgMakeTransMat4 (T, t);
  top->setTransform (T);
}

void CGlobeTile::UpdatePosition (SPosition pos, float vis)
{
  // Get lat/lon and cartesian coords for base position
  int xBase, zBase;
  lat_lon_to_globe_tile (pos.lat / 3600.0, pos.lon / 3600.0, xBase, zBase);

  // Calculate globe tile difference between this GT and base position
  int xTiles = x - xBase;
  int zTiles = z - zBase;

  float dx, dy;
  if ((xTiles == 0) && (zTiles == 0)) {
    // Same globe tile, no offset
    dx = 0;
    dy = 0;
  } else {
    // Check for wrap around Prime Meridian
    if (xTiles < -128) {
      // Base is W, target is E
      xTiles += 256;
    } else if (xTiles > 128) {
      // Base is E, target is W
      xTiles -= 256;
    }
    float distance = GlobeTileDistance();
    dx = (xTiles * distance);
    dy = (zTiles * distance);
  }

  // Make transform matrix and apply it to globe tile top-level transform
  sgVec3 t;
  sgSetVec3 (t, dx, dy, 0);

  sgMat4 T;
  sgMakeTransMat4 (T, t);
  top->setTransform (T);

  CheckQuarterTileVisibility (pos, vis);
}

//
// Check visibility of all quarter globe tiles in this globe tile.
//
void CGlobeTile::CheckQuarterTileVisibility (SPosition pos, float vis)
{
  // Check visibility of all quarter tiles
  for (int i=0; i<2; i++) {
    for (int j=0; j<2; j++) {
      CQuarterGlobeTile *q = qtArray[i][j];
      if (q != NULL) {
        if (q->CheckVisibility(pos, vis)) {
          // Ensure quarter globe tile is created
          if (!q->IsCreated()) {
            q->Create ();
            top->addKid (q->GetSSGEntity());
          }
        } else {
          // Ensure quarter globe tile is destroyed
          if (q->IsCreated()) {
            q->Destroy ();
            top->removeKid (q->GetSSGEntity());
          }
        }
      }
    }
  }
}

ssgEntity* CGlobeTile::GetSSGEntity (void)
{
  return top;
}

void CGlobeTile::Print (FILE *f)
{
}

*/

Documentation generated by