Terrain.h

Go to the documentation of this file.

/*
 * Terrain.h
 *
 * 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
 *
 */

#ifndef TERRAIN_H
#define TERRAIN_H

#include <stdarg.h>
#include "FlyLegacy.h"
#include "Utility.h"
#include "QTR.h"
#include "LogFile.h"
#include <vector>
#include <queue>
#include <string>
#include <set>

//
// Terrain debugging constants
//
#define TERRAIN_NO_DEBUG            0
#define GLOBE_TILES                 1
#define QUARTER_GLOBE_TILES         2
#define SUPER_TILES                 3
#define DETAIL_TILES                4
#define SLICED_QUARTER_GLOBE_TILES  5
#define SLICED_SUPER_TILES          6

#define TERRAIN_DEBUG_LEVEL     TERRAIN_NO_DEBUG

//
// Terrain subdivision constants
//
#define TERRAIN_SUBDIVISION_BASE                   0
#define TERRAIN_SUBDIVISION_QTR                    5
#define TERRAIN_SUBDIVISION_GLOBE_TILE             8
#define TERRAIN_SUBDIVISION_QUARTER_GLOBE_TILE     9
#define TERRAIN_SUBDIVISION_SUPER_TILE            12
#define TERRAIN_SUBDIVISION_DETAIL_TILE           14


//
// Enum type describing the format of elevation data within a CElevationBlock
//
typedef enum {
  ELEVATION_TYPE_UNKNOWN,
  ELEVATION_TYPE_CENTER,
  ELEVATION_TYPE_CORNER
} EElevationType;

//
// CElevationBlock
//
// Abstract base class for all types of elevation data blocks
//
class CElevationBlock {
public:
  // Constructors/Destructor
  CElevationBlock (int x, int z, int size);
  virtual ~CElevationBlock (void);

  // CElevationBlock methods
  virtual int    GetDetailTileResolution (void) = 0;
  virtual void   GetDetailTileElevations (int x, int z, float **data) = 0;
  EElevationType GetElevationType (void);
  virtual int    GetSize (void);
  virtual bool   DetailTileInBlock (int x, int z);

protected:
  EElevationType  type;
  int             x, z;   // Detail tile indices of lower-left (SW) corner
  int             size;   // Size of the block, in detail tiles
};

//
// CElevationBlockQTR
//
// Concrete class representing an elevation block stored in a QTR file
//
class CElevationBlockQTR : public CElevationBlock {
public:
  // Constructors / Destructor
  CElevationBlockQTR (int x, int z, const char* qtrFilename);
  virtual ~CElevationBlockQTR (void);

  // CElevationBlock methods
  virtual int   GetDetailTileResolution (void);
  virtual void  GetDetailTileElevations (int x, int z, float **data);
protected:
  CQTRFile      *qtrFile;
};


//
// CElevationBlockBT
//
// Concrete class representing an elevation block stored in a .BT
//   (Enviro) file format
//
class CElevationBlockBT : public CElevationBlock {
public:
  // Constructors / Destructor
  CElevationBlockBT (int x, int z, const char* btFilename);
  virtual ~CElevationBlockBT (void);

  // CElevationBlock methods
  virtual int   GetDetailTileResolution (void);
  virtual void  GetDetailTileElevations (int x, int z, float **data);

  // CElevationBlockBT methods
  void          Load (const char* btFilename);

protected:
};

//
// CElevationBlockGrid
//
// Concrete class representing an elevation block stored as a simple
//   array of float elevation values
//
class CElevationBlockGrid : public CElevationBlock {
public:
  // Constructors / Destructor
  CElevationBlockGrid (int x, int z, int size, int resolution, float** data);
  virtual ~CElevationBlockGrid (void);

  // CElevationBlock methods
  virtual int   GetDetailTileResolution (void);
  virtual void  GetDetailTileElevations (int x, int z, float **data);

protected:
  int           subdivision;    // Subdivision level per detail tile
  float         **data;         // Elevation array
};

//
// Super tile TRN elevations
//
class CElevationTRNSuperTile {
public:
  CElevationTRNSuperTile (int x, int z, int subdivision);
  ~CElevationTRNSuperTile (void);

public:
  int                       x, z;         // Super tile indices
  int                       subdivision;  // Detail tile subdivision level
  CElevationBlockGrid       *elev;        // Base resolution elevations
  CElevationBlockGrid       ***dtArray;   // Array of high-detail elevations
};

