SuperTile.cpp

Go to the documentation of this file.

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

//
// CSuperTile
//

CSuperTile::CSuperTile (unsigned int x, unsigned int z)
{
  level = TERRAIN_SUBDIVISION_SUPER_TILE;

  this->x = x;
  this->z = z;
  dimn = 0;

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

  // First calculate parent globe tile indices
  int n = 16;   // Dimension of these tiles per globe tile
  globe_x = x / n;
  globe_z = z / n;

  // Get lat/lon boundaries for the globe tile, and convert to arcsec
  double globe_sw_lon, globe_ne_lon, globe_sw_lat, globe_ne_lat;
  globe_tile_lon_bounds (globe_x, globe_sw_lon, globe_ne_lon);
  globe_tile_lat_bounds (globe_z, globe_sw_lat, globe_ne_lat);
  globe_sw_lon *= 3600;
  globe_sw_lat *= 3600;
  globe_ne_lon *= 3600;
  globe_ne_lat *= 3600;

  // Calculate per-tile offset
  double dLat = (globe_ne_lat - globe_sw_lat) / n;
  double dLon = (globe_ne_lon - globe_sw_lon) / n;

  // Calculate tile corners
  double swLat = globe_sw_lat + (dLat * (z % n));
  double swLon = globe_sw_lon + (dLon * (x % n));
  double neLat = swLat + dLat;
  double neLon = swLon + dLon;
  SetCorners (swLat, swLon, neLat, neLon);

  top = NULL;
}


CSuperTile::~CSuperTile (void)
{
}

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

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


//
// CDefaultSuperTile
//

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

  // Check for ST debug mode
  if (globals->terrainmgr->debugLevel == SUPER_TILES) {

    // Calculate cartesian coordinates for tile 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);

    // Create default 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", globe_x, globe_z);
    DrawTextC (surface, &globals->fonts.ftmono12, 32, 16, fg, label);
    int xmod = (x / 8) % 2;
    int zmod = (z / 8) % 2;
    sprintf (label, "Q%1d%1d", xmod, zmod);
    DrawTextC (surface, &globals->fonts.ftmono12, 32, 36, fg, label);
    sprintf (label, "S%1d%1d", x % 8, z % 8);
    DrawTextC (surface, &globals->fonts.ftmono12, 32, 50, fg, label);
    texid = TextureFromSurface (surface, true);
    FreeSurface (surface);

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

    // Tile is textured with constructed 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);   // NW = Upper-left
    sgSetVec2 (t2, 0.0, 0.0);   // SW = Lower-left
    sgSetVec2 (t3, 1.0, 1.0);   // NE = Upper-right
    sgSetVec2 (t4, 1.0, 0.0);   // SE = 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 {
    // Debug mode is not active; allocate detail tile array and instantiate
    dimn = 4;
    dtArray = new CDetailTile**[dimn];
    for (i=0; i < dimn; i++) {
      dtArray[i] = new CDetailTile*[dimn];
      for (j=0; j < dimn; j++) {
        // Calculate absolute detail tile index
        int dx = (x * dimn) + i;
        int dz = (z * dimn) + j;

        CDetailTile *dt = new CDetailTile (dx, dz);
        dtArray[i][j] = dt;
      }
    }
  }
}

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

  int i, j;

  // Delete detail tiles and deallocate storage
  if (dtArray != NULL) {
    for (i=0; i < dimn; i++) {
      for (j=0; j < dimn; j++) {
        CDetailTile *dt = dtArray[i][j];
        delete dt;
      }
      delete[] dtArray[i];
    }
    delete[] dtArray;
  }
}

void CDefaultSuperTile::Create (void)
{
  // Set default terrain tile detail level
  ETileDetail detail = TILE_DETAIL_LOW;

  // Create top-level transform for the super tile
  top = new ssgBranch;
  char name[64];
  sprintf (name, "ST %d,%d", x, z);
  top->setName (name);

  // Create all detail tiles
  int i, j;
  for (i=0; i<dimn; i++) {
    for (j=0; j<dimn; j++) {
      CDetailTile *dt = dtArray[i][j];
      dt->Create ();
      dt->SetDetail (detail);
      top->addKid (dt->GetSSGEntity());
    }
  }
}

