gfx/CLODTerrainRenderer

Go to the documentation of this file.

//
// This code is a hacked up version of the Demeter Terrain
// code from http://www.terrainengine.com
// (hacked up because I removed the SDL and CommonC++
//  dependencies, and helpded it compile with gcc3.x)
// -David Jung.
//

// Demeter Terrain Visualization Library by Clay Fowler
// Copyright (C) 2001 Clay Fowler

/*
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

This library 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
Library General Public License for more details.

You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the
Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA  02111-1307, USA.
*/

//#define _USE_RAYTRACING_SUPPORT_
//_USE_RAYTRACING_SUPPORT_ enables the ray tracing methods on the Terrain class, but increases
//memory usage considerably. Demeter's ray tracing is very fast and can be used for mouse picking,
//line-of-sight tests, etc. If you enable this option, then be aware that MUCH more memory will be needed,
//particularly for terrains that are over 256x256 vertices. With this option turned off, larger
//terrains are no problem.

//#define _USE_VERTEX_ARRAYS_
// _USE_VERTEX_ARRAYS_ turns on OpenGL vertex arrays for the terrain vertices. There are
// still some unresolved problems with the use of vertex arrays, such as how to use
// multi-texturing with vertex arrays, how to correctly assign texture coordinates, etc. so
// you should only enable this option if you want to debug some of these problems for yourself.

//#define _PROTECT_ACCESS_
// _PROTECT_ACCESS_ turns on extra checks to validate parameters passed to various terrain methods to make sure
// the parameters are within range. Turn this option on when you want the Terrain to clamp
// all values to legal ranges for you - this will slow performance but lets external callers
// not worry about clamping values. If external callers can be trusted to keep all parameters within
// legal extents, then disable this option for performance gains.

#define _SUPPORT_OPENSCENEGRAPH_
// _SUPPORT_OPENSCENEGRAPH_ makes the Terrain class a "Drawable" for use in OpenSceneGraph.
// If you enable this flag, you will need to have OpenSceneGraph installed on your system
// in order to build Demeter.

#ifndef _GFX_CLODTERRAINRENDERER_
#define _GFX_CLODTERRAINRENDERER_

#include <gfx/gfx>
#include <base/BitArray>
#include <string>

#include <GL/gl.h>
#include <GL/glu.h>

// Get rid of these if possible
#include <cstdlib>
#include <cmath>
#include <cstdio>

#include <vector>

#include <osg/Referenced>

#define MAX_VERTICES_PER_FAN 10
#define EPSILON 0.00001f
#ifdef INFINITY
#undef INFINITY
#endif
#define INFINITY 999999999.0f

// Forgive the long comment lines. They are all single lines to accomodate doxygen.

namespace demeter
{
  class TerrainBlock;
  class Terrain;
  class Manifest;
  class TriangleStrip;
  class TriangleFan;
  class Vector;
  
  typedef base::Byte Uint8;
  typedef unsigned int Uint32;

  /// An extremely basic 3D plane class.
  class Plane
  {
  public:
    Plane() {}
    Plane( Vector& p1,Vector& p2,Vector& p3 );
    ~Plane() {}
    void                                defineFromPoints( Vector& p1,Vector& p2,Vector& p3 );
    float                               a,b,c,d;
  };
  
  /// An extremely basic 3D vector class. Demeter does not rely on all of the bells and whistles of most public vector classes
  class Vector
  {
  public:
    Vector() {}
    ~Vector() {}
    float                               GetLength();
    float                               Normalize( float tolerance = EPSILON );
    Vector&                             operator = ( const Vector& vector );
    float                               x,y,z;
  };
  
  class Ray
  {
  public:
    Ray() {}
    ~Ray() {}
    Vector              m_Origin;
    Vector              m_Direction;
  };
  
  class Box
  {
  public:
    Box() {}
    ~Box() {}
    Vector              m_Max;
    Vector              m_Min;
  };
  
  class Texture
  {
  public:
    Texture(Uint8* pBuffer,int width,int height,int stride,int borderSize,bool bClamp,bool useCompression);
    ~Texture();
    GLuint                      UploadTexture();
    void                        UnloadTexture();
  private:
    Uint8*                      m_pBuffer;
    int                         m_Width;
    int                         m_Height;
    int                         m_RowLength;
    int                         m_BorderSize;
    bool                        m_UseCompression;
    bool                        m_bClamp;
    GLuint                      m_TextureID;
  };
  
