QuarterGlobeTile.cpp

Go to the documentation of this file.

/*
 * QuarterGlobeTile.cpp
 *
 * Part of Fly! Legacy project
 *
 * Copyright 2003-2004 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"


//
// CSceneryModels
//
CSceneryModels::CSceneryModels (const char* sxxFilename)
{
  // Instantiate top-level branch
  top = new ssgBranch;

  // Instantiate list, assume 32 objects to start?
  wobjList = new ulList(32);

  SStream *stream = new SStream;
  strcpy (stream->filename, sxxFilename);
  strcpy (stream->mode, "r");
  if (OpenStream (&globals->pfs, stream)) {
    ReadFrom (this, stream);
    CloseStream (stream);
  }
  delete stream;
}

CSceneryModels::~CSceneryModels (void)
{
/*
  int i, n;

  top->removeAllKids();
  delete top;

  // Delete world objects
  n = wobjList->getNumEntities();
  for (i=0; i<n; i++) {
    CWorldObject *wobj = (CWorldObject *)wobjList->getEntity(i);
    delete wobj;
  }
  delete wobjList;
*/
}

int CSceneryModels::Read (SStream *stream, Tag tag)
{
  int rc = TAG_READ;

  switch (tag) {
  case 'wobj':
    {
      // Determine the type of world object
      Tag type;
      ReadTag (&type, stream);
      switch (type) {
      case TYPE_FLY_MODELOBJECT:
        {
          // Instantiate new CModelObject
          CModelObject *mobj = new CModelObject ();
          ReadFrom (mobj, stream);
          wobjList->addEntity (mobj);
          ssgEntity *ssge = mobj->GetSSGEntity();
          if (ssge != NULL) {
            top->addKid (ssge);
          }
        }
        break;

      default:
        SkipObject (stream);
      }
      rc = TAG_READ;
    }
    break;
  }

  return rc;
}

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


//
// CQuarterGlobeTile
//

//
// The universal QGT size is 42.1875 nm square (equivalent to half of 1.40625 deg),
//   so if QGT center coordinate is 0,0 then the bounds are +/- 21.09375 nm.  This
//   macro defines the QGT bound in feet.
//
#define QGT_FLAT_CARTESIAN_BOUND_FT   (1.28165E+5)

// Constructor with void argument instantiates the SSG tree structure but does not
//   load any elevation or texturing information.  This is essentially an empty "shell"
//   for the QGT that is populated when x,z QGT indices are assigned
//
CQuarterGlobeTile::CQuarterGlobeTile (void)
{
  level = TERRAIN_SUBDIVISION_QUARTER_GLOBE_TILE;

  // If terrain debug level indicates QGT level of debug, then create a
  //   simple leaf child.  Since the QGT may not be visible, it is still
  //   untextured
  if (globals->terrainmgr->debugLevel == QUARTER_GLOBE_TILES) {

    // Initialize state information
    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);

    // Assign default texture index; this will be updated when texture is created
    state->enable (GL_TEXTURE_2D);
    state->setTexture ((GLuint)0);
    state->disable (GL_COLOR_MATERIAL);

    // Set vertices
    float d = QGT_FLAT_CARTESIAN_BOUND_FT;
    sgVec3 v1, v2, v3, v4;
    sgSetVec3 (v1, -d,  d, 0);    // NW
    sgSetVec3 (v2, -d, -d, 0);    // SW
    sgSetVec3 (v3,  d,  d, 0);    // NE
    sgSetVec3 (v4,  d, -d, 0);    // SE

    // 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 ("DebugTile");
    addKid (vtab);
  } else {
/*
    int i, j;

    // Not in QGT debugging mode; allocate child super tiles
    stArraySize = 8;
    stArray = new CSuperTile**[stArraySize];
    for (i=0; i<stArraySize; i++) {
      stArray[i] = new CSuperTile*[stArraySize];
      for (j=0; j<stArraySize; j++) {
        CSuperTile *st = new CSuperTile;
        stArray[i][j] = st;
        top->addKid (st->GetSSGEntity());
      }
    }
*/
  }

  state = QGT_UNASSIGNED;
  sceneryModels = NULL;

  // Since this QQT may need to be added and removed from the scene graph,
  //   increment the refcount so it is never automatically deleted when
  //   removed.
  ref();
}