//
// Quarter Globe Tile TRN elevations
//
class CElevationTRNQuarterGlobeTile {
public:
  CElevationTRNQuarterGlobeTile (int x, int z, int subdivision);
  ~CElevationTRNQuarterGlobeTile (void);

public:
  int                       x, z;         // Quarter globe tile indices
  int                       subdivision;  // Super tile subdivision level
  CElevationTRNSuperTile    ***stArray;   // Array of super tile elevation data
};


//
// CElevationLookup.  Applications performing lookups in the elevation database
//  are returned an instance of this class
//
typedef struct {
  float     x, z;           // Relative location within tile, (0,0) = NW corner
  float     elevation;      // Elevation in feet
} SElevationLookupPoint;

class CElevationLookup {
public:
  CElevationLookup (void);
  ~CElevationLookup (void);

public:
  GLint       glType;       // GL_TRIANGLE_FAN or GL_TRIANGLE_STRIP
  union {
    struct {
      int                   nPoints;
    } fanData;
    struct {
      int                   nStrips;
      int                   stripSize;
    } stripData;
  } u;
  ulList      *points;      // List of SElevationLookupPoint
};


//
// Elevation Database.  The database consists of a list of database chunks, and
//   a lookup mechanism to quickly find the chunk with the highest level of detail.
// Lookups are performed on a single detail tile basis.
// Typically, a particular detail tile might have no elevations (in which case
//   zeroes are returned), normal-detail global elevations (one elevation value
//   per corner of the detail tile) or high-detail custom elevations (4x4 or higher
//   grid of array values for the detail tile.
//
class CTileElevationDatabase {
public:
  CTileElevationDatabase (void);
  ~CTileElevationDatabase (void);

  // CTileElevationDatabase methods
  CElevationLookup    *GetDetailTileElevations (int x, int z);
  void                AddQTRBlock (CElevationBlockQTR *block);
  bool                RemoveQTRBlock (CElevationBlockQTR *block);
  CElevationTRNQuarterGlobeTile *AddTRN (int x, int z, int subdivision);
  void                RemoveTRN (int x, int z);

protected:
  int                 DetailTileToQtrTile (int x, int z);
  void                QtrBaseDetailTile (int qtr, int *x, int *z);
  EElevationType      GetElevationType (int x, int z);
  int                 GetDetailTileResolution (int x, int z);
  CElevationBlockBT  *LoadBT (int qtr);
  CElevationBlockQTR *LoadQTR (int qtr);
  CElevationBlock    *Search (int x, int z);
  CElevationTRNQuarterGlobeTile *SearchTRN (int x, int z);

protected:
  ulList             *qtrList;          // List of CElevationBlockQTR*
  ulList             *btList;           // List of CElevationBlockBT*
  ulList             *trnList;          // List of CElevationTRNQuarterGlobeTile*
};

extern CTileElevationDatabase *tedb;    // Defined in Terrain.cpp


//
// Structure used to pass cartesian extents of tiles
//
typedef struct {
  SVector sw, nw, se, ne;
} STileExtents;


//
// CGenericTileType
//
class CGenericTileType : public CStreamObject {
public:
  // Constructors/destructors
  CGenericTileType (void);

  // CStreamObject methods
  int Read (SStream *stream, Tag tag);
  void ReadFinished (void);

protected:
  int   pixl;     // Pixel value in generic tile type bitmap
  int   txti;     // Index value in texture name
  int   tilc;     // Tile count

  char  texture[80];  // Texture filename
};


//
// CGenericTileDatabase
//
class CGenericTileDatabase : public CStreamObject {
public:
  // Constructors/destructors
  CGenericTileDatabase (const char* gentiles);

  // CStreamObject methods
  int Read (SStream *stream, Tag tag);

protected:
  char  schm[64];   // Texture naming scheme
  ulList  tile;     // List of CGenericTile*
};


extern CGenericTileDatabase *gtdb;    // Defined in Terrain.cpp