void CDefaultSuperTile::Destroy (void)
{
  // Destroy all detail tiles
  int i, j;
  for (i=0; i<dimn; i++) {
    for (j=0; j<dimn; j++) {
      CDetailTile *dt = dtArray[i][j];
      dt->Destroy ();
    }
  }
}

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

//
// CHighDetailElevations
//
CHighDetailElevations::CHighDetailElevations (int base_x, int base_z,
                                              CElevationTRNSuperTile *stElev)
{
  this->base_x = base_x;
  this->base_z = base_z;
  this->stElev = stElev;
  block = NULL;
  dimn = 0;
}

CHighDetailElevations::~CHighDetailElevations (void)
{
/*
  // Remove elevation grid from database and delete
  if (block != NULL) {
    if (tedb->RemoveTRNBlock (block)) {
      delete block;
    } else {
      globals->logWarning->Write ("CHighDetailElevations : Could not remove elevation block");
    }
  }
*/
}

int CHighDetailElevations::Read (SStream *stream, Tag tag)
{
  int i, j;

  int rc = TAG_IGNORED;

  switch (tag) {
  case 'dimn':
    // Dimension of sub-tile array
    ReadInt (&dimn, stream);

    // High-detail elevations are only valid for 4x4 or 8x8 subdivisions.
    if ((dimn != 2) && (dimn != 4) && (dimn != 8)) {
      gtfo ("CHighDetailElevations : <dimn>=%d, must be 2, 4 or 8", dimn);
    }
    rc = TAG_READ;
    break;

  case 'type':
    // Terrain type ??
    ReadInt (&type, stream);
    rc = TAG_READ;
    break;

  case 'prta':
    // Indices of this super tile in the parent; discarded
    ReadInt (&prta_x, stream);
    ReadInt (&prta_z, stream);
    rc = TAG_READ;
    break;

  case 'elev':
    if (dimn != 0) {
      // Allocate memory for elevation grid, read and add to database
      float **elev = new float*[dimn+1];
      for (i=0; i<dimn+1; i++) {
        elev[i] = new float[dimn+1];
        for (j=0; j<dimn+1; j++) {
          ReadFloat (&elev[i][j], stream);
        }
      }

      block = new CElevationBlockGrid (base_x + prta_x, base_z + prta_z, 1, dimn, elev);
      stElev->dtArray[prta_x][prta_z] = block;
    } else {
      gtfo ("CHighDetailElevation : <dimn> tag must precede <elev> tag");
    }
    rc = TAG_READ;
    break;
  }

  return rc;
}


//
// CSlicedSuperTile
//

CSlicedSuperTile::CSlicedSuperTile (unsigned int x, unsigned int z,
                                    CElevationTRNQuarterGlobeTile *trn)
: CSuperTile (x, z)
{
  this->trn = trn;

  // Initialize pointer members
  tref = NULL;
  dtArray = NULL;
  textureList = NULL;

  // Initialize elevation information
  block = NULL;

  // Initialize texture info
  STileTextureInfo info;
  info.texid = 0;
  info.lls = info.llt = 0.0f;
  info.urs = info.urt = 1.0f;
  memcpy (&texinfo[TILE_DETAIL_LOW], &info, sizeof(STileTextureInfo));
  memcpy (&texinfo[TILE_DETAIL_MEDIUM], &info, sizeof(STileTextureInfo));
  memcpy (&texinfo[TILE_DETAIL_HIGH], &info, sizeof(STileTextureInfo));

  // Set default terrain tile detail level
  detail = TILE_DETAIL_LOW;
}

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

  int i;

  // Delete texture and elevation data allocated in Read()
  if (textureList != NULL) delete textureList;

  if (tref != NULL) {
    for (i=0; i<dimn; i++) {
      delete[] tref[i];
    }
  }
  delete[] tref;

/*
  // Delete base-resolution elevation grid
  if (block != NULL) {
    if (tedb->RemoveTRNBlock (block)) {
      delete block;
    } else {
      globals->logWarning->Write ("CSlicedSuperTile : Could not remove elevation block");
    }
  }

  // Delete high-detail elevations
  if (hdtl != NULL) {
    n = hdtl->getNumEntities();
    for (i=0; i<n; i++) {
      CHighDetailElevations *h = (CHighDetailElevations *)hdtl->getEntity(i);
      delete h;
    }
    delete hdtl;
  }
*/
}

