DetailTile.cpp

Go to the documentation of this file.

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


//
// CDetailTile
//

CDetailTile::CDetailTile (unsigned int x, unsigned int z)
{
  level = TERRAIN_SUBDIVISION_DETAIL_TILE; 
  this->x = x;
  this->z = z;

  // 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));
  detail = TILE_DETAIL_MEDIUM;

  // Get the default composite texture name for this tile
  dtdb->GetCompositeTextureName (x, z, defaultTextureName);

  elevLookup = NULL;

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

  // First calculate parent globe tile indices
  int n = 64;   // 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-super tile offset
  double dlat = (globe_ne_lat - globe_sw_lat) / n;
  double dlon = (globe_ne_lon - globe_sw_lon) / n;

  // Calculate tile corners
  double sw_lat = globe_sw_lat + (dlat * (z % n));
  double sw_lon = globe_sw_lon + (dlon * (x % n));
  double ne_lat = sw_lat + dlat;
  double ne_lon = sw_lon + dlon;
  SetCorners (sw_lat, sw_lon, ne_lat, ne_lon);

  // Initialize top-level SSG entity
  top = new ssgBranch;
  char name[64];
  sprintf (name, "DT %d,%d", x, z);
  top->setName (name);
}


CDetailTile::~CDetailTile (void)
{
  // Delete all textures
  for (int i=0; i<3; i++) {
    STileTextureInfo &info = texinfo[i];
    if (info.texid != 0) {
      glDeleteTextures (1, &info.texid);
    }
  }

  // Delete top-level branch if it was not added to the scene graph
//  if (top->getRef() == 0) delete top;

  // Delete elevation lookup results
  if (elevLookup != NULL) delete elevLookup;
}

//
// Assign the default terrain texture name, in the form:
//   AAXXBBYYmn
//
void CDetailTile::AssignDefaultTextureName (const char* name)
{
  strcpy (defaultTextureName, name);
}

void CDetailTile::AssignTexture (ETileDetail detail, STileTextureInfo &info)
{
  // Store texturing information
  memcpy (&texinfo[detail], &info, sizeof(STileTextureInfo));

  // Update texturing of leaf nodes if necessary
  if (IsCreated() && (this->detail == detail)) {
    switch (elevLookup->glType) {
    case GL_TRIANGLE_FAN:
      break;

    case GL_TRIANGLE_STRIP:
      UpdateStripTexCoords (info);
      break;
    }
  }
}

//
// Load default terrain texture into the appropriate texinfo array member
//
void CDetailTile::LoadDefaultTexture (ETileDetail detail)
{
  texid = 0;

  if (!globals->settings->terrainReliefShaded) {
    // Get the fully transitioned detail tile texture.  This function
    //   allocates a new CRawImage* object which must be freed when
    //   it is no longer needed
    CRawImage *raw = dtdb->GetCompositeTexture (defaultTextureName, detail);

    if (raw != NULL) {
      // Convert the final A-tile raw image to an OpenGL texture name
      // Low-detail textures should be mipmapped; medium- and high-detail not
      bool mipmap = false;
      switch (detail) {
      case TILE_DETAIL_LOW:
        mipmap = true;
        break;

      case TILE_DETAIL_MEDIUM:
        mipmap = true;
        break;

      case TILE_DETAIL_HIGH:
        mipmap = false;
        break;

      default:
        gtfo ("Invalid texture detail level!");
      }
      texid = raw->GetTexture (mipmap);

      // Delete temporary raw image for A tile
      delete raw;

      // Update texture coordinates.  Low-detail textures are not overlapped;
      //   Medium and high detail textures are overlapped by 16 and 8 pixels
      //   respectively
      float offset = 0.0;
      switch (detail) {
      case TILE_DETAIL_MEDIUM:
        offset = 16.0 / 256.0;
        break;
      case TILE_DETAIL_HIGH:
        offset = 8.0 / 256.0;
        break;
      }

      // Update texture info structure with texture name and coordinates
      STileTextureInfo info;
      info.texid = texid;
      info.lls = info.llt = offset;
      info.urs = info.urt = 1.0f - offset;
      AssignTexture (detail, info);
    }
  }
}