typedef enum {
  TILE_DETAIL_UNDEFINED = -1, // Not applicable
  TILE_DETAIL_LOW = 0,    // Low-detail 64 x 64 resolution
  TILE_DETAIL_MEDIUM = 1,   // Medium-detail 128 x 128 resolution 
  TILE_DETAIL_HIGH = 2    // High-detail 256 x 256 resolution
} ETileDetail;


//
// CTerrainTypeDatabase
//
class CTerrainTypeDatabase {
public:
  CTerrainTypeDatabase (void);
  ~CTerrainTypeDatabase ();

  // CGroundTypeDatabase methods
  ETerrainType GetTerrainType (int x, int z);

protected:
  PODFILE*    img;      // tiletype.img in Globe.pod
};

extern CTerrainTypeDatabase *ttdb;    // Defined in Terrain.cpp


//
// CDefaultTextureDatabase
//
class CDefaultTextureDatabase
{
public:
  CDefaultTextureDatabase (void);
  ~CDefaultTextureDatabase ();

  // CDefaultTextureDatabase methods
  void          Init (void);
  void          Purge (void);
  CRawImage*    GetBaseTexture (int x, int z, ETerrainType type, ETileDetail level);
  void          GetCompositeTextureName (unsigned int x, unsigned int z, char *textureName);
  CRawImage*    GetCompositeTexture (const char* textureName, ETileDetail level);
  CRawImage*    GetCompositeTexture (unsigned int x, unsigned int z, ETileDetail level);
  void          GetReliefShadingRGB (const float elev, float &r, float &g, float &b);

protected:
  // Base texture cache
  CRawImage*    low[256];
  CRawImage*    med[256][4][4];
  CRawImage*    high[256][4][4];

  // Relief shading
  float         relief[256][3];
  float         maxElevation;
  int           negativeIndex, zeroIndex, baseIndex, maxIndex;

  // List of cached composite textures
  ulList        composite;
};

extern CDefaultTextureDatabase  *dtdb;    // Defined in Terrain.cpp


//
// CSceneryModelDatabase
//

typedef struct {
  char        filename[64];
  CModelSMF   *smf;
} SSceneryModel;


class CSceneryModelDatabase {
public:
  ~CSceneryModelDatabase ();

  // CSceneryModelDatabase methods
  ssgEntity* GetSceneryModel (const char* filename);

protected:
  ulList    model;    // List of SSceneryModel*
};

extern CSceneryModelDatabase  *smdb;    // Defined in Terrain.cpp


//
// CTransitionMaskDatabase
//
// This database provides a centralized interface for generic texture transition
//   masks.  There are three types of masks -- "Right-side", "Bottom-side" and
//   "Corner" transitions.  This implementation has only one transition of each
//   type, but in future (when the MSK files are figured out) there will be
//   multiple transitions of each type which will be randomly dispensed.
//

class CTransitionMaskDatabase {
public:
  CTransitionMaskDatabase (void);
  ~CTransitionMaskDatabase (void);

  // CTransitionMaskDatabase methods
  CMaskImage *GetBottomTransition (ETileDetail detail);
  CMaskImage *GetRightTransition (ETileDetail detail);
  CMaskImage *GetCornerTransition (ETileDetail detail);

protected:
  CMaskImage  *high_right, *med_right, *low_right;
  CMaskImage  *high_bottom, *med_bottom, *low_bottom;
  CMaskImage  *high_corner, *med_corner, *low_corner;
};

extern CTransitionMaskDatabase  *tmdb;    // Defined in Terrain.cpp


//
// CGtpTile
//
// Class representation of a default watermask ground tile, which is a component
//   of a GTP default watermask file.  This class is used by CWatermaskDatabase
//
typedef struct {
  short     nPolyVerts;
  short     *pvlist;
} SGtpPolygon;

typedef struct {
  float x, z;
} SGtpVertex;

class CGtpTile {
public:
  void    Print (FILE *f);

public:
  int       x, z;
  short     nVertices;
  SGtpVertex    *vlist;
  short     nPolygons;
  SGtpPolygon   *plist;
};


//
// CGtpFile
//
// Class representation of a default watermask globe tile (GTP) file.  This class
//   is used by CWatermaskDatabase
//
typedef struct {
  unsigned short  x;
  unsigned short  z;
  unsigned long offset;
} SGtpHeader;


