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

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

其他游戏

开发平台：

Visual C++

afTerrainPatch.cpp：源码内容
  1. #include "stdafx.h"
  2. #include "afTerrainPatch.h"
  3. #include "afLog.h"
  4. #include "afMatrix.h"
  5. #include "afPlane.h"
  6. #include "afTerrain.h"
  7. #include <assert.h>
  9. #define setD3DVec(v1, v0)  {  v1.x = v0.x;  v1.y = v0.y;  v1.z = v0.z;  }
  11. struct PATCHVERTEX_MORPH_HW
  12. {
  13. float posX,posZ;
  14. float texX,texY;
  15. float posY, yMoveSelf, v0,v1,
  16. yMoveLeft, yMoveLeft2, yMoveRight, yMoveRight2,
  17. yMoveBottom, yMoveBottom2, yMoveTop, yMoveTop2;
  18. };
  20. afTerrainPatch::afTerrainPatch(afTerrain* nMaster, int nX, int nY) : active(false), scale(1.0f, 1.0f, 1.0f)
  21. {
  22. visFlags = 0;
  24. gridX = nX;
  25. gridY = nY;
  27. minY = maxY = -1.0f;
  29. master = nMaster;
  30. realSelfTes = newRealSelfTes = newSelfTes = selfTes = leftTes = rightTes = topTes = bottomTes = 5;
  31. oldRealSelfTes = 5;
  33. vertices = NULL;
  34. indices = NULL;
  35. indexMap = NULL;
  37. next = prev = NULL;
  38. left = right = bottom = top = NULL;
  40. lowVertMethod2 = false;
  41. currentError = -1.0f;
  43. vBuffer = NULL;
  44. iBuffer = NULL;
  45. verticesLow = NULL;
  46. yMoveSelf = yMoveLeft = yMoveLeft2 = yMoveRight = yMoveRight2 = yMoveBottom = yMoveBottom2 = yMoveTop = yMoveTop2 = NULL;
  47. newFollowsLeft = followsLeft = newFollowsRight = followsRight = newFollowsBottom = followsBottom = newFollowsTop = followsTop = false;
  48. recalcBorderLeft = recalcBorderRight = recalcBorderBottom = recalcBorderTop = false;
  49. forceRetessellation = false;
  50. }
  52. void afTerrainPatch::setNeighbors(const afTerrainPatch* nLeft, const afTerrainPatch* nRight, const afTerrainPatch *nBottom, const afTerrainPatch* nTop)
  53. {
  54. left = nLeft;
  55. right = nRight;
  56. bottom = nBottom;
  57. top = nTop;
  58. }
  60. void afTerrainPatch::init()
  61. {
  62. newSelfTes = selfTes = leftTes = rightTes = topTes = bottomTes = 5;
  63. oldRealSelfTes = 5;
  65. vertices = new PATCHVERTEX[MAX_VERTICES];
  66. indices = new unsigned short[MAX_INDICES];
  67. indexMap = new unsigned short[MAX_VERTICES];
  69. numIndices = numVertices = 0;
  70. numNewVertices = numNewIndices = 0;
  72. forceBufferCreate = true;
  74. active = true;
  75. addToActiveList();
  77. verticesLow = new PATCHVERTEX[MAX_VERTICES];
  78. yMoveSelf = new float[MAX_VERTICES];
  79. yMoveLeft = new float[MAX_VERTICES];
  80. yMoveLeft2 = new float[MAX_VERTICES];
  81. yMoveRight = new float[MAX_VERTICES];
  82. yMoveRight2 = new float[MAX_VERTICES];
  83. yMoveTop = new float[MAX_VERTICES];
  84. yMoveTop2 = new float[MAX_VERTICES];
  85. yMoveBottom = new float[MAX_VERTICES];
  86. yMoveBottom2 = new float[MAX_VERTICES];
  87. newFollowsLeft = followsLeft = newFollowsRight = followsRight = newFollowsBottom = followsBottom = newFollowsTop = followsTop = false;
  88. recalcBorderLeft = recalcBorderRight = recalcBorderBottom = recalcBorderTop = false;
  89. forceRetessellation = false;
  90. }
  93. void afTerrainPatch::deinit()
  94. {
  95. if(vertices)
  96. delete vertices;
  97. vertices = NULL;
  99. if(indices)
  100. delete indices;
  101. indices = NULL;
  103. if(indexMap)
  104. delete indexMap;
  105. indexMap = NULL;
  107. currentError = -1.0f;
  109. active = false;
  110. removeFromActiveList();
  112. if(verticesLow)
  113. delete verticesLow;
  114. verticesLow = NULL;
  116. if(yMoveSelf)
  117. delete yMoveSelf;
  118. yMoveSelf = NULL;
  120. if(yMoveLeft)
  121. delete yMoveLeft;
  122. yMoveLeft = NULL;
  124. if(yMoveLeft2)
  125. delete yMoveLeft2;
  126. yMoveLeft2 = NULL;
  128. if(yMoveRight)
  129. delete yMoveRight;
  130. yMoveRight = NULL;
  132. if(yMoveRight2)
  133. delete yMoveRight2;
  134. yMoveRight2 = NULL;
  136. if(yMoveBottom)
  137. delete yMoveBottom;
  138. yMoveBottom = NULL;
  140. if(yMoveBottom2)
  141. delete yMoveBottom2;
  142. yMoveBottom2 = NULL;
  144. if(yMoveTop)
  145. delete yMoveTop;
  146. yMoveTop = NULL;
  148. if(yMoveTop2)
  149. delete yMoveTop2;
  150. yMoveTop2 = NULL;
  152. deleteDeviceObjects();
  153. }
  155. void afTerrainPatch::addToActiveList()
  156. {
  157. assert(master);
  158. assert(prev==NULL);
  159. assert(next==NULL);
  161. prev = NULL;
  162. next = master->getActiveList();
  163. if(next)
  164. next->prev = this;
  165. master->getActiveList() = this;
  166. }
  169. void afTerrainPatch::removeFromActiveList()
  170. {
  171. if(prev)
  172. prev->next = next;
  174. if(next)
  175. next->prev = prev;
  177. if(master->getActiveList() == this)
  178. {
  179. assert(prev==NULL);
  180. master->getActiveList() = next;
  181. }
  183. prev = next = NULL;
  184. }
  187. void afTerrainPatch::deleteDeviceObjects()
  188. {
  189. SAFE_RELEASE(iBuffer);
  190. SAFE_RELEASE(vBuffer);
  191. }
  194. bool afTerrainPatch::restoreDeviceObjects()
  195. {
  196. forceBufferCreate = true;
  197. return true;
  198. }
  200. int afTerrainPatch::fillBaseVertices(afTerrainPatch::PATCHVERTEX* nDest)
  201. {
  202. memcpy(nDest, vertices, numVertices*sizeof(afTerrainPatch::PATCHVERTEX));
  203. return numVertices;
  204. }
  207. void afTerrainPatch::setScale(const afVec3& nScale)
  208. {
  209. scale = nScale;
  210. }
  213. void afTerrainPatch::setHeightMapPosition(int nX0, int nY0)
  214. {
  215. hmX0 = nX0;
  216. hmY0 = nY0;
  217. }
  220. void afTerrainPatch::setRealTessellation(int nTes)
  221. {
  222. oldRealSelfTes = realSelfTes;
  223. newRealSelfTes = nTes;
  224. }
  226. bool afTerrainPatch::updateTessellation()
  227. {
  229. if(left && left->oldRealSelfTes<5 && left->newRealSelfTes!=left->oldRealSelfTes)
  230. recalcBorderLeft = true;
  232. if(right && right->oldRealSelfTes<5 && right->newRealSelfTes!=right->oldRealSelfTes)
  233. recalcBorderRight = true;
  235. if(bottom && bottom->oldRealSelfTes<5 && bottom->newRealSelfTes!=bottom->oldRealSelfTes)
  236. recalcBorderBottom = true;
  238. if(top && top->oldRealSelfTes<5 && top->newRealSelfTes!=top->oldRealSelfTes)
  239. recalcBorderTop = true;
  241. int lT = left->getNewTessellationSafe(),
  242. rT = right->getNewTessellationSafe(),
  243. bT = bottom->getNewTessellationSafe(),
  244. tT = top->getNewTessellationSafe();
  246. //oldRealSelfTes = realSelfTes;
  248. //bool lReTes = leftTes!=lT && lT>selfTes;
  250. if(forceBufferCreate || newRealSelfTes!=realSelfTes || newSelfTes!=selfTes || leftTes!=lT || rightTes!=rT || bottomTes!=bT || topTes!=tT)
  251. {
  252. realSelfTes = newRealSelfTes;
  253. selfTes = newSelfTes;
  254. leftTes = lT;
  255. rightTes = rT;
  256. bottomTes = bT;
  257. topTes = tT;
  259. //selfTes = 1;
  260. //leftTes = rightTes = topTes = bottomTes = 2;
  262. assert(selfTes-lT<=1);
  263. assert(selfTes-rT<=1);
  264. assert(selfTes-bT<=1);
  265. assert(selfTes-tT<=1);
  267. createTessellation(selfTes, leftTes, rightTes, bottomTes, topTes);
  269. forceBufferCreate = false;
  271. //numVertices = numNewVertices;
  272. //numIndices = numNewIndices;
  273. forceBufferCreate = true;
  274. }
  276. float er0 = errors[realSelfTes].diff,
  277. er1 = errors[realSelfTes+1].diff,
  278. maxErr = master->getMaxError();
  280. if(realSelfTes>=MAX_SUBDIV)
  281. er1 = 2.0f*er0;
  283. currentError = (maxErr-er0)/(er1-er0);
  285. if(realSelfTes>=4 && currentError>1.0f)
  286. currentError = 1.0f;
  287. assert(currentError<=1.0f);
  289. return false;
  290. }
  293. bool afTerrainPatch::updateTessellation2()
  294. {
  295. float selfTesEx = getExactTessellation(),
  296. leftTesEx = (left && left->isActive()) ? left->getExactTessellation() : -1.0f,
  297. rightTesEx = (right && right->isActive()) ? right->getExactTessellation() : -1.0f,
  298. bottomTesEx = (bottom && bottom->isActive()) ? bottom->getExactTessellation() : -1.0f,
  299. topTesEx = (top && top->isActive()) ? top->getExactTessellation() : -1.0f;
  301. newFollowsLeft = (selfTesEx<leftTesEx) || (selfTesEx==leftTesEx&& !left->newFollowsRight);
  302. newFollowsRight = (selfTesEx<rightTesEx) || (selfTesEx==rightTesEx && !right->newFollowsLeft);
  303. newFollowsBottom = (selfTesEx<bottomTesEx) || (selfTesEx==bottomTesEx && !bottom->newFollowsTop);
  304. newFollowsTop = (selfTesEx<topTesEx) || (selfTesEx==topTesEx && !top->newFollowsBottom);
  307. // check if this patch does no longer follow a neighbor
  308. // if there was no retessellation due to some other reason, we have to do one NOW
  309. if(!forceBufferCreate)
  310. if((!newFollowsLeft && followsLeft) || (!newFollowsRight && followsRight) ||
  311.    (!newFollowsBottom && followsBottom) || (!newFollowsTop && followsTop))
  312. {
  313. assert(selfTes-leftTes<=1);
  314. assert(selfTes-rightTes<=1);
  315. assert(selfTes-bottomTes<=1);
  316. assert(selfTes-topTes<=1);
  318. createTessellation(selfTes, leftTes, rightTes, bottomTes, topTes);
  319. numVertices = numNewVertices;
  320. numIndices = numNewIndices;
  321. forceRetessellation = true;
  322. }
  324. fillMorphVertices();
  325. return false;
  326. }
  329. bool afTerrainPatch::updateTessellation3()
  330. {
  331. checkBorderLeft();
  332. checkBorderRight();
  333. checkBorderBottom();
  334. checkBorderTop();
  336. fillBuffers();
  338. followsLeft = newFollowsLeft;
  339. followsRight = newFollowsRight;
  340. followsBottom = newFollowsBottom;
  341. followsTop = newFollowsTop;
  343. recalcBorderLeft = false;
  344. recalcBorderRight = false;
  345. recalcBorderBottom = false;
  346. recalcBorderTop = false;
  347. forceRetessellation = false;
  349. return false;
  350. }
  352. int afTerrainPatch::render()
  353. {
  354. if(!isVisible())
  355. return 0;
  357. if(iBuffer==NULL || vBuffer==NULL) // nothing to do ?
  358. return 0;
  361. float factorLeft2=0.0f, factorRight2=0.0f, factorBottom2=0.0f, factorTop2=0.0f;
  363. assert(selfTes>=0 && selfTes<=MAX_SUBDIV);
  365. factorSelf = 1.0f-currentError;
  366. factorLeft = left ? 1.0f-left->getCurrentError() : 0.0f;
  367. factorRight = right ? 1.0f-right->getCurrentError() : 0.0f;
  368. factorBottom = bottom ? 1.0f-bottom->getCurrentError() : 0.0f;
  369. factorTop = top ? 1.0f-top->getCurrentError() : 0.0f;
  371. assert(factorSelf>=0.0f);
  372. assert(factorLeft>=0.0f);
  373. assert(factorRight>=0.0f);
  374. assert(factorBottom>=0.0f);
  375. assert(factorTop>=0.0f);
  377. // clamping for patches which use selfTes!=realSelfTes
  378. //
  379. if(factorSelf>=1.0f)
  380. factorSelf = 1.0f;
  381. if(factorLeft>=1.0f)
  382. factorLeft = 1.0f;
  383. if(factorRight>=1.0f)
  384. factorRight = 1.0f;
  385. if(factorBottom>=1.0f)
  386. factorBottom = 1.0f;
  387. if(factorTop>=1.0f)
  388. factorTop = 1.0f;
  390. factorLeft2 = (1.0f-factorSelf) * factorLeft;
  391. factorRight2 = (1.0f-factorSelf) * factorRight;
  392. factorBottom2 = (1.0f-factorSelf) * factorBottom;
  393. factorTop2 = (1.0f-factorSelf) * factorTop;
  396. D3DXVECTOR4 weights0(factorSelf, 0.0f, 0.5f, 1.0f),
  397. weights2(factorLeft, factorLeft2, factorRight, factorRight2),
  398. weights3(factorBottom, factorBottom2, factorTop, factorTop2);
  401. pd3dDevice->SetVertexShaderConstantF(0, (float*)&weights0, 1);
  402. pd3dDevice->SetVertexShaderConstantF(2, (float*)&weights2, 1);
  403. pd3dDevice->SetVertexShaderConstantF(3, (float*)&weights3, 1);
  405. pd3dDevice->SetStreamSource(0, vBuffer, 0,sizeof(PATCHVERTEX_MORPH_HW));
  406. pd3dDevice->SetIndices(iBuffer);
  409. // draw the patch with one single D3D call
  410. HRESULT hr = pd3dDevice->DrawIndexedPrimitive(D3DPT_TRIANGLESTRIP,0, 0, numVertices, 0, numIndices-2);
  412. if(hr==D3D_OK)
  413. return numIndices-2;
  414. else
  415. return 0;
  416. }
  419. // check if the patch is visible on the screen (clipping)
  420. //
  421. bool afTerrainPatch::checkVisibility(const D3DXMATRIX* nMatrix, const afPlane nPlanes[6])
  422. {
  423. D3DXVECTOR3 pt0,pt1,pt2,pt3,pt4,pt5,pt6,pt7, tpt0,tpt1,tpt2,tpt3,tpt4,tpt5,tpt6,tpt7, tp0,tp1,tp2,tp3;
  424. const D3DXMATRIX& mat = *nMatrix;
  426. //visible = true;
  427. //return;
  429. // create and transform the cubes corners vertices
  430. //
  431. pt0.x = pos.x; pt0.y = pos.y + minY; pt0.z = pos.z;
  432. pt1.x = pos.x + scale.x; pt1.y = pos.y + minY; pt1.z = pos.z;
  433. pt2.x = pos.x; pt2.y = pos.y + minY; pt2.z = pos.z + scale.z;
  434. pt3.x = pos.x + scale.x; pt3.y = pos.y + minY; pt3.z = pos.z + scale.z;
  435. pt4.x = pt0.x; pt4.y = pt0.y + maxY; pt4.z = pt0.z;
  436. pt5.x = pt1.x; pt5.y = pt1.y + maxY; pt5.z = pt1.z;
  437. pt6.x = pt2.x; pt6.y = pt2.y + maxY; pt6.z = pt2.z;
  438. pt7.x = pt3.x; pt7.y = pt3.y + maxY; pt7.z = pt3.z;
  440. D3DXVec3TransformCoord(&tpt0, &pt0, &mat);
  441. D3DXVec3TransformCoord(&tpt1, &pt1, &mat);
  442. D3DXVec3TransformCoord(&tpt2, &pt2, &mat);
  443. D3DXVec3TransformCoord(&tpt3, &pt3, &mat);
  444. D3DXVec3TransformCoord(&tpt4, &pt4, &mat);
  445. D3DXVec3TransformCoord(&tpt5, &pt5, &mat);
  446. D3DXVec3TransformCoord(&tpt6, &pt6, &mat);
  447. D3DXVec3TransformCoord(&tpt7, &pt7, &mat);
  450. // check against all six planes
  451. //
  452. for(int i=0; i<6; i++)
  453. {
  454. const afPlane& p = nPlanes[i];
  455. bool v = false;
  457. if(tpt0.x*p.x + tpt0.y*p.y + tpt0.z*p.z < p.d)
  458. v = true;
  459. else
  460. if(tpt1.x*p.x + tpt1.y*p.y + tpt1.z*p.z < p.d)
  461. v = true;
  462. else
  463. if(tpt2.x*p.x + tpt2.y*p.y + tpt2.z*p.z < p.d)
  464. v = true;
  465. else
  466. if(tpt3.x*p.x + tpt3.y*p.y + tpt3.z*p.z < p.d)
  467. v = true;
  468. else
  469. if(tpt4.x*p.x + tpt4.y*p.y + tpt4.z*p.z < p.d)
  470. v = true;
  471. else
  472. if(tpt5.x*p.x + tpt5.y*p.y + tpt5.z*p.z < p.d)
  473. v = true;
  474. else
  475. if(tpt6.x*p.x + tpt6.y*p.y + tpt6.z*p.z < p.d)
  476. v = true;
  477. else
  478. if(tpt7.x*p.x + tpt7.y*p.y + tpt7.z*p.z < p.d)
  479. v = true;
  481. if(v==false)
  482. {
  483. setVisible(false);
  484. return false;
  485. }
  486. }
  487. setVisible(true);
  488. return true;
  489. }
  492. void afTerrainPatch::setVisible(bool nVis)
  493. {
  494. visible = nVis;
  496. if(visible)
  497. {
  498. flagActive = true;
  499. if(!active)
  500. init();
  501. }
  502. else if(active)
  503. deinit();
  504. }
  507. void afTerrainPatch::calcMinMaxY()
  508. {
  509. afVec3 p;
  511. minY = scale.y;
  512. maxY = 0.0f;
  514. for(int x=0; x<SOURCE_WIDTH; x++)
  515. for(int y=0; y<SOURCE_HEIGHT; y++)
  516. {
  517. getVertex(x,y, p);
  519. if(p.y<minY)
  520. minY = p.y;
  521. if(p.y>maxY)
  522. maxY = p.y;
  523. }
  524. }
  527. void afTerrainPatch::updateProjectedErrors(const D3DXMATRIX* nMatrix)
  528. {
  529. D3DXVECTOR3 corr0, real0, corr, real;
  531. setD3DVec(corr0, errors[1].correct);
  532. D3DXVec3TransformCoord(&corr, &corr0, nMatrix);
  533. assert(corr.z>0.0f);
  534. if(corr.z<0.0f)
  535. corr.z = 0.0f;
  538. for(int i=1; i<=MAX_SUBDIV; i++)
  539. {
  540. setD3DVec(real0, errors[i].real);
  541. D3DXVec3TransformCoord(&real, &real0, nMatrix);
  542. assert(real.z>0.0f);
  544. if(real.z<0.0f)
  545. real.z = 0.0f;
  547. afVec3 diff(corr.x-real.x, corr.y-real.y, corr.z-real.z);
  548. errors[i].diff = diff.length();
  550. if(errors[i].diff<errors[i-1].diff*1.1f)
  551. errors[i].diff = errors[i-1].diff*1.1f;
  552. }
  553. }
  556. void afTerrainPatch::calcErrors()
  557. {
  558. for(int i=0; i<=MAX_SUBDIV; i++)
  559. calcError(i);
  560. }
  563. void afTerrainPatch::calcError(int nTes)
  564. {
  565. float sumError = 0.0f;
  566. int numErrors = 0;
  568. if(nTes!=0)
  569. {
  570. int pow = getPowerTwo(nTes),
  571. x0,y0, xi,yi;
  573. for(y0=0; y0<SOURCE_HEIGHT-pow; y0+=pow)
  574. for(x0=0; x0<SOURCE_WIDTH-pow; x0+=pow)
  575. for(yi=1; yi<pow; yi++)
  576. for(xi=1; xi<pow; xi++)
  577. {
  578. int x = x0+xi,
  579. y = y0+yi;
  580. float fx0 = (float)xi/(float)pow, fx1 = 1.0f-fx0,
  581. fy0 = (float)yi/(float)pow, fy1 = 1.0f-fy0;
  583. float height00 = getHeight(x0,y0),
  584. height10 = getHeight(x0+pow,y0),
  585. height01 = getHeight(x0,y0+pow),
  586. height11 = getHeight(x0+pow,y0+pow);
  588. float paintHeight = fx1*fy1 * height00 +
  589. fx0*fy1 * height10 +
  590. fx1*fy0 * height01 +
  591. fx0*fy0 * height11,
  592. correctHeight =  getHeight(x,y);
  594. float er = (float)fabs(correctHeight - paintHeight);
  596. numErrors++;
  597. sumError += er;
  598. }
  600. float error = sumError / numErrors;
  601. getVertex(SOURCE_WIDTH/2, SOURCE_HEIGHT/2, errors[nTes].correct);
  602. errors[nTes].real = errors[nTes].correct;
  603. errors[nTes].real.y += error;
  604. errors[nTes].diff = error;
  605. }
  606. }
  609. float afTerrainPatch::getExactTessellation() const
  610. {
  611. if(realSelfTes<0)
  612. return -1.0f;
  614. if(currentError<0.0f)
  615. return (float)realSelfTes;
  616. else
  617. return (float)realSelfTes + currentError;
  618. }
  621. int afTerrainPatch::getPowerTwo(int nVal)
  622. {
  623. switch(nVal)
  624. {
  625. case 0:
  626. default:
  627. return 1;
  628. case 1:
  629. return 2;
  630. case 2:
  631. return 4;
  632. case 3:
  633. return 8;
  634. case 4:
  635. return 16;
  636. case 5:
  637. return 32;
  638. case 6:
  639. return 64;
  640. }
  641. }
  644. void afTerrainPatch::createTessellation(int nCenter, int nLeft, int nRight, int nBottom, int nTop)
  645. {
  646. assert(indexMap);
  647. assert(vertices);
  648. assert(indices);
  650. memset(indexMap, 0xff, MAX_VERTICES*sizeof(unsigned short));
  651. numNewVertices = numNewIndices = 0;
  653. int pow = getPowerTwo(nCenter);
  655. assert(nCenter-nLeft<=1);
  656. assert(nCenter-nRight<=1);
  657. assert(nCenter-nBottom<=1);
  658. assert(nCenter-nTop<=1);
  660. bool bLeft(nLeft<nCenter), bRight(nRight<nCenter), bBottom(nBottom<nCenter), bTop(nTop<nCenter);
  662. if(pow==16)
  663. addLevel4PatchTriangles(bLeft, bRight, bBottom, bTop);
  664. else
  665. for(int y=0; y<SOURCE_HEIGHT-pow; y+=pow)
  666. addTriangleRow(y, pow, bLeft, bRight, bBottom, bTop);
  669. assert((numNewIndices&1) == 0); // indices must always be an even number (we store quads as two triangles)
  671. if(realSelfTes>selfTes)
  672. reduceShapeTo(realSelfTes, vertices);
  674. makeBordersSimpler(vertices);
  675. }
  678. /****************************************************************************************
  679. *                                                                                        *
  680. *                                                                                        *
  681. *                                Tessellation Sub Methods                                 *
  682. *                                                                                        *
  683. *                                                                                        *
  684. ****************************************************************************************/
  687. // calls makeSimpler() sequentially to make a mesh with
  688. // selfTes<nTes to look like being created with nTes
  689. void afTerrainPatch::reduceShapeTo(int nTes, PATCHVERTEX *nData)
  690. {
  691. for(int t=nTes; t>0; t--)
  692. if(selfTes<t)
  693. makeSimpler(t, nData);
  694. }
  697. void afTerrainPatch::makeBordersSimpler(PATCHVERTEX *nData)
  698. {
  699. int sT = selfTes;
  700. int x,y, idx,idx0,idx1, pow,
  701. lDiff = sT-leftTes,
  702. rDiff = sT-rightTes,
  703. bDiff = sT-bottomTes,
  704. tDiff = sT-topTes;
  707. if((lDiff==1 || lDiff==-1) && left)
  708. {
  709. pow = getPowerTwo(min(leftTes,sT));
  711. for(y=pow; y<SOURCE_HEIGHT-1; y+=2*pow)
  712. {
  713. idx = indexMap[0 + y*SOURCE_WIDTH];
  714. idx0 = indexMap[0 + (y-pow)*SOURCE_WIDTH];
  715. idx1 = indexMap[0 + (y+pow)*SOURCE_WIDTH];
  717. assert(idx!=0xffff);
  718. assert(idx0!=0xffff);
  719. assert(idx1!=0xffff);
  721. nData[idx].pos.y = (nData[idx0].pos.y + nData[idx1].pos.y)/2.0f;
  722. }
  723. }
  725. if((rDiff==1 || rDiff==-1) && right)
  726. {
  727. pow = getPowerTwo(min(rightTes,sT));
  729. for(y=pow; y<SOURCE_HEIGHT-1; y+=2*pow)
  730. {
  731. idx = indexMap[SOURCE_WIDTH-1 + y*SOURCE_WIDTH];
  732. idx0 = indexMap[SOURCE_WIDTH-1 + (y-pow)*SOURCE_WIDTH];
  733. idx1 = indexMap[SOURCE_WIDTH-1 + (y+pow)*SOURCE_WIDTH];
  735. assert(idx!=0xffff);
  736. assert(idx0!=0xffff);
  737. assert(idx1!=0xffff);
  739. nData[idx].pos.y = (nData[idx0].pos.y + nData[idx1].pos.y)/2.0f;
  740. }
  741. }
  743. if((bDiff==1 || bDiff==-1) && bottom)
  744. {
  745. pow = getPowerTwo(min(bottomTes, sT));
  747. for(x=pow; x<SOURCE_WIDTH-1; x+=2*pow)
  748. {
  749. idx = indexMap[x + 0*SOURCE_WIDTH];
  750. idx0 = indexMap[x-pow + 0*SOURCE_WIDTH];
  751. idx1 = indexMap[x+pow + 0*SOURCE_WIDTH];
  753. assert(idx!=0xffff);
  754. assert(idx0!=0xffff);
  755. assert(idx1!=0xffff);
  757. nData[idx].pos.y = (nData[idx0].pos.y + nData[idx1].pos.y)/2.0f;
  758. }
  759. }
  761. if((tDiff==1 || tDiff==-1) && top)
  762. {
  763. pow = getPowerTwo(min(topTes,sT));
  765. for(x=pow; x<SOURCE_WIDTH-1; x+=2*pow)
  766. {
  767. idx = indexMap[x + (SOURCE_HEIGHT-1)*SOURCE_WIDTH];
  768. idx0 = indexMap[x-pow + (SOURCE_HEIGHT-1)*SOURCE_WIDTH];
  769. idx1 = indexMap[x+pow + (SOURCE_HEIGHT-1)*SOURCE_WIDTH];
  771. assert(idx!=0xffff);
  772. assert(idx0!=0xffff);
  773. assert(idx1!=0xffff);
  775. nData[idx].pos.y = (nData[idx0].pos.y + nData[idx1].pos.y)/2.0f;
  776. }
  777. }
  778. }
  781. // this methods makes the mesh looking simpler by
  782. // putting vertices into position inbetween its neighbors
  783. // this method can do only for one step at a time
  784. // (to make a tes_1 mesh look like tes_3 first call
  785. // makeSimpler(3,...) then makeSimpler(2,...)
  786. // Call reduceShapeTo() which cares about those constraints
  787. // automatically
  788. void afTerrainPatch::makeSimpler(int nTes, PATCHVERTEX *nData)
  789. {
  790. assert(selfTes<nTes);
  791. assert(nTes>0);
  793. int pow = getPowerTwo(nTes-1),
  794. x,y, xc,yc;
  796. for(yc=y=0; y<SOURCE_HEIGHT; y+=pow,yc++)
  797. for(xc=x=0; x<SOURCE_WIDTH; x+=pow,xc++)
  798. calculateInbetweenVertex(x, y, xc, yc, pow, nData);
  800. }
  803. void afTerrainPatch::calculateInbetweenVertex(int x, int y, int xc, int yc, int pow, PATCHVERTEX *nData)
  804. {
  805. float heightLeftTop=0.0f, heightRightBottom=0.0f;
  806. int idx, idxLT,idxRB;
  808. idx = calculateDiagonalVertices(x, y, xc, yc, pow, nData, heightLeftTop, idxLT, heightRightBottom, idxRB);
  810. if(idx>=0)
  811. nData[idx].pos.y = (heightLeftTop + heightRightBottom) / 2.0f;
  812. }
  815. int afTerrainPatch::calculateDiagonalVertices(int x, int y, int xc, int yc, int pow, PATCHVERTEX *nData,
  816.   float& nHeightLeftTop, int& idxLT, float& nHeightRightBottom, int& idxRB)
  817. {
  818. int c = (xc&1) + (yc&1)*2,
  819. idx = indexMap[x + y*SOURCE_WIDTH];
  821. assert(idx!=0xffff);
  823. switch(c)
  824. {
  825. case 0: // even-x & even-y
  826. // nothing to do...
  827. return -1;
  829. case 1: // odd-x & even-y
  830. assert(x>0 && x<SOURCE_WIDTH-1);
  832. idxLT = indexMap[x-pow + y*SOURCE_WIDTH];
  833. idxRB = indexMap[x+pow + y*SOURCE_WIDTH];
  835. assert(idxLT!=0xffff);
  836. assert(idxRB!=0xffff);
  838. nHeightLeftTop = nData[idxLT].pos.y;
  839. nHeightRightBottom = nData[idxRB].pos.y;
  840. return idx;
  842. case 2: // even-x & odd-y
  843. assert(y>0 && y<SOURCE_HEIGHT-1);
  845. idxLT = indexMap[x + (y+pow)*SOURCE_WIDTH];
  846. idxRB = indexMap[x + (y-pow)*SOURCE_WIDTH];
  848. assert(idxLT!=0xffff);
  849. assert(idxRB!=0xffff);
  851. nHeightLeftTop = nData[idxLT].pos.y;
  852. nHeightRightBottom = nData[idxRB].pos.y;
  853. return idx;
  855. case 3: // odd-x & odd-y
  856. assert(x>0 && x<SOURCE_WIDTH-1);
  857. assert(y>0 && y<SOURCE_HEIGHT-1);
  859. idxLT = indexMap[x-pow + (y+pow)*SOURCE_WIDTH];
  860. idxRB = indexMap[x+pow + (y-pow)*SOURCE_WIDTH];
  862. assert(idxLT!=0xffff);
  863. assert(idxRB!=0xffff);
  865. nHeightLeftTop = nData[idxLT].pos.y;
  866. nHeightRightBottom = nData[idxRB].pos.y;
  867. return idx;
  869. default:
  870. assert(false); // should never come here...
  871. return -1;
  872. }
  874. //nData[idx].pos.y = (y0+y1)/2.0f;
  875. }
  878. void afTerrainPatch::addTriangleRow(int nY, int nPow, bool nLeft, bool nRight, bool nBottom, bool nTop)
  879. {
  880. int powH = nPow/2;
  883. // special case: bottom line with nBottom
  884. //
  885. if(nY==0 && nBottom)
  886. {
  887. addTriangleBottomRow(nPow, nLeft, nRight);
  888. return;
  889. }
  891. if(nY!=0)
  892. {
  893. addLastIndexAgain();
  894. addIndex(getIndex(0,nY));
  895. }
  897. // special case: top line with nTop
  898. //
  899. if(nY>=SOURCE_HEIGHT-2*nPow && nTop)
  900. {
  901. addTriangleTopRow(nPow, nLeft, nRight);
  902. return;
  903. }
  906. // all other cases
  907. //
  908. int x, x0=0, x1=SOURCE_WIDTH;
  910. if(nLeft)
  911. {
  912. assert(powH>=1);
  914. addIndex(getIndex(0,nY));
  915. addIndex(getIndex(0,nY+powH));
  916. addIndex(getIndex(nPow,nY));
  917. addIndex(getIndex(0,nY+nPow));
  918. addIndex(getIndex(nPow,nY+nPow));
  919. addLastIndexAgain(); // finalize sub-strip
  920. x0 = nPow;
  921. }
  923. if(nRight)
  924. x1 -= nPow;
  926. for(x=x0; x<x1; x+=nPow)
  927. {
  928. addIndex(getIndex(x,nY));
  929. addIndex(getIndex(x,nY+nPow));
  930. }
  932. if(nRight)
  933. {
  934. assert(powH>=1);
  936. addIndex(getIndex(SOURCE_WIDTH-1-nPow,nY));
  937. addLastIndexAgain(); // reverse oriented triangles
  938. addIndex(getIndex(SOURCE_WIDTH-1,nY));
  939. addIndex(getIndex(SOURCE_WIDTH-1-nPow,nY+nPow));
  940. addIndex(getIndex(SOURCE_WIDTH-1,nY+powH));
  941. addIndex(getIndex(SOURCE_WIDTH-1,nY+nPow));
  942. }
  943. }
  946. void afTerrainPatch::addTriangleBottomRow(int nPow, bool nLeft, bool nRight)
  947. {
  948. int powH = nPow/2;
  949. int x0=0, x1=SOURCE_WIDTH-1;
  951. assert(powH>=1);
  953. if(nLeft)
  954. {
  955. addIndex(getIndex(0,0));
  956. addIndex(getIndex(0,powH));
  957. addIndex(getIndex(powH,0));
  958. addIndex(getIndex(0,nPow));
  959. addIndex(getIndex(nPow,0));
  960. addIndex(getIndex(nPow,nPow));
  961. x0 = nPow;
  962. }
  964. assert((numNewIndices&1) == 0);
  966. if(nRight)
  967. x1 -= nPow;
  969. for(int x=x0; x<x1; x+=nPow)
  970. {
  971. addIndex(getIndex(x,0));
  972. addLastIndexAgain(); // reverse oriented triangles
  973. addIndex(getIndex(x+powH,0));
  974. addIndex(getIndex(x,nPow));
  975. addIndex(getIndex(x+nPow,0));
  976. addIndex(getIndex(x+nPow,nPow));
  977. }
  979. assert((numNewIndices&1) == 0);
  981. if(nRight)
  982. {
  983. addIndex(getIndex(SOURCE_WIDTH-1-nPow,0));
  984. addIndex(getIndex(SOURCE_WIDTH-1-nPow,nPow));
  985. addIndex(getIndex(SOURCE_WIDTH-1-powH,0));
  986. addIndex(getIndex(SOURCE_WIDTH-1,0));
  987. addLastIndexAgain(); // finalize sub-strip
  988. addIndex(getIndex(SOURCE_WIDTH-1-nPow,nPow));
  989. addIndex(getIndex(SOURCE_WIDTH-1,powH));
  990. addIndex(getIndex(SOURCE_WIDTH-1,nPow));
  991. }
  994. assert((numNewIndices&1) == 0);
  995. }
  998. void afTerrainPatch::addTriangleTopRow(int nPow, bool nLeft, bool nRight)
  999. {
  1000. int powH = nPow/2;
  1001. int x0=0, x1=SOURCE_WIDTH-1;
  1003. assert(powH>=1);
  1005. if(nLeft)
  1006. {
  1007. addIndex(getIndex(0,SOURCE_HEIGHT-1-nPow));
  1008. addIndex(getIndex(0,SOURCE_HEIGHT-1-powH));
  1009. addIndex(getIndex(nPow,SOURCE_HEIGHT-1-nPow));
  1010. addIndex(getIndex(0,SOURCE_HEIGHT-1));
  1011. addIndex(getIndex(powH,SOURCE_HEIGHT-1));
  1012. addLastIndexAgain(); // reverse oriented triangles
  1013. addIndex(getIndex(nPow,SOURCE_HEIGHT-1-nPow));
  1014. addIndex(getIndex(nPow,SOURCE_HEIGHT-1));
  1015. x0 = nPow;
  1016. }
  1018. assert((numNewIndices&1) == 0);
  1020. if(nRight)
  1021. x1 -= nPow;
  1023. for(int x=x0; x<x1; x+=nPow)
  1024. {
  1025. addIndex(getIndex(x,SOURCE_HEIGHT-1-nPow));
  1026. addIndex(getIndex(x,SOURCE_HEIGHT-1));
  1027. addIndex(getIndex(x+nPow,SOURCE_HEIGHT-1-nPow));
  1028. addIndex(getIndex(x+powH,SOURCE_HEIGHT-1));
  1029. addIndex(getIndex(x+nPow,SOURCE_HEIGHT-1));
  1030. addLastIndexAgain(); // reverse oriented triangles
  1031. }
  1033. if(nRight)
  1034. {
  1035. addIndex(getIndex(x,SOURCE_HEIGHT-1-nPow));
  1036. addIndex(getIndex(x,SOURCE_HEIGHT-1));
  1037. addIndex(getIndex(x+nPow,SOURCE_HEIGHT-1-nPow));
  1038. addIndex(getIndex(x+powH,SOURCE_HEIGHT-1));
  1039. addIndex(getIndex(x+nPow,SOURCE_HEIGHT-1-powH));
  1040. addIndex(getIndex(x+nPow,SOURCE_HEIGHT-1));
  1041. }
  1042. }
  1045. void afTerrainPatch::addLevel4PatchTriangles(bool nLeft, bool nRight, bool nBottom, bool nTop)
  1046. {
  1047. const int powH = 8, pow = 16;
  1048. int code = (nLeft ? 1 : 0) | (nRight ? 2 : 0) | (nBottom ? 4 : 0) | (nTop ? 8 : 0);
  1050. // use the created code for fast selection of the case to build...
  1051. //
  1052. switch(code)
  1053. {
  1054. case 0:
  1055. addIndex(getIndex(0,0));
  1056. addIndex(getIndex(0,pow));
  1057. addIndex(getIndex(pow,0));
  1058. addIndex(getIndex(pow,pow));
  1059. break;
  1061. case 1:
  1062. addIndex(getIndex(0,0));
  1063. addIndex(getIndex(0,powH));
  1064. addIndex(getIndex(pow,0));
  1065. addIndex(getIndex(0,pow));
  1066. addIndex(getIndex(pow,pow));
  1067. addLastIndexAgain();
  1068. break;
  1070. case 2:
  1071. addIndex(getIndex(pow,pow));
  1072. addIndex(getIndex(pow,powH));
  1073. addIndex(getIndex(0,pow));
  1074. addIndex(getIndex(pow,0));
  1075. addIndex(getIndex(0,0));
  1076. addLastIndexAgain();
  1077. break;
  1079. case 3:
  1080. addIndex(getIndex(0,0));
  1081. addIndex(getIndex(0,powH));
  1082. addIndex(getIndex(pow,0));
  1083. addIndex(getIndex(0,pow));
  1084. addIndex(getIndex(pow,powH));
  1085. addIndex(getIndex(pow,pow));
  1086. break;
  1088. case 4:
  1089. addIndex(getIndex(0,0));
  1090. addLastIndexAgain();
  1091. addIndex(getIndex(powH,0));
  1092. addIndex(getIndex(0,pow));
  1093. addIndex(getIndex(pow,0));
  1094. addIndex(getIndex(pow,pow));
  1095. break;
  1097. case 5:
  1098. addIndex(getIndex(0,0));
  1099. addIndex(getIndex(0,powH));
  1100. addIndex(getIndex(powH,0));
  1101. addIndex(getIndex(0,pow));
  1102. addIndex(getIndex(pow,0));
  1103. addIndex(getIndex(pow,pow));
  1104. break;
  1106. case 6:
  1107. addIndex(getIndex(0,0));
  1108. addIndex(getIndex(0,pow));
  1109. addIndex(getIndex(powH,0));
  1110. addIndex(getIndex(pow,0));
  1111. addLastIndexAgain();
  1112. addIndex(getIndex(0,pow));
  1113. addIndex(getIndex(pow,powH));
  1114. addIndex(getIndex(pow,pow));
  1115. break;
  1117. case 7:
  1118. addIndex(getIndex(pow,pow));
  1119. addIndex(getIndex(pow,powH));
  1120. addIndex(getIndex(0,pow));
  1121. addIndex(getIndex(pow,0));
  1122. addIndex(getIndex(0,powH));
  1123. addIndex(getIndex(powH,0));
  1124. addIndex(getIndex(0,0));
  1125. addLastIndexAgain();
  1126. break;
  1128. case 8:
  1129. addIndex(getIndex(pow,pow));
  1130. addLastIndexAgain();
  1131. addIndex(getIndex(powH,pow));
  1132. addIndex(getIndex(pow,0));
  1133. addIndex(getIndex(0,pow));
  1134. addIndex(getIndex(0,0));
  1135. break;
  1137. case 9:
  1138. addIndex(getIndex(pow,pow));
  1139. addIndex(getIndex(pow,0));
  1140. addIndex(getIndex(powH,pow));
  1141. addIndex(getIndex(0,pow));
  1142. addLastIndexAgain();
  1143. addIndex(getIndex(pow,0));
  1144. addIndex(getIndex(0,powH));
  1145. addIndex(getIndex(0,0));
  1146. break;
  1148. case 10:
  1149. addIndex(getIndex(pow,pow));
  1150. addIndex(getIndex(pow,powH));
  1151. addIndex(getIndex(powH,pow));
  1152. addIndex(getIndex(pow,0));
  1153. addIndex(getIndex(0,pow));
  1154. addIndex(getIndex(0,0));
  1155. break;
  1157. case 11:
  1158. addIndex(getIndex(0,0));
  1159. addIndex(getIndex(0,powH));
  1160. addIndex(getIndex(pow,0));
  1161. addIndex(getIndex(0,pow));
  1162. addIndex(getIndex(pow,powH));
  1163. addIndex(getIndex(powH,pow));
  1164. addIndex(getIndex(pow,pow));
  1165. addLastIndexAgain();
  1166. break;
  1168. case 12:
  1169. addIndex(getIndex(0,0));
  1170. addLastIndexAgain();
  1171. addIndex(getIndex(powH,0));
  1172. addIndex(getIndex(0,pow));
  1173. addIndex(getIndex(pow,0));
  1174. addIndex(getIndex(powH,pow));
  1175. addIndex(getIndex(pow,pow));
  1176. addLastIndexAgain();
  1177. break;
  1179. case 13:
  1180. addIndex(getIndex(0,0));
  1181. addIndex(getIndex(0,powH));
  1182. addIndex(getIndex(powH,0));
  1183. addIndex(getIndex(0,pow));
  1184. addIndex(getIndex(pow,0));
  1185. addIndex(getIndex(powH,pow));
  1186. addIndex(getIndex(pow,pow));
  1187. addLastIndexAgain();
  1188. break;
  1190. case 14:
  1191. addIndex(getIndex(pow,pow));
  1192. addIndex(getIndex(pow,powH));
  1193. addIndex(getIndex(powH,pow));
  1194. addIndex(getIndex(pow,0));
  1195. addIndex(getIndex(0,pow));
  1196. addIndex(getIndex(powH,0));
  1197. addIndex(getIndex(0,0));
  1198. addLastIndexAgain();
  1199. break;
  1201. case 15:
  1202. addIndex(getIndex(0,0));
  1203. addIndex(getIndex(0,powH));
  1204. addIndex(getIndex(powH,0));
  1205. addIndex(getIndex(0,pow));
  1206. addIndex(getIndex(pow,0));
  1207. addIndex(getIndex(powH,pow));
  1208. addIndex(getIndex(pow,powH));
  1209. addIndex(getIndex(pow,pow));
  1210. break;
  1211. }
  1213. assert((numNewIndices&1) == 0); // indices must always be an even number (we store quads as two triangles)
  1214. }
  1217. inline float afTerrainPatch::getHeight(int nX, int nY) const
  1218. {
  1219. assert(nX>=0 && nX<SOURCE_WIDTH);
  1220. assert(nY>=0 && nY<SOURCE_HEIGHT);
  1221. assert(master);
  1223. return pos.y + scale.y * master->getHeight(hmX0+nX, hmY0+nY); // - scale.y*0.5f;
  1224. }
  1227. inline void afTerrainPatch::getVertex(int nX, int nY, afVec3& nPoint) const
  1228. {
  1229. assert(nX>=0 && nX<SOURCE_WIDTH);
  1230. assert(nY>=0 && nY<SOURCE_HEIGHT);
  1232. nPoint.x = pos.x+scale.x*nX / (float)(SOURCE_WIDTH-1);
  1233. nPoint.y = getHeight(nX,nY);
  1234. nPoint.z = pos.z+scale.z*nY / (float)(SOURCE_HEIGHT-1);
  1235. }
  1238. inline void afTerrainPatch::getTexCoord(int nX, int nY, afVec2& nTCoord) const
  1239. {
  1240. assert(nX>=0 && nX<SOURCE_WIDTH);
  1241. assert(nY>=0 && nY<SOURCE_HEIGHT);
  1242. assert(master);
  1244. master->getTexCoord(hmX0+nX, hmY0+nY, nTCoord);
  1245. }
  1248. inline void afTerrainPatch::getNormal(int nX, int nY, afVec3& nNormal) const
  1249. {
  1250. assert(nX>=0 && nX<SOURCE_WIDTH);
  1251. assert(nY>=0 && nY<SOURCE_HEIGHT);
  1252. assert(master);
  1254. master->getNormal(hmX0+nX, hmY0+nY, nNormal);
  1255. }
  1258. unsigned short afTerrainPatch::getIndex(int nX, int nY)
  1259. {
  1260. int idx = nX + nY * SOURCE_WIDTH;
  1262. assert(nX>=0 && nX<SOURCE_WIDTH);
  1263. assert(nY>=0 && nY<SOURCE_HEIGHT);
  1264. assert(idx<MAX_VERTICES);
  1266. if(indexMap[idx]==0xffff)
  1267. {
  1268. indexMap[idx] = (unsigned short)numNewVertices;
  1270. getVertex(nX,nY, vertices[numNewVertices].pos);
  1271. getTexCoord(nX,nY, vertices[numNewVertices].tex);
  1273. numNewVertices++;
  1274. }
  1276. return indexMap[idx];
  1277. }
  1280. int afTerrainPatch::getNewTessellationSafe() const
  1281. {
  1282. if(this==NULL)
  1283. return MAX_SUBDIV;
  1285. if(!isVisible())
  1286. return  selfTes; // MAX_SUBDIV;
  1288. return getNewTessellation();
  1289. }
  1293. void afTerrainPatch::fillMorphVertices()
  1294. {
  1295. if(forceBufferCreate || forceRetessellation)
  1296. {
  1297. memcpy(verticesLow, vertices, numNewVertices*sizeof(PATCHVERTEX));
  1299. if(realSelfTes<4)
  1300. {
  1301. reduceShapeTo(realSelfTes+1, verticesLow);
  1302. makeBordersSimpler(verticesLow);
  1303. }
  1305. //if(selfTes==realSelfTes+1)
  1306. // memcpy(verticesLow, vertices, numNewVertices*sizeof(PATCHVERTEX));
  1308. for(int i=0; i<numNewVertices; i++)
  1309. yMoveSelf[i] = vertices[i].pos.y - verticesLow[i].pos.y;
  1310. }
  1311. }
  1314. void afTerrainPatch::checkBorderLeft()
  1315. {
  1316. int i, y,yc, pow;
  1318. if(forceBufferCreate || forceRetessellation || followsLeft!=newFollowsLeft)
  1319. {
  1320. for(i=0; i<numNewVertices; i++)
  1321. yMoveLeft[i] = 0.0f;
  1323. for(i=0; i<numNewVertices; i++)
  1324. yMoveLeft2[i] = 0.0f;
  1325. }
  1328. if(newFollowsLeft && (!followsLeft || forceBufferCreate || forceRetessellation || recalcBorderLeft))
  1329. {
  1330. // copy shared border column
  1331. //
  1332. assert(selfTes==left->rightTes);
  1333. assert(leftTes==left->selfTes);
  1334. assert(left->indexMap);
  1336. pow = getPowerTwo(min(selfTes,leftTes));
  1338. for(y=pow; y<SOURCE_HEIGHT-1; y+=pow)
  1339. {
  1340. int idx = indexMap[0 + y * SOURCE_WIDTH],
  1341. idxL = left->indexMap[SOURCE_WIDTH-1 + y * SOURCE_WIDTH];
  1342. assert(idx!=0xffff);
  1343. assert(idxL!=0xffff);
  1345. verticesLow[idx].pos.y = left->verticesLow[idxL].pos.y;
  1346. vertices[idx].pos.y = left->vertices[idxL].pos.y;
  1347. yMoveLeft[idx] = left->yMoveSelf[idxL];
  1348. yMoveSelf[idx] = 0.0f;
  1349. }
  1352. if(selfTes>=3)
  1353. return;
  1355. // correct border neighbors
  1356. //
  1357. pow = getPowerTwo(selfTes);
  1359. for(y=pow,yc=1; y<SOURCE_HEIGHT-1; y+=pow,yc++)
  1360. {
  1361. float yLT=0.0f,yRB=0.0f;
  1362. int idx, idxLT=0,idxRB=0;
  1364. idx = calculateDiagonalVertices(pow, y, 1, yc, pow, verticesLow, yLT,idxLT, yRB,idxRB);
  1365. assert(idx>=0 && idx!=0xffff);
  1367. float moveLT = vertices[idxLT].pos.y - verticesLow[idxLT].pos.y;
  1369. verticesLow[idx].pos.y = (yLT + yRB) / 2.0f;
  1371. // our vertex is moved 50% by the left (-top) neighbor
  1372. // this garanties that this vertex is on the diagonal when currentError is 0.0f
  1373. yMoveLeft2[idx] = moveLT * 0.5f;
  1375. yMoveSelf[idx] = vertices[idx].pos.y - verticesLow[idx].pos.y;
  1376. }
  1379. // correct neighbors to lie on a diagonal
  1380. //
  1381. if(selfTes!=realSelfTes)
  1382. {
  1383. pow = getPowerTwo(selfTes);
  1385. for(y=pow,yc=1; y<SOURCE_HEIGHT-1; y+=pow,yc++)
  1386. {
  1387. float yLT=0.0f,yRB=0.0f;
  1388. int idx, idxLT=0,idxRB=0;
  1390. idx = calculateDiagonalVertices(pow, y, 1, yc, pow, verticesLow, yLT,idxLT, yRB,idxRB);
  1391. assert(idx>=0 && idx!=0xffff);
  1393. verticesLow[idx].pos.y = (yLT + yRB) * 0.5f;
  1394. vertices[idx].pos.y = (vertices[idxLT].pos.y + vertices[idxRB].pos.y) * 0.5f;
  1396. // the real new part: this vertex always STAYS on the diagonal
  1397. //
  1398. yMoveLeft2[idx] = 0.0f;
  1399. yMoveLeft[idx] = (vertices[idxLT].pos.y - verticesLow[idxLT].pos.y) * 0.5f;
  1400. yMoveSelf[idx] = (vertices[idxRB].pos.y - verticesLow[idxRB].pos.y) * 0.5f;
  1401. }
  1403. // necessary to recorrect the shared right-top border neighbor
  1404. //
  1405. if(followsBottom)
  1406. recalcBorderBottom = true;
  1407. }
  1408. }
  1409. }
  1412. void afTerrainPatch::checkBorderRight()
  1413. {
  1414. int i, y,yc, pow, xcMax;
  1416. if(forceBufferCreate || forceRetessellation || followsRight!=newFollowsRight)
  1417. {
  1418. for(i=0; i<numNewVertices; i++)
  1419. yMoveRight[i] = 0.0f;
  1421. for(i=0; i<numNewVertices; i++)
  1422. yMoveRight2[i] = 0.0f;
  1423. }
  1425. if(newFollowsRight && (!followsRight || forceBufferCreate || forceRetessellation || recalcBorderRight))
  1426. {
  1427. // copy shared border column
  1428. //
  1429. assert(selfTes==right->leftTes);
  1430. assert(rightTes==right->selfTes);
  1431. assert(right->indexMap);
  1433. pow = getPowerTwo(min(selfTes,rightTes));
  1435. for(y=pow; y<SOURCE_HEIGHT-1; y+=pow)
  1436. {
  1437. int idx = indexMap[SOURCE_WIDTH-1 + y * SOURCE_WIDTH],
  1438. idxR = right->indexMap[0 + y * SOURCE_WIDTH];
  1439. assert(idx!=0xffff);
  1440. assert(idxR!=0xffff);
  1442. verticesLow[idx].pos.y = right->verticesLow[idxR].pos.y;
  1443. vertices[idx].pos.y = right->vertices[idxR].pos.y;
  1444. yMoveRight[idx] = right->yMoveSelf[idxR];
  1445. yMoveSelf[idx] = 0.0f;
  1446. }
  1449. // correct border neighbors
  1450. //
  1451. if(realSelfTes<3)
  1452. {
  1453. pow = getPowerTwo(realSelfTes);
  1454. xcMax = (SOURCE_WIDTH-1-pow)/pow;
  1456. for(y=pow,yc=1; y<SOURCE_HEIGHT-1; y+=pow,yc++)
  1457. {
  1458. float yLT=0.0f,yRB=0.0f;
  1459. int idx, idxLT=0,idxRB=0;
  1461. idx = calculateDiagonalVertices(SOURCE_WIDTH-1-pow, y, xcMax, yc, pow, verticesLow, yLT,idxLT, yRB,idxRB);
  1462. assert(idx>=0 && idx!=0xffff);
  1464. verticesLow[idx].pos.y = (yLT + yRB) * 0.5f;
  1466. // our vertex is moved 50% by the right (-bottom) neighbor
  1467. // this garanties that this vertex is on the diagonal when currentError is 0.0f
  1468. yMoveRight2[idx] = (vertices[idxRB].pos.y - verticesLow[idxRB].pos.y) * 0.5f;
  1470. yMoveSelf[idx] = vertices[idx].pos.y - verticesLow[idx].pos.y;
  1471. }
  1472. }
  1475. // correct neighbors to lie on a diagonal
  1476. //
  1477. if(selfTes!=realSelfTes)
  1478. {
  1479. pow = getPowerTwo(selfTes);
  1480. xcMax = (SOURCE_WIDTH-1-pow)/pow;
  1482. for(y=pow,yc=1; y<SOURCE_HEIGHT-1; y+=pow,yc++)
  1483. {
  1484. float yLT=0.0f,yRB=0.0f;
  1485. int idx, idxLT=0,idxRB=0;
  1487. idx = calculateDiagonalVertices(SOURCE_WIDTH-1-pow, y, xcMax, yc, pow, verticesLow, yLT,idxLT, yRB,idxRB);
  1488. assert(idx>=0 && idx!=0xffff);
  1490. verticesLow[idx].pos.y = (yLT + yRB) * 0.5f;
  1491. vertices[idx].pos.y = (vertices[idxLT].pos.y + vertices[idxRB].pos.y) * 0.5f;
  1493. // the real new part: this vertex always STAYS on the diagonal
  1494. //
  1495. yMoveRight2[idx] = 0.0f;
  1496. yMoveRight[idx] = (vertices[idxRB].pos.y - verticesLow[idxRB].pos.y) * 0.5f;
  1497. yMoveSelf[idx] = (vertices[idxLT].pos.y - verticesLow[idxLT].pos.y) * 0.5f;
  1498. }
  1500. // necessary to recorrect the shared right-top border neighbor
  1501. //
  1502. if(followsTop)
  1503. recalcBorderTop = true;
  1504. }
  1505. }
  1506. }
  1508. void afTerrainPatch::checkBorderBottom()
  1509. {
  1510. int i, x,xc, pow;
  1512. if(forceBufferCreate || forceRetessellation || followsBottom!=newFollowsBottom)
  1513. {
  1514. for(i=0; i<numNewVertices; i++)
  1515. yMoveBottom[i] = 0.0f;
  1517. for(i=0; i<numNewVertices; i++)
  1518. yMoveBottom2[i] = 0.0f;
  1519. }
  1522. if(newFollowsBottom && (!followsBottom || forceBufferCreate || forceRetessellation || recalcBorderBottom))
  1523. {
  1524. // copy shared border column
  1525. //
  1526. assert(selfTes==bottom->topTes);
  1527. assert(bottomTes==bottom->selfTes);
  1528. assert(bottom->indexMap);
  1530. pow = getPowerTwo(min(selfTes,bottomTes));
  1532. for(x=pow; x<SOURCE_WIDTH-1; x+=pow)
  1533. {
  1534. int idx = indexMap[x + 0 * SOURCE_WIDTH],
  1535. idxB = bottom->indexMap[x + (SOURCE_WIDTH-1) * SOURCE_WIDTH];
  1536. assert(idx!=0xffff);
  1537. assert(idxB!=0xffff);
  1539. verticesLow[idx].pos.y = bottom->verticesLow[idxB].pos.y;
  1540. vertices[idx].pos.y = bottom->vertices[idxB].pos.y;
  1541. yMoveBottom[idx] = bottom->yMoveSelf[idxB];
  1542. yMoveSelf[idx] = 0.0f;
  1543. }
  1546. if(selfTes>=3)
  1547. return;
  1549. // correct border neighbors
  1550. //
  1551. pow = getPowerTwo(selfTes);
  1553. for(x=pow,xc=1; x<SOURCE_WIDTH-1; x+=pow,xc++)
  1554. {
  1555. float yLT=0.0f,yRB=0.0f;
  1556. int idx, idxLT=0,idxRB=0;
  1558. idx = calculateDiagonalVertices(x, pow, xc, 1, pow, verticesLow, yLT,idxLT, yRB,idxRB);
  1559. assert(idx>=0 && idx!=0xffff);
  1561. float moveRB = vertices[idxRB].pos.y - verticesLow[idxRB].pos.y;
  1563. verticesLow[idx].pos.y = (yLT + yRB) / 2.0f;
  1565. // our vertex is moved 50% by the right (-bottom) neighbor
  1566. // this garanties that this vertex is on the diagonal when currentError is 0.0f
  1567. yMoveBottom2[idx] = moveRB * 0.5f;
  1569. yMoveSelf[idx] = vertices[idx].pos.y - verticesLow[idx].pos.y;
  1570. }
  1573. // correct neighbors to lie on a diagonal
  1574. //
  1575. if(selfTes!=realSelfTes)
  1576. {
  1577. pow = getPowerTwo(selfTes);
  1579. for(x=pow,xc=1; x<SOURCE_WIDTH-1; x+=pow,xc++)
  1580. {
  1581. float yLT=0.0f,yRB=0.0f;
  1582. int idx, idxLT=0,idxRB=0;
  1584. idx = calculateDiagonalVertices(x, pow, xc, 1, pow, verticesLow, yLT,idxLT, yRB,idxRB);
  1585. assert(idx>=0 && idx!=0xffff);
  1587. verticesLow[idx].pos.y = (yLT + yRB) * 0.5f;
  1588. vertices[idx].pos.y = (vertices[idxLT].pos.y + vertices[idxRB].pos.y) * 0.5f;
  1590. // the real new part: this vertex always STAYS on the diagonal
  1591. //
  1592. yMoveBottom2[idx] = 0.0f;
  1593. yMoveBottom[idx] = (vertices[idxRB].pos.y - verticesLow[idxRB].pos.y) * 0.5f;
  1595. if(yMoveLeft[idx]==0.0f)
  1596. yMoveSelf[idx] = (vertices[idxLT].pos.y - verticesLow[idxLT].pos.y) * 0.5f;
  1597. else
  1598. yMoveSelf[idx] = 0.0f;
  1599. }
  1600. }
  1601. }
  1602. }
  1605. void afTerrainPatch::checkBorderTop()
  1606. {
  1607. int i, x,xc, pow, ycMax;
  1609. if(forceBufferCreate || forceRetessellation || followsTop!=newFollowsTop)
  1610. {
  1611. for(i=0; i<numNewVertices; i++)
  1612. yMoveTop[i] = 0.0f;
  1614. for(i=0; i<numNewVertices; i++)
  1615. yMoveTop2[i] = 0.0f;
  1616. }
  1618. if(newFollowsTop && (!followsTop || forceBufferCreate || forceRetessellation || recalcBorderTop))
  1619. {
  1620. // copy shared border column
  1621. //
  1622. assert(selfTes==top->bottomTes);
  1623. assert(topTes==top->selfTes);
  1624. assert(top->indexMap);
  1626. pow = getPowerTwo(min(selfTes,topTes));
  1628. for(x=pow; x<SOURCE_WIDTH-1; x+=pow)
  1629. {
  1630. int idx = indexMap[x + (SOURCE_HEIGHT-1) * SOURCE_WIDTH],
  1631. idxT = top->indexMap[x + 0 * SOURCE_WIDTH];
  1632. assert(idx!=0xffff);
  1633. assert(idxT!=0xffff);
  1635. verticesLow[idx].pos.y = top->verticesLow[idxT].pos.y;
  1636. vertices[idx].pos.y = top->vertices[idxT].pos.y;
  1637. yMoveTop[idx] = top->yMoveSelf[idxT];
  1638. yMoveSelf[idx] = 0.0f;
  1639. }
  1642. if(selfTes>=3)
  1643. return;
  1645. // correct border neighbors
  1646. //
  1647. pow = getPowerTwo(selfTes);
  1648. ycMax = (SOURCE_WIDTH-1-pow)/pow;
  1650. for(x=pow,xc=1; x<SOURCE_WIDTH-1; x+=pow,xc++)
  1651. {
  1652. float yLT=0.0f,yRB=0.0f;
  1653. int idx, idxLT=0,idxRB=0;
  1655. idx = calculateDiagonalVertices(x, SOURCE_HEIGHT-1-pow, xc, ycMax, pow, verticesLow, yLT,idxLT, yRB,idxRB);
  1656. assert(idx>=0 && idx!=0xffff);
  1658. float moveLT = vertices[idxLT].pos.y - verticesLow[idxLT].pos.y;
  1660. verticesLow[idx].pos.y = (yLT + yRB) / 2.0f;
  1662. // our vertex is moved 50% by the left (-top) neighbor
  1663. // this garanties that this vertex is on the diagonal when currentError is 0.0f
  1664. yMoveTop2[idx] = moveLT * 0.5f;
  1666. yMoveSelf[idx] = vertices[idx].pos.y - verticesLow[idx].pos.y;
  1667. }
  1670. // correct neighbors to lie on a diagonal
  1671. //
  1672. if(selfTes!=realSelfTes)
  1673. {
  1674. pow = getPowerTwo(selfTes);
  1675. ycMax = (SOURCE_WIDTH-1-pow)/pow;
  1677. for(x=pow,xc=1; x<SOURCE_WIDTH-1; x+=pow,xc++)
  1678. {
  1679. float yLT=0.0f,yRB=0.0f;
  1680. int idx, idxLT=0,idxRB=0;
  1682. idx = calculateDiagonalVertices(x, SOURCE_HEIGHT-1-pow, xc, ycMax, pow, verticesLow, yLT,idxLT, yRB,idxRB);
  1683. assert(idx>=0 && idx!=0xffff);
  1685. verticesLow[idx].pos.y = (yLT + yRB) * 0.5f;
  1686. vertices[idx].pos.y = (vertices[idxLT].pos.y + vertices[idxRB].pos.y) * 0.5f;
  1688. // the real new part: this vertex always STAYS on the diagonal
  1689. //
  1690. yMoveTop2[idx] = 0.0f;
  1691. yMoveTop[idx] = (vertices[idxLT].pos.y - verticesLow[idxLT].pos.y) * 0.5f;
  1693. if(yMoveRight[idx]==0.0f)
  1694. yMoveSelf[idx] = (vertices[idxRB].pos.y - verticesLow[idxRB].pos.y) * 0.5f;
  1695. else
  1696. yMoveSelf[idx] = 0.0f;
  1698. }
  1699. }
  1700. }
  1701. }
  1704. bool afTerrainPatch::fillBuffers()
  1705. {
  1706. if(master->getMergePatches() && selfTes==4)
  1707. {
  1708. numIndices = numNewIndices;
  1709. numVertices = numNewVertices;
  1710. forceBufferCreate = false;
  1711. return true;
  1712. }
  1714. if(!forceBufferCreate && !forceRetessellation &&
  1715. followsLeft==newFollowsLeft && !recalcBorderLeft &&
  1716. followsRight==newFollowsRight && !recalcBorderRight &&
  1717. followsBottom==newFollowsBottom && !recalcBorderBottom &&
  1718. followsTop==newFollowsTop && !recalcBorderTop)
  1719. return true;
  1721. if(!checkBuffers())
  1722. return false;
  1724. if(numVertices==0 || numIndices==0) // nothing to do ???
  1725. return true;
  1727. int i;
  1729. //if(forceBufferCreate)
  1730. master->addBufferCreateCount();
  1732. // fill vertex buffer
  1733. //
  1734. PATCHVERTEX_MORPH_HW* pVertices = NULL;
  1735. vBuffer->Lock(0, 0, (void**)&pVertices, D3DLOCK_NOSYSLOCK|D3DLOCK_DISCARD);
  1737. for(i=0; i<numVertices; i++)
  1738. {
  1739. pVertices[i].posX = vertices[i].pos.x;
  1740. pVertices[i].posZ = vertices[i].pos.z;
  1741. pVertices[i].texX = vertices[i].tex.x;
  1742. pVertices[i].texY = vertices[i].tex.y;
  1744. pVertices[i].posY = verticesLow[i].pos.y;
  1745. pVertices[i].yMoveSelf = yMoveSelf[i];
  1746. pVertices[i].v0 = 0.0f,
  1747. pVertices[i].v1 = 1.0f,
  1748. pVertices[i].yMoveLeft = yMoveLeft[i];
  1749. pVertices[i].yMoveLeft2 = yMoveLeft2[i];
  1750. pVertices[i].yMoveRight = yMoveRight[i];
  1751. pVertices[i].yMoveRight2 = yMoveRight2[i];
  1752. pVertices[i].yMoveBottom = yMoveBottom[i];
  1753. pVertices[i].yMoveBottom2 = yMoveBottom2[i];
  1754. pVertices[i].yMoveTop = yMoveTop[i];
  1755. pVertices[i].yMoveTop2 = yMoveTop2[i];
  1756. }
  1757. vBuffer->Unlock();
  1760. // fill index buffer
  1761. //
  1762. WORD* pIndices = NULL;
  1764. iBuffer->Lock(0, 0, (void**)&pIndices, D3DLOCK_NOSYSLOCK|D3DLOCK_DISCARD);
  1765. for(i=0; i<numIndices; i++)
  1766. {
  1767. pIndices[i] = indices[i];
  1768. //pgLog::trace("%d: %dn", i, indices[i]);
  1769. }
  1770. iBuffer->Unlock();
  1773. //pgLog::trace("patch buffers (%d|%d) filledn", gridX,gridY);
  1774. return true;
  1775. }
  1778. bool afTerrainPatch::checkBuffers()
  1779. {
  1780. // create new buffers if the size changed
  1781. //
  1782. if(numIndices<numNewIndices || forceBufferCreate)
  1783. {
  1784. numIndices = numNewIndices;
  1785. SAFE_RELEASE(iBuffer)
  1787. if(numIndices>0)
  1788. if(FAILED(pd3dDevice->CreateIndexBuffer(numIndices * sizeof(WORD), D3DUSAGE_WRITEONLY|D3DUSAGE_DYNAMIC,
  1789. D3DFMT_INDEX16, D3DPOOL_DEFAULT, &iBuffer,NULL)))
  1790. {
  1791. afLog::error("creating index buffer for terrainpatch failed");
  1792. return false;
  1793. }
  1795. //pgLog::trace("index-buffer (%d|%d) recreatedn", gridX,gridY);
  1796. }
  1799. if(numVertices<numNewVertices  || forceBufferCreate)
  1800. {
  1801. numVertices = numNewVertices;
  1802. SAFE_RELEASE(vBuffer)
  1804. if(numVertices>0)
  1805. if(FAILED(pd3dDevice->CreateVertexBuffer(numVertices * sizeof(PATCHVERTEX_MORPH_HW), D3DUSAGE_WRITEONLY|D3DUSAGE_DYNAMIC,
  1806.  0, D3DPOOL_DEFAULT, &vBuffer,NULL)))
  1807. {
  1808. afLog::error("creating base vertex buffer for terrainpatch failed");
  1809. SAFE_RELEASE(iBuffer);
  1810. return false;
  1811. }
  1812. }
  1814. forceBufferCreate = false;
  1815. return true;
  1816. }