int CSlicedSuperTile::Read (SStream *stream, Tag tag)
{
  int i, j;

  int rc = TAG_IGNORED;

  switch (tag) {
  case 'dimn':
    // Dimension of sub-tile array
    ReadInt (&dimn, stream);

    // Currently, all super tiles must be subdivided into a 4x4 grid of detail tiles
    //   I think that all Fly! II compatible TRN files comply with this restriction.
    //   Future development may make this more flexible
    if (dimn != 4) {
      gtfo ("CSlicedSuperTile::Read : <dimn>=%d, must be 4", dimn);
    }

    // Allocate array for texture references
    tref = new int*[dimn];

    rc = TAG_READ;
    break;

  case 'type':
    // Terrain type ??
    ReadInt (&type, stream);
    rc = TAG_READ;
    break;

  case 'prta':
    // Indices of this super tile in the parent
    ReadInt (&prta_x, stream);
    ReadInt (&prta_z, stream);

    // Instantiate TEDB object for this super tile
    trn->stArray[prta_x][prta_z] = new CElevationTRNSuperTile (x, z, dimn);

    rc = TAG_READ;
    break;

  case 'txtl':
    textureList = new CSlicedTextureList;
    ReadFrom (textureList, stream);
    rc = TAG_READ;
    break;

  case 'tref':
    // Read <dimn> * <dimn> references into <txtl> list
    if (tref != NULL) {
      for (i=0; i<dimn; i++) {
        tref[i] = new int[dimn];
        for (j=0; j<dimn; j++) {
          ReadInt (&tref[i][j], stream);
        }
      }
    } else {
      // <tref> tag found before <dimn>
      gtfo ("CSuperTile : <dimn> tag must precede <tref> data");
    }
    rc = TAG_READ;
    break;

  case 'elev':
    if (dimn != 0) {
      int dx = x * dimn;
      int dz = z * dimn;

      // Instantiate elevation block and add it to the database
      float **elev;
      elev = new float*[dimn+1];
      for (i=0; i<dimn+1; i++) {
        elev[i] = new float[dimn+1];
        for (j=0; j<dimn+1; j++) {
          ReadFloat (&elev[i][j], stream);
        }
      }
      block = new CElevationBlockGrid (dx, dz, dimn, 1, elev);

      CElevationTRNSuperTile *stElev = trn->stArray[prta_x][prta_z];
      if (stElev != NULL) stElev->elev = block;
    } else {
      // <elev> tag found before <dimn>
      gtfo ("CSuperTile : <dimn> tag must precede <elev> data");
    }
    rc = TAG_READ;
    break;

  case 'hdtl':
    // High-detail elevations
    if (dimn != 0) {
      int dx = x * dimn;
      int dz = z * dimn;

      // Process <hdtl> sub-object.  The only purpose here is to insert
      //   the detail tile elevations into the TEDB, which is done
      //   within CHighDetailElevations::Read().
      CElevationTRNSuperTile *stElev = trn->stArray[prta_x][prta_z];
      CHighDetailElevations *h = new CHighDetailElevations (dx, dz, stElev);
      ReadFrom (h, stream);
      delete h;
    } else {
      // <hdtl> tag found before <dimn>
      gtfo ("CSuperTile : <dimn> tag must precede <hdtl> data");
    }
    rc = TAG_READ;
    break;
  }

  return rc;
}

void CSlicedSuperTile::ReadFinished (void)
{
  int i, j;

  // Verify that all mandatory data was present in the super tile specification

  if (dimn == 0) {
    gtfo ("CSlicedSuperTile : No <dimn> tag specified");
  }

  if (tref == NULL) {
    gtfo ("CSlicedSuperTile : No texture references specified");
  }

  if (textureList == NULL) {
    gtfo ("CSlicedSuperTile : No texture list object specified");
  }

  // Allocate array for sliced detail tiles
  dtArray = new CDetailTile**[dimn];
  for (i=0; i<dimn; i++) {
    dtArray[i] = new CDetailTile*[dimn];
    for (j=0; j<dimn; j++) {
      dtArray[i][j] = NULL;
    }
  }
}