class CGtpFile {
public:
  // Constructors/destructors
  CGtpFile (void);
  ~CGtpFile (void);

  // CGtpFile methods
  void    Print (FILE *f);

public:
  int     x, z;
  short   nTiles;
  CGtpTile  *tile;
};


//
// CWatermaskDatabase
//

class CWaterMaskDatabase {
public:
  // Constructors/Destructor
  CWaterMaskDatabase (void);
  ~CWaterMaskDatabase (void);

  // CWaterMaskDatabase methods
  void    AddGlobeTile (int x, int z);
  void    DeleteGlobeTile (int x, int z);
  CGtpTile  *FindDetailTile (int dx, int dz);
//  bool    DetailTileOffset (int dx, int dz, unsigned long *offset, int *index);
  CMaskImage  *GetWaterMask (int dx, int dz, ETileDetail detail);
  void    Print (FILE *f);

protected:
  int     FindGlobeTile (int x, int z);

protected:
  ulList    gtlist;     // List of *CGtpFile
};

extern CWaterMaskDatabase *wmdb;    // Defined in Terrain.cpp


//
// CScenerySet
//
// Implementation : ScenerySet.cpp
//
// A CScenerySet encompasses a chunk of sliced scenery of any arbitrary size.
//   The stream file that defines a scenery set is located in a sub-directory
//   of any \Scenery folder.
//
class CScenerySet : public CStreamObject {
public:
  // Constructors / Destructor
  CScenerySet (const char* baseFolder, const char* scfFolder, const char* scfFilename);
  ~CScenerySet (void);

  // CStreamObject methods
  int Read (SStream *stream, Tag tag);

  // CScenerySet methods
  bool    InLoadRange (SPosition pos);
  bool    InCoverageRange (SPosition pos);
  bool    IsLoaded (void);
  void    Load (void);
  void    Unload (void);
  int     GetRefCount (void);
  void    IncRefCount (void);
  void    DecRefCount (void);

protected:
  SPosition                 call, caur; // Coverage area lower-left / upper-right
  SPosition                 ldll, ldur; // Load area lower-left / upper-right
  std::vector<std::string>  podList;    // List of POD filenames
  char          baseFolder[1024];  // Base folder name
  char          scfFolder[1024];   // SCF folder name
  char          scfFilename[64];   // SCF filename
  PFS           *pfs;              // Pod filesystem containing files for the scenery
  bool          loaded;            // Whether scenery set is loaded
  int           refCount;          // Number of references
};


//
// CScenerySetDatabase
//

class CScenerySetDatabase {
public:
  // Constructors/Destructor
  CScenerySetDatabase (void);
  ~CScenerySetDatabase (void);

  // CScenerySetDatabase methods
  void    Purge (void);
  void    Init (void);
  void    LoadInFolder (const char* base, const char *path);
  void    Register (SPosition pos);
  void    Deregister (SPosition pos);

protected:
  std::set<CScenerySet*>    setActive;    // Set of active scenery sets
  std::set<CScenerySet*>    setInactive;  // Set of inactive scenery sets
};

extern CScenerySetDatabase *ssdb;    // Defined in ScenerySet.cpp


//
// Construct texture name for a given detail tile
//
void GetDetailTileTextureName (int x, int z, char *textureName);

//
// This function compiles a customized generic detail tile texture.
//   The composite texture is composed of up to four generic detail
//   tile textures, properly transitioned based on the terrain type
//   of the tile in question, and the terrain types of the tiles to
//   the east, south and south-east.
//
CRawImage *GetDetailTileTexture (int x, int z, ETileDetail detail);


typedef struct {
  GLuint            texid;
  float             lls;
  float             llt;
  float             urs;
  float             urt;
} STileTextureInfo;


//
// Data structure representing the six plane equations of a viewing frustum.
//
typedef struct {
  sgVec4  plane[6];
} SFrustumPlanes;


//
// Up to sixteen texture formats can possibly be supported.  
//
// 0 = 64x64    8-bit indexed
// 4 = 128x128  8-bit indexed
// 5 = 256x256  8-bit indexed
//

