roam.h

VC++ DEMO, used for the beginners and the amour

#ifdef CGE_HEADER_H
#ifndef CGE_ROAM_H
#define CGE_ROAM_H
namespace CGE
{
	namespace TERRAIN
	{
		
		#define MAP_1024
		
		#ifdef MAP_2048		
		// ------- 2048x2048 MAP -------
		#define MAP_SIZE (2048)
		#define NUM_PATCHES_PER_SIDE (32)
		
		#else
		#ifdef MAP_1024
		
		// ------- 1024x1024 MAP -------
		#define MAP_SIZE (1024)
		#define NUM_PATCHES_PER_SIDE (16)
		
		#else
		#ifdef MAP_512
		// ------- 512x512 MAP -------
		#define MAP_SIZE (512)
		#define NUM_PATCHES_PER_SIDE (8)

		#else
		#ifdef MAP_128
		// ------- 128x128 MAP -------
		#define MAP_SIZE (128)
		#define NUM_PATCHES_PER_SIDE (2)

		#endif
		#endif
		#endif
		#endif
		
		// ---------------------------------------------------------------------
		// Scale of the terrain ie: 1 unit of the height map == how many world units (meters)?
		// 1.0f == 1 meter resolution
		// 0.5f == 1/2 meter resolution
		// 0.25f == 1/4 meter resolution
		// etc..
		#define MULT_SCALE (0.5f)

		#define CAMERA_HEIGHT (15.0f);
		
		// How many TriTreeNodes should be allocated?
		#define POOL_SIZE (200000)
		
		// Some more definitions
		#define PATCH_SIZE (MAP_SIZE/NUM_PATCHES_PER_SIDE)

		#define VARIANCE_DEPTH (10)
		
		typedef struct TERRAINVERTEX
		{
			union {
				FLOAT     x;             /* Homogeneous coordinates */
				FLOAT     dvX;
			};
			union {
				FLOAT     y;
				FLOAT     dvY;
			};
			union {
				FLOAT     z;
				FLOAT     dvZ;
			};
			union {
				FLOAT     nx;            /* Normal */
				FLOAT     dvNX;
			};
			union {
				FLOAT     ny;
				FLOAT     dvNY;
			};
			union {
				FLOAT     nz;
				FLOAT     dvNZ;
			};
			union {
				FLOAT     tu;            /* Texture coordinates */
				FLOAT     dvTU;
			};
			union {
				FLOAT     tv;
				FLOAT     dvTV;
			};
			TERRAINVERTEX() { }
			TERRAINVERTEX(const D3DVECTOR& v, const D3DVECTOR& n, FLOAT _tu, FLOAT _tv)
			{
				x = v.x; y = v.y; z = v.z;
				nx = n.x; ny = n.y; nz = n.z;
				tu = _tu; tv = _tv;
			}
			enum
			{
				TERRAINFVF_VERTEX = (D3DFVF_XYZ|D3DFVF_NORMAL|D3DFVF_TEX1)
			};
			
		}*LPTERRAINVERTEX;

		struct TRIFACE
		{
			TERRAINVERTEX vFace[3];
		};
		
		struct BinTriangleNode
		{
			BinTriangleNode   *LeftChild;
			BinTriangleNode   *RightChild;
			
			BinTriangleNode   *LeftNeighbour;
			BinTriangleNode   *RightNeighbour;
			BinTriangleNode   *BaseNeighbour;
		};
		class LANDSCAPE;

		class PATCH
		{
		public:
			VOID Reset();
			VOID PatchInToLand();
			VOID ReformTriangles( BinTriangleNode *tri, INT leftX, INT leftY, INT rightX, INT rightY, INT apexX, INT apexY );
			VOID Tessellate();
			VOID RecursTessellate( BinTriangleNode *tri,INT leftX,INT leftY,INT rightX, INT rightY,INT apexX,  INT apexY,INT node );
			VOID Split(BinTriangleNode *tri);
			BYTE ComputeVariance( INT leftX,  INT leftY,  BYTE leftZ,INT rightX, INT rightY, BYTE rightZ,INT apexX,  INT apexY,  BYTE apexZ,INT node);
			VOID ComputeVariance();
			BOOL CreatePatch( LANDSCAPE * ParentLand,LONG heightX, LONG heightY, LONG worldX, LONG worldY, BYTE *hMap );
			BOOL IsVisible();
			PATCH();
			~PATCH();
			BOOL IsDirty() { return m_VarianceDirty; }
			BinTriangleNode *GetBaseLeft()  { return &m_BaseLeft; }
			BinTriangleNode *GetBaseRight() { return &m_BaseRight; }
		protected:
			BYTE *m_HeightMap;									// Pointer to height map to use
			LONG  m_WorldX, m_WorldY;										// World coordinate offset of this patch.
			
			BYTE m_VarianceLeft[1<<(VARIANCE_DEPTH)];			// Left variance tree
			BYTE m_VarianceRight[1<<(VARIANCE_DEPTH)];			// Right variance tree
			
			BYTE *m_CurrentVariance;							// Which varience we are currently using. [Only valid during the Tessellate and ComputeVariance passes]
			BYTE  m_VarianceDirty;								// Does the Varience Tree need to be recalculated for this Patch?
			
			BinTriangleNode m_BaseLeft;										// Left base triangle tree node
			BinTriangleNode m_BaseRight;									// Right base triangle tree node
			LANDSCAPE * m_ParentLand;
		public:
			static std::vector<TRIFACE> m_vTriangles;
		};

		typedef class LANDSCAPE
		{
		public:
			LANDSCAPE();
			~LANDSCAPE();
		public:
			VOID Create(LPDIRECT3DDEVICE8 device,TCHAR * tstrOfName);
			VOID CreateLandMesh();
			VOID LandInScene();
			VOID SetNewFrame(CULLING::LPFRUSTUM Frustum);
			BYTE GetHeightValue(LONG x,LONG y);
			VOID SetLandTexture(LPDIRECT3DTEXTURE8 texture) { m_pLandTexture = texture; }
			VOID SetTextureTile( FLOAT xTile,FLOAT yTile ) { m_fXTile = xTile; m_fYTile = yTile; }
			VOID SetMaxDesiredTri(LONG nMaxDesiredTri) { m_nMaxDesiredTris = nMaxDesiredTri;}
			VOID SetFrameVariance(FLOAT fFrameVariance) { m_fFrameVariance = fFrameVariance;}
		public:
			static LONG GetNextTriNode() { return m_NextTriNode; }
			static VOID SetNextTriNode( LONG nNextNode ) { m_NextTriNode = nNextNode; }
			static BinTriangleNode * AllocateNode();

			static LONG	m_NextTriNode;										// Index to next free BinTriangleNode
			static BinTriangleNode m_TriPool[POOL_SIZE];						// Pool of TriTree nodes for splitting
		public:
			FLOAT m_fFrameVariance;
			LONG m_nMaxDesiredTris;
		    MATRIX::LPCAMERA m_Camera;
			BYTE * m_pHeightMap;
			FLOAT m_fXTile,m_fYTile;
			CULLING::LPFRUSTUM m_Frustum;
			LPDIRECT3DDEVICE8 m_pD3DDevice;
			LPDIRECT3DTEXTURE8 m_pLandTexture;
			LPDIRECT3DVERTEXBUFFER8 m_pLandVB;
			PATCH m_vPatches[NUM_PATCHES_PER_SIDE][NUM_PATCHES_PER_SIDE];

		}*LPLANDSCAPE;		
	}
}
#endif
#endif