void CDetailTile::SetDetail (ETileDetail detail)
{
  this->detail = detail;
/*
  if (globals->terrainmgr->debugLevel != DETAIL_TILES) {


    // Apply the texture to the detail tile's state
    for (int i=0; i<top->getNumKids(); i++) {
      ssgLeaf *leaf = (ssgLeaf *)top->getKid(i);
      ssgSimpleState *state = (ssgSimpleState*) leaf->getState ();
      state->setTexture (texID[detail]);
    }
  }
*/
}


//
// Create tile geometry based on the elevation database returning a set of
//   data points in a triangle fan
//
void CDetailTile::CreateFanGeometry (CElevationLookup *elev)
{
  // Find cartesian coordinates of tile corners
  SVector vsw, vnw, vse, vne;
  vnw = PosToFlatCartesian (nw, globe_x, globe_z);
  vne = PosToFlatCartesian (ne, globe_x, globe_z);
  vse = PosToFlatCartesian (se, globe_x, globe_z);
  vsw = PosToFlatCartesian (sw, globe_x, globe_z);

  // NW corner is the base point for the E/W and N/S distances
  float ewDistance = vne.x - vnw.x;
  float nsDistance = vsw.y - vnw.y;

  ssgVertexArray *va = NULL;
  ssgColourArray *rgba = NULL;
  ssgTexCoordArray *ta = NULL;

  // Create vertex array
  int nPoints = elev->u.fanData.nPoints;
  va = new ssgVertexArray(nPoints);
  for (int i=0; i<nPoints; i++) {
    SElevationLookupPoint *p = (SElevationLookupPoint *)(elev->points->getEntity(i));
    sgVec3 v;
    sgSetVec3 (v,
               vsw.x + (p->x * ewDistance),
               vsw.y + (p->z * nsDistance),
               p->elevation);
    va->add (v);
  }

  // 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);

  // Check .ini setting to determine whether tiles are relief shaded or textured
  if (globals->settings->terrainReliefShaded) {
    // Terrain is relief-shaded
    state->disable (GL_TEXTURE_2D);
    state->enable (GL_COLOR_MATERIAL);
    state->setColourMaterial (GL_AMBIENT_AND_DIFFUSE);
    state->setMaterial (GL_EMISSION, 0, 0, 0, 1);
    state->setMaterial (GL_SPECULAR, 0, 0, 0, 1);

    rgba = new ssgColourArray (nPoints);
    for (int i=0; i<nPoints; i++) {
      SElevationLookupPoint *p = (SElevationLookupPoint *)(elev->points->getEntity(i));
      float r, g, b;
      dtdb->GetReliefShadingRGB (p->elevation, r, g, b);
      sgVec4 c;
      sgSetVec4 (c, r, g, b, 1.0);
      rgba->add (c);
    }
  } else {
    // Terrain is textured normally
    state->enable (GL_TEXTURE_2D);
    state->disable (GL_COLOR_MATERIAL);

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

      // 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
      unsigned int dot = MakeRGB (255, 0, 0);       // Red
      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.ftasci10, 32, 1, fg, label);
      int qx = (x / 32) % 2;
      int qz = (z / 32) % 2;
      sprintf (label, "Q%1d%1d", qx, qz);
      DrawTextC (surface, &globals->fonts.ftasci10, 32, 13, fg, label);
      int sx = (x / 4) % 8;
      int sz = (z / 4) % 8;
      sprintf (label, "S%1d%1d", sx, sz);
      DrawTextC (surface, &globals->fonts.ftasci10, 32, 25, fg, label);
      int dx = x % 4;
      int dz = z % 4;
      sprintf (label, "D%02d", (dx * 4) + dz);
      DrawTextC (surface, &globals->fonts.ftasci10, 32, 37, fg, label);
      DrawDot (surface, 31, 31, dot);
      DrawDot (surface, 32, 31, dot);
      DrawDot (surface, 31, 32, dot);
      DrawDot (surface, 32, 32, dot);
      texid = TextureFromSurface (surface, true);
      FreeSurface (surface);
      state->setTexture (texid);
    } else {

      state->setTexture ((GLuint) 0);

    }

    // Allocate texture coordinates
    ta = new ssgTexCoordArray (nPoints);
    for (int i=0; i<nPoints; i++) {
      SElevationLookupPoint *p = (SElevationLookupPoint *)(elev->points->getEntity(i));
      sgVec2 t;
      sgSetVec2 (t, p->x, p->z);
      ta->add (t);
    }
  }

  // Create leaf node
  ssgVtxTable *vtab = new ssgVtxTable (GL_TRIANGLE_FAN, va, NULL, ta, rgba);
  vtab->setState (state);
  top->addKid (vtab);
}