//
// CTerrainTexture is an abstract base class for all terrain texture classes.
//
class CTerrainTexture {
public:
  CTerrainTexture (void);
  virtual ~CTerrainTexture (void);

  // CTerrainTexture methods
          GLuint    GetTextureObject (void);
  virtual void      Load (const char* name, int level=0) = 0;
  virtual void      Unload (void);

protected:
  GLuint            texid;    
  int               level;    
};

//
// CTerrainTextureGeneric encapsulates generic textures which are composited from
//   four individual generic sub-textures.  The texture name specification passed
//   to the Load() function must be of the following form:
//      "AABBXXYY"
//
class CTerrainTextureGeneric : public CTerrainTexture {
public:
  CTerrainTextureGeneric (void);
  ~CTerrainTextureGeneric (void);

  // CTerrainTextureGeneric methods

protected:
};

//
// CTerrainTextureSliced encapsulates a sliced texture, which is loaded from
//   a specific custom texture file.  A generic texture name may also be supplied
//   which is used when a custom texture of the given detail level is not
//   available.  If no texture is available then the texture will use the default
//   GL texture.
class CTerrainTextureSliced : public CTerrainTexture {
public:
  CTerrainTextureSliced (void);
  ~CTerrainTextureSliced (void);

  // CTerrainTextureSliced methods
  void      Load (const char* slicedname, const char*defaultname, int level=0);

protected:
};

//
// CTerrainTextureDebug encapsulates a debugging texture.  Currently this is the
//   texture name formatted in white text on a gray background.  The texture
//   is also edged with a white border.
//
class CTerrainTextureDebug : public CTerrainTexture {
public:
  CTerrainTextureDebug (void);
  ~CTerrainTextureDebug (void);

  // CTerrainTextureSliced methods
  void      Load (const char* slicedname, const char*defaultname, int level=0);

protected:
};


//
// CTerrainTile is an abstract class encapsulating attributes and functions common
//   to all terrain tile types.  This class is subclassed below into the various
//   types of tiles, i.e. Globe, Quarter Globe, Super and Detail Tiles
//
class CTerrainTile : public ssgTransform {
public:
  CTerrainTile (void);
  virtual ~CTerrainTile (void);

  // ssgTransform methods
  virtual void print (FILE *fd = stderr, char *indent = "", int how_much = 2);

  // CTerrainTile methods
  virtual void  CalculateCenter (void);
  virtual void  SetBounds (SPosition sw, SPosition nw, SPosition ne, SPosition se);
  virtual void  SetCorners (double sw_lat, double sw_lon,
                            double ne_lat, double ne_lon);
  virtual void  FormatBounds (void);
//  virtual bool  CheckVisibility (SPosition from, float vis);
  virtual void  Create (void);
  virtual void  Destroy (void);
  virtual bool  IsCreated (void);
  void          SetDetail (ETileDetail detail);

protected:
  int           level;            // Subdivision level
  bool          created;          // Has renderable tile geometry been created
  GLuint        texid;            // GL texture ID

  SPosition     sw, nw, ne, se;   // Boundary lat/lon of the tile
  SPosition     c;                // Center lat/lon of the tile
  char          swBound[64];      // SW corner lat/lon in string format
  char          nwBound[64];      // NW corner lat/lon in string format
  char          neBound[64];      // NE corner lat/lon in string format
  char          seBound[64];      // SW corner lat/lon in string format
};

//
// CDetailTile
//
// The Detail Tile (DT) is the lowest level of terrain tile decomposition.
//
class CDetailTile : public CTerrainTile {
public:
  CDetailTile (unsigned int x, unsigned int z);
  virtual ~CDetailTile (void);

  // CTerrainTile methods
  virtual void    Create (void);
  virtual void    Destroy (void);