  /// This class represents a single, contiguous chunk of terrain and is the primary public interface to Demeter. Most applications will create a single instance of this class to represent the terrain in the application, but multiple instances could be used to create separate islands or to stitch together a very large world comprised of multiple terrains.
class Terrain : public osg::Referenced
{
public:
  /// Constructs a new terrain from raw grayscale data. This constructor is only used by the terrain compiler and should generally not be used by applications. Applications should use the constructor that takes map files (map files are generated by the terrain compiler.)
  Terrain(char* szElevationsFilename,char* szTextureFilename,char* szDetailTextureFilename,float vertexSpacing,float elevationScale,int maxNumTriangles,bool bUseBorders);
  /// Constructs a new terrain from a compiled map file. Map files are created by the terrain compiler and they can be distributed with your application.
  Terrain(char* szCompiledMapFilename,int maxNumTriangles,bool bUseBorders = false,float offsetX = 0.0f,float offsetY = 0.0f);
  /// Constructs a new terrain by downloading a compiled map file from a remote HTTP server. Map files are created by the terrain compiler. The URL should be a well formed address with the protocol explicitly listed (for example, "http://www.terrainengine.com") The compiled map file AND the texture and detail texture files that are referenced by the compiled map file should be available from the same URL.
  Terrain(char* szURL,char* szCompiledMapFilename,int maxNumTriangles,bool bUseBorders = false);                        
  /// Destructor.
  ~Terrain();
  /// Based on the current viewing parameters, this method breaks the terrain down into a visually optimum set of triangles that can be rendered. Normally, an application will never call this method directly, but will instead call the method ModelViewMatrixChanged() to allow Demeter to take care of this automatically.
  int                           Tessellate();
  /// Renders the terrain to the current OpenGL surface. \warning Applications should always call ModelViewMatrixChanged() at least once prior to calling Render(), so that Demeter will have a chance to tessellate the terrain.
  void                  Render();
  /// Sets the "detail theshold", which controls how much Demeter simplifies the terrain. Higher thresholds will increase performance but make the terrain look worse, while lower thresholds will reduce performance and increase visual quality. Extremely high thresholds can cause significant visual artifacts and make the terrain look very strange.
  void                  SetDetailThreshold( float threshold );
  /// Returns the "detail threshold", which controls how much Demeter simplifies the terrain. Higher thresholds will increase performance but make the terrain look worse, while lower thresholds will reduce performance and increase visual quality. Extremely high thresholds can cause significant visual artifacts and make the terrain look very strange.
  float                 GetDetailThreshold();
  /// Sets the maximum size of blocks that can be simplified when the terrain is tessellated. The parameter stride specifies the number of vertices along one edge of the block (blocks are always square.) This parameter can be used by applications that allow much of the terrain to be visible from above, such as flight simulators, to prevent oversimplification of terrain in the distance. Setting this value too low will adversely affect performance.
  void                  SetMaximumVisibleBlockSize( int stride );
  /// Returns the width of the terrain in vertices (this is the count of vertices along the world's x-axis.)
  int                           GetWidthVertices();
  /// Returns the height of the terrain in vertices (this is the count of vertices along the world's y-axis.)
  int                           GetHeightVertices();
  /// Returns the width of the terrain in real units (this is the length of the terrain along the world's x-axis.)
  float                 GetWidth() const;
  /// Returns the height of the terrain in real units (this is the length of the terrain along the world's y-axis.)
  float                 GetHeight() const;
  /// Returns the number of real units between vertices in the terrain's mesh.
  float                 GetVertexSpacing();
  /// Returns the elevation (z-coordinate) in real units of the specified point on the terrain.
  float           GetElevation( float x,float y );
  /// Returns the elevation (z-coordinate) in real units of the specified terrain vertex.
  float                 GetElevation( int index );
  /// Returns the surface normal of the terrain at the specified point.
  void            GetNormal( float x,float y,float& normalX,float& normalY,float& normalZ );
  /// Returns the elevation (z-coordinate) in real units of the highest point on the terrain.
  float                 GetMaxElevation() const;
  /// Returns the elevation (z-coordinate) in real units of the specified vertex on the terrain.
  float                 GetVertexElevation(int index) const;
  /// Sets the elevation (z-coordinate) in real units of the specified vertex on the terrain.
  void                  SetVertexElevation(int index,float newElevation);
  /// Writes the current terrain to disk as a compiled map file. This method is used by the terrain compiler, but could also be used by applications as a way to persist the terrain's current state.
  bool                  Write( char* szCompiledMapFilename );
  /// Returns the total number of vertices in the terrain's mesh.
  int                           GetNumberOfVertices();
  /// Returns the width (in vertices) of the terrain's texture tiles.
  int                           GetTextureTileWidth();
  /// Returns the height (in vertices) of the terrain's texture tiles.
  int                           GetTextureTileHeight();
  /// Returns the number of texture tiles along the terrain's x-axis.
  int                           GetNumberOfTextureTilesWidth();
  /// Returns the number of texture tiles along the terrain's y-axis.
  int                           GetNumberOfTextureTilesHeight();
  /// Returns the OpenGL texture number (which can be used in calls to glBindTexture()) of the specified tile. This method could be used by applications that allow some form of terrain "editing" by the user, etc. where it is necessary to show the user some or all of the tiles on the map.
  GLuint                        GetTerrainTile( int index );
  /// Applies the specified graphics image as a texture to the terrain. This is done by breaking the specified image up into smaller textures of 256x256 called "tiles" and mapping these contiguously onto the terrain's surface. The parameter bUseBorders specified whether or not the texture border OpenGL extensions should be used when creating the tiles. Textures are automatically applied when loading compiled map files, so use of this method is strictly optional.
  bool                  SetTexture( char* szFilename,bool bUseBorders );
  /// A simple convenience method that draws the terrain's texture to a SDL surface. This method is a cheap way to show the terrain from directly overhead, such as in a "map view", etc. It is a simple matter to scale the resultant SDL surface to the desired size, using normal SDL functionality.
  //  void                      DrawTexture( SDL_Surface* pTargetSurface,int width,int height );
  /// A simple convenience method that draws the specified terrain tile to a SDL surface. This method could be used by applications that allow some form of terrain "editing" by the user, etc. where it is necessary to show the user some or all of the tiles on the map.
  //void                        DrawTile( SDL_Surface* pSurface,int index,int width,int height );
  /// Uses the specified graphics file to apply a "common" texture to the entire surface of the terrain. A common texture is repeated across the entire terrain and is blended with the terrain's normal texture (if blending is supported by the user's hardware - which covers almost all OpenGL cards.) This is used to provide a "detailed" texture to give the ground some definition when the camera is close to the ground.
  bool                  SetCommonTexture( char* szFilename );
  /// Sets the number of times that the "common" texture (as set by a call to SetCommonTexture()) is to repeated within each texture tile.
  void                  SetCommonTextureRepeats( float commonTextureRepeats );
  /// Returns the number of times that the "common" texture (as set by a call to SetCommonTexture()) is to repeated within each texture tile.
  float                 GetCommonTextureRepeats();
  /// Not yet well implemented. Fluid support will be available soon. \todo Provide better support for fluids (bodies of water, etc.)
  void                  SetFluidElevation( float elevation );
  /// Not yet well implemented. Fluid support will be available soon. \todo Provide better support for fluids (bodies of water, etc.)
  bool                  SetFluidTexture( char* szFilename );
  /// Not yet well implemented. Animation support will be available soon. \todo Provide better support for animation of terrain features such as fluids, moving features, etc.
  void                  Animate();
  /// Notifies Demeter that OpenGL's modelview matrix has been modified, allowing Demeter to tessellate the terrain based on the new modelview matrix. It is IMPERATIVE that his method be called every time the modelview matrix is changed, even if this is in every single rendering cycle of the application.
  int                   ModelViewMatrixChanged();
  /// Returns whether or not the specified cube is inside of the viewing frustum (as defined at the previous call to ModelViewMatrixChanged())
  bool                  CubeInFrustum( float x,float y,float z,float size );
#ifdef _USE_RAYTRACING_SUPPORT_
  /// Casts a ray from the specified point, in the specified direction, and calculates the ray's point of intersection with the terrain. The return value is the distance from the starting point to the intersection. This method makes use of the terrain's quad tree to optimize the ray-tracing.
  float           IntersectRay( float startX,float startY,float startZ,float dirX,float dirY,float dirZ,float& intersectX,float& intersectY,float& intersectZ );
#endif  
  /// Indicates whether or not OpenGL multitexture extensions are available from the OpenGL driver that this terrain instance is currently rendering against (as determined at the time the terrain instance was first constructed.)
  bool            IsMultiTextureSupported();
  /// A convenience method that sets the current OpenGL state to untextured. \warning Calling this method disables texture state immediately; it has no effect on the terrain itself (which will reenable textures the next time it is rendered.) This is only a convenience method that allows external callers to have easy access to OpenGL multitexture extensions. There is rarely a good reason for applications to call this method.
  void            DisableTextures();
  /// A convenience method that sets the current OpenGL state to textured. \warning Calling this method enables texture state immediately; it has no effect on the terrain itself (which will reenable textures the next time it is rendered.) This is only a convenience method that allows external callers to have easy access to OpenGL multitexture extensions. There is rarely a good reason for applications to call this method.
  void            EnableTextures();
  void                  SetLatticePosition(int x,int y);
  void                  GetLatticePosition(int& x,int& y);
  
