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

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

游戏引擎

开发平台：

C++ Builder

llviewerregion.cpp：源码内容
  1. /** 
  2.  * @file llviewerregion.cpp
  3.  * @brief Implementation of the LLViewerRegion 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 "llviewerregion.h"
  37. #include "indra_constants.h"
  38. #include "llfloaterreg.h"
  39. #include "llmath.h"
  40. #include "llhttpclient.h"
  41. #include "llregionflags.h"
  42. #include "llregionhandle.h"
  43. #include "llsurface.h"
  44. #include "message.h"
  45. //#include "vmath.h"
  46. #include "v3math.h"
  47. #include "v4math.h"
  49. #include "llagent.h"
  50. #include "llcallingcard.h"
  51. #include "llcaphttpsender.h"
  52. #include "lldir.h"
  53. #include "lleventpoll.h"
  54. #include "llfloatergodtools.h"
  55. #include "llfloaterreporter.h"
  56. #include "llfloaterregioninfo.h"
  57. #include "llhttpnode.h"
  58. #include "llsdutil.h"
  59. #include "llstartup.h"
  60. #include "lltrans.h"
  61. #include "llviewerobjectlist.h"
  62. #include "llviewerparceloverlay.h"
  63. #include "llvlmanager.h"
  64. #include "llvlcomposition.h"
  65. #include "llvocache.h"
  66. #include "llvoclouds.h"
  67. #include "llworld.h"
  68. #include "llspatialpartition.h"
  69. #include "stringize.h"
  71. #ifdef LL_WINDOWS
  72. #pragma warning(disable:4355)
  73. #endif
  75. // Viewer object cache version, change if object update
  76. // format changes. JC
  77. const U32 INDRA_OBJECT_CACHE_VERSION = 14;
  80. extern BOOL gNoRender;
  82. const F32 WATER_TEXTURE_SCALE = 8.f; //  Number of times to repeat the water texture across a region
  83. const S16 MAX_MAP_DIST = 10;
  85. class BaseCapabilitiesComplete : public LLHTTPClient::Responder
  86. {
  87. LOG_CLASS(BaseCapabilitiesComplete);
  88. public:
  89.     BaseCapabilitiesComplete(LLViewerRegion* region)
  90. : mRegion(region)
  91.     { }
  92. virtual ~BaseCapabilitiesComplete()
  93. {
  94. if(mRegion)
  95. {
  96. mRegion->setHttpResponderPtrNULL() ;
  97. }
  98. }
  100. void setRegion(LLViewerRegion* region)
  101. {
  102. mRegion = region ;
  103. }
  105.     void error(U32 statusNum, const std::string& reason)
  106.     {
  107. LL_WARNS2("AppInit", "Capabilities") << statusNum << ": " << reason << LL_ENDL;
  109. if (STATE_SEED_GRANTED_WAIT == LLStartUp::getStartupState())
  110. {
  111. LLStartUp::setStartupState( STATE_SEED_CAP_GRANTED );
  112. }
  113.     }
  115.     void result(const LLSD& content)
  116.     {
  117. if(!mRegion || LLHTTPClient::ResponderPtr(this) != mRegion->getHttpResponderPtr()) //region is removed or responder is not created.
  118. {
  119. return ;
  120. }
  122. LLSD::map_const_iterator iter;
  123. for(iter = content.beginMap(); iter != content.endMap(); ++iter)
  124. {
  125. mRegion->setCapability(iter->first, iter->second);
  126. LL_DEBUGS2("AppInit", "Capabilities") << "got capability for " 
  127. << iter->first << LL_ENDL;
  129. /* HACK we're waiting for the ServerReleaseNotes */
  130. if (iter->first == "ServerReleaseNotes" && mRegion->getReleaseNotesRequested())
  131. {
  132. mRegion->showReleaseNotes();
  133. }
  134. }
  136. if (STATE_SEED_GRANTED_WAIT == LLStartUp::getStartupState())
  137. {
  138. LLStartUp::setStartupState( STATE_SEED_CAP_GRANTED );
  139. }
  140. }
  142.     static boost::intrusive_ptr<BaseCapabilitiesComplete> build(
  143. LLViewerRegion* region)
  144.     {
  145. return boost::intrusive_ptr<BaseCapabilitiesComplete>(
  146.  new BaseCapabilitiesComplete(region));
  147.     }
  149. private:
  150. LLViewerRegion* mRegion;
  151. };
  154. LLViewerRegion::LLViewerRegion(const U64 &handle,
  155.    const LLHost &host,
  156.    const U32 grids_per_region_edge, 
  157.    const U32 grids_per_patch_edge, 
  158.    const F32 region_width_meters)
  159. : mCenterGlobal(),
  160. mHandle(handle),
  161. mHost( host ),
  162. mTimeDilation(1.0f),
  163. mName(""),
  164. mZoning(""),
  165. mOwnerID(),
  166. mIsEstateManager(FALSE),
  167. mCompositionp(NULL),
  168. mRegionFlags( REGION_FLAGS_DEFAULT ),
  169. mSimAccess( SIM_ACCESS_MIN ),
  170. mBillableFactor(1.0),
  171. mMaxTasks(DEFAULT_MAX_REGION_WIDE_PRIM_COUNT),
  172. mClassID(0),
  173. mCPURatio(0),
  174. mColoName("unknown"),
  175. mProductSKU("unknown"),
  176. mProductName("unknown"),
  177. mCacheLoaded(FALSE),
  178. mCacheEntriesCount(0),
  179. mCacheID(),
  180. mEventPoll(NULL),
  181. mReleaseNotesRequested(FALSE),
  182.     // I'd prefer to set the LLCapabilityListener name to match the region
  183.     // name -- it's disappointing that's not available at construction time.
  184.     // We could instead store an LLCapabilityListener*, making
  185.     // setRegionNameAndZone() replace the instance. Would that pose
  186.     // consistency problems? Can we even request a capability before calling
  187.     // setRegionNameAndZone()?
  188.     // For testability -- the new Michael Feathers paradigm --
  189.     // LLCapabilityListener binds all the globals it expects to need at
  190.     // construction time.
  191.     mCapabilityListener(host.getString(), gMessageSystem, *this,
  192.                         gAgent.getID(), gAgent.getSessionID())
  193. {
  194. mWidth = region_width_meters;
  195. mOriginGlobal = from_region_handle(handle); 
  196. updateRenderMatrix();
  198. mLandp = new LLSurface('l', NULL);
  199. if (!gNoRender)
  200. {
  201. // Create the composition layer for the surface
  202. mCompositionp = new LLVLComposition(mLandp, grids_per_region_edge, region_width_meters/grids_per_region_edge);
  203. mCompositionp->setSurface(mLandp);
  205. // Create the surfaces
  206. mLandp->setRegion(this);
  207. mLandp->create(grids_per_region_edge,
  208. grids_per_patch_edge,
  209. mOriginGlobal,
  210. mWidth);
  211. }
  213. if (!gNoRender)
  214. {
  215. mParcelOverlay = new LLViewerParcelOverlay(this, region_width_meters);
  216. }
  217. else
  218. {
  219. mParcelOverlay = NULL;
  220. }
  222. setOriginGlobal(from_region_handle(handle));
  223. calculateCenterGlobal();
  225. // Create the object lists
  226. initStats();
  228. mCacheStart.append(mCacheEnd);
  230. //create object partitions
  231. //MUST MATCH declaration of eObjectPartitions
  232. mObjectPartition.push_back(new LLHUDPartition()); //PARTITION_HUD
  233. mObjectPartition.push_back(new LLTerrainPartition()); //PARTITION_TERRAIN
  234. mObjectPartition.push_back(new LLWaterPartition()); //PARTITION_WATER
  235. mObjectPartition.push_back(new LLTreePartition()); //PARTITION_TREE
  236. mObjectPartition.push_back(new LLParticlePartition()); //PARTITION_PARTICLE
  237. mObjectPartition.push_back(new LLCloudPartition()); //PARTITION_CLOUD
  238. mObjectPartition.push_back(new LLGrassPartition()); //PARTITION_GRASS
  239. mObjectPartition.push_back(new LLVolumePartition()); //PARTITION_VOLUME
  240. mObjectPartition.push_back(new LLBridgePartition()); //PARTITION_BRIDGE
  241. mObjectPartition.push_back(new LLHUDParticlePartition());//PARTITION_HUD_PARTICLE
  242. mObjectPartition.push_back(NULL); //PARTITION_NONE
  243. }
  246. void LLViewerRegion::initStats()
  247. {
  248. mLastNetUpdate.reset();
  249. mPacketsIn = 0;
  250. mBitsIn = 0;
  251. mLastBitsIn = 0;
  252. mLastPacketsIn = 0;
  253. mPacketsOut = 0;
  254. mLastPacketsOut = 0;
  255. mPacketsLost = 0;
  256. mLastPacketsLost = 0;
  257. mPingDelay = 0;
  258. mAlive = false; // can become false if circuit disconnects
  259. }
  261. LLViewerRegion::~LLViewerRegion() 
  262. {
  263. if(mHttpResponderPtr)
  264. {
  265. (static_cast<BaseCapabilitiesComplete*>(mHttpResponderPtr.get()))->setRegion(NULL) ;
  266. }
  268. gVLManager.cleanupData(this);
  269. // Can't do this on destruction, because the neighbor pointers might be invalid.
  270. // This should be reference counted...
  271. disconnectAllNeighbors();
  272. mCloudLayer.destroy();
  273. LLViewerPartSim::getInstance()->cleanupRegion(this);
  275. gObjectList.killObjects(this);
  277. delete mCompositionp;
  278. delete mParcelOverlay;
  279. delete mLandp;
  280. delete mEventPoll;
  281. LLHTTPSender::clearSender(mHost);
  283. saveCache();
  285. std::for_each(mObjectPartition.begin(), mObjectPartition.end(), DeletePointer());
  286. }
  289. void LLViewerRegion::loadCache()
  290. {
  291. if (mCacheLoaded)
  292. {
  293. return;
  294. }
  296. // Presume success.  If it fails, we don't want to try again.
  297. mCacheLoaded = TRUE;
  299. LLVOCacheEntry *entry;
  301. std::string filename;
  302. filename = gDirUtilp->getExpandedFilename(LL_PATH_CACHE,"") + gDirUtilp->getDirDelimiter() +
  303. llformat("objects_%d_%d.slc",U32(mHandle>>32)/REGION_WIDTH_UNITS, U32(mHandle)/REGION_WIDTH_UNITS );
  305. LLFILE* fp = LLFile::fopen(filename, "rb"); /* Flawfinder: ignore */
  306. if (!fp)
  307. {
  308. // might not have a file, which is normal
  309. return;
  310. }
  312. U32 zero;
  313. size_t nread;
  314. nread = fread(&zero, sizeof(U32), 1, fp);
  315. if (nread != 1 || zero)
  316. {
  317. // a non-zero value here means bad things!
  318. // skip reading the cached values
  319. llinfos << "Cache file invalid" << llendl;
  320. fclose(fp);
  321. return;
  322. }
  324. U32 version;
  325. nread = fread(&version, sizeof(U32), 1, fp);
  326. if (nread != 1 || version != INDRA_OBJECT_CACHE_VERSION)
  327. {
  328. // a version mismatch here means we've changed the binary format!
  329. // skip reading the cached values
  330. llinfos << "Cache version changed, discarding" << llendl;
  331. fclose(fp);
  332. return;
  333. }
  335. LLUUID cache_id;
  336. nread = fread(&cache_id.mData, 1, UUID_BYTES, fp);
  337. if (nread != (size_t)UUID_BYTES || mCacheID != cache_id)
  338. {
  339. llinfos << "Cache ID doesn't match for this region, discarding"
  340. << llendl;
  341. fclose(fp);
  342. return;
  343. }
  345. S32 num_entries;
  346. nread = fread(&num_entries, sizeof(S32), 1, fp);
  347. if (nread != 1)
  348. {
  349. llinfos << "Short read, discarding" << llendl;
  350. fclose(fp);
  351. return;
  352. }
  354. S32 i;
  355. for (i = 0; i < num_entries; i++)
  356. {
  357. entry = new LLVOCacheEntry(fp);
  358. if (!entry->getLocalID())
  359. {
  360. llwarns << "Aborting cache file load for " << filename << ", cache file corruption!" << llendl;
  361. delete entry;
  362. entry = NULL;
  363. break;
  364. }
  365. mCacheEnd.insert(*entry);
  366. mCacheMap[entry->getLocalID()] = entry;
  367. mCacheEntriesCount++;
  368. }
  370. fclose(fp);
  371. }
  374. void LLViewerRegion::saveCache()
  375. {
  376. if (!mCacheLoaded)
  377. {
  378. return;
  379. }
  381. S32 num_entries = mCacheEntriesCount;
  382. if (0 == num_entries)
  383. {
  384. return;
  385. }
  387. std::string filename;
  388. filename = gDirUtilp->getExpandedFilename(LL_PATH_CACHE,"") + gDirUtilp->getDirDelimiter() +
  389. llformat("sobjects_%d_%d.slc", U32(mHandle>>32)/REGION_WIDTH_UNITS, U32(mHandle)/REGION_WIDTH_UNITS );
  391. LLFILE* fp = LLFile::fopen(filename, "wb"); /* Flawfinder: ignore */
  392. if (!fp)
  393. {
  394. llwarns << "Unable to write cache file " << filename << llendl;
  395. return;
  396. }
  398. // write out zero to indicate a version cache file
  399. U32 zero = 0;
  400. if (fwrite(&zero, sizeof(U32), 1, fp) != 1)
  401. {
  402. llwarns << "Short write" << llendl;
  403. }
  405. // write out version number
  406. U32 version = INDRA_OBJECT_CACHE_VERSION;
  407. if (fwrite(&version, sizeof(U32), 1, fp) != 1)
  408. {
  409. llwarns << "Short write" << llendl;
  410. }
  412. // write the cache id for this sim
  413. if (fwrite(&mCacheID.mData, 1, UUID_BYTES, fp) != (size_t)UUID_BYTES)
  414. {
  415. llwarns << "Short write" << llendl;
  416. }
  418. if (fwrite(&num_entries, sizeof(S32), 1, fp) != 1)
  419. {
  420. llwarns << "Short write" << llendl;
  421. }
  423. LLVOCacheEntry *entry;
  425. for (entry = mCacheStart.getNext(); entry && (entry != &mCacheEnd); entry = entry->getNext())
  426. {
  427. entry->writeToFile(fp);
  428. }
  430. mCacheMap.clear();
  431. mCacheEnd.unlink();
  432. mCacheEnd.init();
  433. mCacheStart.deleteAll();
  434. mCacheStart.init();
  436. fclose(fp);
  437. }
  439. void LLViewerRegion::sendMessage()
  440. {
  441. gMessageSystem->sendMessage(mHost);
  442. }
  444. void LLViewerRegion::sendReliableMessage()
  445. {
  446. gMessageSystem->sendReliable(mHost);
  447. }
  449. void LLViewerRegion::setFlags(BOOL b, U32 flags)
  450. {
  451. if (b)
  452. {
  453. mRegionFlags |=  flags;
  454. }
  455. else
  456. {
  457. mRegionFlags &= ~flags;
  458. }
  459. }
  461. void LLViewerRegion::setWaterHeight(F32 water_level)
  462. {
  463. mLandp->setWaterHeight(water_level);
  464. }
  466. F32 LLViewerRegion::getWaterHeight() const
  467. {
  468. return mLandp->getWaterHeight();
  469. }
  471. BOOL LLViewerRegion::isVoiceEnabled() const
  472. {
  473. return (getRegionFlags() & REGION_FLAGS_ALLOW_VOICE);
  474. }
  476. void LLViewerRegion::setRegionFlags(U32 flags)
  477. {
  478. mRegionFlags = flags;
  479. }
  482. void LLViewerRegion::setOriginGlobal(const LLVector3d &origin_global) 
  483. { 
  484. mOriginGlobal = origin_global; 
  485. updateRenderMatrix();
  486. mLandp->setOriginGlobal(origin_global);
  487. mWind.setOriginGlobal(origin_global);
  488. mCloudLayer.setOriginGlobal(origin_global);
  489. calculateCenterGlobal();
  490. }
  492. void LLViewerRegion::updateRenderMatrix()
  493. {
  494. mRenderMatrix.setTranslation(getOriginAgent());
  495. }
  497. void LLViewerRegion::setTimeDilation(F32 time_dilation)
  498. {
  499. mTimeDilation = time_dilation;
  500. }
  503. LLVector3 LLViewerRegion::getOriginAgent() const
  504. {
  505. return gAgent.getPosAgentFromGlobal(mOriginGlobal);
  506. }
  509. LLVector3 LLViewerRegion::getCenterAgent() const
  510. {
  511. return gAgent.getPosAgentFromGlobal(mCenterGlobal);
  512. }
  514. void LLViewerRegion::setRegionNameAndZone (const std::string& name_zone)
  515. {
  516. std::string::size_type pipe_pos = name_zone.find('|');
  517. S32 length   = name_zone.size();
  518. if (pipe_pos != std::string::npos)
  519. {
  520. mName   = name_zone.substr(0, pipe_pos);
  521. mZoning = name_zone.substr(pipe_pos+1, length-(pipe_pos+1));
  522. }
  523. else
  524. {
  525. mName   = name_zone;
  526. mZoning = "";
  527. }
  529. LLStringUtil::stripNonprintable(mName);
  530. LLStringUtil::stripNonprintable(mZoning);
  531. }
  533. BOOL LLViewerRegion::canManageEstate() const
  534. {
  535. return gAgent.isGodlike()
  536. || isEstateManager()
  537. || gAgent.getID() == getOwner();
  538. }
  540. const std::string LLViewerRegion::getSimAccessString() const
  541. {
  542. return accessToString(mSimAccess);
  543. }
  546. // static
  547. std::string LLViewerRegion::regionFlagsToString(U32 flags)
  548. {
  549. std::string result;
  551. if (flags & REGION_FLAGS_SANDBOX)
  552. {
  553. result += "Sandbox";
  554. }
  556. if (flags & REGION_FLAGS_ALLOW_DAMAGE)
  557. {
  558. result += " Not Safe";
  559. }
  561. return result;
  562. }
  564. // static
  565. std::string LLViewerRegion::accessToString(U8 sim_access)
  566. {
  567. switch(sim_access)
  568. {
  569. case SIM_ACCESS_PG:
  570. return LLTrans::getString("SIM_ACCESS_PG");
  572. case SIM_ACCESS_MATURE:
  573. return LLTrans::getString("SIM_ACCESS_MATURE");
  575. case SIM_ACCESS_ADULT:
  576. return LLTrans::getString("SIM_ACCESS_ADULT");
  578. case SIM_ACCESS_DOWN:
  579. return LLTrans::getString("SIM_ACCESS_DOWN");
  581. case SIM_ACCESS_MIN:
  582. default:
  583. return LLTrans::getString("SIM_ACCESS_MIN");
  584. }
  585. }
  587. // static
  588. std::string LLViewerRegion::accessToShortString(U8 sim_access)
  589. {
  590. switch(sim_access) /* Flawfinder: ignore */
  591. {
  592. case SIM_ACCESS_PG:
  593. return "PG";
  595. case SIM_ACCESS_MATURE:
  596. return "M";
  598. case SIM_ACCESS_ADULT:
  599. return "A";
  601. case SIM_ACCESS_MIN:
  602. default:
  603. return "U";
  604. }
  605. }
  607. // static
  608. void LLViewerRegion::processRegionInfo(LLMessageSystem* msg, void**)
  609. {
  610. // send it to 'observers'
  611. LLFloaterGodTools::processRegionInfo(msg);
  612. LLFloaterRegionInfo::processRegionInfo(msg);
  613. LLFloaterReporter::processRegionInfo(msg);
  614. }
  618. S32 LLViewerRegion::renderPropertyLines()
  619. {
  620. if (mParcelOverlay)
  621. {
  622. return mParcelOverlay->renderPropertyLines();
  623. }
  624. else
  625. {
  626. return 0;
  627. }
  628. }
  630. // This gets called when the height field changes.
  631. void LLViewerRegion::dirtyHeights()
  632. {
  633. // Property lines need to be reconstructed when the land changes.
  634. if (mParcelOverlay)
  635. {
  636. mParcelOverlay->setDirty();
  637. }
  638. }
  640. BOOL LLViewerRegion::idleUpdate(F32 max_update_time)
  641. {
  642. LLMemType mt_ivr(LLMemType::MTYPE_IDLE_UPDATE_VIEWER_REGION);
  643. // did_update returns TRUE if we did at least one significant update
  644. BOOL did_update = mLandp->idleUpdate(max_update_time);
  646. if (mParcelOverlay)
  647. {
  648. // Hopefully not a significant time sink...
  649. mParcelOverlay->idleUpdate();
  650. }
  652. return did_update;
  653. }
  656. // As above, but forcibly do the update.
  657. void LLViewerRegion::forceUpdate()
  658. {
  659. mLandp->idleUpdate(0.f);
  661. if (mParcelOverlay)
  662. {
  663. mParcelOverlay->idleUpdate(true);
  664. }
  665. }
  667. void LLViewerRegion::connectNeighbor(LLViewerRegion *neighborp, U32 direction)
  668. {
  669. mLandp->connectNeighbor(neighborp->mLandp, direction);
  670. mCloudLayer.connectNeighbor(&(neighborp->mCloudLayer), direction);
  671. }
  674. void LLViewerRegion::disconnectAllNeighbors()
  675. {
  676. mLandp->disconnectAllNeighbors();
  677. mCloudLayer.disconnectAllNeighbors();
  678. }
  681. F32 LLViewerRegion::getCompositionXY(const S32 x, const S32 y) const
  682. {
  683. if (x >= 256)
  684. {
  685. if (y >= 256)
  686. {
  687. LLVector3d center = getCenterGlobal() + LLVector3d(256.f, 256.f, 0.f);
  688. LLViewerRegion *regionp = LLWorld::getInstance()->getRegionFromPosGlobal(center);
  689. if (regionp)
  690. {
  691. // OK, we need to do some hackery here - different simulators no longer use
  692. // the same composition values, necessarily.
  693. // If we're attempting to blend, then we want to make the fractional part of
  694. // this region match the fractional of the adjacent.  For now, just minimize
  695. // the delta.
  696. F32 our_comp = getComposition()->getValueScaled(255, 255);
  697. F32 adj_comp = regionp->getComposition()->getValueScaled(x - 256.f, y - 256.f);
  698. while (llabs(our_comp - adj_comp) >= 1.f)
  699. {
  700. if (our_comp > adj_comp)
  701. {
  702. adj_comp += 1.f;
  703. }
  704. else
  705. {
  706. adj_comp -= 1.f;
  707. }
  708. }
  709. return adj_comp;
  710. }
  711. }
  712. else
  713. {
  714. LLVector3d center = getCenterGlobal() + LLVector3d(256.f, 0, 0.f);
  715. LLViewerRegion *regionp = LLWorld::getInstance()->getRegionFromPosGlobal(center);
  716. if (regionp)
  717. {
  718. // OK, we need to do some hackery here - different simulators no longer use
  719. // the same composition values, necessarily.
  720. // If we're attempting to blend, then we want to make the fractional part of
  721. // this region match the fractional of the adjacent.  For now, just minimize
  722. // the delta.
  723. F32 our_comp = getComposition()->getValueScaled(255.f, (F32)y);
  724. F32 adj_comp = regionp->getComposition()->getValueScaled(x - 256.f, (F32)y);
  725. while (llabs(our_comp - adj_comp) >= 1.f)
  726. {
  727. if (our_comp > adj_comp)
  728. {
  729. adj_comp += 1.f;
  730. }
  731. else
  732. {
  733. adj_comp -= 1.f;
  734. }
  735. }
  736. return adj_comp;
  737. }
  738. }
  739. }
  740. else if (y >= 256)
  741. {
  742. LLVector3d center = getCenterGlobal() + LLVector3d(0.f, 256.f, 0.f);
  743. LLViewerRegion *regionp = LLWorld::getInstance()->getRegionFromPosGlobal(center);
  744. if (regionp)
  745. {
  746. // OK, we need to do some hackery here - different simulators no longer use
  747. // the same composition values, necessarily.
  748. // If we're attempting to blend, then we want to make the fractional part of
  749. // this region match the fractional of the adjacent.  For now, just minimize
  750. // the delta.
  751. F32 our_comp = getComposition()->getValueScaled((F32)x, 255.f);
  752. F32 adj_comp = regionp->getComposition()->getValueScaled((F32)x, y - 256.f);
  753. while (llabs(our_comp - adj_comp) >= 1.f)
  754. {
  755. if (our_comp > adj_comp)
  756. {
  757. adj_comp += 1.f;
  758. }
  759. else
  760. {
  761. adj_comp -= 1.f;
  762. }
  763. }
  764. return adj_comp;
  765. }
  766. }
  768. return getComposition()->getValueScaled((F32)x, (F32)y);
  769. }
  771. void LLViewerRegion::calculateCenterGlobal() 
  772. {
  773. mCenterGlobal = mOriginGlobal;
  774. mCenterGlobal.mdV[VX] += 0.5 * mWidth;
  775. mCenterGlobal.mdV[VY] += 0.5 * mWidth;
  776. mCenterGlobal.mdV[VZ] = 0.5*mLandp->getMinZ() + mLandp->getMaxZ();
  777. }
  779. void LLViewerRegion::calculateCameraDistance()
  780. {
  781. mCameraDistanceSquared = (F32)(gAgent.getCameraPositionGlobal() - getCenterGlobal()).magVecSquared();
  782. }
  784. std::ostream& operator<<(std::ostream &s, const LLViewerRegion &region)
  785. {
  786. s << "{ ";
  787. s << region.mHost;
  788. s << " mOriginGlobal = " << region.getOriginGlobal()<< "n";
  789.     std::string name(region.getName()), zone(region.getZoning());
  790.     if (! name.empty())
  791.     {
  792.         s << " mName         = " << name << 'n';
  793.     }
  794.     if (! zone.empty())
  795.     {
  796.         s << " mZoning       = " << zone << 'n';
  797.     }
  798. s << "}";
  799. return s;
  800. }
  803. // ---------------- Protected Member Functions ----------------
  805. void LLViewerRegion::updateNetStats()
  806. {
  807. F32 dt = mLastNetUpdate.getElapsedTimeAndResetF32();
  809. LLCircuitData *cdp = gMessageSystem->mCircuitInfo.findCircuit(mHost);
  810. if (!cdp)
  811. {
  812. mAlive = false;
  813. return;
  814. }
  816. mAlive = true;
  817. mDeltaTime = dt;
  819. mLastPacketsIn = mPacketsIn;
  820. mLastBitsIn = mBitsIn;
  821. mLastPacketsOut = mPacketsOut;
  822. mLastPacketsLost = mPacketsLost;
  824. mPacketsIn = cdp->getPacketsIn();
  825. mBitsIn = 8 * cdp->getBytesIn();
  826. mPacketsOut = cdp->getPacketsOut();
  827. mPacketsLost = cdp->getPacketsLost();
  828. mPingDelay = cdp->getPingDelay();
  830. mBitStat.addValue(mBitsIn - mLastBitsIn);
  831. mPacketsStat.addValue(mPacketsIn - mLastPacketsIn);
  832. mPacketsLostStat.addValue(mPacketsLost);
  833. }
  836. U32 LLViewerRegion::getPacketsLost() const
  837. {
  838. LLCircuitData *cdp = gMessageSystem->mCircuitInfo.findCircuit(mHost);
  839. if (!cdp)
  840. {
  841. llinfos << "LLViewerRegion::getPacketsLost couldn't find circuit for " << mHost << llendl;
  842. return 0;
  843. }
  844. else
  845. {
  846. return cdp->getPacketsLost();
  847. }
  848. }
  850. BOOL LLViewerRegion::pointInRegionGlobal(const LLVector3d &point_global) const
  851. {
  852. LLVector3 pos_region = getPosRegionFromGlobal(point_global);
  854. if (pos_region.mV[VX] < 0)
  855. {
  856. return FALSE;
  857. }
  858. if (pos_region.mV[VX] >= mWidth)
  859. {
  860. return FALSE;
  861. }
  862. if (pos_region.mV[VY] < 0)
  863. {
  864. return FALSE;
  865. }
  866. if (pos_region.mV[VY] >= mWidth)
  867. {
  868. return FALSE;
  869. }
  870. return TRUE;
  871. }
  873. LLVector3 LLViewerRegion::getPosRegionFromGlobal(const LLVector3d &point_global) const
  874. {
  875. LLVector3 pos_region;
  876. pos_region.setVec(point_global - mOriginGlobal);
  877. return pos_region;
  878. }
  880. LLVector3d LLViewerRegion::getPosGlobalFromRegion(const LLVector3 &pos_region) const
  881. {
  882. LLVector3d pos_region_d;
  883. pos_region_d.setVec(pos_region);
  884. return pos_region_d + mOriginGlobal;
  885. }
  887. LLVector3 LLViewerRegion::getPosAgentFromRegion(const LLVector3 &pos_region) const
  888. {
  889. LLVector3d pos_global = getPosGlobalFromRegion(pos_region);
  891. return gAgent.getPosAgentFromGlobal(pos_global);
  892. }
  894. LLVector3 LLViewerRegion::getPosRegionFromAgent(const LLVector3 &pos_agent) const
  895. {
  896. return pos_agent - getOriginAgent();
  897. }
  899. F32 LLViewerRegion::getLandHeightRegion(const LLVector3& region_pos)
  900. {
  901. return mLandp->resolveHeightRegion( region_pos );
  902. }
  904. bool LLViewerRegion::isAlive()
  905. {
  906. return mAlive;
  907. }
  909. BOOL LLViewerRegion::isOwnedSelf(const LLVector3& pos)
  910. {
  911. if (mParcelOverlay)
  912. {
  913. return mParcelOverlay->isOwnedSelf(pos);
  914. } else {
  915. return FALSE;
  916. }
  917. }
  919. // Owned by a group you belong to?  (officer or member)
  920. BOOL LLViewerRegion::isOwnedGroup(const LLVector3& pos)
  921. {
  922. if (mParcelOverlay)
  923. {
  924. return mParcelOverlay->isOwnedGroup(pos);
  925. } else {
  926. return FALSE;
  927. }
  928. }
  930. // the new TCP coarse location handler node
  931. class CoarseLocationUpdate : public LLHTTPNode
  932. {
  933. public:
  934. virtual void post(
  935. ResponsePtr responder,
  936. const LLSD& context,
  937. const LLSD& input) const
  938. {
  939. LLHost host(input["sender"].asString());
  940. LLViewerRegion* region = LLWorld::getInstance()->getRegion(host);
  941. if( !region )
  942. {
  943. return;
  944. }
  946. S32 target_index = input["body"]["Index"][0]["Prey"].asInteger();
  947. S32 you_index    = input["body"]["Index"][0]["You" ].asInteger();
  949. LLDynamicArray<U32>* avatar_locs = &region->mMapAvatars;
  950. LLDynamicArray<LLUUID>* avatar_ids = &region->mMapAvatarIDs;
  951. avatar_locs->reset();
  952. avatar_ids->reset();
  954. //llinfos << "coarse locations agent[0] " << input["body"]["AgentData"][0]["AgentID"].asUUID() << llendl;
  955. //llinfos << "my agent id = " << gAgent.getID() << llendl;
  956. //llinfos << ll_pretty_print_sd(input) << llendl;
  958. LLSD 
  959. locs   = input["body"]["Location"],
  960. agents = input["body"]["AgentData"];
  961. LLSD::array_iterator 
  962. locs_it = locs.beginArray(), 
  963. agents_it = agents.beginArray();
  964. BOOL has_agent_data = input["body"].has("AgentData");
  966. for(int i=0; 
  967. locs_it != locs.endArray(); 
  968. i++, locs_it++)
  969. {
  970. U8 
  971. x = locs_it->get("X").asInteger(),
  972. y = locs_it->get("Y").asInteger(),
  973. z = locs_it->get("Z").asInteger();
  974. // treat the target specially for the map, and don't add you or the target
  975. if(i == target_index)
  976. {
  977. LLVector3d global_pos(region->getOriginGlobal());
  978. global_pos.mdV[VX] += (F64)x;
  979. global_pos.mdV[VY] += (F64)y;
  980. global_pos.mdV[VZ] += (F64)z * 4.0;
  981. LLAvatarTracker::instance().setTrackedCoarseLocation(global_pos);
  982. }
  983. else if( i != you_index)
  984. {
  985. U32 loc = x << 16 | y << 8 | z; loc = loc;
  986. U32 pos = 0x0;
  987. pos |= x;
  988. pos <<= 8;
  989. pos |= y;
  990. pos <<= 8;
  991. pos |= z;
  992. avatar_locs->put(pos);
  993. //llinfos << "next pos: " << x << "," << y << "," << z << ": " << pos << llendl;
  994. if(has_agent_data) // for backwards compatibility with old message format
  995. {
  996. LLUUID agent_id(agents_it->get("AgentID").asUUID());
  997. //llinfos << "next agent: " << agent_id.asString() << llendl;
  998. avatar_ids->put(agent_id);
  999. }
  1000. }
  1001. if (has_agent_data)
  1002. {
  1003. agents_it++;
  1004. }
  1005. }
  1006. }
  1007. };
  1009. // build the coarse location HTTP node under the "/message" URL
  1010. LLHTTPRegistration<CoarseLocationUpdate>
  1011.    gHTTPRegistrationCoarseLocationUpdate(
  1012.    "/message/CoarseLocationUpdate");
  1015. // the deprecated coarse location handler
  1016. void LLViewerRegion::updateCoarseLocations(LLMessageSystem* msg)
  1017. {
  1018. //llinfos << "CoarseLocationUpdate" << llendl;
  1019. mMapAvatars.reset();
  1020. mMapAvatarIDs.reset(); // only matters in a rare case but it's good to be safe.
  1022. U8 x_pos = 0;
  1023. U8 y_pos = 0;
  1024. U8 z_pos = 0;
  1026. U32 pos = 0x0;
  1028. S16 agent_index;
  1029. S16 target_index;
  1030. msg->getS16Fast(_PREHASH_Index, _PREHASH_You, agent_index);
  1031. msg->getS16Fast(_PREHASH_Index, _PREHASH_Prey, target_index);
  1033. BOOL has_agent_data = msg->has(_PREHASH_AgentData);
  1034. S32 count = msg->getNumberOfBlocksFast(_PREHASH_Location);
  1035. for(S32 i = 0; i < count; i++)
  1036. {
  1037. msg->getU8Fast(_PREHASH_Location, _PREHASH_X, x_pos, i);
  1038. msg->getU8Fast(_PREHASH_Location, _PREHASH_Y, y_pos, i);
  1039. msg->getU8Fast(_PREHASH_Location, _PREHASH_Z, z_pos, i);
  1040. LLUUID agent_id = LLUUID::null;
  1041. if(has_agent_data)
  1042. {
  1043. msg->getUUIDFast(_PREHASH_AgentData, _PREHASH_AgentID, agent_id, i);
  1044. }
  1046. //llinfos << "  object X: " << (S32)x_pos << " Y: " << (S32)y_pos
  1047. // << " Z: " << (S32)(z_pos * 4)
  1048. // << llendl;
  1050. // treat the target specially for the map
  1051. if(i == target_index)
  1052. {
  1053. LLVector3d global_pos(mOriginGlobal);
  1054. global_pos.mdV[VX] += (F64)(x_pos);
  1055. global_pos.mdV[VY] += (F64)(y_pos);
  1056. global_pos.mdV[VZ] += (F64)(z_pos) * 4.0;
  1057. LLAvatarTracker::instance().setTrackedCoarseLocation(global_pos);
  1058. }
  1060. //don't add you
  1061. if( i != agent_index)
  1062. {
  1063. pos = 0x0;
  1064. pos |= x_pos;
  1065. pos <<= 8;
  1066. pos |= y_pos;
  1067. pos <<= 8;
  1068. pos |= z_pos;
  1069. mMapAvatars.put(pos);
  1070. if(has_agent_data)
  1071. {
  1072. mMapAvatarIDs.put(agent_id);
  1073. }
  1074. }
  1075. }
  1076. }
  1078. void LLViewerRegion::getInfo(LLSD& info)
  1079. {
  1080. info["Region"]["Host"] = getHost().getIPandPort();
  1081. info["Region"]["Name"] = getName();
  1082. U32 x, y;
  1083. from_region_handle(getHandle(), &x, &y);
  1084. info["Region"]["Handle"]["x"] = (LLSD::Integer)x;
  1085. info["Region"]["Handle"]["y"] = (LLSD::Integer)y;
  1086. }
  1088. void LLViewerRegion::cacheFullUpdate(LLViewerObject* objectp, LLDataPackerBinaryBuffer &dp)
  1089. {
  1090. U32 local_id = objectp->getLocalID();
  1091. U32 crc = objectp->getCRC();
  1093. LLVOCacheEntry* entry = get_if_there(mCacheMap, local_id, (LLVOCacheEntry*)NULL);
  1095. if (entry)
  1096. {
  1097. // we've seen this object before
  1098. if (entry->getCRC() == crc)
  1099. {
  1100. // Record a hit
  1101. entry->recordDupe();
  1102. }
  1103. else
  1104. {
  1105. // Update the cache entry
  1106. mCacheMap.erase(local_id);
  1107. delete entry;
  1108. entry = new LLVOCacheEntry(local_id, crc, dp);
  1109. mCacheEnd.insert(*entry);
  1110. mCacheMap[local_id] = entry;
  1111. }
  1112. }
  1113. else
  1114. {
  1115. // we haven't seen this object before
  1117. // Create new entry and add to map
  1118. if (mCacheEntriesCount > MAX_OBJECT_CACHE_ENTRIES)
  1119. {
  1120. entry = mCacheStart.getNext();
  1121. mCacheMap.erase(entry->getLocalID());
  1122. delete entry;
  1123. mCacheEntriesCount--;
  1124. }
  1125. entry = new LLVOCacheEntry(local_id, crc, dp);
  1127. mCacheEnd.insert(*entry);
  1128. mCacheMap[local_id] = entry;
  1129. mCacheEntriesCount++;
  1130. }
  1131. return ;
  1132. }
  1134. // Get data packer for this object, if we have cached data
  1135. // AND the CRC matches. JC
  1136. LLDataPacker *LLViewerRegion::getDP(U32 local_id, U32 crc)
  1137. {
  1138. llassert(mCacheLoaded);
  1140. LLVOCacheEntry* entry = get_if_there(mCacheMap, local_id, (LLVOCacheEntry*)NULL);
  1142. if (entry)
  1143. {
  1144. // we've seen this object before
  1145. if (entry->getCRC() == crc)
  1146. {
  1147. // Record a hit
  1148. entry->recordHit();
  1149. return entry->getDP(crc);
  1150. }
  1151. else
  1152. {
  1153. // llinfos << "CRC miss for " << local_id << llendl;
  1154. mCacheMissCRC.put(local_id);
  1155. }
  1156. }
  1157. else
  1158. {
  1159. // llinfos << "Cache miss for " << local_id << llendl;
  1160. mCacheMissFull.put(local_id);
  1161. }
  1162. return NULL;
  1163. }
  1165. void LLViewerRegion::addCacheMissFull(const U32 local_id)
  1166. {
  1167. mCacheMissFull.put(local_id);
  1168. }
  1170. void LLViewerRegion::requestCacheMisses()
  1171. {
  1172. S32 full_count = mCacheMissFull.count();
  1173. S32 crc_count = mCacheMissCRC.count();
  1174. if (full_count == 0 && crc_count == 0) return;
  1176. LLMessageSystem* msg = gMessageSystem;
  1177. BOOL start_new_message = TRUE;
  1178. S32 blocks = 0;
  1179. S32 i;
  1181. const U8 CACHE_MISS_TYPE_FULL = 0;
  1182. const U8 CACHE_MISS_TYPE_CRC  = 1;
  1184. // Send full cache miss updates.  For these, we KNOW we don't
  1185. // have a viewer object.
  1186. for (i = 0; i < full_count; i++)
  1187. {
  1188. if (start_new_message)
  1189. {
  1190. msg->newMessageFast(_PREHASH_RequestMultipleObjects);
  1191. msg->nextBlockFast(_PREHASH_AgentData);
  1192. msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
  1193. msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
  1194. start_new_message = FALSE;
  1195. }
  1197. msg->nextBlockFast(_PREHASH_ObjectData);
  1198. msg->addU8Fast(_PREHASH_CacheMissType, CACHE_MISS_TYPE_FULL);
  1199. msg->addU32Fast(_PREHASH_ID, mCacheMissFull[i]);
  1200. blocks++;
  1202. if (blocks >= 255)
  1203. {
  1204. sendReliableMessage();
  1205. start_new_message = TRUE;
  1206. blocks = 0;
  1207. }
  1208. }
  1210. // Send CRC miss updates.  For these, we _might_ have a viewer object,
  1211. // but probably not.
  1212. for (i = 0; i < crc_count; i++)
  1213. {
  1214. if (start_new_message)
  1215. {
  1216. msg->newMessageFast(_PREHASH_RequestMultipleObjects);
  1217. msg->nextBlockFast(_PREHASH_AgentData);
  1218. msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
  1219. msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
  1220. start_new_message = FALSE;
  1221. }
  1223. msg->nextBlockFast(_PREHASH_ObjectData);
  1224. msg->addU8Fast(_PREHASH_CacheMissType, CACHE_MISS_TYPE_CRC);
  1225. msg->addU32Fast(_PREHASH_ID, mCacheMissCRC[i]);
  1226. blocks++;
  1228. if (blocks >= 255)
  1229. {
  1230. sendReliableMessage();
  1231. start_new_message = TRUE;
  1232. blocks = 0;
  1233. }
  1234. }
  1236. // finish any pending message
  1237. if (!start_new_message)
  1238. {
  1239. sendReliableMessage();
  1240. }
  1241. mCacheMissFull.reset();
  1242. mCacheMissCRC.reset();
  1244. // llinfos << "KILLDEBUG Sent cache miss full " << full_count << " crc " << crc_count << llendl;
  1245. }
  1247. void LLViewerRegion::dumpCache()
  1248. {
  1249. const S32 BINS = 4;
  1250. S32 hit_bin[BINS];
  1251. S32 change_bin[BINS];
  1253. S32 i;
  1254. for (i = 0; i < BINS; ++i)
  1255. {
  1256. hit_bin[i] = 0;
  1257. change_bin[i] = 0;
  1258. }
  1260. LLVOCacheEntry *entry;
  1262. for (entry = mCacheStart.getNext(); entry && (entry != &mCacheEnd); entry = entry->getNext())
  1263. {
  1264. S32 hits = entry->getHitCount();
  1265. S32 changes = entry->getCRCChangeCount();
  1267. hits = llclamp(hits, 0, BINS-1);
  1268. changes = llclamp(changes, 0, BINS-1);
  1270. hit_bin[hits]++;
  1271. change_bin[changes]++;
  1272. }
  1274. llinfos << "Count " << mCacheEntriesCount << llendl;
  1275. for (i = 0; i < BINS; i++)
  1276. {
  1277. llinfos << "Hits " << i << " " << hit_bin[i] << llendl;
  1278. }
  1279. for (i = 0; i < BINS; i++)
  1280. {
  1281. llinfos << "Changes " << i << " " << change_bin[i] << llendl;
  1282. }
  1283. }
  1285. void LLViewerRegion::unpackRegionHandshake()
  1286. {
  1287. LLMessageSystem *msg = gMessageSystem;
  1289. U32 region_flags;
  1290. U8 sim_access;
  1291. std::string sim_name;
  1292. LLUUID sim_owner;
  1293. BOOL is_estate_manager;
  1294. F32 water_height;
  1295. F32 billable_factor;
  1296. LLUUID cache_id;
  1298. msg->getU32 ("RegionInfo", "RegionFlags", region_flags);
  1299. msg->getU8 ("RegionInfo", "SimAccess", sim_access);
  1300. msg->getString ("RegionInfo", "SimName", sim_name);
  1301. msg->getUUID ("RegionInfo", "SimOwner", sim_owner);
  1302. msg->getBOOL ("RegionInfo", "IsEstateManager", is_estate_manager);
  1303. msg->getF32 ("RegionInfo", "WaterHeight", water_height);
  1304. msg->getF32 ("RegionInfo", "BillableFactor", billable_factor);
  1305. msg->getUUID ("RegionInfo", "CacheID", cache_id );
  1307. setRegionFlags(region_flags);
  1308. setSimAccess(sim_access);
  1309. setRegionNameAndZone(sim_name);
  1310. setOwner(sim_owner);
  1311. setIsEstateManager(is_estate_manager);
  1312. setWaterHeight(water_height);
  1313. setBillableFactor(billable_factor);
  1314. setCacheID(cache_id);
  1316. LLUUID region_id;
  1317. msg->getUUID("RegionInfo2", "RegionID", region_id);
  1318. setRegionID(region_id);
  1320. // Retrieve the CR-53 (Homestead/Land SKU) information
  1321. S32 classID = 0;
  1322. S32 cpuRatio = 0;
  1323. std::string coloName;
  1324. std::string productSKU;
  1325. std::string productName;
  1327. // the only reasonable way to decide if we actually have any data is to
  1328. // check to see if any of these fields have positive sizes
  1329. if (msg->getSize("RegionInfo3", "ColoName") > 0 ||
  1330.     msg->getSize("RegionInfo3", "ProductSKU") > 0 ||
  1331.     msg->getSize("RegionInfo3", "ProductName") > 0)
  1332. {
  1333. msg->getS32     ("RegionInfo3", "CPUClassID",  classID);
  1334. msg->getS32     ("RegionInfo3", "CPURatio",    cpuRatio);
  1335. msg->getString  ("RegionInfo3", "ColoName",    coloName);
  1336. msg->getString  ("RegionInfo3", "ProductSKU",  productSKU);
  1337. msg->getString  ("RegionInfo3", "ProductName", productName);
  1339. mClassID = classID;
  1340. mCPURatio = cpuRatio;
  1341. mColoName = coloName;
  1342. mProductSKU = productSKU;
  1343. mProductName = productName;
  1344. }
  1346. LLVLComposition *compp = getComposition();
  1347. if (compp)
  1348. {
  1349. LLUUID tmp_id;
  1351. msg->getUUID("RegionInfo", "TerrainDetail0", tmp_id);
  1352. compp->setDetailTextureID(0, tmp_id);
  1353. msg->getUUID("RegionInfo", "TerrainDetail1", tmp_id);
  1354. compp->setDetailTextureID(1, tmp_id);
  1355. msg->getUUID("RegionInfo", "TerrainDetail2", tmp_id);
  1356. compp->setDetailTextureID(2, tmp_id);
  1357. msg->getUUID("RegionInfo", "TerrainDetail3", tmp_id);
  1358. compp->setDetailTextureID(3, tmp_id);
  1360. F32 tmp_f32;
  1361. msg->getF32("RegionInfo", "TerrainStartHeight00", tmp_f32);
  1362. compp->setStartHeight(0, tmp_f32);
  1363. msg->getF32("RegionInfo", "TerrainStartHeight01", tmp_f32);
  1364. compp->setStartHeight(1, tmp_f32);
  1365. msg->getF32("RegionInfo", "TerrainStartHeight10", tmp_f32);
  1366. compp->setStartHeight(2, tmp_f32);
  1367. msg->getF32("RegionInfo", "TerrainStartHeight11", tmp_f32);
  1368. compp->setStartHeight(3, tmp_f32);
  1370. msg->getF32("RegionInfo", "TerrainHeightRange00", tmp_f32);
  1371. compp->setHeightRange(0, tmp_f32);
  1372. msg->getF32("RegionInfo", "TerrainHeightRange01", tmp_f32);
  1373. compp->setHeightRange(1, tmp_f32);
  1374. msg->getF32("RegionInfo", "TerrainHeightRange10", tmp_f32);
  1375. compp->setHeightRange(2, tmp_f32);
  1376. msg->getF32("RegionInfo", "TerrainHeightRange11", tmp_f32);
  1377. compp->setHeightRange(3, tmp_f32);
  1379. // If this is an UPDATE (params already ready, we need to regenerate
  1380. // all of our terrain stuff, by
  1381. if (compp->getParamsReady())
  1382. {
  1383. getLand().dirtyAllPatches();
  1384. }
  1385. else
  1386. {
  1387. compp->setParamsReady();
  1388. }
  1389. }
  1392. // Now that we have the name, we can load the cache file
  1393. // off disk.
  1394. loadCache();
  1396. // After loading cache, signal that simulator can start
  1397. // sending data.
  1398. // TODO: Send all upstream viewer->sim handshake info here.
  1399. LLHost host = msg->getSender();
  1400. msg->newMessage("RegionHandshakeReply");
  1401. msg->nextBlock("AgentData");
  1402. msg->addUUID("AgentID", gAgent.getID());
  1403. msg->addUUID("SessionID", gAgent.getSessionID());
  1404. msg->nextBlock("RegionInfo");
  1405. msg->addU32("Flags", 0x0 );
  1406. msg->sendReliable(host);
  1407. }
  1409. void LLViewerRegion::setSeedCapability(const std::string& url)
  1410. {
  1411. if (getCapability("Seed") == url)
  1412.     {
  1413. // llwarns << "Ignoring duplicate seed capability" << llendl;
  1414. return;
  1415.     }
  1417. delete mEventPoll;
  1418. mEventPoll = NULL;
  1420. mCapabilities.clear();
  1421. setCapability("Seed", url);
  1423. LLSD capabilityNames = LLSD::emptyArray();
  1425. capabilityNames.append("AttachmentResources");
  1426. capabilityNames.append("ChatSessionRequest");
  1427. capabilityNames.append("CopyInventoryFromNotecard");
  1428. capabilityNames.append("DispatchRegionInfo");
  1429. capabilityNames.append("EstateChangeInfo");
  1430. capabilityNames.append("EventQueueGet");
  1431. capabilityNames.append("FetchInventory");
  1432. capabilityNames.append("ObjectMedia");
  1433. capabilityNames.append("ObjectMediaNavigate");
  1434. capabilityNames.append("FetchLib");
  1435. capabilityNames.append("FetchLibDescendents");
  1436. capabilityNames.append("GetTexture");
  1437. capabilityNames.append("GroupProposalBallot");
  1438. capabilityNames.append("HomeLocation");
  1439. capabilityNames.append("LandResources");
  1440. capabilityNames.append("MapLayer");
  1441. capabilityNames.append("MapLayerGod");
  1442. capabilityNames.append("NewFileAgentInventory");
  1443. capabilityNames.append("ParcelPropertiesUpdate");
  1444. capabilityNames.append("ParcelMediaURLFilterList");
  1445. capabilityNames.append("ParcelNavigateMedia");
  1446. capabilityNames.append("ParcelVoiceInfoRequest");
  1447. capabilityNames.append("ProductInfoRequest");
  1448. capabilityNames.append("ProvisionVoiceAccountRequest");
  1449. capabilityNames.append("RemoteParcelRequest");
  1450. capabilityNames.append("RequestTextureDownload");
  1451. capabilityNames.append("SearchStatRequest");
  1452. capabilityNames.append("SearchStatTracking");
  1453. capabilityNames.append("SendPostcard");
  1454. capabilityNames.append("SendUserReport");
  1455. capabilityNames.append("SendUserReportWithScreenshot");
  1456. capabilityNames.append("ServerReleaseNotes");
  1457. capabilityNames.append("StartGroupProposal");
  1458. capabilityNames.append("TextureStats");
  1459. capabilityNames.append("UntrustedSimulatorMessage");
  1460. capabilityNames.append("UpdateAgentInformation");
  1461. capabilityNames.append("UpdateAgentLanguage");
  1462. capabilityNames.append("UpdateGestureAgentInventory");
  1463. capabilityNames.append("UpdateNotecardAgentInventory");
  1464. capabilityNames.append("UpdateScriptAgent");
  1465. capabilityNames.append("UpdateGestureTaskInventory");
  1466. capabilityNames.append("UpdateNotecardTaskInventory");
  1467. capabilityNames.append("UpdateScriptTask");
  1468. capabilityNames.append("UploadBakedTexture");
  1469. capabilityNames.append("ViewerStartAuction");
  1470. capabilityNames.append("ViewerStats");
  1471. capabilityNames.append("WebFetchInventoryDescendents");
  1472. // Please add new capabilities alphabetically to reduce
  1473. // merge conflicts.
  1475. llinfos << "posting to seed " << url << llendl;
  1477. mHttpResponderPtr = BaseCapabilitiesComplete::build(this) ;
  1478. LLHTTPClient::post(url, capabilityNames, mHttpResponderPtr);
  1479. }
  1481. void LLViewerRegion::setCapability(const std::string& name, const std::string& url)
  1482. {
  1483. if(name == "EventQueueGet")
  1484. {
  1485. delete mEventPoll;
  1486. mEventPoll = NULL;
  1487. mEventPoll = new LLEventPoll(url, getHost());
  1488. }
  1489. else if(name == "UntrustedSimulatorMessage")
  1490. {
  1491. LLHTTPSender::setSender(mHost, new LLCapHTTPSender(url));
  1492. }
  1493. else
  1494. {
  1495. mCapabilities[name] = url;
  1496. }
  1497. }
  1499. bool LLViewerRegion::isSpecialCapabilityName(const std::string &name)
  1500. {
  1501. return name == "EventQueueGet" || name == "UntrustedSimulatorMessage";
  1502. }
  1504. std::string LLViewerRegion::getCapability(const std::string& name) const
  1505. {
  1506. CapabilityMap::const_iterator iter = mCapabilities.find(name);
  1507. if(iter == mCapabilities.end())
  1508. {
  1509. return "";
  1510. }
  1511. return iter->second;
  1512. }
  1514. void LLViewerRegion::logActiveCapabilities() const
  1515. {
  1516. int count = 0;
  1517. CapabilityMap::const_iterator iter;
  1518. for (iter = mCapabilities.begin(); iter != mCapabilities.end(); iter++, count++)
  1519. {
  1520. if (!iter->second.empty())
  1521. {
  1522. llinfos << iter->first << " URL is " << iter->second << llendl;
  1523. }
  1524. }
  1525. llinfos << "Dumped " << count << " entries." << llendl;
  1526. }
  1528. LLSpatialPartition* LLViewerRegion::getSpatialPartition(U32 type)
  1529. {
  1530. if (type < mObjectPartition.size())
  1531. {
  1532. return mObjectPartition[type];
  1533. }
  1534. return NULL;
  1535. }
  1537. void LLViewerRegion::showReleaseNotes()
  1538. {
  1539. std::string url = this->getCapability("ServerReleaseNotes");
  1541. if (url.empty()) {
  1542. // HACK haven't received the capability yet, we'll wait until
  1543. // it arives.
  1544. mReleaseNotesRequested = TRUE;
  1545. return;
  1546. }
  1548. LLWeb::loadURL(url);
  1549. mReleaseNotesRequested = FALSE;
  1550. }
  1552. std::string LLViewerRegion::getDescription() const
  1553. {
  1554.     return stringize(*this);
  1555. }