  // CDetailTile methods
  inline ssgEntity* GetSSGEntity (void) { return top; }
  void              LoadDefaultTexture (ETileDetail detail);
  void              SetDetail (ETileDetail detail);
  virtual void      Print (FILE *f) {}
  void              AssignDefaultTextureName (const char* name);
  void              AssignTexture (ETileDetail detail, STileTextureInfo &info);

protected:
  void    CreateFanGeometry (CElevationLookup *elev);
  void    UpdateFanTexCoords (STileTextureInfo &info);
  void    CreateStripGeometry (CElevationLookup *elev);
  void    UpdateStripTexCoords (STileTextureInfo &info);

protected:
  unsigned int    x, z;
  int             globe_x, globe_z; // Index of parent Globe Tile
  ssgBranch       *top;

public:
  STileTextureInfo  texinfo[3];             // Texture info
  char              defaultTextureName[16];
  ETileDetail       detail;
  CElevationLookup *elevLookup;             // Results from elevation database lookup
};

/*
//
// CDefaultDetailTile
//
class CDefaultDetailTile : public CDetailTile {
public:
  CDefaultDetailTile (unsigned int x, unsigned int z);
  virtual ~CDefaultDetailTile (void);

  // CTerrainTile methods
  void    Create (void);
  void    Destroy (void);

  // CDetailTile methods
  GLuint  LoadTexture (ETileDetail detail);
  void    SetDetail (ETileDetail detail);
  void    Print (FILE *f);
};


//
// CSlicedDetailTile
//
class CSlicedDetailTile : public CDetailTile {
public:
  CSlicedDetailTile (unsigned int x, unsigned int z, const char* texturename);
  virtual ~CSlicedDetailTile (void);

  // CTerrainTile methods
  void    Create (void);
  void    Destroy (void);

  // CDetailTile methods
  void            AssignTexture (ETileDetail detail, STileTextureInfo &info);
  virtual void    Print (FILE *f);

protected:
};
*/

//
// CSuperTile
//
// The Super Tile (ST) consists of a regular array (8x8 by default) of detail tiles
//
class CSuperTile : public CTerrainTile {
public:
  CSuperTile (unsigned int supr_x, unsigned int supr_z);
  virtual ~CSuperTile (void);

  // CTerrainTile methods

  // CSuperTile methods
  virtual ssgEntity*    GetSSGEntity (void);
  virtual void          Print (FILE* f);
//  virtual bool  CullAgainstFrustum (SFrustumPlanes f);

protected:
  unsigned int  x, z;             // Absolute index of this super tile
  int           globe_x, globe_z; // Index of parent globe tile

  int           dimn;             // Dimension of detail tile array

  ssgBranch*    top;
};


//
// CDefaultSuperTile
//
class CDefaultSuperTile : public CSuperTile {
public:
  // Constructors
  CDefaultSuperTile (unsigned int supr_x, unsigned int supr_z);
  ~CDefaultSuperTile (void);

  // CTerrainTile methods
  void Create (void);
  void Destroy (void);

  // CDefaultSuperTile methods
  void    Print (FILE* f);

protected:
  CDetailTile*   **dtArray;      // Array of child CDefaultDetailTile*
};


//
// CSlicedTextureList
//
// This object is a member of the CSlicedSuperTile object
//
class CSlicedTextureList : public CStreamObject {
public:
  // Constructors / Destructor
  CSlicedTextureList (void);
  ~CSlicedTextureList (void);

  // CStreamObject methods
  int Read (SStream *stream, Tag tag);

  // CSlicedTextureList methods
  char* TextureName (int i);

protected:
  int     nTextureNames;
  char    **textureNames;
};


//
// CHighDetailElevations
//
// This object is a member of the CSlicedSuperTile object, corresponding to
//   and instance of the <hdtl> object type in a TRN file
//
class CHighDetailElevations : public CStreamObject {
public:
  CHighDetailElevations (int base_x, int base_z, CElevationTRNSuperTile *stElev);
  virtual ~CHighDetailElevations (void);

  // CStreamObject methods
  int Read (SStream *stream, Tag tag);

public:
  int                 base_x, base_z; // Reference detail tile indices of parent
  int                 dimn;           // Subtile dimensions
  int                 type;           // Tile type ?
  int                 prta_x, prta_z; // Dimensions within parent tile

  CElevationTRNSuperTile *stElev;     // Parent super tile elevations
  CElevationBlockGrid    *block;      // Elevation block
};


//
// CSlicedSuperTile
//
class CSlicedSuperTile : public CSuperTile, public CStreamObject {
public:
  // Constructors
  CSlicedSuperTile (unsigned int x, unsigned int z, CElevationTRNQuarterGlobeTile *trn);
  ~CSlicedSuperTile (void);