  enum                  DIRECTION {DIR_NORTH = 0,DIR_NORTHEAST = 1,DIR_EAST = 2,DIR_SOUTHEAST = 3,DIR_SOUTH = 4,DIR_SOUTHWEST = 5,DIR_WEST = 6,DIR_NORTHWEST = 7,DIR_CENTER = 8,DIR_INVALID = 9};
private:
  void                  UnloadTerrainTile(int index);
  void                  UpdateNeighbor(Terrain* pTerrain,DIRECTION direction);
  void                  Init(char* szCompiledMapFilename,int maxNumTriangles,bool bUseBorders,float offsetX = 0.0f,float offsetY = 0.0f);
  bool                  DownloadFile(char* szFilename);
  void                  SetVertexStatus(int index,bool status);
  bool                  GetVertexStatus(int index);
  bool                  Read( char* szCompiledMapFilename,bool bUseBorders );
  void                  BuildBlocks();
  void                  ChopTexture(Uint8* pImage,int width,int height,int tileSize,bool bUseBorders);
  void                  ExtractFrustum();
  char*                 m_szTextureFilename;
  char*                 m_szDetailTextureFilename;
  int                   m_WidthVertices;
  int                   m_HeightVertices;
  float                 m_DetailThreshold;
  float                 m_VertexSpacing;
  TerrainBlock* m_pRootBlock;
  base::BitArray*               m_pVertexStatus;
  int                           m_NumberOfVertices;
  //            GLuint*                 m_pTextureList;
  std::vector<Texture*> m_Textures;
  int                           m_TextureTileWidth,m_TextureTileHeight;
  int                           m_NumberOfTextureTilesWidth;
  int                           m_NumberOfTextureTilesHeight;
  int                           m_TileSize;
  Uint8**                       m_pTiles;
  int                           m_NumberOfTextureTiles;
  //            GLuint                  m_CommonTextureId;
  Texture*              m_pCommonTexture;
  float                 m_FogColorRed,m_FogColorGreen,m_FogColorBlue,m_FogColorAlpha;
  Vector*                   m_pVertices;
  int                           m_MaximumVisibleBlockSize;
  float                 m_CommonTextureRepeats;
  TriangleStrip*        m_pTriangleStrips;
  TriangleFan*  m_pTriangleFans;
  int                           m_CountStrips,m_CountFans;
  float                 m_Frustum[6][4];
  bool            m_bMultiTextureSupported;
  int                           m_MaxNumberOfPrimitives;
  char*                 m_szSourceURL;
  float                 m_MaxElevation;
  float                 m_OffsetX,m_OffsetY;
  int                           m_LatticePositionX,m_LatticePositionY;
  