CQuarterGlobeTile::~CQuarterGlobeTile (void)
{
  // Clean up scenery models
  if (sceneryModels != NULL) delete sceneryModels;
}

void CQuarterGlobeTile::AssignIndices (unsigned int x, unsigned int z)
{
  if (state == QGT_UNASSIGNED) {
    this->x = x;
    this->z = z;

    this->globe_x = x/2;
    this->globe_z = z/2;

    char name[80];
    sprintf (name, "QGT %d,%d (%d,%d Q%c%c)", x, z, globe_x, globe_z,
      '0'+(x%2), '0'+(z%2));
    setName (name);
  } else {
    // Re-assigning indices is not permitted.  Must Unassign() then Assign()
    gtfo ("CQuarterGlobeTile : Multiple assignment of indices : %d,%d to %d,%d",
      this->x, this->z, x, z);
  }

  state = QGT_ASSIGNED;
}

void CQuarterGlobeTile::UnassignIndices (void)
{
  if (globals->terrainmgr->debugLevel == QUARTER_GLOBE_TILES) {
    // Get pointer to leaf node and its state
    ssgVtxTable *vtab = (ssgVtxTable*)this->getKid(0);
    ssgSimpleState *state = (ssgSimpleState*)vtab->getState();

    if (texid != 0) {
      state->setTexture ((GLuint)0);
      glDeleteTextures (1, &texid);
      texid = 0;
    }
  } else {
    // Unassign child super tiles
  }

  state = QGT_UNASSIGNED;
}

bool CQuarterGlobeTile::IsAssigned (void)
{
  return (state == QGT_ASSIGNED);
}

void CQuarterGlobeTile::GetIndices (unsigned int &x, unsigned int &z)
{
  x = this->x;
  z = this->z;
}

void CQuarterGlobeTile::Create (void)
{
  globals->terrainmgr->Log ("Creating Quarter Globe Tile %d,%d(Q%1d%1d)",
    globe_x, globe_z, (x%2), (z%2));

  // Check for QGT debug mode
  if (globals->terrainmgr->debugLevel == QUARTER_GLOBE_TILES) {
    
    // Get pointer to leaf node and its state
    ssgVtxTable *vtab = (ssgVtxTable*)this->getKid(0);
    ssgSimpleState *state = (ssgSimpleState*)vtab->getState();

    // Create debug texture 
    int size = 128;
    SSurface *surface = CreateSurface (size, size);
    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, size-1, 0, fg);
    DrawLine (surface, size-1, 0, size-1, size-1, fg);
    DrawLine (surface, size-1, size-1, 0, size-1, fg);
    DrawLine (surface, size-1, 0, 0, 0, fg);
    char label[16];
    sprintf (label, "%03d,%03d", globe_x, globe_z);
    DrawTextC (surface, &globals->fonts.ftthin24, size/2, size/4, fg, label);
    sprintf (label, "Q%1d%1d", x%2, z%2);
    DrawTextC (surface, &globals->fonts.ftthin24, size/2, 3*size/4, fg, label);
    texid = TextureFromSurface (surface, true);
    FreeSurface (surface);

    state->setTexture (texid);

  } else {
    
    // Populate super tile textures

  }


  CTerrainTile::Create ();
}

void CQuarterGlobeTile::Destroy (void)
{
  CTerrainTile::Destroy ();
}