void CDetailTile::UpdateFanTexCoords (STileTextureInfo &info)
{
  // Get leaf node
  ssgVtxTable *vtab = (ssgVtxTable *)top->getKid(0);
  ssgSimpleState *state = (ssgSimpleState *)vtab->getState ();
  ssgTexCoordArray *ta = vtab->getTexCoords ();

  // Update state with new texture ID
  state->setTexture (info.texid);

  // Update texcoord array
  float sDelta = info.urs - info.lls;
  float tDelta = info.urt - info.llt;

  int fanSize = elevLookup->u.fanData.nPoints;
  for (int i=0; i<fanSize; i++) {
    SElevationLookupPoint *p =
      (SElevationLookupPoint *)elevLookup->points->getEntity(i);
    sgVec2 t;
    sgSetVec2 (t, info.lls + (p->x * sDelta), info.llt + (p->z * tDelta));
    ta->set (t, i);
  }
}


//
// Create tile geometry based on the elevation database returning a set of
//   data points in a series of triangle strips
//
void CDetailTile::CreateStripGeometry (CElevationLookup *elev)
{
  // Find cartesian coordinates of tile corners
  SVector vsw, vnw, vse, vne;
  vnw = PosToFlatCartesian (nw, globe_x, globe_z);
  vne = PosToFlatCartesian (ne, globe_x, globe_z);
  vse = PosToFlatCartesian (se, globe_x, globe_z);
  vsw = PosToFlatCartesian (sw, globe_x, globe_z);

  // NW corner is the base point for the E/W and N/S distances
  float ewDistance = vne.x - vnw.x;
  float nsDistance = vsw.y - vnw.y;

  ssgVertexArray *va = NULL;
  ssgColourArray *rgba = NULL;
  ssgTexCoordArray *ta = NULL;
  ssgSimpleState *state = NULL;

  SElevationLookupPoint *p = NULL;

  // Create triangle strip leaf nodes
  for (int i=0; i<elev->u.stripData.nStrips; i++) {
    // Create vertex array
    int nPoints = elev->u.stripData.stripSize;

    // Populate vertex array
    va = new ssgVertexArray(nPoints);
    p = (SElevationLookupPoint *)(elev->points->getEntity(i * nPoints));
    for (int j=0; j<nPoints; j++) {
      sgVec3 v;
      sgSetVec3 (v,
                 vsw.x + (p->x * ewDistance),
                 vsw.y + (p->z * nsDistance),
                 p->elevation);
      va->add (v);

      // Get next point from list
      p = (SElevationLookupPoint *)(elev->points->getNextEntity());
    }

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

    // Check .ini setting to determine whether tiles are relief shaded or textured
    if (globals->settings->terrainReliefShaded) {
      // Terrain is relief-shaded
      state->disable (GL_TEXTURE_2D);
      state->enable (GL_COLOR_MATERIAL);
      state->setColourMaterial (GL_AMBIENT_AND_DIFFUSE);
      state->setMaterial (GL_EMISSION, 0, 0, 0, 1);
      state->setMaterial (GL_SPECULAR, 0, 0, 0, 1);

      // Populate colour array
      rgba = new ssgColourArray (nPoints);
      p = (SElevationLookupPoint *)(elev->points->getEntity(i * nPoints));
      for (int j=0; j<nPoints; j++) {
        float r, g, b;
        dtdb->GetReliefShadingRGB (p->elevation, r, g, b);
        sgVec4 c;
        sgSetVec4 (c, r, g, b, 1.0);
        rgba->add (c);

        // Get next point from list
        p = (SElevationLookupPoint *)(elev->points->getNextEntity());
      }
    } else {
      // Terrain is textured normally
      state->enable (GL_TEXTURE_2D);
      state->disable (GL_COLOR_MATERIAL);

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

        // 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
        unsigned int dot = MakeRGB (255, 0, 0);       // Red
        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.ftasci10, 32, 1, fg, label);
        int qx = (x / 32) % 2;
        int qz = (z / 32) % 2;
        sprintf (label, "Q%1d%1d", qx, qz);
        DrawTextC (surface, &globals->fonts.ftasci10, 32, 13, fg, label);
        int sx = (x / 4) % 8;
        int sz = (z / 4) % 8;
        sprintf (label, "S%1d%1d", sx, sz);
        DrawTextC (surface, &globals->fonts.ftasci10, 32, 25, fg, label);
        int dx = x % 4;
        int dz = z % 4;
        sprintf (label, "D%02d", (dx * 4) + dz);
        DrawTextC (surface, &globals->fonts.ftasci10, 32, 37, fg, label);
        DrawDot (surface, 31, 31, dot);
        DrawDot (surface, 32, 31, dot);
        DrawDot (surface, 31, 32, dot);
        DrawDot (surface, 32, 32, dot);
        texid = TextureFromSurface (surface, true);
        FreeSurface (surface);
        state->setTexture (texid);
      } else {
        state->setTexture ((GLuint) 0);
      }

      // Get the composite texture name for this tile
      dtdb->GetCompositeTextureName (x, z, defaultTextureName);

      // Allocate texture coordinates
      ta = new ssgTexCoordArray (nPoints);
      p = (SElevationLookupPoint *)(elev->points->getEntity(i * nPoints));
      for (int j=0; j<nPoints; j++) {
        sgVec2 t;
        sgSetVec2 (t, p->x, p->z);
        ta->add (t);

        // Get next point from list
        p = (SElevationLookupPoint *)(elev->points->getNextEntity());
      }
    }

    // Create leaf node
    ssgVtxTable *vtab = new ssgVtxTable (GL_TRIANGLE_STRIP, va, NULL, ta, rgba);
    vtab->setState (state);
    top->addKid (vtab);
  }
}

