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

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

游戏引擎

开发平台：

C++ Builder

llsurface.cpp：源码内容
  1. /** 
  2.  * @file llsurface.cpp
  3.  * @brief Implementation of LLSurface class
  4.  *
  5.  * $LicenseInfo:firstyear=2000&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2000-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 "llsurface.h"
  37. #include "llrender.h"
  39. #include "llviewertexturelist.h"
  40. #include "llpatchvertexarray.h"
  41. #include "patch_dct.h"
  42. #include "patch_code.h"
  43. #include "bitpack.h"
  44. #include "llviewerobjectlist.h"
  45. #include "llregionhandle.h"
  46. #include "llagent.h"
  47. #include "llappviewer.h"
  48. #include "llworld.h"
  49. #include "llviewercontrol.h"
  50. #include "llviewertexture.h"
  51. #include "llsurfacepatch.h"
  52. #include "llvosurfacepatch.h"
  53. #include "llvowater.h"
  54. #include "pipeline.h"
  55. #include "llviewerregion.h"
  56. #include "llvlcomposition.h"
  57. #include "noise.h"
  58. #include "llviewercamera.h"
  59. #include "llglheaders.h"
  60. #include "lldrawpoolterrain.h"
  61. #include "lldrawable.h"
  63. extern LLPipeline gPipeline;
  65. LLColor4U MAX_WATER_COLOR(0, 48, 96, 240);
  68. S32 LLSurface::sTextureSize = 256;
  69. S32 LLSurface::sTexelsUpdated = 0;
  70. F32 LLSurface::sTextureUpdateTime = 0.f;
  72. // ---------------- LLSurface:: Public Members ---------------
  74. LLSurface::LLSurface(U32 type, LLViewerRegion *regionp) :
  75. mGridsPerEdge(0),
  76. mOOGridsPerEdge(0.f),
  77. mPatchesPerEdge(0),
  78. mNumberOfPatches(0),
  79. mType(type),
  80. mDetailTextureScale(0.f),
  81. mOriginGlobal(0.0, 0.0, 0.0),
  82. mSTexturep(NULL),
  83. mWaterTexturep(NULL),
  84. mGridsPerPatchEdge(0),
  85. mMetersPerGrid(1.0f),
  86. mMetersPerEdge(1.0f),
  87. mRegionp(regionp)
  88. {
  89. // Surface data
  90. mSurfaceZ = NULL;
  91. mNorm = NULL;
  93. // Patch data
  94. mPatchList = NULL;
  96. // One of each for each camera
  97. mVisiblePatchCount = 0;
  99. mHasZData = FALSE;
  100. // "uninitialized" min/max z
  101. mMinZ = 10000.f;
  102. mMaxZ = -10000.f;
  104. mWaterObjp = NULL;
  106. // In here temporarily.
  107. mSurfacePatchUpdateCount = 0;
  109. for (S32 i = 0; i < 8; i++)
  110. {
  111. mNeighbors[i] = NULL;
  112. }
  113. }
  116. LLSurface::~LLSurface()
  117. {
  118. delete [] mSurfaceZ;
  119. mSurfaceZ = NULL;
  121. delete [] mNorm;
  123. mGridsPerEdge = 0;
  124. mGridsPerPatchEdge = 0;
  125. mPatchesPerEdge = 0;
  126. mNumberOfPatches = 0;
  127. destroyPatchData();
  129. LLDrawPoolTerrain *poolp = (LLDrawPoolTerrain*) gPipeline.findPool(LLDrawPool::POOL_TERRAIN, mSTexturep);
  130. if (!poolp)
  131. {
  132. llwarns << "No pool for terrain on destruction!" << llendl;
  133. }
  134. else if (poolp->mReferences.empty())
  135. {
  136. gPipeline.removePool(poolp);
  137. // Don't enable this until we blitz the draw pool for it as well.  -- djs
  138. if (mSTexturep)
  139. {
  140. mSTexturep = NULL;
  141. }
  142. if (mWaterTexturep)
  143. {
  144. mWaterTexturep = NULL;
  145. }
  146. }
  147. else
  148. {
  149. llerrs << "Terrain pool not empty!" << llendl;
  150. }
  151. }
  153. void LLSurface::initClasses()
  154. {
  155. }
  157. void LLSurface::setRegion(LLViewerRegion *regionp)
  158. {
  159. mRegionp = regionp;
  160. }
  162. // Assumes that arguments are powers of 2, and that
  163. // grids_per_edge / grids_per_patch_edge = power of 2 
  164. void LLSurface::create(const S32 grids_per_edge,
  165.    const S32 grids_per_patch_edge,
  166.    const LLVector3d &origin_global,
  167.    const F32 width) 
  168. {
  169. // Initialize various constants for the surface
  170. mGridsPerEdge = grids_per_edge + 1;  // Add 1 for the east and north buffer
  171. mOOGridsPerEdge = 1.f / mGridsPerEdge;
  172. mGridsPerPatchEdge = grids_per_patch_edge;
  173. mPatchesPerEdge = (mGridsPerEdge - 1) / mGridsPerPatchEdge;
  174. mNumberOfPatches = mPatchesPerEdge * mPatchesPerEdge;
  175. mMetersPerGrid = width / ((F32)(mGridsPerEdge - 1));
  176. mMetersPerEdge = mMetersPerGrid * (mGridsPerEdge - 1);
  178. mOriginGlobal.setVec(origin_global);
  180. mPVArray.create(mGridsPerEdge, mGridsPerPatchEdge, LLWorld::getInstance()->getRegionScale());
  182. S32 number_of_grids = mGridsPerEdge * mGridsPerEdge;
  184. /////////////////////////////////////
  185. //
  186. // Initialize data arrays for surface
  187. ///
  188. mSurfaceZ = new F32[number_of_grids];
  189. mNorm = new LLVector3[number_of_grids];
  191. // Reset the surface to be a flat square grid
  192. for(S32 i=0; i < number_of_grids; i++) 
  193. {
  194. // Surface is flat and zero
  195. // Normals all point up
  196. mSurfaceZ[i] = 0.0f;
  197. mNorm[i].setVec(0.f, 0.f, 1.f);
  198. }
  201. mVisiblePatchCount = 0;
  204. ///////////////////////
  205. //
  206. // Initialize textures
  207. //
  209. initTextures();
  211. // Has to be done after texture initialization
  212. createPatchData();
  213. }
  215. LLViewerTexture* LLSurface::getSTexture()
  216. {
  217. if (mSTexturep.notNull() && !mSTexturep->hasGLTexture())
  218. {
  219. createSTexture();
  220. }
  221. return mSTexturep;
  222. }
  224. LLViewerTexture* LLSurface::getWaterTexture()
  225. {
  226. if (mWaterTexturep.notNull() && !mWaterTexturep->hasGLTexture())
  227. {
  228. createWaterTexture();
  229. }
  230. return mWaterTexturep;
  231. }
  233. void LLSurface::createSTexture()
  234. {
  235. if (!mSTexturep)
  236. {
  237. // Fill with dummy gray data.
  238. // GL NOT ACTIVE HERE
  239. LLPointer<LLImageRaw> raw = new LLImageRaw(sTextureSize, sTextureSize, 3);
  240. U8 *default_texture = raw->getData();
  241. for (S32 i = 0; i < sTextureSize; i++)
  242. {
  243. for (S32 j = 0; j < sTextureSize; j++)
  244. {
  245. *(default_texture + (i*sTextureSize + j)*3) = 128;
  246. *(default_texture + (i*sTextureSize + j)*3 + 1) = 128;
  247. *(default_texture + (i*sTextureSize + j)*3 + 2) = 128;
  248. }
  249. }
  251. mSTexturep = LLViewerTextureManager::getLocalTexture(raw.get(), FALSE);
  252. mSTexturep->dontDiscard();
  253. gGL.getTexUnit(0)->bind(mSTexturep);
  254. mSTexturep->setAddressMode(LLTexUnit::TAM_CLAMP);
  255. }
  256. }
  258. void LLSurface::createWaterTexture()
  259. {
  260. if (!mWaterTexturep)
  261. {
  262. // Create the water texture
  263. LLPointer<LLImageRaw> raw = new LLImageRaw(sTextureSize/2, sTextureSize/2, 4);
  264. U8 *default_texture = raw->getData();
  265. for (S32 i = 0; i < sTextureSize/2; i++)
  266. {
  267. for (S32 j = 0; j < sTextureSize/2; j++)
  268. {
  269. *(default_texture + (i*sTextureSize/2 + j)*4) = MAX_WATER_COLOR.mV[0];
  270. *(default_texture + (i*sTextureSize/2 + j)*4 + 1) = MAX_WATER_COLOR.mV[1];
  271. *(default_texture + (i*sTextureSize/2 + j)*4 + 2) = MAX_WATER_COLOR.mV[2];
  272. *(default_texture + (i*sTextureSize/2 + j)*4 + 3) = MAX_WATER_COLOR.mV[3];
  273. }
  274. }
  276. mWaterTexturep = LLViewerTextureManager::getLocalTexture(raw.get(), FALSE);
  277. mWaterTexturep->dontDiscard();
  278. gGL.getTexUnit(0)->bind(mWaterTexturep);
  279. mWaterTexturep->setAddressMode(LLTexUnit::TAM_CLAMP);
  280. }
  281. }
  283. void LLSurface::initTextures()
  284. {
  285. ///////////////////////
  286. //
  287. // Main surface texture
  288. //
  289. createSTexture();
  291. ///////////////////////
  292. //
  293. // Water texture
  294. //
  295. if (gSavedSettings.getBOOL("RenderWater") )
  296. {
  297. createWaterTexture();
  298. mWaterObjp = (LLVOWater *)gObjectList.createObjectViewer(LLViewerObject::LL_VO_WATER, mRegionp);
  299. gPipeline.createObject(mWaterObjp);
  300. LLVector3d water_pos_global = from_region_handle(mRegionp->getHandle());
  301. water_pos_global += LLVector3d(128.0, 128.0, DEFAULT_WATER_HEIGHT);
  302. mWaterObjp->setPositionGlobal(water_pos_global);
  303. }
  304. }
  307. void LLSurface::setOriginGlobal(const LLVector3d &origin_global) 
  308. {
  309. LLVector3d new_origin_global;
  310. mOriginGlobal = origin_global;
  311. LLSurfacePatch *patchp;
  312. S32 i, j;
  313. // Need to update the southwest corners of the patches
  314. for (j=0; j<mPatchesPerEdge; j++) 
  315. {
  316. for (i=0; i<mPatchesPerEdge; i++) 
  317. {
  318. patchp = getPatch(i, j);
  320. new_origin_global = patchp->getOriginGlobal();
  322. new_origin_global.mdV[0] = mOriginGlobal.mdV[0] + i * mMetersPerGrid * mGridsPerPatchEdge;
  323. new_origin_global.mdV[1] = mOriginGlobal.mdV[1] + j * mMetersPerGrid * mGridsPerPatchEdge;
  324. patchp->setOriginGlobal(new_origin_global);
  325. }
  326. }
  328. // Hack!
  329. if (mWaterObjp.notNull() && mWaterObjp->mDrawable.notNull())
  330. {
  331. const F64 x = origin_global.mdV[VX] + 128.0;
  332. const F64 y = origin_global.mdV[VY] + 128.0;
  333. const F64 z = mWaterObjp->getPositionGlobal().mdV[VZ];
  335. LLVector3d water_origin_global(x, y, z);
  337. mWaterObjp->setPositionGlobal(water_origin_global);
  338. }
  339. }
  342. void LLSurface::connectNeighbor(LLSurface *neighborp, U32 direction)
  343. {
  344. S32 i;
  345. LLSurfacePatch *patchp, *neighbor_patchp;
  347. if (gNoRender)
  348. {
  349. return;
  350. }
  352. mNeighbors[direction] = neighborp;
  353. neighborp->mNeighbors[gDirOpposite[direction]] = this;
  355. // Connect patches
  356. if (NORTHEAST == direction)
  357. {
  358. patchp = getPatch(mPatchesPerEdge - 1, mPatchesPerEdge - 1);
  359. neighbor_patchp = neighborp->getPatch(0, 0);
  361. patchp->connectNeighbor(neighbor_patchp, direction);
  362. neighbor_patchp->connectNeighbor(patchp, gDirOpposite[direction]);
  364. patchp->updateNorthEdge(); // Only update one of north or east.
  365. patchp->dirtyZ();
  366. }
  367. else if (NORTHWEST == direction)
  368. {
  369. patchp = getPatch(0, mPatchesPerEdge - 1);
  370. neighbor_patchp = neighborp->getPatch(mPatchesPerEdge - 1, 0);
  372. patchp->connectNeighbor(neighbor_patchp, direction);
  373. neighbor_patchp->connectNeighbor(patchp, gDirOpposite[direction]);
  374. }
  375. else if (SOUTHWEST == direction)
  376. {
  377. patchp = getPatch(0, 0);
  378. neighbor_patchp = neighborp->getPatch(mPatchesPerEdge - 1, mPatchesPerEdge - 1);
  380. patchp->connectNeighbor(neighbor_patchp, direction);
  381. neighbor_patchp->connectNeighbor(patchp, gDirOpposite[direction]);
  383. neighbor_patchp->updateNorthEdge(); // Only update one of north or east.
  384. neighbor_patchp->dirtyZ();
  385. }
  386. else if (SOUTHEAST == direction)
  387. {
  388. patchp = getPatch(mPatchesPerEdge - 1, 0);
  389. neighbor_patchp = neighborp->getPatch(0, mPatchesPerEdge - 1);
  391. patchp->connectNeighbor(neighbor_patchp, direction);
  392. neighbor_patchp->connectNeighbor(patchp, gDirOpposite[direction]);
  393. }
  394. else if (EAST == direction)
  395. {
  396. // Do east/west connections, first
  397. for (i = 0; i < (S32)mPatchesPerEdge; i++)
  398. {
  399. patchp = getPatch(mPatchesPerEdge - 1, i);
  400. neighbor_patchp = neighborp->getPatch(0, i);
  402. patchp->connectNeighbor(neighbor_patchp, direction);
  403. neighbor_patchp->connectNeighbor(patchp, gDirOpposite[direction]);
  405. patchp->updateEastEdge();
  406. patchp->dirtyZ();
  407. }
  409. // Now do northeast/southwest connections
  410. for (i = 0; i < (S32)mPatchesPerEdge - 1; i++)
  411. {
  412. patchp = getPatch(mPatchesPerEdge - 1, i);
  413. neighbor_patchp = neighborp->getPatch(0, i+1);
  415. patchp->connectNeighbor(neighbor_patchp, NORTHEAST);
  416. neighbor_patchp->connectNeighbor(patchp, SOUTHWEST);
  417. }
  418. // Now do southeast/northwest connections
  419. for (i = 1; i < (S32)mPatchesPerEdge; i++)
  420. {
  421. patchp = getPatch(mPatchesPerEdge - 1, i);
  422. neighbor_patchp = neighborp->getPatch(0, i-1);
  424. patchp->connectNeighbor(neighbor_patchp, SOUTHEAST);
  425. neighbor_patchp->connectNeighbor(patchp, NORTHWEST);
  426. }
  427. }
  428. else if (NORTH == direction)
  429. {
  430. // Do north/south connections, first
  431. for (i = 0; i < (S32)mPatchesPerEdge; i++)
  432. {
  433. patchp = getPatch(i, mPatchesPerEdge - 1);
  434. neighbor_patchp = neighborp->getPatch(i, 0);
  436. patchp->connectNeighbor(neighbor_patchp, direction);
  437. neighbor_patchp->connectNeighbor(patchp, gDirOpposite[direction]);
  439. patchp->updateNorthEdge();
  440. patchp->dirtyZ();
  441. }
  443. // Do northeast/southwest connections
  444. for (i = 0; i < (S32)mPatchesPerEdge - 1; i++)
  445. {
  446. patchp = getPatch(i, mPatchesPerEdge - 1);
  447. neighbor_patchp = neighborp->getPatch(i+1, 0);
  449. patchp->connectNeighbor(neighbor_patchp, NORTHEAST);
  450. neighbor_patchp->connectNeighbor(patchp, SOUTHWEST);
  451. }
  452. // Do southeast/northwest connections
  453. for (i = 1; i < (S32)mPatchesPerEdge; i++)
  454. {
  455. patchp = getPatch(i, mPatchesPerEdge - 1);
  456. neighbor_patchp = neighborp->getPatch(i-1, 0);
  458. patchp->connectNeighbor(neighbor_patchp, NORTHWEST);
  459. neighbor_patchp->connectNeighbor(patchp, SOUTHEAST);
  460. }
  461. }
  462. else if (WEST == direction)
  463. {
  464. // Do east/west connections, first
  465. for (i = 0; i < mPatchesPerEdge; i++)
  466. {
  467. patchp = getPatch(0, i);
  468. neighbor_patchp = neighborp->getPatch(mPatchesPerEdge - 1, i);
  470. patchp->connectNeighbor(neighbor_patchp, direction);
  471. neighbor_patchp->connectNeighbor(patchp, gDirOpposite[direction]);
  473. neighbor_patchp->updateEastEdge();
  474. neighbor_patchp->dirtyZ();
  475. }
  477. // Now do northeast/southwest connections
  478. for (i = 1; i < mPatchesPerEdge; i++)
  479. {
  480. patchp = getPatch(0, i);
  481. neighbor_patchp = neighborp->getPatch(mPatchesPerEdge - 1, i - 1);
  483. patchp->connectNeighbor(neighbor_patchp, SOUTHWEST);
  484. neighbor_patchp->connectNeighbor(patchp, NORTHEAST);
  485. }
  487. // Now do northwest/southeast connections
  488. for (i = 0; i < mPatchesPerEdge - 1; i++)
  489. {
  490. patchp = getPatch(0, i);
  491. neighbor_patchp = neighborp->getPatch(mPatchesPerEdge - 1, i + 1);
  493. patchp->connectNeighbor(neighbor_patchp, NORTHWEST);
  494. neighbor_patchp->connectNeighbor(patchp, SOUTHEAST);
  495. }
  496. }
  497. else if (SOUTH == direction)
  498. {
  499. // Do north/south connections, first
  500. for (i = 0; i < mPatchesPerEdge; i++)
  501. {
  502. patchp = getPatch(i, 0);
  503. neighbor_patchp = neighborp->getPatch(i, mPatchesPerEdge - 1);
  505. patchp->connectNeighbor(neighbor_patchp, direction);
  506. neighbor_patchp->connectNeighbor(patchp, gDirOpposite[direction]);
  508. neighbor_patchp->updateNorthEdge();
  509. neighbor_patchp->dirtyZ();
  510. }
  512. // Now do northeast/southwest connections
  513. for (i = 1; i < mPatchesPerEdge; i++)
  514. {
  515. patchp = getPatch(i, 0);
  516. neighbor_patchp = neighborp->getPatch(i - 1, mPatchesPerEdge - 1);
  518. patchp->connectNeighbor(neighbor_patchp, SOUTHWEST);
  519. neighbor_patchp->connectNeighbor(patchp, NORTHEAST);
  520. }
  521. // Now do northeast/southwest connections
  522. for (i = 0; i < mPatchesPerEdge - 1; i++)
  523. {
  524. patchp = getPatch(i, 0);
  525. neighbor_patchp = neighborp->getPatch(i + 1, mPatchesPerEdge - 1);
  527. patchp->connectNeighbor(neighbor_patchp, SOUTHEAST);
  528. neighbor_patchp->connectNeighbor(patchp, NORTHWEST);
  529. }
  530. }
  531. }
  533. void LLSurface::disconnectNeighbor(LLSurface *surfacep)
  534. {
  535. S32 i;
  536. for (i = 0; i < 8; i++)
  537. {
  538. if (surfacep == mNeighbors[i])
  539. {
  540. mNeighbors[i] = NULL;
  541. }
  542. }
  544. // Iterate through surface patches, removing any connectivity to removed surface.
  545. for (i = 0; i < mNumberOfPatches; i++)
  546. {
  547. (mPatchList + i)->disconnectNeighbor(surfacep);
  548. }
  549. }
  552. void LLSurface::disconnectAllNeighbors()
  553. {
  554. S32 i;
  555. for (i = 0; i < 8; i++)
  556. {
  557. if (mNeighbors[i])
  558. {
  559. mNeighbors[i]->disconnectNeighbor(this);
  560. mNeighbors[i] = NULL;
  561. }
  562. }
  563. }
  567. const LLVector3d &LLSurface::getOriginGlobal() const
  568. {
  569. return mOriginGlobal;
  570. }
  572. LLVector3 LLSurface::getOriginAgent() const
  573. {
  574. return gAgent.getPosAgentFromGlobal(mOriginGlobal);
  575. }
  577. F32 LLSurface::getMetersPerGrid() const
  578. {
  579. return mMetersPerGrid;
  580. }
  582. S32 LLSurface::getGridsPerEdge() const
  583. {
  584. return mGridsPerEdge;
  585. }
  587. S32 LLSurface::getPatchesPerEdge() const
  588. {
  589. return mPatchesPerEdge;
  590. }
  592. S32 LLSurface::getGridsPerPatchEdge() const
  593. {
  594. return mGridsPerPatchEdge;
  595. }
  597. void LLSurface::moveZ(const S32 x, const S32 y, const F32 delta)
  598. {
  599. llassert(x >= 0);
  600. llassert(y >= 0);
  601. llassert(x < mGridsPerEdge);
  602. llassert(y < mGridsPerEdge);
  603. mSurfaceZ[x + y*mGridsPerEdge] += delta;
  604. }
  607. void LLSurface::updatePatchVisibilities(LLAgent &agent) 
  608. {
  609. LLVector3 pos_region = mRegionp->getPosRegionFromGlobal(gAgent.getCameraPositionGlobal());
  611. LLSurfacePatch *patchp;
  613. mVisiblePatchCount = 0;
  614. for (S32 i=0; i<mNumberOfPatches; i++) 
  615. {
  616. patchp = mPatchList + i;
  618. patchp->updateVisibility();
  619. if (patchp->getVisible())
  620. {
  621. mVisiblePatchCount++;
  622. patchp->updateCameraDistanceRegion(pos_region);
  623. }
  624. }
  625. }
  627. BOOL LLSurface::idleUpdate(F32 max_update_time)
  628. {
  629. LLMemType mt_ius(LLMemType::MTYPE_IDLE_UPDATE_SURFACE);
  630. if (!gPipeline.hasRenderType(LLPipeline::RENDER_TYPE_TERRAIN))
  631. {
  632. return FALSE;
  633. }
  635. // Perform idle time update of non-critical stuff.
  636. // In this case, texture and normal updates.
  637. LLTimer update_timer;
  638. BOOL did_update = FALSE;
  640. // If the Z height data has changed, we need to rebuild our
  641. // property line vertex arrays.
  642. if (mDirtyPatchList.size() > 0)
  643. {
  644. getRegion()->dirtyHeights();
  645. }
  647. // Always call updateNormals() / updateVerticalStats()
  648. //  every frame to avoid artifacts
  649. for(std::set<LLSurfacePatch *>::iterator iter = mDirtyPatchList.begin();
  650. iter != mDirtyPatchList.end(); )
  651. {
  652. std::set<LLSurfacePatch *>::iterator curiter = iter++;
  653. LLSurfacePatch *patchp = *curiter;
  654. patchp->updateNormals();
  655. patchp->updateVerticalStats();
  656. if (max_update_time == 0.f || update_timer.getElapsedTimeF32() < max_update_time)
  657. {
  658. if (patchp->updateTexture())
  659. {
  660. did_update = TRUE;
  661. patchp->clearDirty();
  662. mDirtyPatchList.erase(curiter);
  663. }
  664. }
  665. }
  666. return did_update;
  667. }
  669. void LLSurface::decompressDCTPatch(LLBitPack &bitpack, LLGroupHeader *gopp, BOOL b_large_patch) 
  670. {
  672. LLPatchHeader  ph;
  673. S32 j, i;
  674. S32 patch[LARGE_PATCH_SIZE*LARGE_PATCH_SIZE];
  675. LLSurfacePatch *patchp;
  677. init_patch_decompressor(gopp->patch_size);
  678. gopp->stride = mGridsPerEdge;
  679. set_group_of_patch_header(gopp);
  681. while (1)
  682. {
  683. decode_patch_header(bitpack, &ph);
  684. if (ph.quant_wbits == END_OF_PATCHES)
  685. {
  686. break;
  687. }
  689. i = ph.patchids >> 5;
  690. j = ph.patchids & 0x1F;
  692. if ((i >= mPatchesPerEdge) || (j >= mPatchesPerEdge))
  693. {
  694. llwarns << "Received invalid terrain packet - patch header patch ID incorrect!" 
  695. << " patches per edge " << mPatchesPerEdge
  696. << " i " << i
  697. << " j " << j
  698. << " dc_offset " << ph.dc_offset
  699. << " range " << (S32)ph.range
  700. << " quant_wbits " << (S32)ph.quant_wbits
  701. << " patchids " << (S32)ph.patchids
  702. << llendl;
  703.             LLAppViewer::instance()->badNetworkHandler();
  704. return;
  705. }
  707. patchp = &mPatchList[j*mPatchesPerEdge + i];
  710. decode_patch(bitpack, patch);
  711. decompress_patch(patchp->getDataZ(), patch, &ph);
  713. // Update edges for neighbors.  Need to guarantee that this gets done before we generate vertical stats.
  714. patchp->updateNorthEdge();
  715. patchp->updateEastEdge();
  716. if (patchp->getNeighborPatch(WEST))
  717. {
  718. patchp->getNeighborPatch(WEST)->updateEastEdge();
  719. }
  720. if (patchp->getNeighborPatch(SOUTHWEST))
  721. {
  722. patchp->getNeighborPatch(SOUTHWEST)->updateEastEdge();
  723. patchp->getNeighborPatch(SOUTHWEST)->updateNorthEdge();
  724. }
  725. if (patchp->getNeighborPatch(SOUTH))
  726. {
  727. patchp->getNeighborPatch(SOUTH)->updateNorthEdge();
  728. }
  730. // Dirty patch statistics, and flag that the patch has data.
  731. patchp->dirtyZ();
  732. patchp->setHasReceivedData();
  733. }
  734. }
  737. // Retrurns TRUE if "position" is within the bounds of surface.
  738. // "position" is region-local
  739. BOOL LLSurface::containsPosition(const LLVector3 &position)
  740. {
  741. if (position.mV[VX] < 0.0f  ||  position.mV[VX] > mMetersPerEdge ||
  742. position.mV[VY] < 0.0f  ||  position.mV[VY] > mMetersPerEdge)
  743. {
  744. return FALSE;
  745. }
  746. return TRUE;
  747. }
  750. F32 LLSurface::resolveHeightRegion(const F32 x, const F32 y) const
  751. {
  752. F32 height = 0.0f;
  753. F32 oometerspergrid = 1.f/mMetersPerGrid;
  755. // Check to see if v is actually above surface 
  756. // We use (mGridsPerEdge-1) below rather than (mGridsPerEdge) 
  757. // becuase of the east and north buffers 
  759. if (x >= 0.f  &&  
  760. x <= mMetersPerEdge  &&
  761. y >= 0.f  &&  
  762. y <= mMetersPerEdge)
  763. {
  764. const S32 left   = llfloor(x * oometerspergrid);
  765. const S32 bottom = llfloor(y * oometerspergrid);
  767. // Don't walk off the edge of the array!
  768. const S32 right  = ( left+1   < (S32)mGridsPerEdge-1 ? left+1   : left );
  769. const S32 top    = ( bottom+1 < (S32)mGridsPerEdge-1 ? bottom+1 : bottom );
  771. // Figure out if v is in first or second triangle of the square
  772. // and calculate the slopes accordingly
  773. //    |       |
  774. // -(i,j+1)---(i+1,j+1)--   
  775. //    |  1   /  |          ^
  776. //    |    /  2 |          |
  777. //    |  /      |          j
  778. // --(i,j)----(i+1,j)--
  779. //    |       |
  780. // 
  781. //      i ->
  782. // where N = mGridsPerEdge
  784. const F32 left_bottom  = getZ( left,  bottom );
  785. const F32 right_bottom = getZ( right, bottom );
  786. const F32 left_top     = getZ( left,  top );
  787. const F32 right_top    = getZ( right, top );
  789. // dx and dy are incremental steps from (mSurface + k)
  790. F32 dx = x - left   * mMetersPerGrid;
  791. F32 dy = y - bottom * mMetersPerGrid;
  793. if (dy > dx) 
  794. {
  795. // triangle 1
  796. dy *= left_top  - left_bottom;
  797. dx *= right_top - left_top;
  798. }
  799. else 
  800. {
  801. // triangle 2
  802. dx *= right_bottom - left_bottom;
  803. dy *= right_top    - right_bottom;
  804. }
  805. height = left_bottom + (dx + dy) * oometerspergrid;
  806. }
  807. return height;
  808. }
  811. F32 LLSurface::resolveHeightGlobal(const LLVector3d& v) const
  812. {
  813. if (!mRegionp)
  814. {
  815. return 0.f;
  816. }
  818. LLVector3 pos_region = mRegionp->getPosRegionFromGlobal(v);
  820. return resolveHeightRegion(pos_region);
  821. }
  824. LLVector3 LLSurface::resolveNormalGlobal(const LLVector3d& pos_global) const
  825. {
  826. if (!mSurfaceZ)
  827. {
  828. // Hmm.  Uninitialized surface!
  829. return LLVector3::z_axis;
  830. }
  831. //
  832. // Returns the vector normal to a surface at location specified by vector v
  833. //
  834. F32 oometerspergrid = 1.f/mMetersPerGrid;
  835. LLVector3 normal;
  836. F32 dzx, dzy;
  838. if (pos_global.mdV[VX] >= mOriginGlobal.mdV[VX]  &&  
  839. pos_global.mdV[VX] < mOriginGlobal.mdV[VX] + mMetersPerEdge  &&
  840. pos_global.mdV[VY] >= mOriginGlobal.mdV[VY]  &&  
  841. pos_global.mdV[VY] < mOriginGlobal.mdV[VY] + mMetersPerEdge)
  842. {
  843. U32 i, j, k;
  844. F32 dx, dy;
  845. i = (U32) ((pos_global.mdV[VX] - mOriginGlobal.mdV[VX]) * oometerspergrid);
  846. j = (U32) ((pos_global.mdV[VY] - mOriginGlobal.mdV[VY]) * oometerspergrid );
  847. k = i + j*mGridsPerEdge;
  849. // Figure out if v is in first or second triangle of the square
  850. // and calculate the slopes accordingly
  851. //    |       |
  852. // -(k+N)---(k+1+N)--   
  853. //    |  1 /  |          ^
  854. //    |   / 2 |          |
  855. //    |  /    |          j
  856. // --(k)----(k+1)--
  857. //    |       |
  858. // 
  859. //      i ->
  860. // where N = mGridsPerEdge
  862. // dx and dy are incremental steps from (mSurface + k)
  863. dx = (F32)(pos_global.mdV[VX] - i*mMetersPerGrid - mOriginGlobal.mdV[VX]);
  864. dy = (F32)(pos_global.mdV[VY] - j*mMetersPerGrid - mOriginGlobal.mdV[VY]);
  865. if (dy > dx) 
  866. {  // triangle 1
  867. dzx = *(mSurfaceZ + k + 1 + mGridsPerEdge) - *(mSurfaceZ + k + mGridsPerEdge);
  868. dzy = *(mSurfaceZ + k) - *(mSurfaceZ + k + mGridsPerEdge);
  869. normal.setVec(-dzx,dzy,1);
  870. }
  871. else 
  872. { // triangle 2
  873. dzx = *(mSurfaceZ + k) - *(mSurfaceZ + k + 1);
  874. dzy = *(mSurfaceZ + k + 1 + mGridsPerEdge) - *(mSurfaceZ + k + 1);
  875. normal.setVec(dzx,-dzy,1);
  876. }
  877. }
  878. normal.normVec();
  879. return normal;
  882. }
  884. LLSurfacePatch *LLSurface::resolvePatchRegion(const F32 x, const F32 y) const
  885. {
  886. // x and y should be region-local coordinates. 
  887. // If x and y are outside of the surface, then the returned
  888. // index will be for the nearest boundary patch.
  889. //
  890. // 12      | 13| 14|       15
  891. //         |   |   |    
  892. //     +---+---+---+---+
  893. //     | 12| 13| 14| 15|
  894. // ----+---+---+---+---+-----
  895. // 8   | 8 | 9 | 10| 11|   11
  896. // ----+---+---+---+---+-----
  897. // 4   | 4 | 5 | 6 | 7 |    7
  898. // ----+---+---+---+---+-----
  899. //     | 0 | 1 | 2 | 3 |
  900. //     +---+---+---+---+
  901. //         |   |   |    
  902. // 0       | 1 | 2 |        3
  903. //
  905. // When x and y are not region-local do the following first
  907. S32 i, j;
  908. if (x < 0.0f)
  909. {
  910. i = 0;
  911. }
  912. else if (x >= mMetersPerEdge)
  913. {
  914. i = mPatchesPerEdge - 1;
  915. }
  916. else
  917. {
  918. i = (U32) (x / (mMetersPerGrid * mGridsPerPatchEdge));
  919. }
  921. if (y < 0.0f)
  922. {
  923. j = 0;
  924. }
  925. else if (y >= mMetersPerEdge)
  926. {
  927. j = mPatchesPerEdge - 1;
  928. }
  929. else
  930. {
  931. j = (U32) (y / (mMetersPerGrid * mGridsPerPatchEdge));
  932. }
  934. // *NOTE: Super paranoia code follows.
  935. S32 index = i + j * mPatchesPerEdge;
  936. if((index < 0) || (index >= mNumberOfPatches))
  937. {
  938. if(0 == mNumberOfPatches)
  939. {
  940. llwarns << "No patches for current region!" << llendl;
  941. return NULL;
  942. }
  943. S32 old_index = index;
  944. index = llclamp(old_index, 0, (mNumberOfPatches - 1));
  945. llwarns << "Clamping out of range patch index " << old_index
  946. << " to " << index << llendl;
  947. }
  948. return &(mPatchList[index]);
  949. }
  952. LLSurfacePatch *LLSurface::resolvePatchRegion(const LLVector3 &pos_region) const
  953. {
  954. return resolvePatchRegion(pos_region.mV[VX], pos_region.mV[VY]);
  955. }
  958. LLSurfacePatch *LLSurface::resolvePatchGlobal(const LLVector3d &pos_global) const
  959. {
  960. LLVector3 pos_region = mRegionp->getPosRegionFromGlobal(pos_global);
  961. return resolvePatchRegion(pos_region);
  962. }
  965. std::ostream& operator<<(std::ostream &s, const LLSurface &S) 
  966. {
  967. s << "{ n";
  968. s << "  mGridsPerEdge = " << S.mGridsPerEdge - 1 << " + 1n";
  969. s << "  mGridsPerPatchEdge = " << S.mGridsPerPatchEdge << "n";
  970. s << "  mPatchesPerEdge = " << S.mPatchesPerEdge << "n";
  971. s << "  mOriginGlobal = " << S.mOriginGlobal << "n";
  972. s << "  mMetersPerGrid = " << S.mMetersPerGrid << "n";
  973. s << "  mVisiblePatchCount = " << S.mVisiblePatchCount << "n";
  974. s << "}";
  975. return s;
  976. }
  979. // ---------------- LLSurface:: Protected ----------------
  981. void LLSurface::createPatchData() 
  982. {
  983. // Assumes mGridsPerEdge, mGridsPerPatchEdge, and mPatchesPerEdge have been properly set
  984. // TODO -- check for create() called when surface is not empty
  985. S32 i, j;
  986. LLSurfacePatch *patchp;
  988. // Allocate memory
  989. mPatchList = new LLSurfacePatch[mNumberOfPatches];
  991. // One of each for each camera
  992. mVisiblePatchCount = mNumberOfPatches;
  994. for (j=0; j<mPatchesPerEdge; j++) 
  995. {
  996. for (i=0; i<mPatchesPerEdge; i++) 
  997. {
  998. patchp = getPatch(i, j);
  999. patchp->setSurface(this);
  1000. }
  1001. }
  1003. for (j=0; j<mPatchesPerEdge; j++) 
  1004. {
  1005. for (i=0; i<mPatchesPerEdge; i++) 
  1006. {
  1007. patchp = getPatch(i, j);
  1008. patchp->mHasReceivedData = FALSE;
  1009. patchp->mSTexUpdate = TRUE;
  1011. S32 data_offset = i * mGridsPerPatchEdge + j * mGridsPerPatchEdge * mGridsPerEdge;
  1013. patchp->setDataZ(mSurfaceZ + data_offset);
  1014. patchp->setDataNorm(mNorm + data_offset);
  1017. // We make each patch point to its neighbors so we can do resolution checking 
  1018. // when butting up different resolutions.  Patches that don't have neighbors
  1019. // somewhere will point to NULL on that side.
  1020. if (i < mPatchesPerEdge-1)  
  1021. {
  1022. patchp->setNeighborPatch(EAST,getPatch(i+1, j));
  1023. }
  1024. else 
  1025. {
  1026. patchp->setNeighborPatch(EAST, NULL);
  1027. }
  1029. if (j < mPatchesPerEdge-1)  
  1030. {
  1031. patchp->setNeighborPatch(NORTH, getPatch(i, j+1));
  1032. }
  1033. else 
  1034. {
  1035. patchp->setNeighborPatch(NORTH, NULL);
  1036. }
  1038. if (i > 0) 
  1039. {
  1040. patchp->setNeighborPatch(WEST, getPatch(i - 1, j));
  1041. }
  1042. else 
  1043. {
  1044. patchp->setNeighborPatch(WEST, NULL);
  1045. }
  1047. if (j > 0)  
  1048. {
  1049. patchp->setNeighborPatch(SOUTH, getPatch(i, j-1));
  1050. }
  1051. else 
  1052. {
  1053. patchp->setNeighborPatch(SOUTH, NULL);
  1054. }
  1056. if (i < (mPatchesPerEdge-1)  &&  j < (mPatchesPerEdge-1)) 
  1057. {
  1058. patchp->setNeighborPatch(NORTHEAST, getPatch(i + 1, j + 1));
  1059. }
  1060. else 
  1061. {
  1062. patchp->setNeighborPatch(NORTHEAST, NULL);
  1063. }
  1065. if (i > 0  &&  j < (mPatchesPerEdge-1)) 
  1066. {
  1067. patchp->setNeighborPatch(NORTHWEST, getPatch(i - 1, j + 1));
  1068. }
  1069. else 
  1070. {
  1071. patchp->setNeighborPatch(NORTHWEST, NULL);
  1072. }
  1074. if (i > 0  &&  j > 0) 
  1075. {
  1076. patchp->setNeighborPatch(SOUTHWEST, getPatch(i - 1, j - 1));
  1077. }
  1078. else 
  1079. {
  1080. patchp->setNeighborPatch(SOUTHWEST, NULL);
  1081. }
  1083. if (i < (mPatchesPerEdge-1)  &&  j > 0) 
  1084. {
  1085. patchp->setNeighborPatch(SOUTHEAST, getPatch(i + 1, j - 1));
  1086. }
  1087. else 
  1088. {
  1089. patchp->setNeighborPatch(SOUTHEAST, NULL);
  1090. }
  1092. LLVector3d origin_global;
  1093. origin_global.mdV[0] = mOriginGlobal.mdV[0] + i * mMetersPerGrid * mGridsPerPatchEdge;
  1094. origin_global.mdV[1] = mOriginGlobal.mdV[0] + j * mMetersPerGrid * mGridsPerPatchEdge;
  1095. origin_global.mdV[2] = 0.f;
  1096. patchp->setOriginGlobal(origin_global);
  1097. }
  1098. }
  1099. }
  1102. void LLSurface::destroyPatchData()
  1103. {
  1104. // Delete all of the cached patch data for these patches.
  1106. delete [] mPatchList;
  1107. mPatchList = NULL;
  1108. mVisiblePatchCount = 0;
  1109. }
  1112. void LLSurface::setTextureSize(const S32 texture_size)
  1113. {
  1114. sTextureSize = texture_size;
  1115. }
  1118. U32 LLSurface::getRenderLevel(const U32 render_stride) const
  1119. {
  1120. return mPVArray.mRenderLevelp[render_stride];
  1121. }
  1124. U32 LLSurface::getRenderStride(const U32 render_level) const
  1125. {
  1126. return mPVArray.mRenderStridep[render_level];
  1127. }
  1130. LLSurfacePatch *LLSurface::getPatch(const S32 x, const S32 y) const
  1131. {
  1132. if ((x < 0) || (x >= mPatchesPerEdge))
  1133. {
  1134. llerrs << "Asking for patch out of bounds" << llendl;
  1135. return NULL;
  1136. }
  1137. if ((y < 0) || (y >= mPatchesPerEdge))
  1138. {
  1139. llerrs << "Asking for patch out of bounds" << llendl;
  1140. return NULL;
  1141. }
  1143. return mPatchList + x + y*mPatchesPerEdge;
  1144. }
  1147. void LLSurface::dirtyAllPatches()
  1148. {
  1149. S32 i;
  1150. for (i = 0; i < mNumberOfPatches; i++)
  1151. {
  1152. mPatchList[i].dirtyZ();
  1153. }
  1154. }
  1156. void LLSurface::dirtySurfacePatch(LLSurfacePatch *patchp)
  1157. {
  1158. // Put surface patch on dirty surface patch list
  1159. mDirtyPatchList.insert(patchp);
  1160. }
  1163. void LLSurface::setWaterHeight(F32 height)
  1164. {
  1165. if (!mWaterObjp.isNull())
  1166. {
  1167. LLVector3 water_pos_region = mWaterObjp->getPositionRegion();
  1168. water_pos_region.mV[VZ] = height;
  1169. mWaterObjp->setPositionRegion(water_pos_region);
  1170. }
  1171. else
  1172. {
  1173. llwarns << "LLSurface::setWaterHeight with no water object!" << llendl;
  1174. }
  1175. }
  1177. F32 LLSurface::getWaterHeight() const
  1178. {
  1179. if (!mWaterObjp.isNull())
  1180. {
  1181. // we have a water object, the usual case
  1182. return mWaterObjp->getPositionRegion().mV[VZ];
  1183. }
  1184. else
  1185. {
  1186. return DEFAULT_WATER_HEIGHT;
  1187. }
  1188. }
  1191. BOOL LLSurface::generateWaterTexture(const F32 x, const F32 y,
  1192.  const F32 width, const F32 height)
  1193. {
  1194. if (!getWaterTexture())
  1195. {
  1196. return FALSE;
  1197. }
  1199. S32 tex_width = mWaterTexturep->getWidth();
  1200. S32 tex_height = mWaterTexturep->getHeight();
  1201. S32 tex_comps = mWaterTexturep->getComponents();
  1202. S32 tex_stride = tex_width * tex_comps;
  1203. LLPointer<LLImageRaw> raw = new LLImageRaw(tex_width, tex_height, tex_comps);
  1204. U8 *rawp = raw->getData();
  1206. F32 scale = 256.f * getMetersPerGrid() / (F32)tex_width;
  1207. F32 scale_inv = 1.f / scale;
  1209. S32 x_begin, y_begin, x_end, y_end;
  1211. x_begin = llround(x * scale_inv);
  1212. y_begin = llround(y * scale_inv);
  1213. x_end = llround((x + width) * scale_inv);
  1214. y_end = llround((y + width) * scale_inv);
  1216. if (x_end > tex_width)
  1217. {
  1218. x_end = tex_width;
  1219. }
  1220. if (y_end > tex_width)
  1221. {
  1222. y_end = tex_width;
  1223. }
  1225. LLVector3d origin_global = from_region_handle(getRegion()->getHandle());
  1227. // OK, for now, just have the composition value equal the height at the point.
  1228. LLVector3 location;
  1229. LLColor4U coloru;
  1231. const F32 WATER_HEIGHT = getWaterHeight();
  1233. S32 i, j, offset;
  1234. for (j = y_begin; j < y_end; j++)
  1235. {
  1236. for (i = x_begin; i < x_end; i++)
  1237. {
  1238. //F32 nv[2];
  1239. //nv[0] = i/256.f;
  1240. //nv[1] = j/256.f;
  1241. // const S32 modulation = noise2(nv)*40;
  1242. offset = j*tex_stride + i*tex_comps;
  1243. location.mV[VX] = i*scale;
  1244. location.mV[VY] = j*scale;
  1246. // Sample multiple points
  1247. const F32 height = resolveHeightRegion(location);
  1249. if (height > WATER_HEIGHT)
  1250. {
  1251. // Above water...
  1252. coloru = MAX_WATER_COLOR;
  1253. coloru.mV[3] = ABOVE_WATERLINE_ALPHA;
  1254. *(rawp + offset++) = coloru.mV[0];
  1255. *(rawp + offset++) = coloru.mV[1];
  1256. *(rawp + offset++) = coloru.mV[2];
  1257. *(rawp + offset++) = coloru.mV[3];
  1258. }
  1259. else
  1260. {
  1261. // Want non-linear curve for transparency gradient
  1262. coloru = MAX_WATER_COLOR;
  1263. const F32 frac = 1.f - 2.f/(2.f - (height - WATER_HEIGHT));
  1264. S32 alpha = 64 + llround((255-64)*frac);
  1266. alpha = llmin(llround((F32)MAX_WATER_COLOR.mV[3]), alpha);
  1267. alpha = llmax(64, alpha);
  1269. coloru.mV[3] = alpha;
  1270. *(rawp + offset++) = coloru.mV[0];
  1271. *(rawp + offset++) = coloru.mV[1];
  1272. *(rawp + offset++) = coloru.mV[2];
  1273. *(rawp + offset++) = coloru.mV[3];
  1274. }
  1275. }
  1276. }
  1278. if (!mWaterTexturep->hasGLTexture())
  1279. {
  1280. mWaterTexturep->createGLTexture(0, raw);
  1281. }
  1283. mWaterTexturep->setSubImage(raw, x_begin, y_begin, x_end - x_begin, y_end - y_begin);
  1284. return TRUE;
  1285. }