void CSlicedSuperTile::AssignTexture (ETileDetail detail, STileTextureInfo &info)
{
  int i, j;

  // Store texturing information
  memcpy (&texinfo[detail], &info, sizeof(STileTextureInfo));
  float sDelta = (info.urs - info.lls) / dimn;
  float tDelta = (info.urt - info.llt) / dimn;

  // Update detail tiles
  if (IsCreated()) {
    for (i=0; i<dimn; i++) {
      for (j=0; j<dimn; j++) {
        CDetailTile *dt = dtArray[i][j];
        STileTextureInfo dtinfo;
        dtinfo.texid = info.texid;
        dtinfo.lls = info.lls + (i * sDelta);
        dtinfo.urs = dtinfo.lls + sDelta;
        dtinfo.llt = info.llt + ((dimn - j - 1) * tDelta);
        dtinfo.urt = dtinfo.llt + tDelta;
        dt->AssignTexture (detail, dtinfo);
      }
    }
  }
}

void CSlicedSuperTile::Create (void)
{
  int i, j;

  // Create top-level transform for the super tile
  top = new ssgBranch;
  char name[64];
  sprintf (name, "ST %d,%d", x, z);
  top->setName (name);

  if (globals->terrainmgr->debugLevel == SLICED_SUPER_TILES) {

    STileTextureInfo &info = texinfo[detail];

    // 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 (info.texid);
    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
    sgVec2 t1, t2, t3, t4;
    sgSetVec2 (t1, info.lls, info.llt);   // NW = Lower-left
    sgSetVec2 (t2, info.lls, info.urt);   // SW = Upper-left
    sgSetVec2 (t3, info.urs, info.llt);   // NE = Lower-right
    sgSetVec2 (t4, info.urs, info.urt);   // 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 sliced detail tiles
    for (i=0; i<dimn; i++) {      // X-index from W to E
      for (j=0; j<dimn; j++) {    // Z-index from S to N
        int dx = (x * dimn) + i;
        int dz = (z * dimn) + j;

        CDetailTile *dt = new CDetailTile (dx, dz);
        dtArray[i][j] = dt;

        // Assign low-detail texture that was supplied by parent CSlicedQuarterGlobeTile
        STileTextureInfo dtinfo;
        STileTextureInfo &info = texinfo[detail];
        float sDelta = (info.urs - info.lls) / dimn;
        float tDelta = (info.urt - info.llt) / dimn;
        dtinfo.texid = info.texid;
        dtinfo.lls = info.lls + (i * sDelta);
        dtinfo.urs = dtinfo.lls + sDelta;
        dtinfo.llt = info.llt + ((dimn - j - 1) * tDelta);
        dtinfo.urt = dtinfo.llt + tDelta;
        dt->AssignTexture (detail, dtinfo);
        dt->Create ();
        top->addKid (dt->GetSSGEntity());
      }
    }
  }

  CTerrainTile::Create ();
}

void CSlicedSuperTile::Destroy (void)
{
  int i, j;

  // Delete array of detail tiles
  for (i=0; i<dimn; i++) {
    for (j=0; j<dimn; j++) {
      CDetailTile *dt = dtArray[i][j];
      if (dt != NULL) {
        dt->Destroy ();
        delete dt;
        dtArray[i][j] = NULL;
      }
    }
  }

  CTerrainTile::Destroy ();
}

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



//
// CSlicedTextureList
//
CSlicedTextureList::CSlicedTextureList (void)
{
  nTextureNames = 0;
  textureNames = NULL;
}

CSlicedTextureList::~CSlicedTextureList (void)
{
  for (int i=0; i<nTextureNames; i++) {
    delete[] textureNames[i];
  }
  delete[] textureNames;
}

int CSlicedTextureList::Read (SStream *stream, Tag tag)
{
  int i;

  int rc = TAG_IGNORED;

  switch (tag) {
  case 'txtl':
    // Texture name list; first entry is number of elements
    ReadInt (&nTextureNames, stream);
    textureNames = new char*[nTextureNames];
    for (i=0; i<nTextureNames; i++) {
      textureNames[i] = new char[64];
      ReadString (textureNames[i], 64, stream);
    }
    rc = TAG_READ;
    break;
  }

  return rc;
}

char* CSlicedTextureList::TextureName (int i)
{
  return textureNames[i];
}

Documentation generated by