void CDetailTile::UpdateStripTexCoords (STileTextureInfo &info)
{
  int n = elevLookup->u.stripData.nStrips;
  for (int i=0; i<n; i++) {
    // Get leaf node
    ssgVtxTable *vtab = (ssgVtxTable *)top->getKid(i);
    ssgSimpleState *state = (ssgSimpleState *)vtab->getState ();
    ssgTexCoordArray *ta = vtab->getTexCoords ();

    // Update state with new texture ID
    state->setTexture (info.texid);

    // Update texcoord array
    float sDelta = info.urs - info.lls;
    float tDelta = info.urt - info.llt;

    int stripSize = elevLookup->u.stripData.stripSize;
    for (int j=0; j<stripSize; j++) {
      SElevationLookupPoint *p =
        (SElevationLookupPoint *)elevLookup->points->getEntity(i * stripSize + j);
      sgVec2 t;
      sgSetVec2 (t, info.lls + (p->x * sDelta), info.llt + (p->z * tDelta));
      ta->set (t, j);
    }
  }
}

void CDetailTile::Create (void)
{
  // Ensure there is valid low-resolution texture info.  If a fulltex image
  //   was found for the QGT then it should have been supplied through a call
  //   to AssignTexture.  If not then the texture info will be default, and
  //   the default terrain texture should be used
  STileTextureInfo &info = texinfo[detail];
  if (info.texid == 0) {
    LoadDefaultTexture (detail);
  }

  // Lookup elevations for this detail tile from the database.  The elevation
  //   points determine the geometry of the mesh for this tile
  elevLookup = tedb->GetDetailTileElevations (x, z);
  if (elevLookup == NULL) {
    gtfo ("CDetailTile : Could not get elevations for DT %d,%d", x, z);
  }

  switch (elevLookup->glType) {
  case GL_TRIANGLE_FAN:
    CreateFanGeometry (elevLookup);
    UpdateFanTexCoords (info);
    break;

  case GL_TRIANGLE_STRIP:
    CreateStripGeometry (elevLookup);
    UpdateStripTexCoords (info);
    break;
  }

  CTerrainTile::Create ();
}

void CDetailTile::Destroy (void)
{
  if (elevLookup != NULL) {
    delete elevLookup;
    elevLookup = NULL;
  }

  CTerrainTile::Destroy ();
}

Documentation generated by