  // CStreamObject methods
  int Read (SStream *stream, Tag tag);
  void ReadFinished (void);

  // CTerrainTile methods
  void Create (void);
  void Destroy (void);

  // CSlicedSuperTile methods
  void    GetDetailTileElevations (int x, int z,
                                   int *xSize, int *zSize, float **data);
  void    AssignTexture (ETileDetail detail, STileTextureInfo &info);
  void    Print (FILE* f);

protected:
  int                 prta_x, prta_z;  // Indices of this super tile in parent QGT
  int                 type;         // Texture type
  CSlicedTextureList  *textureList; // List of texture names
  int                 **tref;       // Array of texture references

  // Super tile elevations
  CElevationTRNQuarterGlobeTile *trn;
  CElevationBlockGrid *block;       // Base level elevation block

  CDetailTile*        **dtArray;    // Array of child CSlicedDetailTile*

  ETileDetail         detail;       // Texture detail level for this tile
  STileTextureInfo    texinfo[3];   // Texture info for low, medium and high detail
};


//
// CSceneryModels
//
// This class reads world object specifications from a scenery (.Sxx) file
//   and adds them to a top-level branch
//
class CSceneryModels : public CStreamObject {
public:
  CSceneryModels (const char* sxxFilename);
  ~CSceneryModels (void);

  // CStreamObject methods
  int Read (SStream *stream, Tag tag);

  // CSceneryModels methods
  ssgEntity*      GetSSGEntity (void);

protected:
  ssgBranch   *top;           // Top-level branch
  ulList      *wobjList;      // List of CWorldObject*
};


typedef enum {
  QGT_UNASSIGNED   = 0,
  QGT_ASSIGNED     = 1
} EQgtState;


//
// CQuarterGlobeTile
//
// A Quarter Globe Tile (QGT) is the first level of terrain tile decomposition
//   below the Globe Tile.
//
class CQuarterGlobeTile : public CTerrainTile {
public:
  CQuarterGlobeTile (void);
//  CQuarterGlobeTile (unsigned int x, unsigned int z);
  virtual ~CQuarterGlobeTile (void);

  // ssgTransform methods
  virtual void print (FILE *fd = stderr, char *indent = "", int how_much = 2);

  // CTerrainTile methods
  void      Create (void);
  void      Destroy (void);

  // CQuarterGlobeTile methods
  void            Initialize (void);
  void            AssignIndices (unsigned int x, unsigned int z);
  void            UnassignIndices (void);
  bool            IsAssigned (void);
  void            GetIndices (unsigned int &x, unsigned int &z);
  void            UpdatePosition (SPosition pos);
//  virtual bool    CullAgainstFrustum (SFrustumPlanes f);

protected:
  EQgtState       state;            // State of this QGT instance
  unsigned int    x, z;             // Absolute index of the QGT
  int             globe_x, globe_z; // Index of parent Globe Tile

  char            datapath[64];   // Path to data files for this QGT

  CSceneryModels  *sceneryModels;

  int             stArraySize;
  CSuperTile*     **stArray;      // Array of child CSuperTile*
};

