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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 游戏引擎 > 查看源码
llsurfacepatch.cpp
资源名称：snowglobe-src-viewer-2.0.0-r0.tar.gz　[点击查看]
上传用户：king477883
上传日期：2021-03-01
资源大小：9553k
文件大小：25k
源码类别：

游戏引擎

开发平台：

C++ Builder

llsurfacepatch.cpp：源码内容
  1. /** 
  2.  * @file llsurfacepatch.cpp
  3.  * @brief LLSurfacePatch class implementation
  4.  *
  5.  * $LicenseInfo:firstyear=2001&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2001-2010, Linden Research, Inc.
  8.  * 
  9.  * Second Life Viewer Source Code
  10.  * The source code in this file ("Source Code") is provided by Linden Lab
  11.  * to you under the terms of the GNU General Public License, version 2.0
  12.  * ("GPL"), unless you have obtained a separate licensing agreement
  13.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  14.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  15.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  16.  * 
  17.  * There are special exceptions to the terms and conditions of the GPL as
  18.  * it is applied to this Source Code. View the full text of the exception
  19.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  20.  * online at
  21.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  22.  * 
  23.  * By copying, modifying or distributing this software, you acknowledge
  24.  * that you have read and understood your obligations described above,
  25.  * and agree to abide by those obligations.
  26.  * 
  27.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  28.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  29.  * COMPLETENESS OR PERFORMANCE.
  30.  * $/LicenseInfo$
  31.  */
  33. #include "llviewerprecompiledheaders.h"
  35. #include "llsurfacepatch.h"
  36. #include "llpatchvertexarray.h"
  37. #include "llviewerobjectlist.h"
  38. #include "llvosurfacepatch.h"
  39. #include "llsurface.h"
  40. #include "pipeline.h"
  41. #include "llagent.h"
  42. #include "timing.h"
  43. #include "llsky.h"
  44. #include "llviewercamera.h"
  46. // For getting composition values
  47. #include "llviewerregion.h"
  48. #include "llvlcomposition.h"
  49. #include "lldrawpool.h"
  50. #include "noise.h"
  52. extern U64 gFrameTime;
  53. extern LLPipeline gPipeline;
  55. LLSurfacePatch::LLSurfacePatch() :
  56. mHasReceivedData(FALSE),
  57. mSTexUpdate(FALSE),
  58. mDirty(FALSE),
  59. mDirtyZStats(TRUE),
  60. mHeightsGenerated(FALSE),
  61. mDataOffset(0),
  62. mDataZ(NULL),
  63. mDataNorm(NULL),
  64. mVObjp(NULL),
  65. mOriginRegion(0.f, 0.f, 0.f),
  66. mCenterRegion(0.f, 0.f, 0.f),
  67. mMinZ(0.f),
  68. mMaxZ(0.f),
  69. mMeanZ(0.f),
  70. mRadius(0.f),
  71. mMinComposition(0.f),
  72. mMaxComposition(0.f),
  73. mMeanComposition(0.f),
  74. // This flag is used to communicate between adjacent surfaces and is
  75. // set to non-zero values by higher classes.  
  76. mConnectedEdge(NO_EDGE),
  77. mLastUpdateTime(0),
  78. mSurfacep(NULL)
  79. {
  80. S32 i;
  81. for (i = 0; i < 8; i++)
  82. {
  83. setNeighborPatch(i, NULL);
  84. }
  85. for (i = 0; i < 9; i++)
  86. {
  87. mNormalsInvalid[i] = TRUE;
  88. }
  89. }
  92. LLSurfacePatch::~LLSurfacePatch()
  93. {
  94. mVObjp = NULL;
  95. }
  98. void LLSurfacePatch::dirty()
  99. {
  100. // These are outside of the loop in case we're still waiting for a dirty from the
  101. // texture being updated...
  102. if (mVObjp)
  103. {
  104. mVObjp->dirtyGeom();
  105. }
  106. else
  107. {
  108. llwarns << "No viewer object for this surface patch!" << llendl;
  109. }
  111. mDirtyZStats = TRUE;
  112. mHeightsGenerated = FALSE;
  114. if (!mDirty)
  115. {
  116. mDirty = TRUE;
  117. mSurfacep->dirtySurfacePatch(this);
  118. }
  119. }
  122. void LLSurfacePatch::setSurface(LLSurface *surfacep)
  123. {
  124. mSurfacep = surfacep;
  125. if (mVObjp == (LLVOSurfacePatch *)NULL)
  126. {
  127. llassert(mSurfacep->mType == 'l');
  129. mVObjp = (LLVOSurfacePatch *)gObjectList.createObjectViewer(LLViewerObject::LL_VO_SURFACE_PATCH, mSurfacep->getRegion());
  130. mVObjp->setPatch(this);
  131. mVObjp->setPositionRegion(mCenterRegion);
  132. gPipeline.createObject(mVObjp);
  133. }
  134. } 
  136. void LLSurfacePatch::disconnectNeighbor(LLSurface *surfacep)
  137. {
  138. U32 i;
  139. for (i = 0; i < 8; i++)
  140. {
  141. if (getNeighborPatch(i))
  142. {
  143. if (getNeighborPatch(i)->mSurfacep == surfacep)
  144. {
  145. setNeighborPatch(i, NULL);
  146. mNormalsInvalid[i] = TRUE;
  147. }
  148. }
  149. }
  151. // Clean up connected edges
  152. if (getNeighborPatch(EAST))
  153. {
  154. if (getNeighborPatch(EAST)->mSurfacep == surfacep)
  155. {
  156. mConnectedEdge &= ~EAST_EDGE;
  157. }
  158. }
  159. if (getNeighborPatch(NORTH))
  160. {
  161. if (getNeighborPatch(NORTH)->mSurfacep == surfacep)
  162. {
  163. mConnectedEdge &= ~NORTH_EDGE;
  164. }
  165. }
  166. if (getNeighborPatch(WEST))
  167. {
  168. if (getNeighborPatch(WEST)->mSurfacep == surfacep)
  169. {
  170. mConnectedEdge &= ~WEST_EDGE;
  171. }
  172. }
  173. if (getNeighborPatch(SOUTH))
  174. {
  175. if (getNeighborPatch(SOUTH)->mSurfacep == surfacep)
  176. {
  177. mConnectedEdge &= ~SOUTH_EDGE;
  178. }
  179. }
  180. }
  182. LLVector3 LLSurfacePatch::getPointAgent(const U32 x, const U32 y) const
  183. {
  184. U32 surface_stride = mSurfacep->getGridsPerEdge();
  185. U32 point_offset = x + y*surface_stride;
  186. LLVector3 pos;
  187. pos = getOriginAgent();
  188. pos.mV[VX] += x * mSurfacep->getMetersPerGrid();
  189. pos.mV[VY] += y * mSurfacep->getMetersPerGrid();
  190. pos.mV[VZ] = *(mDataZ + point_offset);
  191. return pos;
  192. }
  194. LLVector2 LLSurfacePatch::getTexCoords(const U32 x, const U32 y) const
  195. {
  196. U32 surface_stride = mSurfacep->getGridsPerEdge();
  197. U32 point_offset = x + y*surface_stride;
  198. LLVector3 pos, rel_pos;
  199. pos = getOriginAgent();
  200. pos.mV[VX] += x * mSurfacep->getMetersPerGrid();
  201. pos.mV[VY] += y * mSurfacep->getMetersPerGrid();
  202. pos.mV[VZ] = *(mDataZ + point_offset);
  203. rel_pos = pos - mSurfacep->getOriginAgent();
  204. rel_pos *= 1.f/surface_stride;
  205. return LLVector2(rel_pos.mV[VX], rel_pos.mV[VY]);
  206. }
  209. void LLSurfacePatch::eval(const U32 x, const U32 y, const U32 stride, LLVector3 *vertex, LLVector3 *normal,
  210.   LLVector2 *tex0, LLVector2 *tex1)
  211. {
  212. if (!mSurfacep || !mSurfacep->getRegion() || !mSurfacep->getGridsPerEdge())
  213. {
  214. return; // failsafe
  215. }
  216. llassert_always(vertex && normal && tex0 && tex1);
  218. U32 surface_stride = mSurfacep->getGridsPerEdge();
  219. U32 point_offset = x + y*surface_stride;
  221. *normal = getNormal(x, y);
  223. LLVector3 pos_agent = getOriginAgent();
  224. pos_agent.mV[VX] += x * mSurfacep->getMetersPerGrid();
  225. pos_agent.mV[VY] += y * mSurfacep->getMetersPerGrid();
  226. pos_agent.mV[VZ]  = *(mDataZ + point_offset);
  227. *vertex     = pos_agent;
  229. LLVector3 rel_pos = pos_agent - mSurfacep->getOriginAgent();
  230. LLVector3 tex_pos = rel_pos * (1.f/surface_stride);
  231. tex0->mV[0]  = tex_pos.mV[0];
  232. tex0->mV[1]  = tex_pos.mV[1];
  233. tex1->mV[0] = mSurfacep->getRegion()->getCompositionXY(llfloor(mOriginRegion.mV[0])+x, llfloor(mOriginRegion.mV[1])+y);
  235. const F32 xyScale = 4.9215f*7.f; //0.93284f;
  236. const F32 xyScaleInv = (1.f / xyScale)*(0.2222222222f);
  238. F32 vec[3] = {
  239. fmod((F32)(mOriginGlobal.mdV[0] + x)*xyScaleInv, 256.f),
  240. fmod((F32)(mOriginGlobal.mdV[1] + y)*xyScaleInv, 256.f),
  241. 0.f
  242. };
  243. F32 rand_val = llclamp(noise2(vec)* 0.75f + 0.5f, 0.f, 1.f);
  244. tex1->mV[1] = rand_val;
  247. }
  250. void LLSurfacePatch::calcNormal(const U32 x, const U32 y, const U32 stride)
  251. {
  252. U32 patch_width = mSurfacep->mPVArray.mPatchWidth;
  253. U32 surface_stride = mSurfacep->getGridsPerEdge();
  255. const F32 mpg = mSurfacep->getMetersPerGrid() * stride;
  257. S32 poffsets[2][2][2];
  258. poffsets[0][0][0] = x - stride;
  259. poffsets[0][0][1] = y - stride;
  261. poffsets[0][1][0] = x - stride;
  262. poffsets[0][1][1] = y + stride;
  264. poffsets[1][0][0] = x + stride;
  265. poffsets[1][0][1] = y - stride;
  267. poffsets[1][1][0] = x + stride;
  268. poffsets[1][1][1] = y + stride;
  270. const LLSurfacePatch *ppatches[2][2];
  272. // LLVector3 p1, p2, p3, p4;
  274. ppatches[0][0] = this;
  275. ppatches[0][1] = this;
  276. ppatches[1][0] = this;
  277. ppatches[1][1] = this;
  279. U32 i, j;
  280. for (i = 0; i < 2; i++)
  281. {
  282. for (j = 0; j < 2; j++)
  283. {
  284. if (poffsets[i][j][0] < 0)
  285. {
  286. if (!ppatches[i][j]->getNeighborPatch(WEST))
  287. {
  288. poffsets[i][j][0] = 0;
  289. }
  290. else
  291. {
  292. poffsets[i][j][0] += patch_width;
  293. ppatches[i][j] = ppatches[i][j]->getNeighborPatch(WEST);
  294. }
  295. }
  296. if (poffsets[i][j][1] < 0)
  297. {
  298. if (!ppatches[i][j]->getNeighborPatch(SOUTH))
  299. {
  300. poffsets[i][j][1] = 0;
  301. }
  302. else
  303. {
  304. poffsets[i][j][1] += patch_width;
  305. ppatches[i][j] = ppatches[i][j]->getNeighborPatch(SOUTH);
  306. }
  307. }
  308. if (poffsets[i][j][0] >= (S32)patch_width)
  309. {
  310. if (!ppatches[i][j]->getNeighborPatch(EAST))
  311. {
  312. poffsets[i][j][0] = patch_width - 1;
  313. }
  314. else
  315. {
  316. poffsets[i][j][0] -= patch_width;
  317. ppatches[i][j] = ppatches[i][j]->getNeighborPatch(EAST);
  318. }
  319. }
  320. if (poffsets[i][j][1] >= (S32)patch_width)
  321. {
  322. if (!ppatches[i][j]->getNeighborPatch(NORTH))
  323. {
  324. poffsets[i][j][1] = patch_width - 1;
  325. }
  326. else
  327. {
  328. poffsets[i][j][1] -= patch_width;
  329. ppatches[i][j] = ppatches[i][j]->getNeighborPatch(NORTH);
  330. }
  331. }
  332. }
  333. }
  335. LLVector3 p00(-mpg,-mpg,
  336.   *(ppatches[0][0]->mDataZ
  337.   + poffsets[0][0][0]
  338.   + poffsets[0][0][1]*surface_stride));
  339. LLVector3 p01(-mpg,+mpg,
  340.   *(ppatches[0][1]->mDataZ
  341.   + poffsets[0][1][0]
  342.   + poffsets[0][1][1]*surface_stride));
  343. LLVector3 p10(+mpg,-mpg,
  344.   *(ppatches[1][0]->mDataZ
  345.   + poffsets[1][0][0]
  346.   + poffsets[1][0][1]*surface_stride));
  347. LLVector3 p11(+mpg,+mpg,
  348.   *(ppatches[1][1]->mDataZ
  349.   + poffsets[1][1][0]
  350.   + poffsets[1][1][1]*surface_stride));
  352. LLVector3 c1 = p11 - p00;
  353. LLVector3 c2 = p01 - p10;
  355. LLVector3 normal = c1;
  356. normal %= c2;
  357. normal.normVec();
  359. llassert(mDataNorm);
  360. *(mDataNorm + surface_stride * y + x) = normal;
  361. }
  363. const LLVector3 &LLSurfacePatch::getNormal(const U32 x, const U32 y) const
  364. {
  365. U32 surface_stride = mSurfacep->getGridsPerEdge();
  366. llassert(mDataNorm);
  367. return *(mDataNorm + surface_stride * y + x);
  368. }
  371. void LLSurfacePatch::updateCameraDistanceRegion(const LLVector3 &pos_region)
  372. {
  373. if (LLPipeline::sDynamicLOD)
  374. {
  375. LLVector3 dv = pos_region;
  376. dv -= mCenterRegion;
  377. mVisInfo.mDistance = llmax(0.f, (F32)(dv.magVec() - mRadius))/
  378. llmax(LLVOSurfacePatch::sLODFactor, 0.1f);
  379. }
  380. else
  381. {
  382. mVisInfo.mDistance = 0.f;
  383. }
  384. }
  386. F32 LLSurfacePatch::getDistance() const
  387. {
  388. return mVisInfo.mDistance;
  389. }
  392. // Called when a patch has changed its height field
  393. // data.
  394. void LLSurfacePatch::updateVerticalStats() 
  395. {
  396. if (!mDirtyZStats)
  397. {
  398. return;
  399. }
  401. U32 grids_per_patch_edge = mSurfacep->getGridsPerPatchEdge();
  402. U32 grids_per_edge = mSurfacep->getGridsPerEdge();
  403. F32 meters_per_grid = mSurfacep->getMetersPerGrid();
  405. U32 i, j, k;
  406. F32 z, total;
  408. llassert(mDataZ);
  409. z = *(mDataZ);
  411. mMinZ = z;
  412. mMaxZ = z;
  414. k = 0;
  415. total = 0.0f;
  417. // Iterate to +1 because we need to do the edges correctly.
  418. for (j=0; j<(grids_per_patch_edge+1); j++) 
  419. {
  420. for (i=0; i<(grids_per_patch_edge+1); i++) 
  421. {
  422. z = *(mDataZ + i + j*grids_per_edge);
  424. if (z < mMinZ)
  425. {
  426. mMinZ = z;
  427. }
  428. if (z > mMaxZ)
  429. {
  430. mMaxZ = z;
  431. }
  432. total += z;
  433. k++;
  434. }
  435. }
  436. mMeanZ = total / (F32) k;
  437. mCenterRegion.mV[VZ] = 0.5f * (mMinZ + mMaxZ);
  439. LLVector3 diam_vec(meters_per_grid*grids_per_patch_edge,
  440. meters_per_grid*grids_per_patch_edge,
  441. mMaxZ - mMinZ);
  442. mRadius = diam_vec.magVec() * 0.5f;
  444. mSurfacep->mMaxZ = llmax(mMaxZ, mSurfacep->mMaxZ);
  445. mSurfacep->mMinZ = llmin(mMinZ, mSurfacep->mMinZ);
  446. mSurfacep->mHasZData = TRUE;
  447. mSurfacep->getRegion()->calculateCenterGlobal();
  449. if (mVObjp)
  450. {
  451. mVObjp->dirtyPatch();
  452. }
  453. mDirtyZStats = FALSE;
  454. }
  457. void LLSurfacePatch::updateNormals() 
  458. {
  459. if (mSurfacep->mType == 'w')
  460. {
  461. return;
  462. }
  463. U32 grids_per_patch_edge = mSurfacep->getGridsPerPatchEdge();
  464. U32 grids_per_edge = mSurfacep->getGridsPerEdge();
  466. BOOL dirty_patch = FALSE;
  468. U32 i, j;
  469. // update the east edge
  470. if (mNormalsInvalid[EAST] || mNormalsInvalid[NORTHEAST] || mNormalsInvalid[SOUTHEAST])
  471. {
  472. for (j = 0; j <= grids_per_patch_edge; j++)
  473. {
  474. calcNormal(grids_per_patch_edge, j, 2);
  475. calcNormal(grids_per_patch_edge - 1, j, 2);
  476. calcNormal(grids_per_patch_edge - 2, j, 2);
  477. }
  479. dirty_patch = TRUE;
  480. }
  482. // update the north edge
  483. if (mNormalsInvalid[NORTHEAST] || mNormalsInvalid[NORTH] || mNormalsInvalid[NORTHWEST])
  484. {
  485. for (i = 0; i <= grids_per_patch_edge; i++)
  486. {
  487. calcNormal(i, grids_per_patch_edge, 2);
  488. calcNormal(i, grids_per_patch_edge - 1, 2);
  489. calcNormal(i, grids_per_patch_edge - 2, 2);
  490. }
  492. dirty_patch = TRUE;
  493. }
  495. // update the west edge
  496. if (mNormalsInvalid[NORTHWEST] || mNormalsInvalid[WEST] || mNormalsInvalid[SOUTHWEST])
  497. {
  498. for (j = 0; j < grids_per_patch_edge; j++)
  499. {
  500. calcNormal(0, j, 2);
  501. calcNormal(1, j, 2);
  502. }
  503. dirty_patch = TRUE;
  504. }
  506. // update the south edge
  507. if (mNormalsInvalid[SOUTHWEST] || mNormalsInvalid[SOUTH] || mNormalsInvalid[SOUTHEAST])
  508. {
  509. for (i = 0; i < grids_per_patch_edge; i++)
  510. {
  511. calcNormal(i, 0, 2);
  512. calcNormal(i, 1, 2);
  513. }
  514. dirty_patch = TRUE;
  515. }
  517. // Invalidating the northeast corner is different, because depending on what the adjacent neighbors are,
  518. // we'll want to do different things.
  519. if (mNormalsInvalid[NORTHEAST])
  520. {
  521. if (!getNeighborPatch(NORTHEAST))
  522. {
  523. if (!getNeighborPatch(NORTH))
  524. {
  525. if (!getNeighborPatch(EAST))
  526. {
  527. // No north or east neighbors.  Pull from the diagonal in your own patch.
  528. *(mDataZ + grids_per_patch_edge + grids_per_patch_edge*grids_per_edge) =
  529. *(mDataZ + grids_per_patch_edge - 1 + (grids_per_patch_edge - 1)*grids_per_edge);
  530. }
  531. else
  532. {
  533. if (getNeighborPatch(EAST)->getHasReceivedData())
  534. {
  535. // East, but not north.  Pull from your east neighbor's northwest point.
  536. *(mDataZ + grids_per_patch_edge + grids_per_patch_edge*grids_per_edge) =
  537. *(getNeighborPatch(EAST)->mDataZ + (grids_per_patch_edge - 1)*grids_per_edge);
  538. }
  539. else
  540. {
  541. *(mDataZ + grids_per_patch_edge + grids_per_patch_edge*grids_per_edge) =
  542. *(mDataZ + grids_per_patch_edge - 1 + (grids_per_patch_edge - 1)*grids_per_edge);
  543. }
  544. }
  545. }
  546. else
  547. {
  548. // We have a north.
  549. if (getNeighborPatch(EAST))
  550. {
  551. // North and east neighbors, but not northeast.
  552. // Pull from diagonal in your own patch.
  553. *(mDataZ + grids_per_patch_edge + grids_per_patch_edge*grids_per_edge) =
  554. *(mDataZ + grids_per_patch_edge - 1 + (grids_per_patch_edge - 1)*grids_per_edge);
  555. }
  556. else
  557. {
  558. if (getNeighborPatch(NORTH)->getHasReceivedData())
  559. {
  560. // North, but not east.  Pull from your north neighbor's southeast corner.
  561. *(mDataZ + grids_per_patch_edge + grids_per_patch_edge*grids_per_edge) =
  562. *(getNeighborPatch(NORTH)->mDataZ + (grids_per_patch_edge - 1));
  563. }
  564. else
  565. {
  566. *(mDataZ + grids_per_patch_edge + grids_per_patch_edge*grids_per_edge) =
  567. *(mDataZ + grids_per_patch_edge - 1 + (grids_per_patch_edge - 1)*grids_per_edge);
  568. }
  569. }
  570. }
  571. }
  572. else if (getNeighborPatch(NORTHEAST)->mSurfacep != mSurfacep)
  573. {
  574. if (
  575. (!getNeighborPatch(NORTH) || (getNeighborPatch(NORTH)->mSurfacep != mSurfacep))
  576. &&
  577. (!getNeighborPatch(EAST) || (getNeighborPatch(EAST)->mSurfacep != mSurfacep)))
  578. {
  579. *(mDataZ + grids_per_patch_edge + grids_per_patch_edge*grids_per_edge) =
  580. *(getNeighborPatch(NORTHEAST)->mDataZ);
  581. }
  582. }
  583. else
  584. {
  585. // We've got a northeast patch in the same surface.
  586. // The z and normals will be handled by that patch.
  587. }
  588. calcNormal(grids_per_patch_edge, grids_per_patch_edge, 2);
  589. calcNormal(grids_per_patch_edge, grids_per_patch_edge - 1, 2);
  590. calcNormal(grids_per_patch_edge - 1, grids_per_patch_edge, 2);
  591. calcNormal(grids_per_patch_edge - 1, grids_per_patch_edge - 1, 2);
  592. dirty_patch = TRUE;
  593. }
  595. // update the middle normals
  596. if (mNormalsInvalid[MIDDLE])
  597. {
  598. for (j=2; j < grids_per_patch_edge - 2; j++)
  599. {
  600. for (i=2; i < grids_per_patch_edge - 2; i++)
  601. {
  602. calcNormal(i, j, 2);
  603. }
  604. }
  605. dirty_patch = TRUE;
  606. }
  608. if (dirty_patch)
  609. {
  610. mSurfacep->dirtySurfacePatch(this);
  611. }
  613. for (i = 0; i < 9; i++)
  614. {
  615. mNormalsInvalid[i] = FALSE;
  616. }
  617. }
  619. void LLSurfacePatch::updateEastEdge()
  620. {
  621. U32 grids_per_patch_edge = mSurfacep->getGridsPerPatchEdge();
  622. U32 grids_per_edge = mSurfacep->getGridsPerEdge();
  624. U32 j, k;
  625. F32 *west_surface, *east_surface;
  627. if (!getNeighborPatch(EAST))
  628. {
  629. west_surface = mDataZ + grids_per_patch_edge;
  630. east_surface = mDataZ + grids_per_patch_edge - 1;
  631. }
  632. else if (mConnectedEdge & EAST_EDGE)
  633. {
  634. west_surface = mDataZ + grids_per_patch_edge;
  635. east_surface = getNeighborPatch(EAST)->mDataZ;
  636. }
  637. else
  638. {
  639. return;
  640. }
  642. // If patchp is on the east edge of its surface, then we update the east
  643. // side buffer
  644. for (j=0; j < grids_per_patch_edge; j++)
  645. {
  646. k = j * grids_per_edge;
  647. *(west_surface + k) = *(east_surface + k); // update buffer Z
  648. }
  649. }
  652. void LLSurfacePatch::updateNorthEdge()
  653. {
  654. U32 grids_per_patch_edge = mSurfacep->getGridsPerPatchEdge();
  655. U32 grids_per_edge = mSurfacep->getGridsPerEdge();
  657. U32 i;
  658. F32 *south_surface, *north_surface;
  660. if (!getNeighborPatch(NORTH))
  661. {
  662. south_surface = mDataZ + grids_per_patch_edge*grids_per_edge;
  663. north_surface = mDataZ + (grids_per_patch_edge - 1) * grids_per_edge;
  664. }
  665. else if (mConnectedEdge & NORTH_EDGE)
  666. {
  667. south_surface = mDataZ + grids_per_patch_edge*grids_per_edge;
  668. north_surface = getNeighborPatch(NORTH)->mDataZ;
  669. }
  670. else
  671. {
  672. return;
  673. }
  675. // Update patchp's north edge ...
  676. for (i=0; i<grids_per_patch_edge; i++)
  677. {
  678. *(south_surface + i) = *(north_surface + i); // update buffer Z
  679. }
  680. }
  683. BOOL LLSurfacePatch::updateTexture()
  684. {
  685. if (mSTexUpdate) //  Update texture as needed
  686. {
  687. F32 meters_per_grid = getSurface()->getMetersPerGrid();
  688. F32 grids_per_patch_edge = (F32)getSurface()->getGridsPerPatchEdge();
  690. if ((!getNeighborPatch(EAST) || getNeighborPatch(EAST)->getHasReceivedData())
  691. && (!getNeighborPatch(WEST) || getNeighborPatch(WEST)->getHasReceivedData())
  692. && (!getNeighborPatch(SOUTH) || getNeighborPatch(SOUTH)->getHasReceivedData())
  693. && (!getNeighborPatch(NORTH) || getNeighborPatch(NORTH)->getHasReceivedData()))
  694. {
  695. LLViewerRegion *regionp = getSurface()->getRegion();
  696. LLVector3d origin_region = getOriginGlobal() - getSurface()->getOriginGlobal();
  698. // Have to figure out a better way to deal with these edge conditions...
  699. LLVLComposition* comp = regionp->getComposition();
  700. if (!mHeightsGenerated)
  701. {
  702. F32 patch_size = meters_per_grid*(grids_per_patch_edge+1);
  703. if (comp->generateHeights((F32)origin_region[VX], (F32)origin_region[VY],
  704.   patch_size, patch_size))
  705. {
  706. mHeightsGenerated = TRUE;
  707. }
  708. else
  709. {
  710. return FALSE;
  711. }
  712. }
  714. if (comp->generateComposition())
  715. {
  716. if (mVObjp)
  717. {
  718. mVObjp->dirtyGeom();
  719. gPipeline.markGLRebuild(mVObjp);
  720. return TRUE;
  721. }
  722. }
  723. }
  724. return FALSE;
  725. }
  726. else
  727. {
  728. return TRUE;
  729. }
  730. }
  732. void LLSurfacePatch::updateGL()
  733. {
  734. F32 meters_per_grid = getSurface()->getMetersPerGrid();
  735. F32 grids_per_patch_edge = (F32)getSurface()->getGridsPerPatchEdge();
  737. LLViewerRegion *regionp = getSurface()->getRegion();
  738. LLVector3d origin_region = getOriginGlobal() - getSurface()->getOriginGlobal();
  740. LLVLComposition* comp = regionp->getComposition();
  742. updateCompositionStats();
  743. F32 tex_patch_size = meters_per_grid*grids_per_patch_edge;
  744. if (comp->generateTexture((F32)origin_region[VX], (F32)origin_region[VY],
  745.   tex_patch_size, tex_patch_size))
  746. {
  747. mSTexUpdate = FALSE;
  749. // Also generate the water texture
  750. mSurfacep->generateWaterTexture((F32)origin_region.mdV[VX], (F32)origin_region.mdV[VY],
  751. tex_patch_size, tex_patch_size);
  752. }
  753. }
  755. void LLSurfacePatch::dirtyZ()
  756. {
  757. mSTexUpdate = TRUE;
  759. // Invalidate all normals in this patch
  760. U32 i;
  761. for (i = 0; i < 9; i++)
  762. {
  763. mNormalsInvalid[i] = TRUE;
  764. }
  766. // Invalidate normals in this and neighboring patches
  767. for (i = 0; i < 8; i++)
  768. {
  769. if (getNeighborPatch(i))
  770. {
  771. getNeighborPatch(i)->mNormalsInvalid[gDirOpposite[i]] = TRUE;
  772. getNeighborPatch(i)->dirty();
  773. if (i < 4)
  774. {
  775. getNeighborPatch(i)->mNormalsInvalid[gDirAdjacent[gDirOpposite[i]][0]] = TRUE;
  776. getNeighborPatch(i)->mNormalsInvalid[gDirAdjacent[gDirOpposite[i]][1]] = TRUE;
  777. }
  778. }
  779. }
  781. dirty();
  782. mLastUpdateTime = gFrameTime;
  783. }
  786. const U64 &LLSurfacePatch::getLastUpdateTime() const
  787. {
  788. return mLastUpdateTime;
  789. }
  791. F32 LLSurfacePatch::getMaxZ() const
  792. {
  793. return mMaxZ;
  794. }
  796. F32 LLSurfacePatch::getMinZ() const
  797. {
  798. return mMinZ;
  799. }
  801. void LLSurfacePatch::setOriginGlobal(const LLVector3d &origin_global)
  802. {
  803. mOriginGlobal = origin_global;
  805. LLVector3 origin_region;
  806. origin_region.setVec(mOriginGlobal - mSurfacep->getOriginGlobal());
  808. mOriginRegion = origin_region;
  809. mCenterRegion.mV[VX] = origin_region.mV[VX] + 0.5f*mSurfacep->getGridsPerPatchEdge()*mSurfacep->getMetersPerGrid();
  810. mCenterRegion.mV[VY] = origin_region.mV[VY] + 0.5f*mSurfacep->getGridsPerPatchEdge()*mSurfacep->getMetersPerGrid();
  812. mVisInfo.mbIsVisible = FALSE;
  813. mVisInfo.mDistance = 512.0f;
  814. mVisInfo.mRenderLevel = 0;
  815. mVisInfo.mRenderStride = mSurfacep->getGridsPerPatchEdge();
  817. }
  819. void LLSurfacePatch::connectNeighbor(LLSurfacePatch *neighbor_patchp, const U32 direction)
  820. {
  821. llassert(neighbor_patchp);
  822. mNormalsInvalid[direction] = TRUE;
  823. neighbor_patchp->mNormalsInvalid[gDirOpposite[direction]] = TRUE;
  825. setNeighborPatch(direction, neighbor_patchp);
  826. neighbor_patchp->setNeighborPatch(gDirOpposite[direction], this);
  828. if (EAST == direction)
  829. {
  830. mConnectedEdge |= EAST_EDGE;
  831. neighbor_patchp->mConnectedEdge |= WEST_EDGE;
  832. }
  833. else if (NORTH == direction)
  834. {
  835. mConnectedEdge |= NORTH_EDGE;
  836. neighbor_patchp->mConnectedEdge |= SOUTH_EDGE;
  837. }
  838. else if (WEST == direction)
  839. {
  840. mConnectedEdge |= WEST_EDGE;
  841. neighbor_patchp->mConnectedEdge |= EAST_EDGE;
  842. }
  843. else if (SOUTH == direction)
  844. {
  845. mConnectedEdge |= SOUTH_EDGE;
  846. neighbor_patchp->mConnectedEdge |= NORTH_EDGE;
  847. }
  848. }
  850. void LLSurfacePatch::updateVisibility()
  851. {
  852. if (mVObjp.isNull())
  853. {
  854. return;
  855. }
  857. const F32 DEFAULT_DELTA_ANGLE  = (0.15f);
  858. U32 old_render_stride, max_render_stride;
  859. U32 new_render_level;
  860. F32 stride_per_distance = DEFAULT_DELTA_ANGLE / mSurfacep->getMetersPerGrid();
  861. U32 grids_per_patch_edge = mSurfacep->getGridsPerPatchEdge();
  863. LLVector3 center = mCenterRegion + mSurfacep->getOriginAgent();
  864. LLVector3 radius = LLVector3(mRadius, mRadius, mRadius);
  866. // sphere in frustum on global coordinates
  867. if (LLViewerCamera::getInstance()->AABBInFrustumNoFarClip(center, radius))
  868. {
  869. // We now need to calculate the render stride based on patchp's distance 
  870. // from LLCamera render_stride is governed by a relation something like this...
  871. //
  872. //                       delta_angle * patch.distance
  873. // render_stride <=  ----------------------------------------
  874. //                           mMetersPerGrid
  875. //
  876. // where 'delta_angle' is the desired solid angle of the average polgon on a patch.
  877. //
  878. // Any render_stride smaller than the RHS would be 'satisfactory'.  Smaller 
  879. // strides give more resolution, but efficiency suggests that we use the largest 
  880. // of the render_strides that obey the relation.  Flexibility is achieved by 
  881. // modulating 'delta_angle' until we have an acceptable number of triangles.
  883. old_render_stride = mVisInfo.mRenderStride;
  885. // Calculate the render_stride using information in agent
  886. max_render_stride = lltrunc(mVisInfo.mDistance * stride_per_distance);
  887. max_render_stride = llmin(max_render_stride , 2*grids_per_patch_edge);
  889. // We only use render_strides that are powers of two, so we use look-up tables to figure out
  890. // the render_level and corresponding render_stride
  891. new_render_level = mVisInfo.mRenderLevel = mSurfacep->getRenderLevel(max_render_stride);
  892. mVisInfo.mRenderStride = mSurfacep->getRenderStride(new_render_level);
  894. if ((mVisInfo.mRenderStride != old_render_stride)) 
  895. // The reason we check !mbIsVisible is because non-visible patches normals 
  896. // are not updated when their data is changed.  When this changes we can get 
  897. // rid of mbIsVisible altogether.
  898. {
  899. if (mVObjp)
  900. {
  901. mVObjp->dirtyGeom();
  902. if (getNeighborPatch(WEST))
  903. {
  904. getNeighborPatch(WEST)->mVObjp->dirtyGeom();
  905. }
  906. if (getNeighborPatch(SOUTH))
  907. {
  908. getNeighborPatch(SOUTH)->mVObjp->dirtyGeom();
  909. }
  910. }
  911. }
  912. mVisInfo.mbIsVisible = TRUE;
  913. }
  914. else
  915. {
  916. mVisInfo.mbIsVisible = FALSE;
  917. }
  918. }
  921. const LLVector3d &LLSurfacePatch::getOriginGlobal() const
  922. {
  923. return mOriginGlobal;
  924. }
  926. LLVector3 LLSurfacePatch::getOriginAgent() const
  927. {
  928. return gAgent.getPosAgentFromGlobal(mOriginGlobal);
  929. }
  931. BOOL LLSurfacePatch::getVisible() const
  932. {
  933. return mVisInfo.mbIsVisible;
  934. }
  936. U32 LLSurfacePatch::getRenderStride() const
  937. {
  938. return mVisInfo.mRenderStride;
  939. }
  941. S32 LLSurfacePatch::getRenderLevel() const
  942. {
  943. return mVisInfo.mRenderLevel;
  944. }
  946. void LLSurfacePatch::setHasReceivedData()
  947. {
  948. mHasReceivedData = TRUE;
  949. }
  951. BOOL LLSurfacePatch::getHasReceivedData() const
  952. {
  953. return mHasReceivedData;
  954. }
  956. const LLVector3 &LLSurfacePatch::getCenterRegion() const
  957. {
  958. return mCenterRegion;
  959. }
  962. void LLSurfacePatch::updateCompositionStats()
  963. {
  964. LLViewerLayer *vlp = mSurfacep->getRegion()->getComposition();
  966. F32 x, y, width, height, mpg, min, mean, max;
  968. LLVector3 origin = getOriginAgent() - mSurfacep->getOriginAgent();
  969. mpg = mSurfacep->getMetersPerGrid();
  970. x = origin.mV[VX];
  971. y = origin.mV[VY];
  972. width = mpg*(mSurfacep->getGridsPerPatchEdge()+1);
  973. height = mpg*(mSurfacep->getGridsPerPatchEdge()+1);
  975. mean = 0.f;
  976. min = vlp->getValueScaled(x, y);
  977. max= min;
  978. U32 count = 0;
  979. F32 i, j;
  980. for (j = 0; j < height; j += mpg)
  981. {
  982. for (i = 0; i < width; i += mpg)
  983. {
  984. F32 comp = vlp->getValueScaled(x + i, y + j);
  985. mean += comp;
  986. min = llmin(min, comp);
  987. max = llmax(max, comp);
  988. count++;
  989. }
  990. }
  991. mean /= count;
  993. mMinComposition = min;
  994. mMeanComposition = mean;
  995. mMaxComposition = max;
  996. }
  998. F32 LLSurfacePatch::getMeanComposition() const
  999. {
  1000. return mMeanComposition;
  1001. }
  1003. F32 LLSurfacePatch::getMinComposition() const
  1004. {
  1005. return mMinComposition;
  1006. }
  1008. F32 LLSurfacePatch::getMaxComposition() const
  1009. {
  1010. return mMaxComposition;
  1011. }
  1013. void LLSurfacePatch::setNeighborPatch(const U32 direction, LLSurfacePatch *neighborp)
  1014. {
  1015. mNeighborPatches[direction] = neighborp;
  1016. mNormalsInvalid[direction] = TRUE;
  1017. if (direction < 4)
  1018. {
  1019. mNormalsInvalid[gDirAdjacent[direction][0]] = TRUE;
  1020. mNormalsInvalid[gDirAdjacent[direction][1]] = TRUE;
  1021. }
  1022. }
  1024. LLSurfacePatch *LLSurfacePatch::getNeighborPatch(const U32 direction) const
  1025. {
  1026. return mNeighborPatches[direction];
  1027. }
  1029. void LLSurfacePatch::clearVObj()
  1030. {
  1031. mVObjp = NULL;
  1032. }