  friend class  Triangle;
  friend class  TriangleStrip;
  friend class  TerrainBlock;
  friend class  TriangleFan;
  friend class  TerrainLattice;
};
  
/// The Settings class is simply a manager of global variables. It provides a single place to set and retrieve all of the global settings that affect Demeter as a whole.
class Settings
{
public:
  /// Destructor.
  ~Settings();
  /// Returns the global instance of this class. The Settings class acts a singleton, so there is only one instance of this class per application.
  static Settings*    GetInstance();
  /// Sets the filesystem path that Demeter will look in when reading textures, maps, etc.
  void                          SetMediaPath( char* szPath );
  /// Gets the filesystem path that Demeter will look in when reading textures, maps, etc.
  void                          GetMediaPath( char** szPath );
  /// Prepends the current media path to the specified filename.
  void                          PrependMediaPath( char* szFilename,char** pszFullFilename );
  /// Specifies whether or not Demeter should output diagnostic information at runtime.
  void                          SetVerbose( bool bVerbose );
  /// Indicates whether or not Demeter is outputting diagnostic information at runtime.
  bool                          IsVerbose();
  /// Tells Demeter what the current width of the rendering surface is.
  void                          SetScreenWidth( int width );
  /// Retrieves the current width of the rendering surface assumed by Demeter.
  int                                   GetScreenWidth();
  /// Tells Demeter what the current height of the rendering surface is.
  void                          SetScreenHeight( int height );
  /// Retrieves the current height of the rendering surface assumed by Demeter.
  int                                   GetScreenHeight();
  /// Sets a named global property to the specified value.
  bool                          SetProperty( char* szProperty,char* szValue );
  /// Retrieves a named global property.
  bool                          GetProperty( char* szProperty,char* szValue );
  /// Indicates whether or not the application that is using Demeter is a terrain compiler-like tool or a real application
  bool                IsCompilerOnly();
  /// Determins whether or not the application that is using Demeter is a terrain compiler-like tool or a real application
  void                SetCompilerOnly( bool bIsCompilerOnly );
  void                          SetUseDynamicTextures(bool useDynamic);
  bool                          UseDynamicTextures();
  bool                          IsTextureCompression();
  void                          SetTextureCompression(bool bCompress);
  void                          SetHeadless(bool isHeadless);
  bool                          IsHeadless();
private:
  Settings();
  static Settings*      m_pInstance;
  char*                         m_szMediaPath;
  bool                          m_bVerbose;
  bool                m_bIsCompilerOnly;
  bool                          m_bCompressTextures;
  int                                   m_ScreenWidth,m_ScreenHeight;
  bool                          m_IsHeadless;
  bool                          m_UseDynamicTextures;
};

class TriangleFan
{
public:
  TriangleFan();
  ~TriangleFan();
  void                  Render( Terrain* pTerrain );
  void                  Setup( Terrain* pTerrain );
private:
  int                           m_pVertices[MAX_VERTICES_PER_FAN]; // Indices into the terrain vertices
  // TBD: It is a pretty awful waste of memory to preallocate MAX_VERTICES_PER_FAN vertices for every triangle fan,
  // when in most cases only a few vertices are needed. However, dynamically allocating these vertices
  // during every tessellation is not an option either because it causes huge performance problems and
  // badly fragments memory. Any good ideas for this?
  unsigned char m_NumberOfVertices;
  float                 minX,minY;
  int                           textureId;
  
