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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 游戏引擎 > 查看源码
Heightmap.cpp
资源名称：3dexplorerTest.rar　[点击查看]
上传用户：hkb425
上传日期：2007-06-16
资源大小：34191k
文件大小：19k
源码类别：

游戏引擎

开发平台：

Visual C++

Heightmap.cpp：源码内容
  1. // Heightmap.cpp: implementation of the CHeightmap class.
  2. //
  3. //////////////////////////////////////////////////////////////////////
  5. #include "stdafx.h"
  6. #include "Heightmap.h"
  7. #include "stdio.h"
  8. #include "GameSetting.h"
  9. //////////////////////////////////////////////////////////////////////
  10. // Construction/Destruction
  11. //////////////////////////////////////////////////////////////////////
  12. MOVE_VERTEX    * CHeightmap::m_pMovemap=NULL;
  13. unsigned char  * CHeightmap::m_pTmap=NULL;
  14. CFrustumCull     CHeightmap::m_cFrustumCull=CFrustumCull();
  16. unsigned char  * CHeightmap::m_pCovermap=NULL;
  17. GRID_BIAS      * CHeightmap::m_pCoverBias=NULL;
  19. VERTEX           CHeightmap::m_ViewPos=VERTEX(0,0,0);
  20. float            CHeightmap::m_ViewRotX=0;
  21. float            CHeightmap::m_ViewRotY=0;
  23. int              CHeightmap::m_numUser=0;
  24. int              CHeightmap::m_ViewOffsetX=0;
  25. int              CHeightmap::m_ViewOffsetZ=0;
  27. //////////////focus
  28. double           CHeightmap::m_focusPosX=0;
  29. double           CHeightmap::m_focusPosY=0;
  30. double           CHeightmap::m_focusPosZ=0;
  31. double           CHeightmap::m_distFromFocus=0;
  32. int              CHeightmap::m_focusState=FOCUS_GROUND;
  33. bool             CHeightmap::m_bAttack=false;
  34. float            CHeightmap::m_myHealth=1;
  36. //////////building
  37. int              CHeightmap::m_numBuilding=0;
  38. VERTEX          *CHeightmap::m_buildingPos=NULL;
  39. BOUNDARY_3D    **CHeightmap::m_bigBndyBuilding=NULL;
  40. BOUNDARY_3D    **CHeightmap::m_smallBndyBuilding=NULL;
  42. /////////////sprite
  43. int              CHeightmap::m_numSoldier=0;
  44. VERTEX          *CHeightmap::m_soldierPos=NULL;
  45. float           *CHeightmap::m_soldierRot=NULL;
  46. float           *CHeightmap::m_soldierHealth=NULL;
  48. int              CHeightmap::m_numTriangles=0;
  50. CHeightmap::CHeightmap()
  51. {
  52. if(m_numUser==0)
  53. {
  54. /////////read terrain map
  55.      if(!ReadTerrainmapFile())
  56. {
  57.     MessageBox(0, "read heightmap failed", "Error", MB_OK | MB_ICONERROR);
  58.     return ;
  59. }
  60.      if(!ReadPlantmapFile())
  61. {
  62.     MessageBox(0, "read plantmap failed", "Error", MB_OK | MB_ICONERROR);
  63.     return ;
  64. }
  65. GetMissionSetting();
  67. m_pMovemap =new MOVE_VERTEX [256*256];
  69. }
  70. m_numUser++;
  71. }
  73. CHeightmap::~CHeightmap()
  74. {
  75. m_numUser--;
  76. if(m_numUser==0)
  77. {
  78. if(m_pTmap!=NULL)
  79. {
  80.     delete [] m_pTmap;
  81.      m_pTmap=NULL;
  82. }
  83. if(m_pCovermap!=NULL)
  84. {
  85. delete [] m_pCovermap;
  86.      m_pCovermap=NULL;
  87. }
  88. if(m_pCoverBias!=NULL)
  89. {
  90. delete [] m_pCoverBias;
  91.             m_pCoverBias=NULL;
  92. }
  93. if(m_pMovemap!=NULL)
  94. {
  95. delete [] m_pMovemap;
  96.      m_pMovemap=NULL;
  97. }
  98. if(m_bigBndyBuilding!=NULL)
  99. {
  100. ///// only release pointers
  101. delete [] m_bigBndyBuilding;
  102.      m_bigBndyBuilding=NULL;
  103. }
  104. if(m_smallBndyBuilding!=NULL)
  105. {
  106. ///// only release pointers
  107. delete [] m_smallBndyBuilding;
  108.      m_smallBndyBuilding=NULL;
  109. }
  110. if(m_buildingPos!=NULL)
  111. {
  112. ///// only release pointers
  113. delete [] m_buildingPos;
  114.      m_buildingPos=NULL;
  115. }
  116. if(m_soldierPos!=NULL)
  117. {
  118. ///// only release pointers
  119. delete [] m_soldierPos;
  120.      m_soldierPos=NULL;
  121. }
  122. if(m_soldierRot!=NULL)
  123. {
  124. ///// only release pointers
  125. delete [] m_soldierRot;
  126.      m_soldierRot=NULL;
  127. }
  128. if(m_soldierHealth!=NULL)
  129. {
  130. ///// only release pointers
  131. delete [] m_soldierHealth;
  132.      m_soldierHealth=NULL;
  133. }
  134. }
  135. }
  136. bool CHeightmap::GetMissionSetting()
  137. {
  138. char missionName[64];
  139. char sINIPath[MAX_PATH];
  140. wsprintf(missionName,"mission/mission%d.ini",CGameSetting::m_iMissionSelect);
  141. MakeModulePath(missionName, sINIPath);
  143. m_numBuilding = GetPrivateProfileInt("Building", "HouseNumber", 1, sINIPath);
  144.     m_buildingPos = new VERTEX[m_numBuilding];
  145.     m_bigBndyBuilding   = new BOUNDARY_3D* [m_numBuilding];
  146.     m_smallBndyBuilding = new BOUNDARY_3D* [m_numBuilding];
  148. char keyName[64];
  149. for(int i=0;i<m_numBuilding;i++)
  150. {
  151. wsprintf(keyName,"House%dX",i+1);
  152. m_buildingPos[i].xpos=(float)GetPrivateProfileInt("Building", keyName, 1000, sINIPath);
  153. wsprintf(keyName,"House%dZ",i+1);
  154. m_buildingPos[i].zpos=(float)GetPrivateProfileInt("Building", keyName, 1000, sINIPath);
  155. }
  158. m_numSoldier = GetPrivateProfileInt("Sprite", "SpriteNumber", 1, sINIPath);
  159.     m_soldierPos = new VERTEX[m_numSoldier];
  160.     m_soldierRot = new float [m_numSoldier];
  161. m_soldierHealth=new float [m_numSoldier];
  163. for( i=0;i<m_numSoldier;i++)
  164. {
  165. wsprintf(keyName,"Sprite%dX",i+1);
  166. m_soldierPos[i].xpos=(float)GetPrivateProfileInt("Sprite", keyName, 1000, sINIPath);
  167. wsprintf(keyName,"Sprite%dZ",i+1);
  168. m_soldierPos[i].zpos=(float)GetPrivateProfileInt("Sprite", keyName, 1000, sINIPath);
  169. wsprintf(keyName,"Sprite%dRot",i+1);
  170. m_soldierRot[i]     =(float)GetPrivateProfileInt("Sprite", keyName, 0, sINIPath);
  171.         m_soldierHealth[i]=1;
  172. }
  173. return true;
  174. }
  175. void CHeightmap::UpdateHeightmap()
  176. {
  177. m_cFrustumCull.m_ViewerRotate=m_ViewRotY;
  179. m_cFrustumCull.UpdateFrustumCull();
  180.      
  181. /*  m_rect.minz=m_cFrustumCull.m_pos[m_upPos].y-2;
  182.     m_rect.maxz=m_cFrustumCull.m_pos[m_downPos].y+2;
  183.     m_rect.minx=m_cFrustumCull.m_pos[minx].x-2;
  184.     m_rect.maxx=m_cFrustumCull.m_pos[maxx].x+2;
  185. */
  186. int offsetx,offsetz;
  187. offsetx=int(m_ViewPos.xpos*0.025f);
  188. if(offsetx<0)offsetx-=1;
  190. offsetz=int(m_ViewPos.zpos*0.025f);
  191. if(offsetz<0)offsetz-=1;
  192. ////////////////////////////////////////////////
  193. int x,z;
  194. int startx;
  195. int xpos,zpos;
  197. int uppos=m_cFrustumCull.m_upPos;
  198. int downpos=m_cFrustumCull.m_downPos;
  200. for(z=(m_cFrustumCull.m_pos[uppos].y-2);z<(m_cFrustumCull.m_pos[downpos].y+3);z++)
  201. {
  202.     zpos=((z-128+offsetz)*4)%256;
  203.     if(zpos<0)zpos=256+zpos;
  205.         startx=((  (m_cFrustumCull.m_LeftArray[z]-2)  -128+offsetx)*4)%256;
  206.     if(startx<0)startx=256+startx;
  208. xpos=startx;
  210. for(x=(m_cFrustumCull.m_LeftArray[z]-2);x<(m_cFrustumCull.m_RightArray[z]+3);x++)
  211. {
  212. m_pMovemap[z*256+x].xpos=xpos;
  213. m_pMovemap[z*256+x].zpos=zpos;
  214.     
  215. xpos+=4;
  216. if(xpos>252)xpos=0;
  217. }
  218. }
  219.     ////////////////////////////////////////////////
  220. m_ViewOffsetX=offsetx*40;
  221. m_ViewOffsetZ=offsetz*40;
  223.     m_numTriangles=0;
  224. }
  225. float CHeightmap::GetHeight(VERTEX *checked)
  226. {
  227. POINT point=ConvertToHeightmap(checked);
  228. float Xpos,Zpos;
  230. if(checked->xpos<0)
  231.     Xpos=1+checked->xpos*0.1f-int(checked->xpos*0.1f);
  232. else
  233.     Xpos=checked->xpos*0.1f-int(checked->xpos*0.1f);
  234. if(checked->zpos<0)
  235.     Zpos=1+checked->zpos*0.1f-int(checked->zpos*0.1f);
  236. else 
  237. Zpos=checked->zpos*0.1f-int(checked->zpos*0.1f);
  239.     ///////////////////////
  240. float ypos;
  241. float h11,h12,h22,h21;
  242. float ha,hb;
  243. //////////check Xpos and Zpos
  244. ////////////////////////////
  245. int addx=point.x+1;
  246. int addy=point.y+1;
  247. if(addx==256)addx=0;
  248. if(addy==256)addy=0;
  250.     h11=float(m_pTmap[256*(point.y+0) + (point.x+0)]);
  251.     h12=float(m_pTmap[256*(addy) + (point.x+0)]);
  252.     h21=float(m_pTmap[256*(point.y+0) + addx]);
  253.     h22=float(m_pTmap[256*(addy) + addx]);
  255. ha=h11+Xpos*(h21-h11);
  256. hb=h12+Xpos*(h22-h12);
  258.     ypos=ha +Zpos*(hb-ha);
  260. return ypos;
  262. }
  263. float CHeightmap::GetHeight(float xpos,float zpos)
  264. {
  265.    VERTEX temp=VERTEX(xpos,0,zpos);
  266.    float ypos=GetHeight(&temp);
  267.    return ypos;
  268. }
  270. bool CHeightmap::CollideCheck(VERTEX startPos,VERTEX endPos,float step)
  271. {
  272.     if(CheckTerrainCollide(startPos,endPos,step))return true;
  273.     if(CheckBuildingCollide(startPos,endPos))return true;
  274.     if(CheckTreeCollide(startPos,endPos))return true;
  276. return false;
  277. }
  278. bool CHeightmap::CheckTerrainCollide(VERTEX viewPos,VERTEX objPos,float step)
  279. {
  280. if(step<1)step=1;
  282. float dy=viewPos.ypos-objPos.ypos;
  283. float dx=viewPos.xpos-objPos.xpos;
  284. float dz=viewPos.zpos-objPos.zpos;
  286. int signx,signy,signz;
  287. if(dx<0)
  288. {dx=-dx; signx=-1;}
  289. else
  290.         signx=1;
  291. if(dy<0)
  292. {dy=-dy; signy=-1;}
  293. else
  294.         signy=1;
  295. if(dz<0)
  296. {dz=-dz; signz=-1;}
  297. else
  298.         signz=1;
  300. float terrainHeight=GetHeight(&viewPos);
  301. float CurLineHeight=viewPos.ypos;
  303. float CurZ=viewPos.zpos;
  304. float CurX=viewPos.xpos;
  306.     VERTEX vertCur;
  307.   if(dz>dx)
  308. {
  309. int times=int(dz/step);
  310. float deltaH=dy/times;
  311. float deltax=signx*dx/times;
  312. times++;
  313.         for(int i=0;i<times;i++)
  314. {
  315. vertCur.xpos=CurX;
  316. vertCur.zpos=CurZ;
  317. vertCur.ypos=CurLineHeight;
  319. if(vertCur.ypos<GetHeight(vertCur.xpos,vertCur.zpos) ) return true;
  321.             CurLineHeight -= signy*deltaH;
  322. CurX-=deltax;
  323. CurZ-=signz*step;
  325. }
  326. }
  327. else
  328. {
  329. int times=int(dx/step);
  331. float deltaH=dy/times;
  332. float deltaz=signz*dz/times;
  333. times++;
  334.         for(int i=0;i<times;i++)
  335. {
  336. vertCur.xpos=CurX;
  337. vertCur.zpos=CurZ;
  338. vertCur.ypos=CurLineHeight;
  340. if(vertCur.ypos<GetHeight(vertCur.xpos,vertCur.zpos) ) return true;
  342.             CurLineHeight -= signy*deltaH;
  343. CurZ-=deltaz;
  344. CurX-=signx*step;
  345. }
  346. }
  347.     return false;
  348. }
  349. bool CHeightmap::CheckTreeCollide(VERTEX viewPos,VERTEX objPos)
  350. {
  352. float dy=viewPos.ypos-objPos.ypos;
  353. float dx=viewPos.xpos-objPos.xpos;
  354. float dz=viewPos.zpos-objPos.zpos;
  356. int signx,signy,signz;
  357. if(dx<0)
  358. {dx=-dx; signx=-1;}
  359. else
  360.         signx=1;
  361. if(dy<0)
  362. {dy=-dy; signy=-1;}
  363. else
  364.         signy=1;
  365. if(dz<0)
  366. {dz=-dz; signz=-1;}
  367. else
  368.         signz=1;
  370.     POINT point;
  371. int   type;
  372. float distance;
  374.   if(dz>dx)
  375. {
  376. float CurZ=float(int(viewPos.zpos)/40)*40;
  377.      if(viewPos.zpos<0)CurZ -=40;
  378.     float CurX=viewPos.xpos+(CurZ-viewPos.zpos)*(viewPos.xpos-objPos.xpos)/(viewPos.zpos-objPos.zpos);
  379.     float gridX;
  380. float deltax=signx*dx*40/dz;
  381. do
  382. {
  383. point=ConvertToPlantmap(CurX,CurZ);
  384. type=GetPlantType(point.x,point.y);
  385. if(type>64)
  386. {
  387. gridX=float(int(CurX)/40)*40;
  388. if(CurX<0)gridX-=40;
  389. distance=m_cMath.GetPointToLineDist2D(viewPos,objPos,
  390.                     VERTEX(gridX+m_pCoverBias[64*point.y+point.x].xbias,0,
  391. CurZ+m_pCoverBias[64*point.y+point.x].zbias));
  393.                 if(type==128 && distance<2)return true;
  394.                 if(type==192 && distance<1.2f)return true;
  395.                 if(type==255 && distance<1)return true;
  396. }
  397.      CurX-=deltax;
  398.     CurZ-=signz*40;
  399. if(signz>0 )
  400. {
  401. if(CurZ<objPos.zpos)return false;
  402. }
  403. else
  404. {
  405. if(CurZ>objPos.zpos)return false;
  406. }
  408. }while(1);
  410. }
  411. else
  412. {
  413. float CurX=float(int(viewPos.xpos)/40)*40;
  414.      if(viewPos.xpos<0)CurX -=40;
  415.     float CurZ=viewPos.zpos+(CurX-viewPos.xpos)*(viewPos.zpos-objPos.zpos)/(viewPos.xpos-objPos.xpos);
  416.     float gridZ;
  418. float deltaz=signz*dz*40/dx;
  419. do
  420. {
  421. point=ConvertToPlantmap(CurX,CurZ);
  422. type=GetPlantType(point.x,point.y);
  423. if(type>64)
  424. {
  425. gridZ=float(int(CurZ)/40)*40;
  426. if(CurZ<0)gridZ-=40;
  427. distance=m_cMath.GetPointToLineDist2D(viewPos,objPos,
  428.                     VERTEX(CurX+m_pCoverBias[64*point.y+point.x].xbias,0,
  429. gridZ+m_pCoverBias[64*point.y+point.x].zbias));
  431. if(type==128 && distance<2)return true;
  432.                 if(type==192 && distance<1.2f)return true;
  433.                 if(type==255 && distance<1)return true;
  436. }
  437.      CurZ-=deltaz;
  438.     CurX-=signx*40;
  439. if(signx>0 )
  440. {
  441. if(CurX<objPos.xpos)return false;
  442. }
  443. else
  444. {
  445. if(CurX>objPos.xpos)return false;
  446. }
  448. }while(1);
  449. }
  451.     return false;
  452. }
  453. bool CHeightmap::CheckBuildingCollide(VERTEX startPos,VERTEX endPos)
  454. {
  455. for(int i=0;i<m_numBuilding;i++)
  456. {
  457. if(m_cMath.IsLineSegmentCutBy3DBoundary(&startPos,&endPos,m_smallBndyBuilding[i]))
  458. return true;
  459. }
  461. return false;
  462. }
  463. bool CHeightmap::CollideTreeBody(VERTEX *check)
  464. {
  465. POINT point=ConvertToMovemap(*check);
  466. int tx,tz;
  467. tx=m_pMovemap[point.y*256+point.x].xpos;
  468. tz=m_pMovemap[point.y*256+point.x].zpos;
  470. if(m_pCovermap[tz*16+tx/4]<65)return false;
  472. float treex,treez;
  473. treex=float(m_ViewOffsetX + (point.x-128)*40 + m_pCoverBias[tz*16+tx/4].xbias);
  474. treez=float(m_ViewOffsetZ + (point.y-128)*40 + m_pCoverBias[tz*16+tx/4].zbias);
  476. float deltaX=(treex>check->xpos)?(treex-check->xpos):(check->xpos-treex);
  477. float deltaZ=(treez>check->zpos)?(treez-check->zpos):(check->zpos-treez);
  478. if(deltaX<4 && deltaZ<4)
  479. {
  480. if(deltaX>deltaZ)
  481. {
  482. if(treex>check->xpos)check->xpos=treex-4;
  483. else check->xpos=treex+4;
  484. }
  485. else
  486. {
  487. if(treez>check->zpos)check->zpos=treez-4;
  488. else check->zpos=treez+4;
  489. }
  490. return true;
  491. }
  492. return false;
  493. }
  494. bool CHeightmap::CollideBuilding(VERTEX *oldPos,VERTEX *newPos)
  495. {
  496. for(int i=0;i<m_numBuilding;i++)
  497. {
  498. if(IsInBoundary3D(newPos,m_bigBndyBuilding[i]))
  499. {
  500. VERTEX temp=VERTEX(newPos->xpos,newPos->ypos,newPos->zpos);
  502. newPos->zpos=oldPos->zpos;
  503. if(!IsInBoundary3D(newPos,m_bigBndyBuilding[i]))
  504.                 return true;
  505. newPos->zpos=temp.zpos;
  506. newPos->xpos=oldPos->xpos;
  507. if(!IsInBoundary3D(newPos,m_bigBndyBuilding[i]))
  508.                 return true;
  510. oldPos->zpos=oldPos->zpos;
  511. return true;
  512. }
  513. }
  514. return false;
  515. }
  516. bool CHeightmap::IsInFrustum(VERTEX *checked)
  517. {
  518. POINT point=ConvertToMovemap(*checked);
  519. return m_cFrustumCull.IsInFrustum(point.x,point.y);
  520. }
  521. bool CHeightmap::IsInFrustum(float x,float z)
  522. {
  523. POINT point=ConvertToMovemap(VERTEX(x,255,z));
  524. return m_cFrustumCull.IsInFrustum(point.x,point.y);
  525. }
  526. bool CHeightmap::IsInFrustum(BOUNDARY_3D *pBoundary)
  527. {
  529. if(IsInFrustum(pBoundary->minx,pBoundary->minz))return true;
  530. if(IsInFrustum(pBoundary->maxx,pBoundary->minz))return true;
  531. if(IsInFrustum(pBoundary->maxx,pBoundary->maxz))return true;
  532. if(IsInFrustum(pBoundary->minx,pBoundary->maxz))return true;
  534. return false;
  535. }
  537. VERTEX CHeightmap::ConvertToWorld(int movemapXPos,int movemapZPos)
  538. {
  539. VERTEX position;
  540. position.xpos=float(m_ViewOffsetX + (movemapXPos-128)*40);
  541. position.zpos=float(m_ViewOffsetZ + (movemapZPos-128)*40);
  543. POINT point ; //point in terrain map
  544. point.x=m_pMovemap[movemapZPos*256+movemapXPos].xpos;
  545. point.y=m_pMovemap[movemapZPos*256+movemapXPos].zpos;
  547. position.ypos=m_pTmap[256*point.y + point.x];
  549. return position;
  551. }
  552. POINT CHeightmap::ConvertToHeightmap(VERTEX *pos)
  553. {
  554. POINT point;
  555. if(pos->xpos<0)
  556.     point.x=255+int(pos->xpos*0.1f)%256;
  557. else
  558. point.x=int(pos->xpos*0.1f)%256;
  559. if(pos->zpos<0)
  560.     point.y=255+int(pos->zpos*0.1f)%256;
  561. else 
  562. point.y=int(pos->zpos*0.1f)%256;
  564. return point;
  565. }
  566. POINT CHeightmap::ConvertToMovemap(VERTEX pos)
  567. {
  568.   POINT point;
  569.     if(pos.xpos < m_ViewOffsetX)
  570.     point.x=int((pos.xpos-m_ViewOffsetX)*0.025f)+127;
  571. else
  572.     point.x=int((pos.xpos-m_ViewOffsetX)*0.025f)+128;
  573. if(pos.zpos<m_ViewOffsetZ)
  574.     point.y=int((pos.zpos-m_ViewOffsetZ)*0.025f)+127;
  575. else
  576.         point.y=int((pos.zpos-m_ViewOffsetZ)*0.025f)+128;
  578. if(point.x<0 || point.x>255 )
  579. {   
  580. POINT p;
  581.     p.x=p.y=0;
  582. return p;
  583. }
  584. if(point.y<0 || point.y>255 )
  585. {   
  586. POINT p;
  587.     p.x=p.y=0;
  588. return p;
  589. }
  590.  
  591. return point;
  592. }
  593. POINT CHeightmap::ConvertToPlantmap(float worldX,float worldZ)
  594. {
  595. POINT point;
  596. if(worldX<0)
  597.     point.x=63+int(worldX*0.025f)%64;
  598. else
  599. point.x=int(worldX*0.025f)%64;
  600. if(worldZ<0)
  601.     point.y=63+int(worldZ*0.025f)%64;
  602. else 
  603. point.y=int(worldZ*0.025f)%64;
  604.     
  605.     return point;
  606. }
  607. void CHeightmap::GetFocusPos()
  608. {
  609.     //////////////// calcau
  610. float depth[2];
  611.     int xpos=CGameSetting::m_iScrWidth/2;
  612. int ypos=CGameSetting::m_iScrHeight/2;
  613. glReadPixels(xpos,ypos,1,1,GL_DEPTH_COMPONENT,GL_FLOAT,depth);
  615.     GLdouble ModelMatrix[16], ProjMatrix[16];
  616.     glGetDoublev(GL_MODELVIEW_MATRIX,  ModelMatrix);
  617.     glGetDoublev(GL_PROJECTION_MATRIX, ProjMatrix);
  619.     GLint    Viewport[4]={0,0,CGameSetting::m_iScrWidth,CGameSetting::m_iScrHeight};
  620.     gluUnProject(xpos,ypos, depth[0], 
  621.          ModelMatrix, ProjMatrix, Viewport,
  622.  &m_focusPosX, &m_focusPosY, &m_focusPosZ);
  624. double dx=m_ViewPos.xpos-m_focusPosX;
  625. double dy=m_ViewPos.ypos-m_focusPosY;
  626. double dz=m_ViewPos.zpos-m_focusPosZ;
  628. m_distFromFocus= dx*dx+dy*dy+dz*dz;
  629. }
  630. bool CHeightmap::IsInBoundary3D(VERTEX *pos, BOUNDARY_3D *boundary)
  631. {
  632. if(pos->xpos > boundary->maxx || pos->xpos < boundary->minx )return false;
  633. if(pos->ypos > boundary->maxy || pos->ypos < boundary->miny )return false;
  634. if(pos->zpos > boundary->maxz || pos->zpos < boundary->minz )return false;
  636. return true;
  637. }
  638. ///////////////////////////////////////////////
  639. //////////////////////////////////////////////
  640. bool CHeightmap::ReadTerrainmapFile()
  641. {
  642.     m_pTmap=new unsigned char[256*256];
  643. if(m_pTmap==NULL)return false;
  646. FILE *fp;
  647. fp=fopen(CGameSetting::m_strHeightmap,"rb");
  648. if(!fp)return false;
  650. BITMAPFILEHEADER fileheader;
  651. fread(&fileheader,sizeof(BITMAPFILEHEADER),1,fp);
  652. if(fileheader.bfType!=19778)return false;
  654.     fseek(fp,1078,SEEK_SET);
  655. for(int z=255;z>-1;z--)
  656. for(int x=0;x<256;x++)
  657. {
  658. fread(&m_pTmap[256*z+x],sizeof(unsigned char),1,fp);
  659. }
  661. fclose(fp);
  662.     return true;
  663. }
  664. bool CHeightmap::ReadPlantmapFile()
  665. {
  666.     m_pCovermap =new unsigned char[64*64];
  667. m_pCoverBias=new GRID_BIAS[64*64];
  669. if(m_pCovermap==NULL)return false;
  670. if(m_pCoverBias==NULL)return false;
  672. FILE *fp;
  673. fp=fopen(CGameSetting::m_strPlantIndex,"rb");
  674. if(!fp)return false;
  676. BITMAPFILEHEADER fileheader;
  677. fread(&fileheader,sizeof(BITMAPFILEHEADER),1,fp);
  678. if(fileheader.bfType!=19778)return false;
  681.     fseek(fp,1078,SEEK_SET);
  682. for(int z=63;z>-1;z--)
  683. for(int x=0;x<64;x++)
  684. {
  685. fread(&m_pCovermap[64*z+x],sizeof(unsigned char),1,fp);
  686. }
  687. fclose(fp);
  689. /////construct plant position
  690. for( z=0;z<64;z++)
  691. for(int x=0;x<64;x++)
  692. {
  693. m_pCoverBias[64*z+x].xbias=5+(rand()%30);
  694. m_pCoverBias[64*z+x].zbias=5+(rand()%30);
  695. }
  696. /////////////////////////////
  697.     return true;
  698. }
  699. int  CHeightmap::GetPosInMovemap(int x,int z)
  700. {
  701.     return m_pMovemap[(128+z)*256+128+x].zpos*256+m_pMovemap[(128+z)*256+128+x].xpos;
  702. }
  703. int CHeightmap::GetPlantType(int mapx,int mapz)
  704. {
  705.     return m_pCovermap[mapz*64+mapx];
  706. }
  707. void CHeightmap::MakeModulePath(char filename[], char sINIPath[])
  708. {
  709. // Add the path of the executable to the passed INI filename
  710. // Buffer to hold the filename
  711. char sModuleFileName[MAX_PATH];
  712. // Pass NULL to get the handle of the current module
  713. HMODULE hModule = GetModuleHandle(NULL);
  714. // Fill the path into sModuleFileName and get the number of returned chars
  715. int iNumChars = GetModuleFileName(hModule, sModuleFileName, MAX_PATH);
  717. // If the path was received
  718. if (iNumChars)
  719. {
  720. // Loop from the last to the first char
  721. for (int iCurChar=iNumChars-1; iCurChar>=0; iCurChar--)
  722. {
  723. // If the current char is a backslash
  724. if (sModuleFileName[iCurChar] == char('\'))
  725. {
  726. // Terminate the the string behind the backslash and
  727. sModuleFileName[iCurChar+1] = char('');
  728. break;
  729. }
  730. }
  731. // Append INI filename at the end of the path
  732. strcat(sModuleFileName, filename);
  733. // Copy the full path into the destibation
  734. strcpy(sINIPath, sModuleFileName);
  735. }
  736. }