/*
//
// CDefaultQuarterGlobeTile
//
class CDefaultQuarterGlobeTile : public CQuarterGlobeTile {
public:
  // Constructors
  CDefaultQuarterGlobeTile (unsigned int x, unsigned int z);
  virtual ~CDefaultQuarterGlobeTile (void);

  // CTerrainTile methods
  void      Create (void);
  void      Destroy (void);

  // CDefaultQuarterGlobeTile methods
  void      Print (FILE* f);

protected:
  int                   stArraySize;
  CDefaultSuperTile*    **stArray;      // Array of child CDefaultSuperTile*
};


//
// CSlicedQuarterGlobeTile
//
class CSlicedQuarterGlobeTile : public CQuarterGlobeTile, public CStreamObject {
public:
  // Constructors
  CSlicedQuarterGlobeTile (unsigned int x, unsigned int z, const char* folder);
  virtual ~CSlicedQuarterGlobeTile (void);

  // CTerrainTile methods
  void      Create (void);
  void      Destroy (void);

  // CStreamObject methods
  int Read (SStream *stream, Tag tag);

  // CSlicedQuarterGlobeTile methods
  void    Print (FILE* f);

protected:
  unsigned int    half_x, half_z;
  unsigned int    lowr_x, lowr_z;

  CRawImage*      fulltex;       // Low-resolution texture
  GLuint          fulltexid;     // GL IDs for low-res texture
  float           fulltexOffset; // Tiling border width in texture coords
  float           ds, dt;        // Texture coordinates per super tile

  CElevationTRNQuarterGlobeTile *trnElevations;

  int                   stArraySize;
  CSlicedSuperTile*     **stArray;      // Array of child CSlicedSuperTile*
};
*/
/*
//
// Structure containing quarter globe tile references in a globe tile.
//   The specific quarter globe tile subclass type must be known in orer
//   to call the proper destructor
//
typedef enum {
  INVALID_QUARTER_GLOBE_TILE,
  DEFAULT_QUARTER_GLOBE_TILE,
  SLICED_QUARTER_GLOBE_TILE
} EQGTType;

typedef struct {
  EQGTType           type;
  CQuarterGlobeTile  *qgt;
} SQGTReference;


//
// CGlobeTile
//
// The Globe Tile (GT) is the highest level of terrain tile decomposition.
//
class CGlobeTile : public CTerrainTile {
public:
  CGlobeTile (unsigned int globe_x, unsigned int globe_z);
  virtual ~CGlobeTile (void);

  // CTerrainTile methods
  void        Create (void);
  void        Destroy (void);

  // CGlobeTile methods
  int         GetX (void);
  int         GetZ (void);
  void        TranslateFrom (int x, int z);
  void        UpdatePosition (SPosition pos, float vis);
//  void        CheckQuarterTileVisibility (SPosition pos, float vis);
  virtual bool  CullAgainstFrustum (SFrustumPlanes f);
  ssgEntity*  GetSSGEntity (void);
  void        Print (FILE* f);

protected:
  unsigned int    x, z;             // Globe tile indices
  char            dataFolder[64];   // Folder containing scenery data for this tile

  ssgTransform*   top;

  CQuarterGlobeTile*  qtArray[2][2];    // Array of child quarter globe tiles

//  GLuint              defaultTexture;   // Default GT texture for debugging
//  SQGTReference       qgtArray[2][2];   // Array of quarter globe tile references

  SNavaid             *navaidList;      // List of navaids in the GT for rendering
};
*/

//
// CTerrainManager
//
// Implementation : TerrainManager.cpp
//
class CTerrainManager {
public:
  CTerrainManager (void);
  ~CTerrainManager (void);

  // CTerrainManager methods
  void    SetCamera (SPosition pos, SPosition lookat, SVector orient);
  void    SetPosition (SPosition pos);
  void    AssignQgtArrayElement (int x, int z);
  float   GetMaxVisibility (void);
  float   GetMediumDetailRange (void);
  float   GetHighDetailRange (void);
  void    UpdateMaxVisibility (void);
  void    UpdateMediumDetailRange (void);
  void    UpdateHighDetailRange (void);
  void    Prepare (void);
  void    Draw (void);
  void    Log (const char *fmt, ...);
  void    Print (FILE* f);

  // Export various tile textures for troubleshooting/debugging
//  void    ExportElevationTileTexture (int tile);
//  void    ExportGlobeTileTexture (int x, int z, ETileDetail detail);

public:
  int           debugLevel; 

protected:
  ssgRoot       *root;      // Root for terrain scene graph
  ssgTransform  *top;       // Top-level transform for all terrain

  // Subtile related data members
  int xLast;
  int zLast;
  std::set<CQuarterGlobeTile*>   qFree;   
  std::set<CQuarterGlobeTile*>   qBusy;   

  // Visibility related data members
  float     visibility;     // Maximum terrain visibility in statute miles
  float     vis_feet;       // Maximum terrain visibility in feet
  float     vis_check;      // Terrain load/unload distance
  float     medium_detail;  // Medium texture detail range in feet
  float     high_detail;    // High texture detail range in feet

private:
  CLogFile      *log;       
};

#endif // TERRAIN_H

Documentation generated by