  friend class TerrainBlock;
  friend class Terrain;
};

class TriangleStrip
{
public:
  TriangleStrip();
  ~TriangleStrip();
  void                  Render( Terrain* pTerrain );
  void                  Setup( Terrain* pTerrain );
private:
  GLuint                        m_pVertices[6]; // Indices into the terrain vertices
  unsigned char m_NumberOfVertices;
  float                 minX,minY;
  int                           textureId;
  bool                  m_bEnabled;
  
  friend class TerrainBlock;
  friend class Terrain;
};

class Triangle
{
public:
  Triangle();
  ~Triangle();
  void            DefineFromPoints( Vector& p1,Vector& p2,Vector& p3 );
  Vector*         GetVertex( int index );
#ifdef _USE_RAYTRACING_SUPPORT_
  Plane*          GetPlane();
#endif
private:
  Vector          m_pVertices[3];
#ifdef _USE_RAYTRACING_SUPPORT_
  Plane           m_Plane;
#endif
};

class TerrainBlock
{
public:
  TerrainBlock( TerrainBlock* pParent );
  TerrainBlock( int homeVertex,int stride,Terrain* pTerrain,TerrainBlock* pParent );
  ~TerrainBlock();
  void                          Tessellate( double* pMatrixModelview,double* pMatrixProjection,int* pViewport,TriangleStrip* pTriangleStrips,TriangleFan* pTriangleFans,int* pCountStrips,int* pCountFans,Terrain* pTerrain );
  void                          Write( FILE* file );
  void                          Read( FILE* file,Terrain* pTerrain );
  void                          DummyFunc( Terrain* pTerrain ); // Forces all exported methods to be referenced
  bool                          IsActive();
  void                          RepairCracks( Terrain* pTerrain,TriangleStrip* pTriangleStrips,TriangleFan* pTriangleFans,int* pCountStrips,int* pCountFans );
  TerrainBlock*         GetParent();
  int                                   GetStride();
  void                          EnableStrip( bool bEnabled );
  int                                   GetHomeIndex();
  void                          CalculateGeometry( Terrain* pTerrain );
  void                IntersectRay( Ray& ray,Vector& intersectionPoint,float& lowestDistance,Terrain* pTerrain );
private:
  void                          CreateTriangleStrip( TriangleStrip* pTriangleStrips,int* pCount,Terrain* pTerrain );
  TerrainBlock**                m_pChildren;
  Vector                                m_BoundingBoxUpperCenter,m_BoundingBoxLowerCenter; // These members are redundant and have become stupid - m_BoundingBox should entirely replace them.
  int                                   m_HomeIndex;
  int                                   m_Stride;
  bool                          m_bIsActive;
  bool                          m_bChildrenActive;
  TerrainBlock*         m_pParent;
  TriangleStrip*                m_pTriangleStrip;
  float                         m_CubeSize; // These members are redundant and have become stupid - m_BoundingBox should entirely replace them.
  float                         m_CubeCenterZ; // These members are redundant and have become stupid - m_BoundingBox should entirely replace them.
  unsigned char         m_DisabledCount;
  Box                 m_BoundingBox;
#ifdef _USE_RAYTRACING_SUPPORT_
  Triangle*           m_pTriangles;
#endif
  