void CQuarterGlobeTile::UpdatePosition (SPosition pos)
{
/*
  int px, pz;
  lat_lon_to_qgt (pos.lat, pos.lon, px, pz);

  int dx = px - x;
  int dz = pz - z;
*/
 
  // Find distance in QGT between center of this QGT and updated position
  double dx = 0;
  double dz = 0;
  delta_qgt (pos, x, z, dx, dz);

  sgVec3 t;
  t[0] = (float)(dx * QGT_FLAT_CARTESIAN_BOUND_FT * 2.0);
  t[1] = (float)(dz * QGT_FLAT_CARTESIAN_BOUND_FT * 2.0);
  t[2] = 0;

  // Set translation transform
  this->setTransform (t);
}

void CQuarterGlobeTile::print (FILE *fd, char *indent, int how_much)
{
  CTerrainTile::print (fd, indent, how_much);
}


/*

CDefaultQuarterGlobeTile::~CDefaultQuarterGlobeTile (void)
{
  if (IsCreated()) Destroy();

  // Delete default super tiles and deallocate storage
  int i, j;
  for (i=0; i<stArraySize; i++) {
    for (j=0; j<stArraySize; j++) {
      CDefaultSuperTile *st = stArray[i][j];
      delete st;
    }
    delete stArray[i];
  }
  delete stArray;
}

void CDefaultQuarterGlobeTile::Create (void)
{
  globals->terrainmgr->Log ("Creating Default Quarter Globe Tile %d,%d(%1d%1d)",
    globe_x, globe_z, x%2, z%2);

  // Create SSG branch as top-level entity
  top = new ssgBranch ();
  char name[64];
  int n = 2;    // Dimension of these tiles per globe tile
  sprintf (name, "QGT (%d,%d)(%1d%1d)", globe_x, globe_z, x%n, z%n);
  top->setName (name);

  // Check for QGT debug mode
  if (globals->terrainmgr->debugLevel == QUARTER_GLOBE_TILES) {
    // Calculate cartesian coordinates for tile corners relative to parent globe tile
    SVector vsw, vnw, vse, vne;
    vsw = PosToFlatCartesian (sw, globe_x, globe_z);
    vnw = PosToFlatCartesian (nw, globe_x, globe_z);
    vse = PosToFlatCartesian (se, globe_x, globe_z);
    vne = PosToFlatCartesian (ne, globe_x, globe_z);
  
    // Create debug 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", globe_x, globe_z);
    DrawTextC (surface, &globals->fonts.ftmono12, 32, 16, fg, label);
    int xmod = x % 2;
    int zmod = z % 2;
    sprintf (label, "Q%1d%1d", xmod, zmod);
    DrawTextC (surface, &globals->fonts.ftmono12, 32, 36, 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 quarter 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 {
    int i, j;

    // Create all default super tiles
    for (i=0; i<8; i++) {
      for (j=0; j<8; j++) {
        CDefaultSuperTile *st = stArray[i][j];
        st->Create ();
        top->addKid (st->GetSSGEntity());
      }
    }
  }

  // If scenery file exists for this quarter globe tile, load the objects
  char sceneryFile[256];
  sprintf (sceneryFile, "DATA\\D%03d%03d\\SCENERYA.S%1d%1d", globe_x, globe_z, x%2, z%2);
  if (pexists (&globals->pfs, sceneryFile)) {
    // Instantiate scenery model object
    sceneryModels = new CSceneryModels (sceneryFile);
    top->addKid (sceneryModels->GetSSGEntity ());
  }

  CTerrainTile::Create ();
}

void CDefaultQuarterGlobeTile::Destroy (void)
{
  globals->terrainmgr->Log ("Destroying Default Quarter Globe Tile %d,%d(%1d%1d)",
    globe_x, globe_z, x%2, z%2);

  // Destroy all default super tiles
  int i, j;
  for (i=0; i<stArraySize; i++) {
    for (j=0; j<stArraySize; j++) {
      CDefaultSuperTile *st = stArray[i][j];
      if (st != NULL) {
        if (st->IsCreated()) {
          st->Destroy();
        }
      }
    }
  }

  CTerrainTile::Destroy();
}

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


//
// CSlicedQuarterGlobeTile
//

CSlicedQuarterGlobeTile::CSlicedQuarterGlobeTile (unsigned int  x,
                                                  unsigned int  z,
                                                  const char* folder)
: CQuarterGlobeTile (x, z)
{
  // Store local copy of data folder path
  strcpy (datapath, folder);

  // Allocate 8x8 array for default super tiles instantiated in Read()
  int i, j;
  stArraySize = 8;
  stArray = new CSlicedSuperTile**[stArraySize];
  for (i=0; i<stArraySize; i++) {
    stArray[i] = new CSlicedSuperTile*[stArraySize];
    for (j=0; j<stArraySize; j++) {
      stArray[i][j] = NULL;
    }
  }

  // Add entry to elevation database that will be populated by super tiles
  trnElevations = tedb->AddTRN (x, z, stArraySize);

  // Initialize low-resolution fulltex data members
  fulltex = NULL;
  fulltexid = 0;
}

CSlicedQuarterGlobeTile::~CSlicedQuarterGlobeTile (void)
{
  if (IsCreated()) Destroy();

  // Delete and deallocate storage for super tile array
  int i, j;
  for (i=0; i<stArraySize; i++) {
    for (j=0; j<stArraySize; j++) {
      delete stArray[i][j];
    }
    delete[] stArray[i];
  }
  delete[] stArray;

  // Remove TRN elevations from TEDB
  tedb->RemoveTRN (x, z);
}

int CSlicedQuarterGlobeTile::Read (SStream *stream, Tag tag)
{
  int rc = TAG_READ;

  switch (tag) {
  case 'half':
    // Quarter globe tile indices
    ReadUInt (&half_x, stream);
    ReadUInt (&half_z, stream);
    rc = TAG_READ;
    break;

  case 'lowr':
    // Detail tile indices for lower-left corner
    ReadUInt (&lowr_x, stream);
    ReadUInt (&lowr_z, stream);
    rc = TAG_READ;
    break;

  case 'supr':
    // Super tile sub-object
    {
      unsigned int supr_x, supr_z;
      ReadUInt (&supr_x, stream);
      ReadUInt (&supr_z, stream);

      int sx = (x * 8) + supr_x;
      int sz = (z * 8) + supr_z;
      
      CSlicedSuperTile *suprtile = new CSlicedSuperTile (sx, sz, trnElevations);
      ReadFrom (suprtile, stream);
      stArray[supr_x][supr_z] = suprtile;
    }
    rc = TAG_READ;
    break;
  }

  return rc;
}

void CSlicedQuarterGlobeTile::Create (void)
{
  globals->terrainmgr->Log ("Creating Sliced Quarter Globe Tile %d,%d(%1d%1d)",
    globe_x, globe_z, x%2, z%2);

  // Create SSG branch as top-level entity
  top = new ssgBranch ();
  char name[64];
  int n = 2;    // Dimension of these tiles per globe tile
  sprintf (name, "QGT (%d,%d)(%1d%1d)", globe_x, globe_z, x%n, z%n);
  top->setName (name);

  int i, j;

  // Load low-detail texture
  char fulltexRaw[64], fulltexAct[64];
  i = ((z % 2)) * 2 + (x % 2);
  sprintf (fulltexRaw, "%s\\FULLTEX%d.RAW", datapath, i+1);
  sprintf (fulltexAct, "%s\\FULLTEX%d.ACT", datapath, i+1);

  if (pexists(&globals->pfs, fulltexRaw) &&
      pexists(&globals->pfs, fulltexAct))
  {
    // Create mipmapped low-res texture
    fulltex = new CRawImage (fulltexRaw, fulltexAct);
    fulltexid = fulltex->GetTexture (true);
    fulltexOffset = 8.0f / 512.0f;
    ds = dt = (1.0f - (2.0f * fulltexOffset)) / (float)stArraySize;
  } else {
    // Can't load low-resolution texture
    globals->logWarning->Write ("CSlicedQuarterGlobeTile : Can't open %s", fulltexRaw);
  }

  // Check for QGT debug mode
  if (globals->terrainmgr->debugLevel == SLICED_QUARTER_GLOBE_TILES) {

    // Calculate cartesian coordinates for subtile corners
    SVector vsw, vnw, vse, vne;
    vsw = PosToFlatCartesian (sw, globe_x, globe_z);
    vnw = PosToFlatCartesian (nw, globe_x, globe_z);
    vse = PosToFlatCartesian (se, globe_x, globe_z);
    vne = PosToFlatCartesian (ne, globe_x, globe_z);

    // 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 quarter globe tile default debug texture
    state->enable (GL_TEXTURE_2D);
    state->setTexture (fulltexid);
    state->disable (GL_COLOR_MATERIAL);

    // Set vertices for triangle strip in order NW, SW, NE, SE
    sgVec3 v1, v2, v3, v4;
    sgSetVec3 (v1, vnw.x, vnw.y, 0);
    sgSetVec3 (v2, vsw.x, vsw.y, 0);
    sgSetVec3 (v3, vne.x, vne.y, 0);
    sgSetVec3 (v4, vse.x, vse.y, 0);

    // 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
    float offset = 8.0f / 512.0f;
    sgVec2 t1, t2, t3, t4;
    sgSetVec2 (t1, 0.0 + offset, 0.0 + offset);   // NW = Lower-left
    sgSetVec2 (t2, 0.0 + offset, 1.0 - offset);   // SW = Upper-left
    sgSetVec2 (t3, 1.0 - offset, 0.0 + offset);   // NE = Lower-right
    sgSetVec2 (t4, 1.0 - offset, 1.0 - offset);   // SE = Upper-right

    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 {

    // Create child sliced super tiles
    STileTextureInfo info;
    info.texid = fulltexid;
    for (i=0; i<stArraySize; i++) {
      for (j=0; j<stArraySize; j++) {
        CSlicedSuperTile *st = stArray[i][j];

        if (fulltexid != 0) {
          info.lls = fulltexOffset + (i * ds);
          info.urs = info.lls + ds;
          info.llt = fulltexOffset + ((stArraySize - j - 1) * dt);
          info.urt = info.llt + dt;
          st->AssignTexture (TILE_DETAIL_LOW, info);
        }
        st->Create ();
        top->addKid (st->GetSSGEntity());
      }
    }
  }

  // If scenery file exists for this quarter globe tile, load the objects
  char sceneryFile[256];
  sprintf (sceneryFile, "DATA\\D%03d%03d\\SCENERYA.S%1d%1d", globe_x, globe_z, x%2, z%2);
  if (pexists (&globals->pfs, sceneryFile)) {
    // Instantiate scenery model object
    sceneryModels = new CSceneryModels (sceneryFile);
    top->addKid (sceneryModels->GetSSGEntity ());
  }

  CTerrainTile::Create();
}

void CSlicedQuarterGlobeTile::Destroy (void)
{
  globals->terrainmgr->Log ("Destroying Sliced Quarter Globe Tile %d,%d(%1d%1d)",
    globe_x, globe_z, x%2, z%2);

  // Destroy child sliced super tiles
  int i, j;
  for (i=0; i<stArraySize; i++) {
    for (j=0; j<stArraySize; j++) {
      CSlicedSuperTile *s = stArray[i][j];
      if (s != NULL && s->IsCreated()) {
        s->Destroy ();
      }
    }
  }

  // Delete low-resolution fulltex texture
  if (fulltex != NULL) delete fulltex;
  if (fulltexid != 0) glDeleteTextures (1, &fulltexid);

  CTerrainTile::Destroy();
}

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


*/

Documentation generated by