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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 其他游戏 > 查看源码
afTerrain.cpp
资源名称：AirForce.rar　[点击查看]
上传用户：kaiguan
上传日期：2007-10-28
资源大小：1074k
文件大小：30k
源码类别：

其他游戏

开发平台：

Visual C++

afTerrain.cpp：源码内容
  1. #include "afTerrain.h"
  2. #include "afMatrix.h"
  3. #include "afPlane.h"
  4. #include "afTime.h"
  5. #include "afSettings.h"
  6. #include "afTerrainPatch.h"
  7. #include "afApplication.h"
  9. inline DWORD FtoDW( FLOAT f ) { return *((DWORD*)&f); }
  11. afTerrain::afTerrain() : iBuffer(NULL), vBuffer(NULL), fogColor(1.0f, 1.0f, 1.0f, 1.0f),
  12.  profileUpdate("update()"), profileRender("render()")
  13. {
  14. for(int i=0; i<=4; i++)
  15. patchCount[i] = 0;
  16. bufferCreateCount = 0;
  17. mergeSmallPatches = true;
  19. // default value
  20. pvs = NULL;
  21. patches = NULL;
  22. patchesX = patchesY = 0;
  23. heightmap = NULL;
  24. hmData=NULL;
  25. normals = NULL;
  26. maxError = 0.015f;
  27. desiredFPS = 0;
  28. activePatches = NULL;
  29. forceBufferCreate = true;
  30. skySpeedX = skySpeedY = 0.0f;
  31. fogNear = fogFar = 0.0f;
  33. mipFilter = afTextureStage::FILTER_LINEAR;
  34. m_pTerrainDecl=NULL;
  35. m_pTerrainShader=NULL;
  37. numNewVertices = numNewIndices = numVertices = numIndices = 0;
  38. useUnitDistance = true;
  39. updateWorldMatrix();
  40. }
  43. void afTerrain::setPatchSize(float nX, float nY, float nZ)
  44. {
  45. patchDX = nX;
  46. patchDY = nY;
  47. patchDZ = nZ;
  48. }
  51. void afTerrain::setHeightMap(afImage* nImage)
  52. {
  53. if(nImage==NULL)
  54. return;
  55. heightmap = nImage;
  56. hmData = heightmap->getData();
  57. hmWidth = heightmap->getWidth();
  58. hmHeight = heightmap->getHeight();
  59. }
  62. void afTerrain::setSkyMap(afTexture* nSkyMap, float nX, float nY, float nSpeedX, float nSpeedY)
  63. {
  64. fillPassInfo(&skyPass, nSkyMap, nX, nY, NULL);
  65. skyPosX = skyPosY = 0.0f;
  66. skySpeedX = nSpeedX;
  67. skySpeedY = nSpeedY;
  68. }
  71. inline void afTerrain::updateSkyMatrix()
  72. {
  73. if(!skyPass.texColor)
  74. return;
  76. float ftime = afTime::getLastFrameTime();
  78. skyPosX += ftime * skySpeedX;
  79. skyPosY += ftime * skySpeedY;
  80. D3DXMatrixScaling(&skyPass.matrix, skyPass.repeatX, skyPass.repeatY, 1.0f);
  81. skyPass.matrix._31 = skyPosX;
  82. skyPass.matrix._32 = skyPosY;
  84. }
  87. void afTerrain::fillPassInfo(MultiPassInfo* nPass, afTexture* nTexture, float nRepeatX, float nRepeatY, afTexture* nModTexture)
  88. {
  89. nPass->texColor = nTexture;
  90. nPass->texMod = nModTexture;
  92. if(nRepeatX==0.0f) nRepeatX = 1.0f;
  93. if(nRepeatY==0.0f) nRepeatY = 1.0f;
  95. nPass->repeatX = nRepeatX;
  96. nPass->repeatY = nRepeatY;
  97. D3DXMatrixScaling(&nPass->matrix, nPass->repeatX, nPass->repeatY, 1.0f);
  98. }
  101. void afTerrain::addPass(afTexture* nColorTexture, float nRepeatX, float nRepeatY, afTexture* nTransTexture)
  102. {
  103. MultiPassInfo* pass = new MultiPassInfo();
  104. multiPassInfos.addTail(pass);
  105. fillPassInfo(pass, nColorTexture, nRepeatX, nRepeatY, nTransTexture);
  106. }
  109. void afTerrain::calcPassVisibility(MultiPassInfo* nInfo, int nX, int nY)
  110. {
  111. int dx = nInfo->texMod->getWidth(),
  112. dy = nInfo->texMod->getHeight();
  113. int px = dx / patchesX,
  114. py = dy / patchesY;
  115. int x0 = nX*px, x1 = nX*px+px,
  116. y0 = nY*py, y1 = nY*py+py,
  117. x,y;
  118. unsigned char *data = nInfo->visData,
  119. min = 10, max = 245;
  120. int pitch = nInfo->visPitch;
  122. nInfo->inVis = nInfo->fullVis = true;
  124. for(x=x0; x<x1; x++)
  125. for(y=y0; y<y1; y++)
  126. {
  127. int idx = 4*x + (dy-1-y)*pitch + 3;
  128. unsigned char d = data[idx];
  130. if(d>=min)
  131. nInfo->inVis = false;
  132. if(d<=max)
  133. nInfo->fullVis = false;
  134. }
  135. }
  137. void afTerrain::build()
  138. {
  139. int x,y, pass, pass2;
  141. if(!heightmap)
  142. return;
  144. patches = new afTerrainPatchPPtr[patchesY];
  145. for(y=0; y<patchesY; y++)
  146. patches[y] = new afTerrainPatchPtr[patchesX];
  148. sizeX = patchDX * patchesX;
  149. sizeY = patchDY;
  150. sizeZ = patchDZ * patchesY;
  152.     
  153. if(pvsName.getLength()>0)
  154. {
  155. pvs = new afTerrainPVS();
  156. if(!pvs->load(afSettings::tmpFullPath(pvsName+".pvs")))
  157. {
  158. delete pvs;
  159. pvs = NULL;
  160. }
  161. } 
  163. for(pass=1; pass<multiPassInfos.getSize(); pass++)
  164. {
  165. MultiPassInfo* p = multiPassInfos[pass];
  166. bool ok = p->texMod->getData(p->visData, p->visPitch);
  167. assert(ok);
  168. }
  171. for(y=0; y<patchesY; y++)
  172. for(x=0; x<patchesX; x++)
  173. {
  174. afTerrainPatch* patch = createPatch(x,y);
  175. patches[y][x] = patch;
  177. patch->setScale(afVec3(patchDX, patchDY, patchDZ));
  178. patch->setPosition(afVec3(x*patchDX, 0.0f, y*patchDZ));
  179. patch->setHeightMapPosition(x*(afTerrainPatch::SOURCE_WIDTH-1),
  180. y*(afTerrainPatch::SOURCE_HEIGHT-1));
  181. patch->calcErrors();
  182. patch->calcMinMaxY();
  184. // calculate for each pass if there is anything to draw
  185. // (check the alpha map)
  186. int visFlags = 0,
  187. numPasses = multiPassInfos.getSize();
  189. for(pass=1; pass<numPasses; pass++)
  190. calcPassVisibility(multiPassInfos[pass], x,y);
  192. visFlags = afTerrainPatch::VIS_LAYERALL;
  194. for(pass=1; pass<numPasses; pass++) // base pass checking
  195. if(multiPassInfos[pass]->fullVis)
  196. visFlags &= ~afTerrainPatch::VIS_BASE;
  198. for(pass=1; pass<numPasses; pass++) // additional passes
  199. {
  200. if(multiPassInfos[pass]->inVis) // is this pass invisible ? (also no need to check on)
  201. {
  202. visFlags &= ~afTerrainPatch::getAddLayerFlag(pass);
  203. continue;
  204. }
  206. for(pass2=pass+1; pass2<numPasses; pass2++) // see if another pass completely covers this pass
  207. if(multiPassInfos[pass2]->fullVis)
  208. {
  209. visFlags &= ~afTerrainPatch::getAddLayerFlag(pass);
  210. break;
  211. }
  212. }
  214. patch->setVisFlags(visFlags);
  215. }
  218. // tell each patch about its neighbors
  219. //
  220. for(y=0; y<patchesY; y++)
  221. for(x=0; x<patchesX; x++)
  222. patches[y][x]->setNeighbors(x>0 ? patches[y][x-1] : NULL,
  223. x<patchesX-1 ? patches[y][x+1] : NULL,
  224. y>0 ? patches[y-1][x] : NULL,
  225. y<patchesY-1 ? patches[y+1][x] : NULL);
  228. for(pass=1; pass<multiPassInfos.getSize(); pass++)
  229. {
  230. MultiPassInfo* p = multiPassInfos[pass];
  231. p->texMod->releaseData();
  232. }
  234. BuildVertexShader();
  235. }
  238. void afTerrain::update()
  239. {
  240. if(!patches)
  241. return;
  243. afVec3 cPos, lPos,rPos;
  244. float fact=(float)tan(g_pApp->m_Camera.GetFOVX()/2.0f),
  245. farP =g_pApp->m_Camera.GetFarPlane();
  246. int x=0,y=0;
  247. D3DXVECTOR3 pt0,pt1,pt2, tpt0,tpt1,tpt2;
  248. D3DXMATRIX vMat, tMat;
  249. afTerrainPatchPtr curPatch;
  250. afPlane planes[6];
  252. profileUpdate.beginSection();
  254. if(desiredFPS>0)
  255. {
  256. if(afTime::getFPS()<desiredFPS*0.95f && maxError<0.5f)
  257. maxError *= 1.03f;
  258. else
  259. if(afTime::getFPS()>desiredFPS*1.05f && maxError>0.005f)
  260. maxError *= 0.97f;
  261. }
  263. numPatchesProcessed = 0;
  264. updateSkyMatrix();
  265. updateWorldMatrix();
  267. // calculate which rectangle of the map
  268. // is visible from the clipping frustum
  269. lPos = cPos + afVec3(-farP*fact, 0.0f, farP);
  270. rPos = cPos + afVec3( farP*fact, 0.0f, farP);
  272. pt0.x=cPos.x; pt0.y=cPos.y; pt0.z=cPos.z;
  273. pt1.x=lPos.x; pt1.y=lPos.y; pt1.z=lPos.z;
  274. pt2.x=rPos.x; pt2.y=rPos.y; pt2.z=rPos.z;
  276. D3DXMatrixInverse(&vMat, NULL, g_pApp->m_Camera.GetViewMatrix());
  278. D3DXMatrixMultiply(&tMat, &worldMatrix, &vMat);
  279. D3DXVec3TransformCoord(&tpt0, &pt0, &tMat);
  280. D3DXVec3TransformCoord(&tpt1, &pt1, &tMat);
  281. D3DXVec3TransformCoord(&tpt2, &pt2, &tMat);
  283. int x0 = (int)(tpt0.x / patchDX), y0 = (int)(tpt0.z / patchDZ),
  284. x1 = (int)(tpt1.x / patchDX), y1 = (int)(tpt1.z / patchDZ),
  285. x2 = (int)(tpt2.x / patchDX), y2 = (int)(tpt2.z / patchDZ);
  287. maxX = -1; maxY = -1; minX = patchesX+1; minY = patchesY+1;
  289. if(x0<minX) minX = x0;
  290. if(y0<minY) minY = y0;
  291. if(x0>maxX) maxX = x0;
  292. if(y0>maxY) maxY = y0;
  293. if(x1<minX) minX = x1;
  294. if(y1<minY) minY = y1;
  295. if(x1>maxX) maxX = x1;
  296. if(y1>maxY) maxY = y1;
  297. if(x2<minX) minX = x2;
  298. if(y2<minY) minY = y2;
  299. if(x2>maxX) maxX = x2;
  300. if(y2>maxY) maxY = y2;
  302. minX-=2; minY-=2; maxX+=2; maxY+=2;
  304. if(minX<0) minX = 0;
  305. if(minY<0) minY = 0;
  306. if(maxX>=patchesX) maxX = patchesX-1;
  308. if(g_pApp->m_Camera.getUpdateVisibility())
  309. {
  310. // mark all patches in the list as non active
  311. // (checkVisibility will set this to active, if
  312. // it is in the list and is active)
  313. curPatch = activePatches;
  314. while(curPatch)
  315. {
  316. curPatch->setFlagActive(false);
  317. curPatch = curPatch->getNextActive();
  318. }
  321. // create and transform the clipping planes
  322. // (we transform them here, so that checkVisibility()
  323. // doesn't need to transform any corner points)
  324. g_pApp->m_Camera.createClippingPlanes(planes);
  326. // first determine for each patch if
  327. // it will be visible during the next rendering
  328. int pvsX=-1, pvsY=-1, pvsZ=-1;
  330. if(pvs)
  331. {
  332. pvsX = tpt0.x>=0.0f ? (int)(tpt0.x / patchDX) : -1;
  333. pvsY = tpt0.z>=0.0f ? patchesY-1 - (int)(tpt0.z / patchDZ) : -1;
  334. pvsZ = (int)((tpt0.y / patchDY) * 255) / pvs->getDataDZ();
  335. }
  337. D3DXMATRIX mat;
  338. D3DXMatrixMultiply(&mat, &worldMatrix, g_pApp->m_Camera.GetViewMatrix());
  341. for(y=minY; y<=maxY; y++)
  342. for(x=minX; x<=maxX; x++)
  343. if(patches[y][x])
  344. {
  345. if(patches[y][x]->checkVisibility(&mat, planes) && pvs)
  346. {
  347. // if the patch could not be frustum-culled we try pvs (if there is pvs...)
  348. //
  349. if(!pvs->isVisible(pvsX,pvsY,pvsZ, x,patchesY-1-y))
  350. patches[y][x]->setVisible(false);
  351. }
  352. numPatchesProcessed++;
  353. }
  356. // deinit all patches will are still in the
  357. // list, but where checkVisibility() has not been called
  358. curPatch = activePatches;
  359. while(curPatch)
  360. {
  361. if(!curPatch->getFlagActive())
  362. curPatch->deinit();
  363. curPatch = curPatch->getNextActive();
  364. }
  367. // next update the projected error
  368. // and tesselation stage
  369. D3DXMATRIX mat2, matT;
  371. D3DXMatrixTranslation(&matT, 0.0f, 0.0f, 1.2f*max(patchDY,max(patchDX,patchDZ)));
  373. D3DXMatrixMultiply(&mat2, &matT, g_pApp->m_Camera.GetProjMatrix());
  374. D3DXMatrixMultiply(&mat, g_pApp->m_Camera.GetViewMatrix(), &mat2);
  375. D3DXMatrixMultiply(&mat2, &worldMatrix, &mat);
  378. curPatch = activePatches;
  379. while(curPatch)
  380. {
  381. curPatch->updateProjectedErrors(&mat2);
  383. for(int i=afTerrainPatch::MAX_SUBDIV; i>=0; i--)
  384. if(curPatch->getProjectedError(i)<maxError)
  385. {
  386. curPatch->setRealTessellation(i);
  387. curPatch->setTessellation(i);
  388. break;
  389. }
  391. curPatch = curPatch->getNextActive();
  392. }
  395. // next check that each neighbor has only a
  396. // tesselation stage difference at max. 1
  397. if(useUnitDistance)
  398. {
  399. bool changed;
  400. do
  401. {
  402. changed=false;
  403. curPatch = activePatches;
  404. while(curPatch)
  405. {
  406. int tes = curPatch->getNewTessellation(),
  407. lT = curPatch->getLeft()->getNewTessellationSafe(),
  408. rT = curPatch->getRight()->getNewTessellationSafe(),
  409. bT = curPatch->getBottom()->getNewTessellationSafe(),
  410. tT = curPatch->getTop()->getNewTessellationSafe();
  413. int sT = min(min(lT+1,rT+1) , min(bT+1,tT+1));
  415. if(tes>sT)
  416. {
  417. curPatch->setTessellation(sT);
  418. //curPatch->setRealTessellation(sT);
  419. changed = true;
  420. }
  421. curPatch = curPatch->getNextActive();
  422. }
  423. } while(changed);
  425. }
  428. // finally update tesselation to be correct to
  429. // all the neighbours' tesselation stages
  430. numNewVertices = numNewIndices = 0;
  431. curPatch = activePatches;
  432. while(curPatch)
  433. {
  434. int tes = curPatch->getNewTessellation(),
  435. lT = curPatch->getLeft()->getNewTessellationSafe(),
  436. rT = curPatch->getRight()->getNewTessellationSafe(),
  437. bT = curPatch->getBottom()->getNewTessellationSafe(),
  438. tT = curPatch->getTop()->getNewTessellationSafe();
  440. assert(tes-lT<=1);
  441. assert(tes-rT<=1);
  442. assert(tes-bT<=1);
  443. assert(tes-tT<=1);
  445. curPatch->updateTessellation();
  446. numNewVertices += curPatch->getNumVertices();
  447. numNewIndices += curPatch->getNumIndices() + 2; // two more for degen-tris
  449. curPatch = curPatch->getNextActive();
  450. }
  452. // some patch types may need a second update method
  453. // (e.g.: to adapt to each other)
  454. curPatch = activePatches;
  455. while(curPatch)
  456. {
  457. curPatch->updateTessellation2();
  458. curPatch = curPatch->getNextActive();
  459. }
  461. // some patch types may need a third update method
  462. // (e.g.: to adapt to each other)
  463. curPatch = activePatches;
  464. while(curPatch)
  465. {
  466. curPatch->updateTessellation3();
  467. curPatch = curPatch->getNextActive();
  468. }
  469. }
  471. if(numNewIndices>0)
  472. numNewIndices -= 2; // the last patch does not need degen-tris
  475. profileUpdate.endSection();
  476. }
  479. inline void afTerrain::setupTextureStages(MultiPassInfo* nPass, bool nBasePass,bool bForceSoftware)
  480. {
  481. // texture stages setup
  482. //
  483. pd3dDevice->SetTextureStageState(0, D3DTSS_COLOROP,  D3DTOP_SELECTARG1);
  484. pd3dDevice->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
  485. pd3dDevice->SetTextureStageState(0, D3DTSS_COLORARG2, D3DTA_CURRENT);
  486. pd3dDevice->SetTextureStageState(0, D3DTSS_ALPHAOP,   nBasePass ? D3DTOP_DISABLE : D3DTOP_SELECTARG1);
  487. pd3dDevice->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
  488. pd3dDevice->SetTextureStageState(0, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE);
  489. pd3dDevice->SetSamplerState(0,D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
  490. pd3dDevice->SetSamplerState(0,D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
  491. pd3dDevice->SetSamplerState(0,D3DSAMP_MIPFILTER, mipFilter);
  492. pd3dDevice->SetTextureStageState(0, D3DTSS_TEXCOORDINDEX, 0);
  494. if(nPass->texMod)
  495. {
  496. pd3dDevice->SetTextureStageState(1, D3DTSS_COLOROP, D3DTOP_MODULATE);
  497. pd3dDevice->SetTextureStageState(1, D3DTSS_COLORARG1, D3DTA_TEXTURE);
  498. pd3dDevice->SetTextureStageState(1, D3DTSS_COLORARG2, D3DTA_CURRENT);
  499. pd3dDevice->SetTextureStageState(1, D3DTSS_ALPHAOP,   nBasePass ? D3DTOP_DISABLE : D3DTOP_SELECTARG1);
  500. pd3dDevice->SetTextureStageState(1, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
  501. pd3dDevice->SetTextureStageState(1, D3DTSS_ALPHAARG2, D3DTA_CURRENT);
  502. pd3dDevice->SetSamplerState(1,D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
  503. pd3dDevice->SetSamplerState(1,D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
  504. pd3dDevice->SetSamplerState(1,D3DSAMP_MIPFILTER, mipFilter);
  505. pd3dDevice->SetTextureStageState(1, D3DTSS_TEXCOORDINDEX,bForceSoftware?0:1);
  506. pd3dDevice->SetTextureStageState(2, D3DTSS_COLOROP,   D3DTOP_DISABLE);
  507. pd3dDevice->SetTextureStageState(2, D3DTSS_ALPHAOP,   D3DTOP_DISABLE);
  508. }
  509. else
  510. {
  511. pd3dDevice->SetTextureStageState(1, D3DTSS_COLOROP,   D3DTOP_DISABLE);
  512. pd3dDevice->SetTextureStageState(1, D3DTSS_ALPHAOP,   D3DTOP_DISABLE);
  513. }
  516. // zbuffer, filling & culling setup
  517. //
  518. pd3dDevice->SetRenderState(D3DRS_ZENABLE, TRUE);
  519. pd3dDevice->SetRenderState(D3DRS_ZWRITEENABLE, TRUE);
  520. pd3dDevice->SetRenderState(D3DRS_FILLMODE, D3DFILL_SOLID);
  521. pd3dDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW);
  524. // fog setup
  525. //
  526. if(fogNear!=0.0f || fogFar!=0.0f)
  527. {
  528. float fogDens = 1.0f;
  530. pd3dDevice->SetRenderState(D3DRS_FOGENABLE, TRUE);
  531. pd3dDevice->SetRenderState(D3DRS_FOGCOLOR,  D3DCOLOR_COLORVALUE(fogColor[0], fogColor[1], fogColor[2], fogColor[3]));
  533. pd3dDevice->SetRenderState(D3DRS_FOGSTART, FtoDW(fogNear));
  534. pd3dDevice->SetRenderState(D3DRS_FOGEND, FtoDW(fogFar));
  535. pd3dDevice->SetRenderState(D3DRS_FOGDENSITY, FtoDW(fogDens));
  536. pd3dDevice->SetRenderState(D3DRS_FOGVERTEXMODE, D3DFOG_LINEAR);
  537. }
  538. else
  539. pd3dDevice->SetRenderState(D3DRS_FOGENABLE, FALSE);
  542. // set textures
  543. //
  544. pd3dDevice->SetTexture(0, nPass->texColor->getD3DTexture());
  545. pd3dDevice->SetTexture(1, nPass->texMod->getD3DTexture());
  548. // setup lighting & blending
  549. //
  550. pd3dDevice->SetRenderState(D3DRS_LIGHTING, FALSE);
  552. if(nBasePass)
  553. pd3dDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
  554. else
  555. {
  556. pd3dDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
  557. pd3dDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
  558. pd3dDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
  559. }
  562. // setup texture matrix for stage 0
  563. //
  564. if(bForceSoftware)
  565. {
  566. if(nPass->repeatX!=1.0f || nPass->repeatY!=1.0f)
  567. {
  568. pd3dDevice->SetTransform(D3DTS_TEXTURE0, &nPass->matrix);
  569. pd3dDevice->SetTextureStageState(0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT2);
  570. }
  571. else
  572. pd3dDevice->SetTextureStageState(0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE);
  573. }
  574. else
  575. {
  576. D3DXMATRIX matTranspose;
  577. D3DXMatrixTranspose(&matTranspose, &nPass->matrix);
  578. g_pApp->m_pd3dDevice->SetVertexShaderConstantF(8,(float*)&matTranspose, 4);
  579. }
  581. pd3dDevice->SetTextureStageState(1, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE);
  582. }
  585. inline void afTerrain::setupTextureStagesForSky(bool bForceSoftware)
  586. {
  587. // texture stages setup
  588. //
  589. pd3dDevice->SetTextureStageState(0, D3DTSS_COLOROP,   D3DTOP_SELECTARG1);
  590. pd3dDevice->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
  591. pd3dDevice->SetTextureStageState(0, D3DTSS_COLORARG2, D3DTA_CURRENT);
  592. pd3dDevice->SetTextureStageState(0, D3DTSS_ALPHAOP,   D3DTOP_SELECTARG1);
  593. pd3dDevice->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
  594. pd3dDevice->SetTextureStageState(0, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE);
  595. pd3dDevice->SetSamplerState(0,D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
  596. pd3dDevice->SetSamplerState(0,D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
  597. pd3dDevice->SetSamplerState(0,D3DSAMP_MIPFILTER, mipFilter);
  598. pd3dDevice->SetTextureStageState(0, D3DTSS_TEXCOORDINDEX, 0);
  600. pd3dDevice->SetTextureStageState(1, D3DTSS_COLOROP,   D3DTOP_DISABLE);
  601. pd3dDevice->SetTextureStageState(1, D3DTSS_ALPHAOP,   D3DTOP_DISABLE);
  604. // zbuffer, filling & culling setup
  605. //
  606. pd3dDevice->SetRenderState(D3DRS_ZENABLE, TRUE);
  607. pd3dDevice->SetRenderState(D3DRS_ZWRITEENABLE, TRUE);
  608. pd3dDevice->SetRenderState(D3DRS_FILLMODE, D3DFILL_SOLID);
  609. pd3dDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW);
  612. // fog setup
  613. //
  614. if(fogNear!=0.0f || fogFar!=0.0f)
  615. {
  616. float fogDens = 0.0f;
  618. pd3dDevice->SetRenderState(D3DRS_FOGENABLE, TRUE);
  619. pd3dDevice->SetRenderState(D3DRS_FOGCOLOR,  D3DCOLOR_COLORVALUE(fogColor[0], fogColor[1], fogColor[2], fogColor[3]));
  621. pd3dDevice->SetRenderState(D3DRS_FOGSTART, FtoDW(fogNear));
  622. pd3dDevice->SetRenderState(D3DRS_FOGEND, FtoDW(fogFar));
  623. pd3dDevice->SetRenderState(D3DRS_FOGDENSITY, FtoDW(fogDens));
  624. pd3dDevice->SetRenderState(D3DRS_FOGVERTEXMODE, D3DFOG_LINEAR);
  625. pd3dDevice->SetRenderState(D3DRS_FOGTABLEMODE, D3DFOG_NONE);
  626. }
  627. else
  628. pd3dDevice->SetRenderState(D3DRS_FOGENABLE, FALSE);
  631. // set texture
  632. //
  633. pd3dDevice->SetTexture(0, skyPass.texColor->getD3DTexture());
  636. // setup lighting & blending
  637. //
  638. pd3dDevice->SetRenderState(D3DRS_LIGHTING, FALSE);
  639. pd3dDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
  640. pd3dDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
  641. pd3dDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
  644. // setup texture matrix for stage 0
  645. //
  646. if(bForceSoftware)
  647. {
  648. if(skyPass.repeatX!=1.0f || skyPass.repeatY!=1.0f)
  649. {
  650. g_pApp->m_pd3dDevice->SetTransform(D3DTS_TEXTURE0, &skyPass.matrix);
  651. g_pApp->m_pd3dDevice->SetTextureStageState(0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT2);
  652. }
  653. else
  654. g_pApp->m_pd3dDevice->SetTextureStageState(0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE);
  655. }
  656. else
  657. {
  658. D3DXMATRIX matTranspose;
  659. D3DXMatrixTranspose(&matTranspose, &skyPass.matrix);
  660. g_pApp->m_pd3dDevice->SetVertexShaderConstantF(8,(float*)&matTranspose, 4);
  661. }
  663. pd3dDevice->SetTextureStageState(1, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE);
  664. }
  666. inline void afTerrain::updateWorldMatrix()
  667. {
  668. D3DXMATRIX matScale, matMove, matRot, mat;
  669. afVec3 scale(1.0f, 1.0f, 1.0f);
  671. D3DXMatrixScaling(&matScale, scale.x, scale.y, scale.z);
  672. D3DXMatrixTranslation(&matMove, pos.x,pos.y,pos.z);
  673. D3DXMatrixRotationYawPitchRoll(&matRot, rot.x,rot.y,rot.z);
  674. D3DXMatrixMultiply(&mat, &matRot, &matMove);
  675. D3DXMatrixMultiply(&worldMatrix, &matScale, &mat);
  676. }
  679. void afTerrain::checkBuffers()
  680. {
  681. if(mergeSmallPatches)
  682. {
  683. assert(numNewIndices < 0xffff);
  684. if(numNewIndices > numIndices || forceBufferCreate)
  685. {
  686. SAFE_RELEASE(iBuffer);
  687. if(numNewIndices>0)
  688. if(FAILED(pd3dDevice->CreateIndexBuffer(numNewIndices * sizeof(WORD), D3DUSAGE_DYNAMIC|D3DUSAGE_WRITEONLY,
  689. D3DFMT_INDEX16, D3DPOOL_DEFAULT, &iBuffer,NULL)))
  690. {
  691. afLog::error("creating index buffer for terrain failed");
  692. return;
  693. }
  694. }
  695. numIndices = numNewIndices;
  697. if(numNewVertices > numVertices || forceBufferCreate)
  698. {
  699. SAFE_RELEASE(vBuffer);
  701. if(numNewVertices>0)
  702. {
  703. if(FAILED(pd3dDevice->CreateVertexBuffer(numNewVertices * sizeof(afTerrainPatch::PATCHVERTEX),
  704.  D3DUSAGE_DYNAMIC|D3DUSAGE_WRITEONLY,
  705.  D3DFVF_PATCHVERTEX, D3DPOOL_DEFAULT, &vBuffer,NULL)))
  706. {
  707. afLog::error("creating vertex buffer for terrain failed");
  708. SAFE_RELEASE(iBuffer);
  709. return;
  710. }
  711. }
  712. }
  713. numVertices = numNewVertices;
  714. }
  716. forceBufferCreate = false;
  717. }
  720. void afTerrain::render()
  721. {
  722.  
  723. profileRender.beginSection();
  725.     // activate the morph shader
  726. SetupVertexShader();
  727. afTerrainPatch* patch;
  728. afTerrainPatch::PATCHVERTEX* pVertices = NULL;
  729. WORD* pIndices = NULL;
  730. int i, pass, numTris=0, numPasses = multiPassInfos.getSize(), numPassesP;
  732. for(i=0; i<=afTerrainPatch::MAX_SUBDIV; i++)
  733. patchCount[i] = 0;
  734. numPatchesRendered = numPatchesPassesRendered = 0;
  736. if(mergeSmallPatches)
  737. {
  738. numNewVertices = 0;
  739. numNewIndices = 0;
  740. patch = activePatches;
  741. while(patch)
  742. {
  743. if(patch->getNewTessellation()==4)
  744. {
  745. numNewVertices += patch->getNumVertices();
  746. numNewIndices += patch->getNumIndices()+2;
  747. }
  748. patch = patch->getNextActive();
  749. }
  750. checkBuffers();
  751. }
  753. numPassesP = skyPass.texColor ? numPasses+1 : numPasses;
  754. for(pass=0; pass<numPassesP; pass++)
  755. {
  756. int numV=0, numI=0;
  757. if(pass<numPasses)
  758. setupTextureStages(multiPassInfos[pass], false,false);
  759. else
  760. setupTextureStagesForSky(false);
  762. if(mergeSmallPatches && vBuffer && iBuffer)
  763. {
  764. if(!SetupVertexShader())
  765. return;
  766. vBuffer->Lock(0, 0, (void**)&pVertices, D3DLOCK_NOSYSLOCK|D3DLOCK_DISCARD);
  767. iBuffer->Lock(0, 0, (void**)&pIndices, D3DLOCK_NOSYSLOCK|D3DLOCK_DISCARD);
  768. }
  771. patch = activePatches;
  773. while(patch)
  774. {
  775. int tes = patch->getNewTessellation();
  777. assert(tes>=0 && tes<=afTerrainPatch::MAX_SUBDIV);
  779. if(pass==0)
  780. {
  781. numPatchesRendered++;
  782. patchCount[tes]++;
  783. patch->setRendered(false);
  784. }
  786. if(pass<numPasses || patch->getVisFlags()&afTerrainPatch::getAddLayerFlag(pass))
  787. {
  788. if(mergeSmallPatches && tes==4)
  789. {
  790. // copy the vertex data
  791. //
  792. int numNewV = patch->fillBaseVertices(pVertices+numV);
  794. // then copy the indices, which must be updated to
  795. // reflect the moved vertex data (index shifts)
  796. //
  797. const WORD* indices = patch->getIndices();
  798. int n = patch->getNumIndices();
  800. if(numI>0) // add degen-tris to concenate strips
  801. {
  802. pIndices[numI++] = pIndices[numI-1];
  803. pIndices[numI++] = (unsigned short)(indices[0] + numV);
  804. }
  806. for(i=0; i<n; i++)
  807. pIndices[numI++] = (unsigned short)(indices[i] + numV);
  809. numV += numNewV;
  810. }
  811. else
  812. {
  813. numTris = patch->render();
  814. }
  816. patch->setRendered(true);
  817. numPatchesPassesRendered++;
  818. }
  820. patch = patch->getNextActive();
  821. }
  823. if(mergeSmallPatches && vBuffer && iBuffer)
  824. {
  825. if(pass<numPasses)
  826. setupTextureStages(multiPassInfos[pass], false,true);
  827. else
  828. setupTextureStagesForSky(true);
  830. iBuffer->Unlock();
  831. vBuffer->Unlock();
  833. assert(numV<=numNewVertices);
  834. assert(numI<=numNewIndices);
  835.             
  836. pd3dDevice->SetVertexShader(NULL);
  837. pd3dDevice->SetFVF(D3DFVF_PATCHVERTEX);
  838. pd3dDevice->SetStreamSource(0, vBuffer,0,sizeof(afTerrainPatch::PATCHVERTEX));
  839. pd3dDevice->SetIndices(iBuffer);
  840. pd3dDevice->DrawIndexedPrimitive(D3DPT_TRIANGLESTRIP,0,0, numV, 0, numI-2);
  841. }
  842. }
  844. //afLog::info("numPatchesRendered:%d,numPatchesPassesRendered:%d",numPatchesRendered,numPatchesPassesRendered);
  845. profileRender.endSection();
  846. }
  849. float afTerrain::getHeightDif(int nX0, int nY0, int nX1, int nY1)
  850. {
  851. return getHeight(nX0,nY0) - getHeight(nX1,nY1);
  852. }
  855. void afTerrain::createNormals()
  856. {
  857. int x,y, w=heightmap->getWidth(), h=heightmap->getHeight();
  859. if(normals)
  860. delete normals;
  862. normals = new afVec3[w*h];
  864. for(y=0; y<h; y++)
  865. for(x=0; x<w; x++)
  866. {
  867. int idx = y*w+x;
  868. float dxp=0.0f,dxm=0.0f, dyp=0.0f,dym=0.0f;
  870. if(x>0 && x<w-1 && y>0 && y<w-1)
  871. {
  872. dxp =  getHeightDif(x,y, x+1,y);
  873. dxm =  getHeightDif(x,y, x-1,y);
  874. dyp =  getHeightDif(x,y, x,y+1);
  875. dym =  getHeightDif(x,y, x,y-1);
  876. }
  878. normals[idx].x = ((dxp - dxm)/2.0f) * patchDX * afTerrainPatch::SOURCE_WIDTH;
  879. normals[idx].y = patchDY;
  880. normals[idx].z = ((dyp - dym)/2.0f) * patchDZ * afTerrainPatch::SOURCE_HEIGHT;
  881. normals[idx].normalize();
  882. }
  884. normals[0] = normals[1+w];
  885. normals[w-1] = normals[w+w-2];
  887. normals[(h-1)*w] = normals[(h-2)*w+1];
  888. normals[(h-1)*w+w-1] = normals[(h-2)*w+w-2];
  890. for(x=1; x<w-1; x++)
  891. {
  892. normals[x] = normals[x+w];
  893. normals[x+(y-1)*w] = normals[x+(y-2)*w];
  894. }
  896. for(y=1; y<h-1; y++)
  897. {
  898. normals[y*w] = normals[y*w+1];
  899. normals[y*w+w-1] = normals[y*w+w-2];
  900. }
  901. }
  904. void afTerrain::deleteDeviceObjects()
  905. {
  906. int x,y;
  908. SAFE_RELEASE(iBuffer);
  909. SAFE_RELEASE(vBuffer);
  911. if(patches)
  912. {
  913. for(y=0; y<patchesY; y++)
  914. for(x=0; x<patchesX; x++)
  915. if(patches[y][x])
  916. patches[y][x]->deleteDeviceObjects();
  917. }
  919. SAFE_DELETE(pvs);
  920. for(int pass=0; pass<multiPassInfos.getSize(); pass++)
  921. {
  922. MultiPassInfo* p = multiPassInfos[pass];
  923. SAFE_DELETE(p);
  924. }
  925. DestroyVertexShader();
  926. }
  929. bool afTerrain::restoreDeviceObjects()
  930. {
  931. int x,y;
  933. forceBufferCreate = true;
  935. if(!patches)
  936. return true;
  938. for(y=0; y<patchesY; y++)
  939. for(x=0; x<patchesX; x++)
  940. if(patches[y][x])
  941. patches[y][x]->restoreDeviceObjects();
  943. return true;
  944. }
  947. void afTerrain::fillInfoString(afString& nStr)
  948. {
  949. float factor = (float)numPatchesPassesRendered/(float)numPatchesRendered;
  950. nStr.set("Terr: %d processed  %d (%d passes -> x%.2f) rendered", numPatchesProcessed, numPatchesRendered, numPatchesPassesRendered, factor);
  951. }
  953. void afTerrain::fillInfoString2(afString& nStr)
  954. {
  955. nStr.set("%d %d %d %d %d | %d", patchCount[0], patchCount[1], patchCount[2], patchCount[3], patchCount[4], bufferCreateCount);
  956. bufferCreateCount = 0;
  957. }
  959. // this method is not yet working correctly...
  960. //
  961. bool afTerrain::intersectLine(const afVec3& nPos0, const afVec3& nPos1, float& nScalarPos) const
  962. {
  963. D3DXMATRIX mat;
  964. D3DXVECTOR3 p0,p1, tp0,tp1, ds, p;
  965. float len, flatLen, f = 0.0f, h;
  966. bool startAbove=false, curAbove=false, startAboveInit=false;
  968. D3DXMatrixInverse(&mat, NULL, &worldMatrix);
  969. p0.x=nPos0.x; p0.y=nPos0.y; p0.z=nPos0.z;
  970. p1.x=nPos1.x; p1.y=nPos1.y; p1.z=nPos1.z;
  971. D3DXVec3TransformCoord(&tp0, &p0, &mat);
  972. D3DXVec3TransformCoord(&tp1, &p1, &mat);
  974. tp0.x /= sizeX; tp0.y /= sizeY; tp0.z /= sizeZ;
  975. tp1.x /= sizeX; tp1.y /= sizeY; tp1.z /= sizeZ;
  977. if((tp0.x<0.0f && tp1.x<0.0f) || (tp0.x>1.0f && tp1.x>1.0f) ||
  978.    (tp0.z<0.0f && tp1.z<0.0f) || (tp0.z>1.0f && tp1.z>1.0f))
  979.    return false;
  981. ds = tp1-tp0;
  982. //ds.x *= 255.0f;
  983. //ds.z *= 255.0f;
  984. flatLen = (float)(sqrt(ds.x*ds.x + ds.z*ds.z));
  985. if(flatLen>0.0f)
  986. {
  987. ds.x /= flatLen;
  988. ds.y /= (255.0f*flatLen);
  989. ds.z /= flatLen;
  990. }
  991. len = (float)(sqrt(ds.x*ds.x + ds.y*ds.y + ds.z*ds.z));
  992. p = tp0;
  994. do
  995. {
  996. if(p.x>=0.0f && p.x<=hmWidth && p.z>=0.0f && p.z<=hmHeight)
  997. {
  998. if(!startAboveInit)
  999. {
  1000. startAboveInit = true;
  1001. startAbove = getHeight((int)p.x, (int)p.z) < p.y;
  1002. }
  1004. p += ds;
  1005. f += 1.0f;
  1007. h = getHeight((int)p.x, (int)p.z);
  1008. curAbove = h < p.y;
  1010. if(startAboveInit && curAbove!=startAbove)
  1011. {
  1012. //nScalarPos = (p-tp0).GetLength() / (tp1-tp0).length();
  1013. nScalarPos = 0.0f;
  1014. return true;
  1015. }
  1016. }
  1017. else
  1018. {
  1019. p += ds;
  1020. f += 1.0f;
  1021. }
  1022. } while(f<flatLen);
  1024. return false;
  1025. }
  1028. bool afTerrain::projectDown(const afVec3& nPos, afVec3& nProjected) const
  1029. {
  1030. D3DXMATRIX mat;
  1031. D3DXVECTOR3 p, tp;
  1033. D3DXMatrixInverse(&mat, NULL, &worldMatrix);
  1035. p.x=nPos.x; p.y=nPos.y; p.z=nPos.z;
  1037. D3DXVec3TransformCoord(&tp, &p, &mat);
  1039. tp.x /= sizeX; tp.y /= sizeY; tp.z /= sizeZ;
  1041. float x = hmWidth*tp.x,
  1042. y = hmHeight*tp.z;
  1044. x -= 0.5f;
  1045. y -= 0.5f;
  1047. int ix = (int)x,
  1048. iy = (int)y;
  1049. float u = x - ix,
  1050. v = y - iy;
  1052. if(ix<0 || iy<0 || ix>=hmWidth-1 || iy>=hmHeight-1)
  1053. return false;
  1055. float h00 = getHeight(ix+0, iy+0),
  1056. h10 = getHeight(ix+1, iy+0),
  1057. h01 = getHeight(ix+0, iy+1),
  1058. h11 = getHeight(ix+1, iy+1);
  1060. tp.y = (1.0f-v) * ((1.0f-u)*h00 + u*h10) + 
  1061.  v  * ((1.0f-u)*h01 + u*h11);
  1063. tp.x *= sizeX; tp.y *= sizeY; tp.z *= sizeZ;
  1065. D3DXVec3TransformCoord(&p, &tp, &worldMatrix);
  1066.     nProjected.x=p.x; nProjected.y=p.y; nProjected.z=p.z;
  1067. return true;
  1068. }
  1071. bool afTerrain::moveAboveSurface(afVec3& nPos, float nHeight, float /*nGlideFactor*/) const
  1072. {
  1073. afVec3 downPos;
  1075. if(projectDown(nPos, downPos))
  1076. {
  1077. if(nPos.y < downPos.y + nHeight)
  1078. {
  1079. nPos.y = downPos.y + nHeight;
  1080. return true;
  1081. }
  1082. }
  1084. return false;
  1085. }
  1088. afTerrainPatch* afTerrain::createPatch(int nX, int nY)
  1089. {
  1090. return new afTerrainPatch(this, nX,nY);
  1092. }
  1095. bool afTerrain::BuildVertexShader()
  1096. {
  1097. D3DVERTEXELEMENT9 declTerrain[] =
  1098.     {        
  1099.         { 0,  0, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT,  D3DDECLUSAGE_POSITION, 0}, 
  1100.         { 0, 16, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT,  D3DDECLUSAGE_TEXCOORD, 0}, 
  1101.         { 0, 32, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT,  D3DDECLUSAGE_TEXCOORD, 1},        
  1102.         { 0, 48, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT,  D3DDECLUSAGE_TEXCOORD, 2},     
  1103.     D3DDECL_END()
  1104.     };
  1106. HRESULT hr;
  1107. if(FAILED( hr =g_pApp->m_pd3dDevice->CreateVertexDeclaration(declTerrain, &m_pTerrainDecl)))
  1108.         return false;
  1109. LPD3DXBUFFER pCode = NULL;
  1110. if( FAILED( hr = D3DXAssembleShaderFromFile(afSettings::tmpFullPath("shader/terrainMorph.vsh"), NULL, NULL, 0, &pCode, NULL)))  
  1111. return false;
  1113. if( FAILED( hr = g_pApp->m_pd3dDevice->CreateVertexShader( (DWORD*)pCode->GetBufferPointer(),
  1114.                                                        &m_pTerrainShader)))
  1115.     {
  1116.         SAFE_RELEASE( pCode );
  1117.         return false;
  1118.     }
  1119.     SAFE_RELEASE( pCode); 
  1120. return true;
  1121. }
  1123. void afTerrain::DestroyVertexShader()
  1124. {
  1125. SAFE_RELEASE(m_pTerrainShader);
  1126. SAFE_RELEASE(m_pTerrainDecl);
  1127. }
  1129. inline bool afTerrain::SetupVertexShader()
  1130. {
  1131. D3DXMATRIX mat, matTranspose;
  1132. D3DXMatrixMultiply(&mat, g_pApp->m_Camera.GetViewMatrix(),g_pApp->m_Camera.GetProjMatrix());
  1133. D3DXMatrixTranspose(&matTranspose, &mat);
  1134. g_pApp->m_pd3dDevice->SetVertexShaderConstantF(4,(float*)&matTranspose, 4);
  1135. g_pApp->m_pd3dDevice->SetVertexDeclaration(m_pTerrainDecl);
  1136. if(m_pTerrainShader)
  1137. return(g_pApp->m_pd3dDevice->SetVertexShader(m_pTerrainShader)==S_OK);
  1138. return false;
  1139. }