  friend class Terrain;
};

class TerrainLoadListener
{
public:
  virtual void          TerrainLoaded(Terrain* pTerrain) = 0;
  virtual void          TerrainUnloading(Terrain* pTerrain) = 0;
};

class TerrainLattice
{
public:
  TerrainLattice(int widthTerrains,int heightTerrains,float terrainWidth,float terrainHeight);
  ~TerrainLattice();
  void                          Load(char* szBaseName,int maxNumTriangles,int maxBlockSize,float commonRepeats,bool bUseBorders = false);
  void                          AddTerrainLoadListener(TerrainLoadListener& listener);
  void                          RemoveTerrainLoadListener(TerrainLoadListener& listener);
  void                          AddTerrain(Terrain* pTerrain,int positionX,int positionY);
  Terrain*                      GetTerrain(int positionX,int positionY);
  Terrain*                      GetTerrainAtPoint(float x,float y);
  void                          SetCameraPosition(float x,float y,float z);
  void                          SetDetailThreshold(float threshold);
  void                          Tessellate();
  void                          Render();
  float                         GetElevation(float x,float y);
  float                         GetWidth();
  float                         GetHeight();
private:
  std::vector<TerrainLoadListener*>     m_TerrainLoadListeners;
  Terrain::DIRECTION                            GetOppositeDirection(Terrain::DIRECTION direction);
  Terrain*                                              GetTerrainRelative(Terrain* pTerrain,int positionX,int positionY);
  Terrain*                                              GetTerrainRelative(Terrain* pTerrain,Terrain::DIRECTION direction);
  void                                                  LoadTerrain(int index);
  int                                                           m_WidthTerrains,m_HeightTerrains;
  int                                                           m_WidthActiveTerrains,m_HeightActiveTerrains;
  float                                                 m_TerrainWidth,m_TerrainHeight;
  Terrain**                                             m_pTerrains;
  int                                                           m_CurrentTerrainIndex[9];
  std::string                                                   m_BaseName;
  int                                                           m_MaxNumTriangles;
  int                                                           m_MaxBlockSize;
  float                                                 m_CommonRepeats;
  bool                                                  m_bUseBorders;
};

} 


namespace gfx {

  typedef demeter::Terrain CLODTerrainRenderer;
  typedef demeter::TerrainLattice CLODTerrainLattice;
  typedef demeter::Settings CLODTerrainSettings;
}

#endif

---