www.pudn.com > sxdl.zip > terrain.h


#if !defined Terrain_Included
#define Terrain_Included

#include "sxdl.h"

enum RenderMode {BRUTEFORCE, LOD };

struct SGEOMM_PATCH
{
float m_fDistance;

int m_iLOD;
bool m_bVisible;
};

struct SGEOMM_NEIGHBOR
{
bool m_bLeft;
bool m_bUp;
bool m_bRight;
bool m_bDown;
};

class CTerrain :
public CCustomRenderer
{
public:
// iXSize : largeur du terrain.
// iYSize : longueur du terrain.
CTerrain ( int Tex1 , int Tex2 , int Data , int iXSize = 512, int iYSize = 512 );
~CTerrain ( void ) ;

bool Initialise ( float fRayonMin = 10.0f,
float fRayonMax = 40.0f,
float fHauteurMin = 0.0f,
float fHauteurMax = 25.0f,
unsigned short uNbMontagnes = 150,
unsigned short uLissage = 1,
bool bIle = false,
unsigned int uGenerateur = 210372 );

// Construit un paysage.
// Les valeurs sont stockées dans un tableau de flottants de taille iXSize * iYSize.
// De plus chaque point de ce tableau se voit affecté d'un vecteur normal qui est constitué
// de 3 flotants. La taille mémoire allouée est donc de iXSize * iYSize * 4 * sizeof(float)
// et donc en prenant 4 octets pour un float et un tableau de 100 sur 100 on se retrouve avec
// une allocation de 160000 octets soit 156Ko. Une zone de 256 de coté consomme elle tout un Mo
// de mémoire.

// arguments:
// fRayonMin : rayon minimum d'une montagne.
// fRayonMax : rayon maximum d'une montagne.
// fHauteurMin : la hauteur par rapport au niveau de la mer du point le plus bas.
// fHauteurMax : la hauteur par rapport au niveau de la mer du point le plus élevé.
// uNbMontagnes : nombre de montagnes à générer.
// uLissage : paramètre de "lissage" des montagnes qui permet d'adoucir un pau les vallées.
// attention : la valeur 1 signifie "pas de lissage", une valeur supérieure indiquera le nombre
// de "passes de lissage" a effectuer
// bIle : si ce flag est a true, le programme génèrera une "île", c'est a dire un terrain dont tous
// les bords sont au niveau fHauteurMin
// uGenerateur : ce nombre initialise le générateur de nombres pseudo-aléatoire. Si on utilise deux fois le même
// nombre on obtiendra exactement le meme paysage. Permet de "stocker" un terrain en ne conservant que
// ses paramètres d'initialisation et ensuite de le recréer au besoin.

bool InitialiseDeRawfile( LPCTSTR sFileName,
int iXYSize,
float fHauteurMin = 0.0f,
float fHauteurMax = 25.0f);

// Cet appel de fonction construit un terrain à partir d'un fichier bitmap
// et ajuste les hauteurs mini et maxi
bool InitialiseDeRawfile2( float fHauteurMin = 0.0f,
float fHauteurMax = 25.0f,
int iRenderMode = BRUTEFORCE);

// Cet appel de fonction construit un terrain à partir d'un fichier bitmap
// en déterminant la taille des cotés et ajuste les hauteurs mini et maxi

int GetXSize(); // renvoit iXSize
int GetYSize(); // renvoit iYSize

void SetHauteurMax(float f); // permet de changer m_fHauteurMax
float GetHauteurMax(); // renvoit m_fHauteurMax

void SetHauteurMin(float f); // permet de changer m_fHauteurMin
float GetHauteurMin(); // renvoit m_fHauteurMin

float* GetTerrain(); // renvoit un pointeur vers le premier point (0,0) du tableau des hauteurs
D3DXVECTOR3* GetNormales(); // renvoit un pointeur vers le premier point (0,0) tu tableau des normales

void AjouteCase( int x, int y, float valeur );
float HauteurCase(int x, int y); // renvoit la hauteur du point (x,y)
float HauteurPosition(float x, float y); // renvoit la hauteur interpolée du point (x, y)
void SetWorldPosition(float x, float y, float z);
void SetWorldScaling(float x, float y, float z);

void Geometry ( Vector3 Position , Vector3 Scale , Vector3 Angles ) ;

// pour le LOD

bool Init( int iPatchSize );
void Shutdown( void );
void Update( void * Vertices , void * Indices, bool bCullPatches= true );
void RenderLOD( void );
void SetRenderMode(int iMode);


//--------------------------------------------------------------
// Name: CGEOMIPMAPPING::GetNumPatchesPerFrame - public
// Description: Get the number of patches being rendered per frame
// Arguments: None
// Return Value: A integer value: number of rendered patches per frame
//--------------------------------------------------------------
inline int GetNumPatchesPerFrame( void )
{ return m_iPatchesPerFrame; }

//--------------------------------------------------------------
// Name: CTERRAIN::GetPatchNumber - public
// Description: Calculate the current patch number
// Arguments: -PX, PZ: the patch number
// Return Value: An integer value: the patch number (for array access)
//--------------------------------------------------------------
inline int GetPatchNumber( int PX, int PZ )
{ return ( ( PZ*m_iNumPatchesPerSide )+PX ); }

// end LOD

// Modifie la valeur au point (x,y) du tableau des hauteurs en ajoutant
// la valeur donnée

void Activate ( bool Animate = true , bool Render = true ) ;

private :

CEntity * Fake ;
HRESULT OnPopulateBuffers ( void * Vertices , void * Indices ) ;
HRESULT OnPopulateIndexBuffer ( void * Indices );
HRESULT OnRender ( LPDIRECT3DDEVICE9 Device , CEntity * Entity ) ;
virtual HRESULT OnSetRenderStates ( LPDIRECT3DDEVICE9 Device ) ;
virtual HRESULT OnRestoreRenderStates ( LPDIRECT3DDEVICE9 Device ) ;

int DataResourceId ;

// LOD

SGEOMM_PATCH* m_pPatches;
int m_iPatchSize;
int m_iNumPatchesPerSide;
unsigned int* piIndices;

int m_iMaxLOD;

int m_iPatchesPerFrame; //the number of rendered patches per second
int m_iTrisPerFrame[50000];
int m_iCompteur;

void RenderFan( float cX, float cZ, float iSize, SGEOMM_NEIGHBOR neighbor, LPDIRECT3DDEVICE9 pd3dDevice, int* pIndices, LPDIRECT3DINDEXBUFFER9* m_pIBTerrainLOD );
void RenderPatch( int PX, int PZ,LPDIRECT3DDEVICE9 pd3dDevice, int* pIndices, LPDIRECT3DINDEXBUFFER9* m_pIBTerrainLOD );

void ComputePatch( int PX, int PZ, void * Vertices , void * Indices );
void ComputeFan( float cX, float cZ, float iSize, SGEOMM_NEIGHBOR neighbor, void * Vertices , void * Indices );

// end LOD

int m_iXSize;
int m_iYSize;
float m_fRayonMin;
float m_fRayonMax;
float m_fHauteurMin;
float m_fHauteurMax;
unsigned short m_uNbMontagnes;
unsigned short m_uLissage;
bool m_bIle;
unsigned int m_uGenerateur;
Vector3 m_vectWorldZeroPosition; // coordonnées du point (0,0,0) dans le repère du monde
D3DXVECTOR3 m_vectWorldScaling; // coefficients multiplicateurs pour scaling du terrain
D3DXMATRIX m_matWorld;

int m_RenderMode; // bruteforce ou LOD
float * m_pMap; // pointeur sur la carte
Vector3 * m_pNormales; // pointeur sur le tableau des normales

void Vider( void ); // met le terrain a 0 (platitude absolue)
void AjouterMontagne( void ); // ajoute une montagne au hasard sur le terrain
void Normalise( void ); // Redimensionne les hauteurs pour qu'elle soient toutes comprises entre 0 et 1.0
void Lisser( void ); // Effectue u lissage pour adoucir les vallées
void HauteursMinMax( void ); // Remet le terrain à l'échelle selon les paramètres m_fHauteurMin et m_fHauteurMax
void CalcNormales( void ); // Calcule le vecteur normal en chaque point
float GetCase( int x, int y ); // Renvoit la hauteur de la case de coordonnée (x, y)
void SetCase( int x, int y, float valeur); // Affecte au point de coordonnées (x,y) la hauteur valeur
void SetNormale( int x, int y, D3DXVECTOR3 valeur); // Affecte au point de coordonnées (x,y) le vecteur normal valeur


bool Animated ;
bool Rendered ;

struct TERRAINVERTEX
{
D3DXVECTOR3 position; // vertex position
D3DXVECTOR3 normal; // vertex normal
DWORD color; // couleur du point
float tu, tv; // valeurs pour coordonnées de texture 1
float tu1, tv1; // valeurs pour coordonnées de texture 2
};

#define D3DFVF_TERRAINVERTEX (D3DFVF_XYZ|D3DFVF_NORMAL|D3DFVF_DIFFUSE|D3DFVF_TEX1|D3DFVF_TEX2)

float HasardIntervalle( float min, float max ); // renvoit un nombre aléatoire compris entre min et max
};

#endif