开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > DirextX编程 > 查看源码
zfxLODTerrain.cpp
资源名称：Direct3D.rar　[点击查看]
上传用户：junlon
上传日期：2022-01-05
资源大小：39075k
文件大小：32k
源码类别：

DirextX编程

开发平台：

Visual C++

zfxLODTerrain.cpp：源码内容
  1. #include "stdafx.h"
  3. #include "zfxLODTerrain.h"
  5. #define LOWEST 100.0f
  6. #define HIGHEST 140.0f
  8. // 全局函数
  9. // num必须是一个大于0的数，返回log2(num)的整数部分，小数部分将被截掉
  10. // 例如，log2(512)返回 9, log2(514)和log2(1000)也将返回 9
  11. UINT log2(UINT num);
  12. // 先销毁该节点的子节点，再销毁该节点
  13. //void deleteTreeNode( CZFXLODTrnNode* pNode );
  15. CZFXLODTrnNode::CZFXLODTrnNode()
  16. {
  17. m_pTLChildNode = NULL;
  18. m_pBLChildNode = NULL;
  19. m_pTRChildNode = NULL;
  20. m_pBRChildNode = NULL;
  21. }
  23. CZFXLODTrnNode::~CZFXLODTrnNode()
  24. {
  25. SAFE_DELETE( m_pTLChildNode );
  26. SAFE_DELETE( m_pBLChildNode );
  27. SAFE_DELETE( m_pTRChildNode );
  28. SAFE_DELETE( m_pBRChildNode );
  29. }
  31. CZFXLODTrnNode::CZFXLODTrnNode(ZFXNODEPOSSIZE nodePosSize)
  32. {
  33. m_pParentNode = NULL;
  34. m_bIsLeaf = true;
  35. m_bReachAcceptableLevel = false;
  36. m_bTouched = false;
  37. m_bIsVisible = false;
  39. m_pTLChildNode = NULL;
  40. m_pBLChildNode = NULL;
  41. m_pTRChildNode = NULL;
  42. m_pBRChildNode = NULL;
  44. m_nodePosSize = nodePosSize;
  45. }
  47. void CZFXLODTrnNode::SplitNode()
  48. {
  49. UINT sizeDivide2 = m_nodePosSize.size >> 1;
  50. UINT sizeDivide4 = sizeDivide2 >> 1;
  51. // 左上角子节点
  52. ZFXNODEPOSSIZE nodePosSize( m_nodePosSize.x - sizeDivide4, m_nodePosSize.y - sizeDivide4, sizeDivide2 );
  53. m_pTLChildNode = new CZFXLODTrnNode( nodePosSize );
  54. m_pTLChildNode->m_pParentNode = this;
  55. m_pTLChildNode->m_level = m_level - 1;
  56. m_pTLChildNode->m_EnumValue = TOPLEFT;
  58. // 左下角子节点
  59. nodePosSize.y += sizeDivide2;
  60. m_pBLChildNode = new CZFXLODTrnNode( nodePosSize );
  61. m_pBLChildNode->m_pParentNode = this;
  62. m_pBLChildNode->m_level = m_level -1;
  63. m_pBLChildNode->m_EnumValue = BOTTOMLEFT;
  65. // 右下角子节点
  66. nodePosSize.x += sizeDivide2;
  67. m_pBRChildNode = new CZFXLODTrnNode( nodePosSize );
  68. m_pBRChildNode->m_pParentNode = this;
  69. m_pBRChildNode->m_level = m_level - 1;
  70. m_pBRChildNode->m_EnumValue = BOTTOMRIGHT;
  72. // 右上角子节点
  73. nodePosSize.y -= sizeDivide2;
  74. m_pTRChildNode = new CZFXLODTrnNode( nodePosSize );
  75. m_pTRChildNode->m_pParentNode = this;
  76. m_pTRChildNode->m_level = m_level -1;
  77. m_pTRChildNode->m_EnumValue = TOPRIGHT;
  79. // 分裂节点后，便不再是叶子节点
  80. m_bIsLeaf = false;
  81. }
  83. BOOL CZFXLODTrnNode::IsSplit()
  84. {
  85. if( m_level > 0 )
  86. return TRUE;
  87. else
  88. return FALSE;
  89. }
  90. /////////////////////////////////////////////////////////////////////////////////////////////////
  92. /////////////////////////////////////////////////////////////////////////////////////////////////
  93. // implementation of  CZFXLODTerrain
  94. CZFXLODTerrain::CZFXLODTerrain()
  95. {
  96. m_pHeadNode = NULL;
  97. m_numNodeRendered = 0;
  98. m_elevArray = NULL;
  100. m_pVB = NULL;
  101. m_pIB = NULL;
  102. m_vertexArray = NULL;
  103. m_indexArray = NULL;
  104. m_lowTexture = NULL;
  105. m_highTexture = NULL;
  106. }
  108. CZFXLODTerrain::CZFXLODTerrain( LPCTSTR strFileName )
  109. {
  110. m_pHeadNode = NULL;
  111. m_numNodeRendered = 0;
  112. // 从文件中读取地形数据。。。。。( .map文件，以float浮点形式读取)
  113. FILE* pFile = _tfopen(strFileName, "rb");
  114. int width, height;
  115. fread( &width, sizeof(int), 1, pFile );
  116. fread( &height,sizeof(int), 1, pFile );
  117. m_width = width;
  119. // 开辟二维高程数组,并以读取数据将其初始化
  120. m_elevArray = new float*[m_width];
  121. for(UINT i=0;i<m_width;i++)
  122. {
  123. m_elevArray[i] = new float[m_width];
  124. fread( m_elevArray[i], sizeof(float), m_width, pFile );
  125. }
  126. fclose(pFile);
  128. // 开辟纹理数组
  129. m_tuArray = new float[m_width];
  130. m_tvArray = new float[m_width];
  132. //在SetDimesion(...)函数中开辟空间，只有知道网格的几何宽度才能求取法线向量的值
  133. m_normalArray = NULL;
  135. for(UINT i=0;i<m_width;i++)
  136. {
  137. m_tvArray[i] = m_tuArray[i] = i * 20.0f / (int)m_width;
  138. }
  140. m_pVB = NULL;
  141. m_pIB = NULL;
  142. m_vertexArray = NULL;
  143. m_indexArray = NULL;
  144. m_lowTexture = NULL;
  145. m_highTexture = NULL;
  146. }
  148. CZFXLODTerrain::~CZFXLODTerrain()
  149. {
  150. // 销毁头结点及其所有的子节点，否则造成内存溢出
  151. SAFE_DELETE(m_pHeadNode);//调用delete pNode会在pNode的析构函数中先释放其四个子节点
  153. // 释放高程数组
  154. if( m_elevArray != NULL )
  155. {
  156. for(UINT i=0;i<m_width;i++)
  157. {
  158. delete [] m_elevArray[i];
  159. }
  160. delete [] m_elevArray;
  161. }
  162. // 释放法线向量数组
  163. if( m_normalArray != NULL )
  164. {
  165. for(UINT i=0;i<m_width;i++)
  166. {
  167. delete [] m_normalArray[i];
  168. }
  169. delete [] m_normalArray;
  170. }
  171. // 释放纹理数组
  172. delete [] m_tuArray;
  173. delete [] m_tvArray;
  174. }
  176. void CZFXLODTerrain::SetDimesion( float width, float height/*地形的几何尺寸*/,D3DXVECTOR2 centerPt/*地形的中点位置*/ )
  177. {
  178. m_fWidth = width;
  179. m_fHeight = height;
  180. m_centerPt = centerPt;
  182. m_GridWidth = m_fWidth/(m_width - 1);
  183. m_GridHeight = m_fHeight/(m_width - 1);
  185. // 开辟二维法线向量数组,并初始化
  186. m_normalArray = new D3DXVECTOR3*[m_width];
  187. for(UINT i=0;i<m_width;i++)
  188. {
  189. m_normalArray[i] = new D3DXVECTOR3[m_width];
  190. }
  191. // 二维法线向量数组初始化，不包括边界部分
  192. for(UINT i=0;i<m_width - 1;i++)
  193. {
  194. for(UINT j=0;j<m_width - 1;j++)
  195. {
  196. D3DXVECTOR3 vec[2];
  197. vec[0] = D3DXVECTOR3( -m_GridWidth, m_elevArray[i][j] - m_elevArray[i+1][j], 0 );
  198. vec[1] = D3DXVECTOR3( 0, m_elevArray[i][j] - m_elevArray[i][j+1], m_GridHeight );
  199. D3DXVec3Cross( &m_normalArray[i][j], &vec[0], &vec[1] );
  200. D3DXVec3Normalize( &m_normalArray[i][j], &m_normalArray[i][j] );
  201. }
  202. }
  203. // 地形边界处 法线向量的初始化
  204. for(UINT i=0;i<m_width;i++)
  205. {
  206. m_normalArray[i][m_width-1] = D3DXVECTOR3(0, 1, 0);
  207. m_normalArray[m_width-1][i] = D3DXVECTOR3(0, 1, 0);
  208. }
  209. }
  211. HRESULT CZFXLODTerrain::InitShader(LPDIRECT3DDEVICE9 pd3dDevice)
  212. {
  213. HRESULT hr;
  214. LPD3DXBUFFER pShaderBuffer;
  215. // Create vertex shader
  216. if( FAILED( hr = D3DXCompileShaderFromFile( "hlsl.vsd", NULL, NULL, "main", 
  217. "vs_2_0", 0/*D3DXSHADER_DEBUG | D3DXSHADER_SKIPOPTIMIZATION*//*Flag*/, &pShaderBuffer, NULL/*Error buffer*/, &m_pVConstTable )))
  218. return hr;
  219. if( FAILED( hr = pd3dDevice->CreateVertexShader((DWORD*)pShaderBuffer->GetBufferPointer(), &m_pVShader)))
  220. return hr;
  221. // Create pixel shader
  222. if( FAILED( hr = D3DXCompileShaderFromFile( "hlsl.psd", NULL, NULL, "main", 
  223. "ps_2_0", 0/*Flag*/, &pShaderBuffer, NULL/*Error buffer*/, &m_pPConstTable )))
  224. return hr;
  225. if( FAILED( hr = pd3dDevice->CreatePixelShader((DWORD*)pShaderBuffer->GetBufferPointer(), &m_pPShader)))
  226. return hr;
  227. return hr;
  228. }
  230. void CZFXLODTerrain::InitQuadTree()
  231. {
  232. m_pHeadNode = new CZFXLODTrnNode( ZFXNODEPOSSIZE( (m_width-1) >> 1, (m_width-1) >> 1, m_width-1 ) );
  233. m_pHeadNode->m_level = log2( m_width - 1 ) - 1;
  234. GrowQuadTree(m_pHeadNode);
  235. }
  238. void CZFXLODTerrain::LoadTextureFromFile( LPDIRECT3DDEVICE9 pd3dDevice, LPCTSTR lowTexFile, LPCTSTR highTexFile )
  239. {
  240. // 创建纹理
  241. if( FAILED( D3DXCreateTextureFromFile( pd3dDevice, lowTexFile, &m_lowTexture )))
  242. {
  243. char strTexFileName[60];
  244. sprintf( strTexFileName, "..\%s", lowTexFile );
  245. if( FAILED( D3DXCreateTextureFromFile( pd3dDevice, strTexFileName, &m_lowTexture )))
  246. m_lowTexture = NULL;
  247. }
  248. if( FAILED( D3DXCreateTextureFromFile( pd3dDevice, highTexFile, &m_highTexture )))
  249. {
  250. char strTexFileName[60];
  251. sprintf( strTexFileName, "..\%s", highTexFile );
  252. if( FAILED( D3DXCreateTextureFromFile( pd3dDevice, highTexFile, &m_highTexture )))
  253. m_highTexture = NULL;
  254. }
  255. }
  257. void CZFXLODTerrain::CreateTerrain( LPDIRECT3DDEVICE9 pd3dDevice, CZFXCamera* pCamera )
  258. {
  260. m_pCamera = pCamera;
  261. // 将根节点及其所有子节点的属性还原为false
  262. ClearTreeFlag(m_pHeadNode);
  264. // 遍历四叉树，判断节点的可见性和它的level是否达到要求，并对节点进行标记
  265. m_numNodeRendered = 0;
  266. m_frustum.Construct( pd3dDevice );
  268. ClimbQuadTree(m_pHeadNode, pd3dDevice);
  269. // 动态开辟顶点数组和索引数组
  270. UINT vertexArraySize = (m_numNodeRendered<<3) + m_numNodeRendered;  //m_numNodeRendered * 9
  271. UINT indexArraySize  = (m_numNodeRendered<<4) + (m_numNodeRendered<<3);   //m_numNodeRendered * 24
  272. m_vertexArray = new ZFXTRNVERTEX[vertexArraySize];
  273. m_indexArray  = new WORD[indexArraySize];
  274. // 遍历四叉树，寻找树中m_bReachAcceptableLevel == true的节点，并将所有符合条件的节点写进顶点数组和索引数组中
  275. m_vertexIndex = 0;
  276. m_indexIndex  = 0;
  277. RefineNode(m_pHeadNode);
  278. // 创建顶点缓冲和索引缓冲,还需设置某些flag以提高性能
  279. SAFE_RELEASE(m_pVB);
  280. SAFE_RELEASE(m_pIB);
  281. // 创建 vertex buffer
  282. if( FAILED( pd3dDevice->CreateVertexBuffer( vertexArraySize * sizeof(ZFXTRNVERTEX),
  283.         D3DUSAGE_DYNAMIC|D3DUSAGE_WRITEONLY/*Usage*/, D3DFVF_ZFXTRNVERTEX, D3DPOOL_SYSTEMMEM/*D3DPOOL*/, &m_pVB, NULL )))
  284. return;
  285. void* pVertices;
  286. if( FAILED(m_pVB->Lock( 0/*offset*/, vertexArraySize * sizeof(ZFXTRNVERTEX), (void**)&pVertices, 
  287. D3DLOCK_DISCARD|D3DLOCK_NOOVERWRITE/*Flag*/ )))
  288. return;
  289. memcpy( pVertices, m_vertexArray, vertexArraySize * sizeof(ZFXTRNVERTEX) );
  290. m_pVB->Unlock();
  291. // 创建 index buffer
  292. if( FAILED( pd3dDevice->CreateIndexBuffer( indexArraySize *sizeof(WORD), 
  293. D3DUSAGE_DYNAMIC|D3DUSAGE_WRITEONLY/*Usage*/, D3DFMT_INDEX16, D3DPOOL_SYSTEMMEM/*D3DPOOL*/, &m_pIB, NULL )))
  294. return;
  295. void* pIndices;
  296. if( FAILED(m_pIB->Lock( 0/*offset*/, indexArraySize * sizeof(WORD), (void**)&pIndices,
  297. D3DLOCK_DISCARD|D3DLOCK_NOOVERWRITE/*Flag*/ )))
  298. return;
  299. memcpy( pIndices, m_indexArray, indexArraySize * sizeof(WORD) );
  300. m_pIB->Unlock();
  301. // 创建 vertex buffer完毕，释放顶点数组
  302. delete [] m_vertexArray;
  303. // 创建 index buffer完毕，释放索引数组
  304. delete [] m_indexArray;
  305. }
  308. // 
  309. void  CZFXLODTerrain::RenderTerrain( LPDIRECT3DDEVICE9 pd3dDevice, BOOL bFog )
  310. {
  311. // pre rendering
  312. D3DXVECTOR4 lightDirVec(3.0f, 1.0f, 0, 0);
  314. // set vertex shader constant table
  315. D3DXMATRIXA16 mWorld, mView, mProj;
  316. pd3dDevice->GetTransform(D3DTS_WORLD, &mWorld);
  317. pd3dDevice->GetTransform(D3DTS_VIEW, &mView);
  318. pd3dDevice->GetTransform(D3DTS_PROJECTION, &mProj);
  319. D3DXMATRIXA16 mWorldViewProj = mWorld * mView * mProj;
  320. D3DXMATRIXA16 mWorldView = mWorld * mView;
  321. m_pVConstTable->SetMatrix(pd3dDevice, "mWorldViewProj", &mWorldViewProj);
  322. m_pVConstTable->SetMatrix(pd3dDevice, "mWorldView", &mWorldView);
  323. m_pVConstTable->SetFloat( pd3dDevice, "lowest", LOWEST);
  324. m_pVConstTable->SetFloat( pd3dDevice, "highest", HIGHEST);
  325. m_pVConstTable->SetFloat( pd3dDevice, "ambient", 0.5f);
  326. m_pVConstTable->SetVector(pd3dDevice, "lightDir", &lightDirVec);
  328. // set pixel shader constant table
  329. D3DXHANDLE hLowSmpl =  m_pPConstTable->GetConstantByName(NULL, "lowTexSmpl");
  330. D3DXHANDLE hHighSmpl = m_pPConstTable->GetConstantByName(NULL, "highTexSmpl");
  331. D3DXCONSTANT_DESC lowSmplDesc, highSmplDesc;
  332. UINT count;
  333. m_pPConstTable->GetConstantDesc(hLowSmpl, &lowSmplDesc, &count);
  334. m_pPConstTable->GetConstantDesc(hHighSmpl,&highSmplDesc,&count);
  336. // set low texture
  337. pd3dDevice->SetTexture(lowSmplDesc.RegisterIndex, m_lowTexture);
  338. pd3dDevice->SetSamplerState(lowSmplDesc.RegisterIndex, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);
  339. pd3dDevice->SetSamplerState(lowSmplDesc.RegisterIndex, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
  340. pd3dDevice->SetSamplerState(lowSmplDesc.RegisterIndex, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
  341. pd3dDevice->SetSamplerState(lowSmplDesc.RegisterIndex, D3DSAMP_ADDRESSU, D3DTADDRESS_MIRROR);
  342. pd3dDevice->SetSamplerState(lowSmplDesc.RegisterIndex, D3DSAMP_ADDRESSV, D3DTADDRESS_MIRROR);
  343. // set high texture
  344. pd3dDevice->SetTexture(highSmplDesc.RegisterIndex, m_highTexture);
  345. pd3dDevice->SetSamplerState(highSmplDesc.RegisterIndex, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);
  346. pd3dDevice->SetSamplerState(highSmplDesc.RegisterIndex, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
  347. pd3dDevice->SetSamplerState(highSmplDesc.RegisterIndex, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
  348. pd3dDevice->SetSamplerState(highSmplDesc.RegisterIndex, D3DSAMP_ADDRESSU, D3DTADDRESS_MIRROR);
  349. pd3dDevice->SetSamplerState(highSmplDesc.RegisterIndex, D3DSAMP_ADDRESSV, D3DTADDRESS_MIRROR);
  351. // set fog
  352. D3DXVECTOR4 fogColor(0.18f, 0.2f, 0.7f, 1.0f);
  353. m_pVConstTable->SetFloat(pd3dDevice, "nearFog", 200.0f);
  354. m_pVConstTable->SetFloat(pd3dDevice, "farFog", 1000.0f);
  355. m_pPConstTable->SetVector(pd3dDevice, "fogColor", &fogColor);
  356. if(bFog)
  357. m_pPConstTable->SetFloat(pd3dDevice, "bFog", 1.0f);
  358. else
  359. m_pPConstTable->SetFloat(pd3dDevice, "bFog", 0.0f);
  361. // rendering
  362. pd3dDevice->SetFVF( D3DFVF_ZFXTRNVERTEX );
  363. pd3dDevice->SetStreamSource( 0, m_pVB, 0, sizeof(ZFXTRNVERTEX) );
  364. pd3dDevice->SetVertexShader(m_pVShader);
  365. pd3dDevice->SetPixelShader(m_pPShader);
  366. pd3dDevice->SetIndices( m_pIB );
  367. pd3dDevice->DrawIndexedPrimitive( D3DPT_TRIANGLELIST, 0/*base index index*/, 0,/*MinVertexIndex*/
  368. (m_numNodeRendered << 3 ) + m_numNodeRendered/*NumVertices*/,
  369. 0/*StartIndex*/,
  370. (m_numNodeRendered << 3 )/*PrimitiveCount*/);
  371. // post rendering
  372. pd3dDevice->SetVertexShader(NULL);
  373. pd3dDevice->SetPixelShader(NULL);
  374. }
  376. // 给定X坐标和Y坐标，求出该点的地形高度  未完
  377. float CZFXLODTerrain::GetTerrainElev(float x, float z)
  378. {
  379. /*float elev;*/
  380. // 先求得对应于点 (x, z) 的相对坐标
  381. float xFloat, zFloat;
  382. xFloat = (x - m_centerPt.x) / m_GridWidth + ((m_width - 1)>>1);
  383. zFloat = (z - m_centerPt.y) / m_GridHeight + ((m_width - 1)>>1);
  384. int i, j;
  385. j = (int)xFloat;  // 取下整数
  386. i = (int)zFloat;  // 取下整数
  387. return m_elevArray[i][j];
  388. }
  390. /////////////////////////////////////////////////////////////////////////////////////////////////////
  391. // 以下为私有成员函数
  392. // 将头结点生长成一棵完全的二叉树
  393. void CZFXLODTerrain::GrowQuadTree(CZFXLODTrnNode* pNode)
  394. {
  395. if(pNode->IsSplit())
  396. {
  397. pNode->SplitNode();
  398. GrowQuadTree( pNode->m_pBLChildNode );
  399. GrowQuadTree( pNode->m_pTLChildNode );
  400. GrowQuadTree( pNode->m_pTRChildNode );
  401. GrowQuadTree( pNode->m_pBRChildNode );
  402. }
  403. }
  406. // 遍历四叉树，判断节点的可见性和它的level是否达到要求，并对节点进行标记
  407. void CZFXLODTerrain::ClimbQuadTree( CZFXLODTrnNode* pNode, LPDIRECT3DDEVICE9 pd3dDevice )
  408. {
  409. pNode->m_bTouched = true;
  410. if( IsVisible( pNode, pd3dDevice ) )// 如果头结点可见，对该节点进行处理，否则，忽略之
  411. {
  412. pNode->m_bIsVisible = true;
  413. if( IsReachAcceptableLevel( pNode )||pNode->m_bIsLeaf )
  414. {// 如果该节点的level已足够低，或者该节点是叶子节点，不再往下遍历
  415. pNode->m_bReachAcceptableLevel = true;
  416. // 下面这句话要求每个节点只能被扩展一次
  417. m_numNodeRendered ++;
  418. }
  419. else
  420. {// 如果该节点的level还不够低，并且不是叶子节点，继续往下扩展遍历
  421. // 往下扩展遍历之前，确认它的四个相邻顶点的父节点被扩展遍历过
  422. pNode->m_bReachAcceptableLevel = false;
  423. CZFXLODTrnNode* pAdjNodeArray[4];
  424. GetAdjNodeParent4( pAdjNodeArray, pNode );
  425. for(int i=0;i<4;i++)
  426. {
  427. if( pAdjNodeArray[i] != NULL && pAdjNodeArray[i]->m_bTouched == false )
  428. ClimbQuadTree( pAdjNodeArray[i], pd3dDevice );
  429. }
  430. if( false == pNode->m_pBLChildNode->m_bTouched )
  431. ClimbQuadTree( pNode->m_pBLChildNode, pd3dDevice );
  432. if( false == pNode->m_pTLChildNode->m_bTouched )
  433. ClimbQuadTree( pNode->m_pTLChildNode, pd3dDevice );
  434. if( false == pNode->m_pBRChildNode->m_bTouched )
  435. ClimbQuadTree( pNode->m_pBRChildNode, pd3dDevice );
  436. if( false == pNode->m_pTRChildNode->m_bTouched )
  437. ClimbQuadTree( pNode->m_pTRChildNode, pd3dDevice );
  438. }
  439. }
  440. else
  441. {
  442. pNode->m_bIsVisible = false;
  443. pNode->m_bReachAcceptableLevel = false;
  444. }
  445. }
  447. // 得到节点的四个相邻节点的父节点，将它们的指针存储在一个数组里
  448. void CZFXLODTerrain::GetAdjNodeParent4(CZFXLODTrnNode** pAdjNodeArray, CZFXLODTrnNode* pNode)
  449. {
  450. ZFXNODEPOSSIZE posSize = pNode->GetPosSize();
  451. // 查找该节点上面的那个节点的父节点
  452. pAdjNodeArray[0] = FindParentNode( posSize.x, posSize.y - posSize.size );
  453. // 查找该节点下面的那个节点的父节点
  454. pAdjNodeArray[1] = FindParentNode( posSize.x, posSize.y + posSize.size );
  455. // 查找该节点左边的那个节点的父节点
  456. pAdjNodeArray[2] = FindParentNode( posSize.x - posSize.size, posSize.y );
  457. // 查找该节点右边的那个节点的父节点
  458. pAdjNodeArray[3] = FindParentNode( posSize.x + posSize.size, posSize.y );
  459. }
  461. // 查找相对位置为(x, y)的那个节点的父节点
  462. CZFXLODTrnNode* CZFXLODTerrain::FindParentNode(UINT x, UINT y)
  463. {
  464. CZFXLODTrnNode* pNode = m_pHeadNode;
  465. while(1)
  466. {
  467. if( pNode == NULL )
  468. return NULL;
  469. ZFXNODEPOSSIZE posSize = pNode->GetPosSize();
  470. if( posSize.x == x )
  471. return pNode->m_pParentNode; // 找到该节点，返回它的父节点
  472. else if( posSize.x < x )
  473. {
  474. if( posSize.y < y )
  475. pNode = pNode->m_pBRChildNode;
  476. else //posSize.y > y
  477. pNode = pNode->m_pTRChildNode;
  478. }
  479. else //posSize.x > x
  480. {
  481. if( posSize.y < y )
  482. pNode = pNode->m_pBLChildNode;
  483. else //posSize.y > y
  484. pNode = pNode->m_pTLChildNode;
  485. }
  486. }
  487. }
  488. // 查找相对位置为(x, y)的那个节点
  489. CZFXLODTrnNode* CZFXLODTerrain::FindNode(UINT x, UINT y)
  490. {
  491. CZFXLODTrnNode* pNode = m_pHeadNode;
  492. while(1)
  493. {
  494. if( pNode == NULL )
  495. return NULL;
  496. ZFXNODEPOSSIZE posSize = pNode->GetPosSize();
  497. if( posSize.x == x )
  498. return pNode; // 找到该节点，返回它的父节点
  499. else if( posSize.x < x )
  500. {
  501. if( posSize.y < y )
  502. pNode = pNode->m_pBRChildNode;
  503. else //posSize.y > y
  504. pNode = pNode->m_pTRChildNode;
  505. }
  506. else //posSize.x > x
  507. {
  508. if( posSize.y < y )
  509. pNode = pNode->m_pBLChildNode;
  510. else //posSize.y > y
  511. pNode = pNode->m_pTLChildNode;
  512. }
  513. }
  514. }
  516. // 判断某个节点是否可见
  518. BOOL CZFXLODTerrain::IsVisible(CZFXLODTrnNode* pNode, LPDIRECT3DDEVICE9 pd3dDevice)
  519. {
  520. ZFXNODEPOSSIZE posSize = pNode->GetPosSize();
  521. D3DXVECTOR3 centerPos;
  522. centerPos.x = ( int(posSize.x - ((m_width - 1)>>1)) ) * m_GridWidth + m_centerPt.x;
  523. centerPos.y = m_elevArray[posSize.y][posSize.x];
  524. centerPos.z = ( int(posSize.y - ((m_width -1 )>>1)) ) * m_GridHeight + m_centerPt.y;
  525. float radius = float((int)(posSize.size) * m_GridWidth)/1.414f;
  526. return m_frustum.CheckSphere( centerPos, radius );
  527. }
  529. // 判断某个节点的level是否已足够低
  530. BOOL CZFXLODTerrain::IsReachAcceptableLevel(CZFXLODTrnNode* pNode)
  531. {
  532. // 先求取节点中心的绝对坐标值
  533. ZFXNODEPOSSIZE posSize = pNode->GetPosSize();
  534. D3DXVECTOR3 centerPos;
  535. centerPos.x = ( int(posSize.x - ((m_width - 1)>>1)) ) * m_GridWidth + m_centerPt.x;
  536. centerPos.y = m_elevArray[posSize.y][posSize.x];
  537. centerPos.z = ( int(posSize.y - ((m_width -1 )>>1)) ) * m_GridHeight + m_centerPt.y;
  538. // 再获取眼睛的绝对坐标值
  539. D3DXVECTOR3 eyePt( m_pCamera->GetPosX(), m_pCamera->GetPosY(), m_pCamera->GetPosZ() );
  540. // 求取眼睛与节点中心之间的绝对距离
  541. D3DXVECTOR3 vec3 = centerPos - eyePt;
  542. float distance = D3DXVec3Length( &vec3 );
  543. ////
  544. D3DXVECTOR3 lookAtVec;
  545. m_pCamera->GetLookVec(&lookAtVec);
  546. D3DXVec3Normalize(&lookAtVec, &lookAtVec);
  547. D3DXVec3Normalize(&vec3, &vec3);
  548. float fNum = D3DXVec3Dot(&vec3, &lookAtVec);
  549. if(fNum < 0)
  550. fNum = 0;
  551. fNum = fNum/2 + 0.5f;
  552. if( distance / fNum > float(posSize.size << 4) )
  553. return TRUE;
  554. else
  555. return FALSE;
  556. }
  558. // 遍历四叉树，寻找树中m_bReachAcceptableLevel == true的节点，并将所有符合条件的节点写进顶点数组和索引数组中
  559. // 每个节点由8个三角形组成，9个顶点数据，24个索引数据
  560. void CZFXLODTerrain::RefineNode(CZFXLODTrnNode* pNode)
  561. {
  562. if( pNode->m_bIsVisible )
  563. {
  564. if( pNode->m_bReachAcceptableLevel/* || !pNode->m_bIsVisible*//*for debug*/)
  565. {// 节点的细节已足够，将它送入顶点数组和索引数组
  566. // 顶点数组赋值，   0 1 2
  567. //                  3 4 5 
  568. //                  6 7 8
  569. // 计算顶点的位置向量和纹理坐标
  570. ZFXNODEPOSSIZE posSize = pNode->GetPosSize();
  571. UINT sizeDivide2 = posSize.size >> 1;
  572. float top = ( int(posSize.y - sizeDivide2 - ((m_width -1 )>>1)) ) * m_GridHeight + m_centerPt.y;
  573. float bottom = ( int(posSize.y + sizeDivide2 - ((m_width -1 )>>1)) ) * m_GridHeight + m_centerPt.y;
  574. float left = ( int(posSize.x - sizeDivide2 - ((m_width -1 )>>1)) ) * m_GridWidth + m_centerPt.x;
  575. float right = ( int(posSize.x + sizeDivide2 - ((m_width -1 )>>1)) ) * m_GridWidth + m_centerPt.x;
  576. float centerX = ( int(posSize.x - ((m_width -1 )>>1)) ) * m_GridWidth + m_centerPt.x;
  577. float centerY = ( int(posSize.y - ((m_width -1 )>>1)) ) * m_GridWidth + m_centerPt.y;
  578. // 左上角顶点
  579. m_vertexArray[m_vertexIndex + 0].position.x = left;
  580. m_vertexArray[m_vertexIndex + 0].position.z = top;
  581. m_vertexArray[m_vertexIndex + 0].position.y = m_elevArray[posSize.y - sizeDivide2][posSize.x - sizeDivide2];
  582. m_vertexArray[m_vertexIndex + 0].normal   = m_normalArray[posSize.y - sizeDivide2][posSize.x - sizeDivide2];
  583. // for debug
  584. //m_vertexArray[m_vertexIndex + 0].position.y = 0;
  585. m_vertexArray[m_vertexIndex + 0].tu = m_tuArray[posSize.x - sizeDivide2];
  586. m_vertexArray[m_vertexIndex + 0].tv = m_tvArray[posSize.y - sizeDivide2];
  588. // 上边顶点
  589. // 判断它上方的那个相邻节点的 m_bTouched 属性是否为true,如为真从数组中读取高程值，否则取相邻顶点高程值的平均值
  590. m_vertexArray[m_vertexIndex + 1].position.x = centerX;
  591. m_vertexArray[m_vertexIndex + 1].position.z = top;
  592. CZFXLODTrnNode* pAdjNode = FindNode( posSize.x, posSize.y - posSize.size );
  593. if( pAdjNode != NULL )
  594. {
  595. if( pAdjNode->m_bTouched )
  596. {
  597. m_vertexArray[m_vertexIndex + 1].position.y = m_elevArray[posSize.y - sizeDivide2][posSize.x];
  598. m_vertexArray[m_vertexIndex + 1].normal   = m_normalArray[posSize.y - sizeDivide2][posSize.x];
  599. }
  600. else
  601. {
  602. //m_vertexArray[m_vertexIndex + 1].position.y = m_elevArray[posSize.y - sizeDivide2][posSize.x];
  603. m_vertexArray[m_vertexIndex + 1].position.y = ( m_elevArray[posSize.y - sizeDivide2][posSize.x - sizeDivide2]
  604. + m_elevArray[posSize.y - sizeDivide2][posSize.x + sizeDivide2])/2;
  605. m_vertexArray[m_vertexIndex + 1].normal = ( m_normalArray[posSize.y - sizeDivide2][posSize.x - sizeDivide2]
  606. + m_normalArray[posSize.y - sizeDivide2][posSize.x + sizeDivide2])/2;
  607. }
  608. }
  609. else
  610. {
  611. m_vertexArray[m_vertexIndex + 1].position.y = m_elevArray[posSize.y - sizeDivide2][posSize.x];
  612. m_vertexArray[m_vertexIndex + 1].normal   = m_normalArray[posSize.y - sizeDivide2][posSize.x];
  613. }
  615. // for debug
  616. //m_vertexArray[m_vertexIndex + 1].position.y = 0;
  617. m_vertexArray[m_vertexIndex + 1].tu = m_tuArray[posSize.x];
  618. m_vertexArray[m_vertexIndex + 1].tv = m_tvArray[posSize.y - sizeDivide2];
  619. // 右上角顶点
  620. m_vertexArray[m_vertexIndex + 2].position.x = right;
  621. m_vertexArray[m_vertexIndex + 2].position.z = top;
  622. m_vertexArray[m_vertexIndex + 2].position.y = m_elevArray[posSize.y - sizeDivide2][posSize.x + sizeDivide2];
  623. m_vertexArray[m_vertexIndex + 2].normal   = m_normalArray[posSize.y - sizeDivide2][posSize.x + sizeDivide2];
  624. // for debug
  625. //m_vertexArray[m_vertexIndex + 2].position.y = 0;
  626. m_vertexArray[m_vertexIndex + 2].tu = m_tuArray[posSize.x + sizeDivide2];
  627. m_vertexArray[m_vertexIndex + 2].tv = m_tvArray[posSize.y - sizeDivide2];
  629. // 左边顶点
  630. // 判断它左方的那个相邻节点的 m_bTouched 属性是否为true,如为真从数组中读取高程值，否则取相邻顶点高程值的平均值
  631. m_vertexArray[m_vertexIndex + 3].position.x = left;
  632. m_vertexArray[m_vertexIndex + 3].position.z = centerY;
  633. pAdjNode = FindNode( posSize.x - posSize.size, posSize.y );
  634. if( pAdjNode != NULL )
  635. {
  636. if( pAdjNode->m_bTouched )
  637. {
  638. m_vertexArray[m_vertexIndex + 3].position.y = m_elevArray[posSize.y][posSize.x - sizeDivide2];
  639. m_vertexArray[m_vertexIndex + 3].normal   = m_normalArray[posSize.y][posSize.x - sizeDivide2];
  640. }
  641. else
  642. {
  643. //m_vertexArray[m_vertexIndex + 3].position.y = m_elevArray[posSize.y][posSize.x - sizeDivide2];
  644. m_vertexArray[m_vertexIndex + 3].position.y = ( m_elevArray[posSize.y - sizeDivide2][posSize.x - sizeDivide2]
  645. + m_elevArray[posSize.y + sizeDivide2][posSize.x - sizeDivide2])/2;
  646. m_vertexArray[m_vertexIndex + 3].normal = ( m_normalArray[posSize.y - sizeDivide2][posSize.x - sizeDivide2]
  647. + m_normalArray[posSize.y + sizeDivide2][posSize.x - sizeDivide2])/2;
  648. }
  649. }
  650. else
  651. {
  652. m_vertexArray[m_vertexIndex + 3].position.y = m_elevArray[posSize.y][posSize.x - sizeDivide2];
  653. m_vertexArray[m_vertexIndex + 3].normal   = m_normalArray[posSize.y][posSize.x - sizeDivide2];
  654. }
  656. // for debug
  657. //m_vertexArray[m_vertexIndex + 3].position.y = 0;
  658. m_vertexArray[m_vertexIndex + 3].tu = m_tuArray[posSize.x - sizeDivide2];
  659. m_vertexArray[m_vertexIndex + 3].tv = m_tvArray[posSize.y];
  661. // 中心顶点
  662. m_vertexArray[m_vertexIndex + 4].position.x = centerX;
  663. m_vertexArray[m_vertexIndex + 4].position.z = centerY;
  664. m_vertexArray[m_vertexIndex + 4].position.y = m_elevArray[posSize.y][posSize.x];
  665. m_vertexArray[m_vertexIndex + 4].normal   = m_normalArray[posSize.y][posSize.x];
  666. // for debug
  667. //m_vertexArray[m_vertexIndex + 4].position.y = 0;
  668. m_vertexArray[m_vertexIndex + 4].tu = m_tuArray[posSize.x];
  669. m_vertexArray[m_vertexIndex + 4].tv = m_tvArray[posSize.y];
  671. // 右边顶点
  672. // 判断它左方的那个相邻节点的 m_bTouched 属性是否为true,如为真从数组中读取高程值，否则取相邻顶点高程值的平均值
  673. m_vertexArray[m_vertexIndex + 5].position.x = right;
  674. m_vertexArray[m_vertexIndex + 5].position.z = centerY;
  675. pAdjNode = FindNode( posSize.x + posSize.size, posSize.y );
  676. if( pAdjNode != NULL )
  677. {
  678. if( pAdjNode->m_bTouched )
  679. {
  680. m_vertexArray[m_vertexIndex + 5].position.y = m_elevArray[posSize.y][posSize.x + sizeDivide2];
  681. m_vertexArray[m_vertexIndex + 5].normal   = m_normalArray[posSize.y][posSize.x + sizeDivide2];
  682. }
  683. else
  684. {
  685. //m_vertexArray[m_vertexIndex + 5].position.y = m_elevArray[posSize.y][posSize.x + sizeDivide2];
  686. m_vertexArray[m_vertexIndex + 5].position.y = ( m_elevArray[posSize.y - sizeDivide2][posSize.x + sizeDivide2]
  687. + m_elevArray[posSize.y + sizeDivide2][posSize.x + sizeDivide2])/2;
  688. m_vertexArray[m_vertexIndex + 5].normal = ( m_normalArray[posSize.y - sizeDivide2][posSize.x + sizeDivide2]
  689. + m_normalArray[posSize.y + sizeDivide2][posSize.x + sizeDivide2])/2;
  690. }
  691. }
  692. else
  693. {
  694. m_vertexArray[m_vertexIndex + 5].position.y = m_elevArray[posSize.y][posSize.x + sizeDivide2];
  695. m_vertexArray[m_vertexIndex + 5].normal = m_normalArray[posSize.y][posSize.x + sizeDivide2];
  696. }
  698. // for debug
  699. //m_vertexArray[m_vertexIndex + 5].position.y = 0;
  700. m_vertexArray[m_vertexIndex + 5].tu = m_tuArray[posSize.x + sizeDivide2];
  701. m_vertexArray[m_vertexIndex + 5].tv = m_tvArray[posSize.y];
  702. // 左下角顶点
  703. m_vertexArray[m_vertexIndex + 6].position.x = left;
  704. m_vertexArray[m_vertexIndex + 6].position.z = bottom;
  705. m_vertexArray[m_vertexIndex + 6].position.y = m_elevArray[posSize.y + sizeDivide2][posSize.x - sizeDivide2];
  706. m_vertexArray[m_vertexIndex + 6].normal   = m_normalArray[posSize.y + sizeDivide2][posSize.x - sizeDivide2];
  707. // for debug
  708. //m_vertexArray[m_vertexIndex + 6].position.y = 0;
  709. m_vertexArray[m_vertexIndex + 6].tu = m_tuArray[posSize.x - sizeDivide2];
  710. m_vertexArray[m_vertexIndex + 6].tv = m_tvArray[posSize.y + sizeDivide2];
  712. // 下边顶点
  713. // 判断它左方的那个相邻节点的 m_bTouched 属性是否为true,如为真从数组中读取高程值，否则取相邻顶点高程值的平均值
  714. m_vertexArray[m_vertexIndex + 7].position.x = centerX;
  715. m_vertexArray[m_vertexIndex + 7].position.z = bottom;
  716. pAdjNode = FindNode( posSize.x, posSize.y + posSize.size );
  717. if( pAdjNode != NULL )
  718. {
  719. if( pAdjNode->m_bTouched )
  720. {
  721. m_vertexArray[m_vertexIndex + 7].position.y = m_elevArray[posSize.y + sizeDivide2][posSize.x];
  722. m_vertexArray[m_vertexIndex + 7].normal   = m_normalArray[posSize.y + sizeDivide2][posSize.x];
  723. }
  724. else
  725. {
  726. //m_vertexArray[m_vertexIndex + 7].position.y = m_elevArray[posSize.y + sizeDivide2][posSize.x];
  727. m_vertexArray[m_vertexIndex + 7].position.y = ( m_elevArray[posSize.y + sizeDivide2][posSize.x - sizeDivide2]
  728. + m_elevArray[posSize.y + sizeDivide2][posSize.x + sizeDivide2])/2;
  729. m_vertexArray[m_vertexIndex + 7].normal = ( m_normalArray[posSize.y + sizeDivide2][posSize.x - sizeDivide2]
  730. + m_normalArray[posSize.y + sizeDivide2][posSize.x + sizeDivide2])/2;
  731. }
  732. }
  733. else
  734. {
  735. m_vertexArray[m_vertexIndex + 7].position.y = m_elevArray[posSize.y + sizeDivide2][posSize.x];
  736. m_vertexArray[m_vertexIndex + 7].normal   = m_normalArray[posSize.y + sizeDivide2][posSize.x];
  737. }
  739. // for debug
  740. //m_vertexArray[m_vertexIndex + 7].position.y = 0;
  741. m_vertexArray[m_vertexIndex + 7].tu = m_tuArray[posSize.x];
  742. m_vertexArray[m_vertexIndex + 7].tv = m_tvArray[posSize.y + sizeDivide2];
  743. // 右下角顶点
  744. m_vertexArray[m_vertexIndex + 8].position.x = right;
  745. m_vertexArray[m_vertexIndex + 8].position.z = bottom;
  746. m_vertexArray[m_vertexIndex + 8].position.y = m_elevArray[posSize.y + sizeDivide2][posSize.x + sizeDivide2];
  747. m_vertexArray[m_vertexIndex + 8].normal   = m_normalArray[posSize.y + sizeDivide2][posSize.x + sizeDivide2];
  748. // for debug
  749. //m_vertexArray[m_vertexIndex + 8].position.y = 0;
  750. m_vertexArray[m_vertexIndex + 8].tu = m_tuArray[posSize.x + sizeDivide2];
  751. m_vertexArray[m_vertexIndex + 8].tv = m_tvArray[posSize.y + sizeDivide2];
  754. //// 顶点数组赋值，   0 1 2
  755. ////                  3 4 5 
  756. ////                  6 7 8
  757. //// 计算顶点的法线向量
  758. ///*ZFXNODEPOSSIZE posSize = pNode->GetPosSize();
  759. //UINT sizeDivide2 = posSize.size >> 1;*/   // 该节点的位置信息（相对）
  760. //POINT pos[9];  //pos[9]保存了0~8个节点的相对位置信息
  761. //// pos数组赋值
  762. //pos[0].x = posSize.x - sizeDivide2;  pos[0].y = posSize.y - sizeDivide2;
  763. //pos[1].x = posSize.x;                pos[1].y = posSize.y - sizeDivide2;
  764. //pos[2].x = posSize.x + sizeDivide2;  pos[2].y = posSize.y - sizeDivide2;
  765. //pos[3].x = posSize.x - sizeDivide2;  pos[3].y = posSize.y;
  766. //pos[4].x = posSize.x;                pos[4].y = posSize.y;
  767. //pos[5].x = posSize.x + sizeDivide2;  pos[5].y = posSize.y;
  768. //pos[6].x = posSize.x - sizeDivide2;  pos[6].y = posSize.y + sizeDivide2;
  769. //pos[7].x = posSize.x;                pos[7].y = posSize.y + sizeDivide2;
  770. //pos[8].x = posSize.x + sizeDivide2;  pos[8].y = posSize.y + sizeDivide2;
  771. //for(int i=0;i<9;i++)
  772. //{
  773. // D3DXVECTOR3 vec[2];
  774. // vec[0].x = -m_GridWidth;
  775. // // 防止pos[i].x + 1冲出边界
  776. // if((UINT)(pos[i].x) < m_width - 1)
  777. // vec[0].y = m_elevArray[pos[i].y][pos[i].x] - m_elevArray[pos[i].y][pos[i].x + 1];
  778. // else
  779. // vec[0].y = m_elevArray[pos[i].y][pos[i].x - 1] - m_elevArray[pos[i].y][pos[i].x];
  780. // vec[0].z = 0;
  782. // vec[1].x = 0;
  783. // // 防止pos[i].y + 1冲出边界
  784. // if((UINT)(pos[i].y) < m_width - 1)
  785. // vec[1].y = m_elevArray[pos[i].y + 1][pos[i].x] - m_elevArray[pos[i].y][pos[i].x];
  786. // else
  787. // vec[1].y = m_elevArray[pos[i].y][pos[i].x] - m_elevArray[pos[i].y - 1][pos[i].x];
  788. // vec[1].z = m_GridHeight;
  789. // D3DXVec3Cross( &m_vertexArray[m_vertexIndex + i].normal, &vec[0], &vec[1] );
  790. //}
  793. for(UINT i=0;i<9;i++)
  794. {
  795. m_vertexArray[m_vertexIndex+i].color = 0xffffffff;
  796. }
  797. // 索引数组赋值，   0 1 2   ，顺时针旋转
  798. //                  3 4 5 
  799. //                  6 7 8
  800. m_indexArray[m_indexIndex + 0]  = m_vertexIndex + 0;
  801. m_indexArray[m_indexIndex + 1]  = m_vertexIndex + 1;
  802. m_indexArray[m_indexIndex + 2]  = m_vertexIndex + 4;
  803. m_indexArray[m_indexIndex + 3]  = m_vertexIndex + 1;
  804. m_indexArray[m_indexIndex + 4]  = m_vertexIndex + 2;
  805. m_indexArray[m_indexIndex + 5]  = m_vertexIndex + 4;
  806. m_indexArray[m_indexIndex + 6]  = m_vertexIndex + 2;
  807. m_indexArray[m_indexIndex + 7]  = m_vertexIndex + 5;
  808. m_indexArray[m_indexIndex + 8]  = m_vertexIndex + 4;
  809. m_indexArray[m_indexIndex + 9]  = m_vertexIndex + 5;
  810. m_indexArray[m_indexIndex + 10] = m_vertexIndex + 8;
  811. m_indexArray[m_indexIndex + 11] = m_vertexIndex + 4;
  812. m_indexArray[m_indexIndex + 12] = m_vertexIndex + 8;
  813. m_indexArray[m_indexIndex + 13] = m_vertexIndex + 7;
  814. m_indexArray[m_indexIndex + 14] = m_vertexIndex + 4;
  815. m_indexArray[m_indexIndex + 15] = m_vertexIndex + 7;
  816. m_indexArray[m_indexIndex + 16] = m_vertexIndex + 6;
  817. m_indexArray[m_indexIndex + 17] = m_vertexIndex + 4;
  818. m_indexArray[m_indexIndex + 18] = m_vertexIndex + 6;
  819. m_indexArray[m_indexIndex + 19] = m_vertexIndex + 3;
  820. m_indexArray[m_indexIndex + 20] = m_vertexIndex + 4;
  821. m_indexArray[m_indexIndex + 21] = m_vertexIndex + 3;
  822. m_indexArray[m_indexIndex + 22] = m_vertexIndex + 0;
  823. m_indexArray[m_indexIndex + 23] = m_vertexIndex + 4;
  825. m_vertexIndex += 9;
  826. m_indexIndex  += 24;
  827. }
  828. else
  829. {
  830. RefineNode( pNode->m_pTLChildNode );
  831. RefineNode( pNode->m_pBLChildNode );
  832. RefineNode( pNode->m_pTRChildNode );
  833. RefineNode( pNode->m_pBRChildNode );
  834. }
  835. }
  836. }
  839. UINT log2(UINT num)
  840. {
  841. UINT a = 0;
  842. while(num != 0)
  843. {
  844. num = num >> 1;
  845. a++;
  846. }
  847. return a - 1;
  848. }