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

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

游戏引擎

开发平台：

C++ Builder

llviewerparcelmgr.cpp：源码内容
  1. /** 
  2.  * @file llviewerparcelmgr.cpp
  3.  * @brief Viewer-side representation of owned land
  4.  *
  5.  * $LicenseInfo:firstyear=2002&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2002-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 "llviewerparcelmgr.h"
  37. // Library includes
  38. #include "llaudioengine.h"
  39. #include "indra_constants.h"
  40. #include "llcachename.h"
  41. #include "llgl.h"
  42. #include "llnotifications.h"
  43. #include "llnotificationsutil.h"
  44. #include "llparcel.h"
  45. #include "llsecondlifeurls.h"
  46. #include "message.h"
  47. #include "llfloaterreg.h"
  49. // Viewer includes
  50. #include "llagent.h"
  51. #include "llviewerwindow.h"
  52. #include "llviewercontrol.h"
  53. //#include "llfirstuse.h"
  54. #include "llfloaterbuyland.h"
  55. #include "llfloatergroups.h"
  56. #include "llpanelnearbymedia.h"
  57. #include "llfloatersellland.h"
  58. #include "llfloatertools.h"
  59. #include "llparcelselection.h"
  60. #include "llresmgr.h"
  61. #include "llsdutil.h"
  62. #include "llsdutil_math.h"
  63. #include "llstatusbar.h"
  64. #include "llui.h"
  65. #include "llviewertexture.h"
  66. #include "llviewertexturelist.h"
  67. #include "llviewermenu.h"
  68. #include "llviewerparcelmedia.h"
  69. #include "llviewerparceloverlay.h"
  70. #include "llviewerregion.h"
  71. #include "llworld.h"
  72. #include "roles_constants.h"
  73. #include "llweb.h"
  75. const F32 PARCEL_COLLISION_DRAW_SECS = 1.f;
  78. // Globals
  80. U8* LLViewerParcelMgr::sPackedOverlay = NULL;
  82. LLUUID gCurrentMovieID = LLUUID::null;
  84. LLPointer<LLViewerTexture> sBlockedImage;
  85. LLPointer<LLViewerTexture> sPassImage;
  87. // Local functions
  88. void optionally_start_music(const std::string& music_url);
  89. void callback_start_music(S32 option, void* data);
  90. void optionally_prepare_video(const LLParcel *parcelp);
  91. void callback_prepare_video(S32 option, void* data);
  92. void prepare_video(const LLParcel *parcelp);
  93. void start_video(const LLParcel *parcelp);
  94. void stop_video();
  95. bool callback_god_force_owner(const LLSD&, const LLSD&);
  97. struct LLGodForceOwnerData
  98. {
  99. LLUUID mOwnerID;
  100. S32 mLocalID;
  101. LLHost mHost;
  103. LLGodForceOwnerData(
  104. const LLUUID& owner_id,
  105. S32 local_parcel_id,
  106. const LLHost& host) :
  107. mOwnerID(owner_id),
  108. mLocalID(local_parcel_id),
  109. mHost(host) {}
  110. };
  112. //
  113. // Methods
  114. //
  115. LLViewerParcelMgr::LLViewerParcelMgr()
  116. : mSelected(FALSE),
  117. mRequestResult(0),
  118. mWestSouth(),
  119. mEastNorth(),
  120. mSelectedDwell(0.f),
  121. mAgentParcelSequenceID(-1),
  122. mHoverRequestResult(0),
  123. mHoverWestSouth(),
  124. mHoverEastNorth(),
  125. mRenderCollision(FALSE),
  126. mRenderSelection(TRUE),
  127. mCollisionBanned(0),
  128. mCollisionTimer(),
  129. mMediaParcelId(0),
  130. mMediaRegionId(0)
  131. {
  132. mCurrentParcel = new LLParcel();
  133. mCurrentParcelSelection = new LLParcelSelection(mCurrentParcel);
  134. mFloatingParcelSelection = new LLParcelSelection(mCurrentParcel);
  136. mAgentParcel = new LLParcel();
  137. mHoverParcel = new LLParcel();
  138. mCollisionParcel = new LLParcel();
  140. mParcelsPerEdge = S32( REGION_WIDTH_METERS / PARCEL_GRID_STEP_METERS );
  141. mHighlightSegments = new U8[(mParcelsPerEdge+1)*(mParcelsPerEdge+1)];
  142. resetSegments(mHighlightSegments);
  144. mCollisionSegments = new U8[(mParcelsPerEdge+1)*(mParcelsPerEdge+1)];
  145. resetSegments(mCollisionSegments);
  147. // JC: Resolved a merge conflict here, eliminated
  148. // mBlockedImage->setAddressMode(LLTexUnit::TAM_WRAP);
  149. // because it is done in llviewertexturelist.cpp
  150. mBlockedImage = LLViewerTextureManager::getFetchedTextureFromFile("world/NoEntryLines.png");
  151. mPassImage = LLViewerTextureManager::getFetchedTextureFromFile("world/NoEntryPassLines.png");
  153. S32 overlay_size = mParcelsPerEdge * mParcelsPerEdge / PARCEL_OVERLAY_CHUNKS;
  154. sPackedOverlay = new U8[overlay_size];
  156. mAgentParcelOverlay = new U8[mParcelsPerEdge * mParcelsPerEdge];
  157. S32 i;
  158. for (i = 0; i < mParcelsPerEdge * mParcelsPerEdge; i++)
  159. {
  160. mAgentParcelOverlay[i] = 0;
  161. }
  163. mTeleportInProgress = TRUE; // the initial parcel update is treated like teleport
  164. }
  167. LLViewerParcelMgr::~LLViewerParcelMgr()
  168. {
  169. mCurrentParcelSelection->setParcel(NULL);
  170. mCurrentParcelSelection = NULL;
  172. mFloatingParcelSelection->setParcel(NULL);
  173. mFloatingParcelSelection = NULL;
  175. delete mCurrentParcel;
  176. mCurrentParcel = NULL;
  178. delete mAgentParcel;
  179. mAgentParcel = NULL;
  181. delete mCollisionParcel;
  182. mCollisionParcel = NULL;
  184. delete mHoverParcel;
  185. mHoverParcel = NULL;
  187. delete[] mHighlightSegments;
  188. mHighlightSegments = NULL;
  190. delete[] mCollisionSegments;
  191. mCollisionSegments = NULL;
  193. delete[] sPackedOverlay;
  194. sPackedOverlay = NULL;
  196. delete[] mAgentParcelOverlay;
  197. mAgentParcelOverlay = NULL;
  199. sBlockedImage = NULL;
  200. sPassImage = NULL;
  201. }
  203. void LLViewerParcelMgr::dump()
  204. {
  205. llinfos << "Parcel Manager Dump" << llendl;
  206. llinfos << "mSelected " << S32(mSelected) << llendl;
  207. llinfos << "Selected parcel: " << llendl;
  208. llinfos << mWestSouth << " to " << mEastNorth << llendl;
  209. mCurrentParcel->dump();
  210. llinfos << "banning " << mCurrentParcel->mBanList.size() << llendl;
  212. access_map_const_iterator cit = mCurrentParcel->mBanList.begin();
  213. access_map_const_iterator end = mCurrentParcel->mBanList.end();
  214. for ( ; cit != end; ++cit)
  215. {
  216. llinfos << "ban id " << (*cit).first << llendl;
  217. }
  218. llinfos << "Hover parcel:" << llendl;
  219. mHoverParcel->dump();
  220. llinfos << "Agent parcel:" << llendl;
  221. mAgentParcel->dump();
  222. }
  225. LLViewerRegion* LLViewerParcelMgr::getSelectionRegion()
  226. {
  227. return LLWorld::getInstance()->getRegionFromPosGlobal( mWestSouth );
  228. }
  231. void LLViewerParcelMgr::getDisplayInfo(S32* area_out, S32* claim_out,
  232.    S32* rent_out,
  233.    BOOL* for_sale_out,
  234.    F32* dwell_out)
  235. {
  236. S32 area = 0;
  237. S32 price = 0;
  238. S32 rent = 0;
  239. BOOL for_sale = FALSE;
  240. F32 dwell = 0.f;
  242. if (mSelected)
  243. {
  244. if (mCurrentParcelSelection->mSelectedMultipleOwners)
  245. {
  246. area = mCurrentParcelSelection->getClaimableArea();
  247. }
  248. else
  249. {
  250. area = getSelectedArea();
  251. }
  253. if (mCurrentParcel->getForSale())
  254. {
  255. price = mCurrentParcel->getSalePrice();
  256. for_sale = TRUE;
  257. }
  258. else
  259. {
  260. price = area * mCurrentParcel->getClaimPricePerMeter();
  261. for_sale = FALSE;
  262. }
  264. rent = mCurrentParcel->getTotalRent();
  266. dwell = mSelectedDwell;
  267. }
  269. *area_out = area;
  270. *claim_out = price;
  271. *rent_out = rent;
  272. *for_sale_out = for_sale;
  273. *dwell_out = dwell;
  274. }
  276. S32 LLViewerParcelMgr::getSelectedArea() const
  277. {
  278. S32 rv = 0;
  279. if(mSelected && mCurrentParcel && mCurrentParcelSelection->mWholeParcelSelected)
  280. {
  281. rv = mCurrentParcel->getArea();
  282. }
  283. else if(mSelected)
  284. {
  285. F64 width = mEastNorth.mdV[VX] - mWestSouth.mdV[VX];
  286. F64 height = mEastNorth.mdV[VY] - mWestSouth.mdV[VY];
  287. F32 area = (F32)(width * height);
  288. rv = llround(area);
  289. }
  290. return rv;
  291. }
  293. void LLViewerParcelMgr::resetSegments(U8* segments)
  294. {
  295. S32 i;
  296. S32 count = (mParcelsPerEdge+1)*(mParcelsPerEdge+1);
  297. for (i = 0; i < count; i++)
  298. {
  299. segments[i] = 0x0;
  300. }
  301. }
  304. void LLViewerParcelMgr::writeHighlightSegments(F32 west, F32 south, F32 east,
  305.    F32 north)
  306. {
  307. S32 x, y;
  308. S32 min_x = llround( west / PARCEL_GRID_STEP_METERS );
  309. S32 max_x = llround( east / PARCEL_GRID_STEP_METERS );
  310. S32 min_y = llround( south / PARCEL_GRID_STEP_METERS );
  311. S32 max_y = llround( north / PARCEL_GRID_STEP_METERS );
  313. const S32 STRIDE = mParcelsPerEdge+1;
  315. // south edge
  316. y = min_y;
  317. for (x = min_x; x < max_x; x++)
  318. {
  319. // exclusive OR means that writing to this segment twice
  320. // will turn it off
  321. mHighlightSegments[x + y*STRIDE] ^= SOUTH_MASK;
  322. }
  324. // west edge
  325. x = min_x;
  326. for (y = min_y; y < max_y; y++)
  327. {
  328. mHighlightSegments[x + y*STRIDE] ^= WEST_MASK;
  329. }
  331. // north edge - draw the south border on the y+1'th cell,
  332. // which given C-style arrays, is item foo[max_y]
  333. y = max_y;
  334. for (x = min_x; x < max_x; x++)
  335. {
  336. mHighlightSegments[x + y*STRIDE] ^= SOUTH_MASK;
  337. }
  339. // east edge - draw west border on x+1'th cell
  340. x = max_x;
  341. for (y = min_y; y < max_y; y++)
  342. {
  343. mHighlightSegments[x + y*STRIDE] ^= WEST_MASK;
  344. }
  345. }
  348. void LLViewerParcelMgr::writeSegmentsFromBitmap(U8* bitmap, U8* segments)
  349. {
  350. S32 x;
  351. S32 y;
  352. const S32 IN_STRIDE = mParcelsPerEdge;
  353. const S32 OUT_STRIDE = mParcelsPerEdge+1;
  355. for (y = 0; y < IN_STRIDE; y++)
  356. {
  357. x = 0;
  358. while( x < IN_STRIDE )
  359. {
  360. U8 byte = bitmap[ (x + y*IN_STRIDE) / 8 ];
  362. S32 bit;
  363. for (bit = 0; bit < 8; bit++)
  364. {
  365. if (byte & (1 << bit) )
  366. {
  367. S32 out = x+y*OUT_STRIDE;
  369. // This and one above it
  370. segments[out]            ^= SOUTH_MASK;
  371. segments[out+OUT_STRIDE] ^= SOUTH_MASK;
  373. // This and one to the right
  374. segments[out]   ^= WEST_MASK;
  375. segments[out+1] ^= WEST_MASK;
  376. }
  377. x++;
  378. }
  379. }
  380. }
  381. }
  384. void LLViewerParcelMgr::writeAgentParcelFromBitmap(U8* bitmap)
  385. {
  386. S32 x;
  387. S32 y;
  388. const S32 IN_STRIDE = mParcelsPerEdge;
  390. for (y = 0; y < IN_STRIDE; y++)
  391. {
  392. x = 0;
  393. while( x < IN_STRIDE )
  394. {
  395. U8 byte = bitmap[ (x + y*IN_STRIDE) / 8 ];
  397. S32 bit;
  398. for (bit = 0; bit < 8; bit++)
  399. {
  400. if (byte & (1 << bit) )
  401. {
  402. mAgentParcelOverlay[x+y*IN_STRIDE] = 1;
  403. }
  404. else
  405. {
  406. mAgentParcelOverlay[x+y*IN_STRIDE] = 0;
  407. }
  408. x++;
  409. }
  410. }
  411. }
  412. }
  415. // Given a point, find the PARCEL_GRID_STEP x PARCEL_GRID_STEP block
  416. // containing it and select that.
  417. LLParcelSelectionHandle LLViewerParcelMgr::selectParcelAt(const LLVector3d& pos_global)
  418. {
  419. LLVector3d southwest = pos_global;
  420. LLVector3d northeast = pos_global;
  422. southwest -= LLVector3d( PARCEL_GRID_STEP_METERS/2, PARCEL_GRID_STEP_METERS/2, 0 );
  423. southwest.mdV[VX] = llround( southwest.mdV[VX], (F64)PARCEL_GRID_STEP_METERS );
  424. southwest.mdV[VY] = llround( southwest.mdV[VY], (F64)PARCEL_GRID_STEP_METERS );
  426. northeast += LLVector3d( PARCEL_GRID_STEP_METERS/2, PARCEL_GRID_STEP_METERS/2, 0 );
  427. northeast.mdV[VX] = llround( northeast.mdV[VX], (F64)PARCEL_GRID_STEP_METERS );
  428. northeast.mdV[VY] = llround( northeast.mdV[VY], (F64)PARCEL_GRID_STEP_METERS );
  430. // Snap to parcel
  431. return selectLand( southwest, northeast, TRUE );
  432. }
  435. // Tries to select the parcel inside the rectangle
  436. LLParcelSelectionHandle LLViewerParcelMgr::selectParcelInRectangle()
  437. {
  438. return selectLand(mWestSouth, mEastNorth, TRUE);
  439. }
  442. void LLViewerParcelMgr::selectCollisionParcel()
  443. {
  444. // BUG: Claim to be in the agent's region
  445. mWestSouth = gAgent.getRegion()->getOriginGlobal();
  446. mEastNorth = mWestSouth;
  447. mEastNorth += LLVector3d(PARCEL_GRID_STEP_METERS, PARCEL_GRID_STEP_METERS, 0.0);
  449. // BUG: must be in the sim you are in
  450. LLMessageSystem *msg = gMessageSystem;
  451. msg->newMessageFast(_PREHASH_ParcelPropertiesRequestByID);
  452. msg->nextBlockFast(_PREHASH_AgentID);
  453. msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID() );
  454. msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID() );
  455. msg->nextBlockFast(_PREHASH_ParcelData);
  456. msg->addS32Fast(_PREHASH_SequenceID, SELECTED_PARCEL_SEQ_ID );
  457. msg->addS32Fast(_PREHASH_LocalID, mCollisionParcel->getLocalID() );
  458. gAgent.sendReliableMessage();
  460. mRequestResult = PARCEL_RESULT_NO_DATA;
  462. // Hack: Copy some data over temporarily
  463. mCurrentParcel->setName( mCollisionParcel->getName() );
  464. mCurrentParcel->setDesc( mCollisionParcel->getDesc() );
  465. mCurrentParcel->setPassPrice(mCollisionParcel->getPassPrice());
  466. mCurrentParcel->setPassHours(mCollisionParcel->getPassHours());
  468. // clear the list of segments to prevent flashing
  469. resetSegments(mHighlightSegments);
  471. mFloatingParcelSelection->setParcel(mCurrentParcel);
  472. mCurrentParcelSelection->setParcel(NULL);
  473. mCurrentParcelSelection = new LLParcelSelection(mCurrentParcel);
  475. mSelected = TRUE;
  476. mCurrentParcelSelection->mWholeParcelSelected = TRUE;
  477. notifyObservers();
  478. return;
  479. }
  482. // snap_selection = auto-select the hit parcel, if there is exactly one
  483. LLParcelSelectionHandle LLViewerParcelMgr::selectLand(const LLVector3d &corner1, const LLVector3d &corner2,
  484.    BOOL snap_selection)
  485. {
  486. sanitize_corners( corner1, corner2, mWestSouth, mEastNorth );
  488. // ...x isn't more than one meter away
  489. F32 delta_x = getSelectionWidth();
  490. if (delta_x * delta_x <= 1.f * 1.f)
  491. {
  492. mSelected = FALSE;
  493. notifyObservers();
  494. return NULL;
  495. }
  497. // ...y isn't more than one meter away
  498. F32 delta_y = getSelectionHeight();
  499. if (delta_y * delta_y <= 1.f * 1.f)
  500. {
  501. mSelected = FALSE;
  502. notifyObservers();
  503. return NULL;
  504. }
  506. // Can't select across region boundary
  507. // We need to pull in the upper right corner by a little bit to allow
  508. // selection up to the x = 256 or y = 256 edge.
  509. LLVector3d east_north_region_check( mEastNorth );
  510. east_north_region_check.mdV[VX] -= 0.5;
  511. east_north_region_check.mdV[VY] -= 0.5;
  513. LLViewerRegion *region = LLWorld::getInstance()->getRegionFromPosGlobal(mWestSouth);
  514. LLViewerRegion *region_other = LLWorld::getInstance()->getRegionFromPosGlobal( east_north_region_check );
  516. if(!region)
  517. {
  518. // just in case they somehow selected no land.
  519. mSelected = FALSE;
  520. return NULL;
  521. }
  523. if (region != region_other)
  524. {
  525. LLNotificationsUtil::add("CantSelectLandFromMultipleRegions");
  526. mSelected = FALSE;
  527. notifyObservers();
  528. return NULL;
  529. }
  531. // Build region global copies of corners
  532. LLVector3 wsb_region = region->getPosRegionFromGlobal( mWestSouth );
  533. LLVector3 ent_region = region->getPosRegionFromGlobal( mEastNorth );
  535. // Send request message
  536. LLMessageSystem *msg = gMessageSystem;
  537. msg->newMessageFast(_PREHASH_ParcelPropertiesRequest);
  538. msg->nextBlockFast(_PREHASH_AgentData);
  539. msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID() );
  540. msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID() );
  541. msg->nextBlockFast(_PREHASH_ParcelData);
  542. msg->addS32Fast(_PREHASH_SequenceID, SELECTED_PARCEL_SEQ_ID );
  543. msg->addF32Fast(_PREHASH_West,  wsb_region.mV[VX] );
  544. msg->addF32Fast(_PREHASH_South, wsb_region.mV[VY] );
  545. msg->addF32Fast(_PREHASH_East,  ent_region.mV[VX] );
  546. msg->addF32Fast(_PREHASH_North, ent_region.mV[VY] );
  547. msg->addBOOL("SnapSelection", snap_selection);
  548. msg->sendReliable( region->getHost() );
  550. mRequestResult = PARCEL_RESULT_NO_DATA;
  552. // clear the list of segments to prevent flashing
  553. resetSegments(mHighlightSegments);
  555. mFloatingParcelSelection->setParcel(mCurrentParcel);
  556. mCurrentParcelSelection->setParcel(NULL);
  557. mCurrentParcelSelection = new LLParcelSelection(mCurrentParcel);
  559. mSelected = TRUE;
  560. mCurrentParcelSelection->mWholeParcelSelected = snap_selection;
  561. notifyObservers();
  562. return mCurrentParcelSelection;
  563. }
  565. void LLViewerParcelMgr::deselectUnused()
  566. {
  567. // no more outstanding references to this selection, other than our own
  568. if (mCurrentParcelSelection->getNumRefs() == 1 && mFloatingParcelSelection->getNumRefs() == 1)
  569. {
  570. deselectLand();
  571. }
  572. }
  574. void LLViewerParcelMgr::deselectLand()
  575. {
  576. if (mSelected)
  577. {
  578. mSelected = FALSE;
  580. // Invalidate the selected parcel
  581. mCurrentParcel->setLocalID(-1);
  582. mCurrentParcel->mAccessList.clear();
  583. mCurrentParcel->mBanList.clear();
  584. //mCurrentParcel->mRenterList.reset();
  586. mSelectedDwell = 0.f;
  588. // invalidate parcel selection so that existing users of this selection can clean up
  589. mCurrentParcelSelection->setParcel(NULL);
  590. mFloatingParcelSelection->setParcel(NULL);
  591. // create new parcel selection
  592. mCurrentParcelSelection = new LLParcelSelection(mCurrentParcel);
  594. notifyObservers(); // Notify observers *after* changing the parcel selection
  595. }
  596. }
  599. void LLViewerParcelMgr::addObserver(LLParcelObserver* observer)
  600. {
  601. mObservers.put(observer);
  602. }
  605. void LLViewerParcelMgr::removeObserver(LLParcelObserver* observer)
  606. {
  607. mObservers.removeObj(observer);
  608. }
  611. // Call this method when it's time to update everyone on a new state.
  612. // Copy the list because an observer could respond by removing itself
  613. // from the list.
  614. void LLViewerParcelMgr::notifyObservers()
  615. {
  616. LLDynamicArray<LLParcelObserver*> observers;
  617. S32 count = mObservers.count();
  618. S32 i;
  619. for(i = 0; i < count; ++i)
  620. {
  621. observers.put(mObservers.get(i));
  622. }
  623. for(i = 0; i < count; ++i)
  624. {
  625. observers.get(i)->changed();
  626. }
  627. }
  630. //
  631. // ACCESSORS
  632. //
  633. BOOL LLViewerParcelMgr::selectionEmpty() const
  634. {
  635. return !mSelected;
  636. }
  639. LLParcelSelectionHandle LLViewerParcelMgr::getParcelSelection() const
  640. {
  641. return mCurrentParcelSelection;
  642. }
  644. LLParcelSelectionHandle LLViewerParcelMgr::getFloatingParcelSelection() const
  645. {
  646. return mFloatingParcelSelection;
  647. }
  649. LLParcel *LLViewerParcelMgr::getAgentParcel() const
  650. {
  651. return mAgentParcel;
  652. }
  654. // Return whether the agent can build on the land they are on
  655. bool LLViewerParcelMgr::allowAgentBuild() const
  656. {
  657. if (mAgentParcel)
  658. {
  659. return (gAgent.isGodlike() ||
  660. (mAgentParcel->allowModifyBy(gAgent.getID(), gAgent.getGroupID())) ||
  661. (isParcelOwnedByAgent(mAgentParcel, GP_LAND_ALLOW_CREATE)));
  662. }
  663. else
  664. {
  665. return gAgent.isGodlike();
  666. }
  667. }
  669. // Return whether anyone can build on the given parcel
  670. bool LLViewerParcelMgr::allowAgentBuild(const LLParcel* parcel) const
  671. {
  672. return parcel->getAllowModify();
  673. }
  675. bool LLViewerParcelMgr::allowAgentVoice() const
  676. {
  677. return allowAgentVoice(gAgent.getRegion(), mAgentParcel);
  678. }
  680. bool LLViewerParcelMgr::allowAgentVoice(const LLViewerRegion* region, const LLParcel* parcel) const
  681. {
  682. return region && region->isVoiceEnabled()
  683. && parcel && parcel->getParcelFlagAllowVoice();
  684. }
  686. bool LLViewerParcelMgr::allowAgentFly(const LLViewerRegion* region, const LLParcel* parcel) const
  687. {
  688. return region && !region->getBlockFly()
  689. && parcel && parcel->getAllowFly();
  690. }
  692. // Can the agent be pushed around by LLPushObject?
  693. bool LLViewerParcelMgr::allowAgentPush(const LLViewerRegion* region, const LLParcel* parcel) const
  694. {
  695. return region && !region->getRestrictPushObject()
  696. && parcel && !parcel->getRestrictPushObject();
  697. }
  699. bool LLViewerParcelMgr::allowAgentScripts(const LLViewerRegion* region, const LLParcel* parcel) const
  700. {
  701. // *NOTE: This code does not take into account group-owned parcels
  702. // and the flag to allow group-owned scripted objects to run.
  703. // This mirrors the traditional menu bar parcel icon code, but is not
  704. // technically correct.
  705. return region
  706. && !(region->getRegionFlags() & REGION_FLAGS_SKIP_SCRIPTS)
  707. && !(region->getRegionFlags() & REGION_FLAGS_ESTATE_SKIP_SCRIPTS)
  708. && parcel
  709. && parcel->getAllowOtherScripts();
  710. }
  712. bool LLViewerParcelMgr::allowAgentDamage(const LLViewerRegion* region, const LLParcel* parcel) const
  713. {
  714. return (region && region->getAllowDamage())
  715. || (parcel && parcel->getAllowDamage());
  716. }
  718. BOOL LLViewerParcelMgr::isOwnedAt(const LLVector3d& pos_global) const
  719. {
  720. LLViewerRegion* region = LLWorld::getInstance()->getRegionFromPosGlobal( pos_global );
  721. if (!region) return FALSE;
  723. LLViewerParcelOverlay* overlay = region->getParcelOverlay();
  724. if (!overlay) return FALSE;
  726. LLVector3 pos_region = region->getPosRegionFromGlobal( pos_global );
  728. return overlay->isOwned( pos_region );
  729. }
  731. BOOL LLViewerParcelMgr::isOwnedSelfAt(const LLVector3d& pos_global) const
  732. {
  733. LLViewerRegion* region = LLWorld::getInstance()->getRegionFromPosGlobal( pos_global );
  734. if (!region) return FALSE;
  736. LLViewerParcelOverlay* overlay = region->getParcelOverlay();
  737. if (!overlay) return FALSE;
  739. LLVector3 pos_region = region->getPosRegionFromGlobal( pos_global );
  741. return overlay->isOwnedSelf( pos_region );
  742. }
  744. BOOL LLViewerParcelMgr::isOwnedOtherAt(const LLVector3d& pos_global) const
  745. {
  746. LLViewerRegion* region = LLWorld::getInstance()->getRegionFromPosGlobal( pos_global );
  747. if (!region) return FALSE;
  749. LLViewerParcelOverlay* overlay = region->getParcelOverlay();
  750. if (!overlay) return FALSE;
  752. LLVector3 pos_region = region->getPosRegionFromGlobal( pos_global );
  754. return overlay->isOwnedOther( pos_region );
  755. }
  757. BOOL LLViewerParcelMgr::isSoundLocal(const LLVector3d& pos_global) const
  758. {
  759. LLViewerRegion* region = LLWorld::getInstance()->getRegionFromPosGlobal( pos_global );
  760. if (!region) return FALSE;
  762. LLViewerParcelOverlay* overlay = region->getParcelOverlay();
  763. if (!overlay) return FALSE;
  765. LLVector3 pos_region = region->getPosRegionFromGlobal( pos_global );
  767. return overlay->isSoundLocal( pos_region );
  768. }
  770. BOOL LLViewerParcelMgr::canHearSound(const LLVector3d &pos_global) const
  771. {
  772. BOOL in_agent_parcel = inAgentParcel(pos_global);
  774. if (in_agent_parcel)
  775. {
  776. // In same parcel as the agent
  777. return TRUE;
  778. }
  779. else
  780. {
  781. if (LLViewerParcelMgr::getInstance()->getAgentParcel()->getSoundLocal())
  782. {
  783. // Not in same parcel, and agent parcel only has local sound
  784. return FALSE;
  785. }
  786. else if (LLViewerParcelMgr::getInstance()->isSoundLocal(pos_global))
  787. {
  788. // Not in same parcel, and target parcel only has local sound
  789. return FALSE;
  790. }
  791. else
  792. {
  793. // Not in same parcel, but neither are local sound
  794. return TRUE;
  795. }
  796. }
  797. }
  800. BOOL LLViewerParcelMgr::inAgentParcel(const LLVector3d &pos_global) const
  801. {
  802. LLViewerRegion* region = LLWorld::getInstance()->getRegionFromPosGlobal(pos_global);
  803. LLViewerRegion* agent_region = gAgent.getRegion();
  804. if (!region || !agent_region)
  805. return FALSE;
  807. if (region != agent_region)
  808. {
  809. // Can't be in the agent parcel if you're not in the same region.
  810. return FALSE;
  811. }
  813. LLVector3 pos_region = agent_region->getPosRegionFromGlobal(pos_global);
  814. S32 row =    S32(pos_region.mV[VY] / PARCEL_GRID_STEP_METERS);
  815. S32 column = S32(pos_region.mV[VX] / PARCEL_GRID_STEP_METERS);
  817. if (mAgentParcelOverlay[row*mParcelsPerEdge + column])
  818. {
  819. return TRUE;
  820. }
  821. else
  822. {
  823. return FALSE;
  824. }
  825. }
  827. // Returns NULL when there is no valid data.
  828. LLParcel* LLViewerParcelMgr::getHoverParcel() const
  829. {
  830. if (mHoverRequestResult == PARCEL_RESULT_SUCCESS)
  831. {
  832. return mHoverParcel;
  833. }
  834. else
  835. {
  836. return NULL;
  837. }
  838. }
  840. // Returns NULL when there is no valid data.
  841. LLParcel* LLViewerParcelMgr::getCollisionParcel() const
  842. {
  843. if (mRenderCollision)
  844. {
  845. return mCollisionParcel;
  846. }
  847. else
  848. {
  849. return NULL;
  850. }
  851. }
  853. //
  854. // UTILITIES
  855. //
  857. void LLViewerParcelMgr::render()
  858. {
  859. if (mSelected && mRenderSelection)
  860. {
  861. // Rendering is done in agent-coordinates, so need to supply
  862. // an appropriate offset to the render code.
  863. LLViewerRegion* regionp = LLWorld::getInstance()->getRegionFromPosGlobal(mWestSouth);
  864. if (!regionp) return;
  866. renderHighlightSegments(mHighlightSegments, regionp);
  867. }
  868. }
  871. void LLViewerParcelMgr::renderParcelCollision()
  872. {
  873. // check for expiration
  874. if (mCollisionTimer.getElapsedTimeF32() > PARCEL_COLLISION_DRAW_SECS)
  875. {
  876. mRenderCollision = FALSE;
  877. }
  879. if (mRenderCollision && gSavedSettings.getBOOL("ShowBanLines"))
  880. {
  881. LLViewerRegion* regionp = gAgent.getRegion();
  882. if (regionp)
  883. {
  884. BOOL use_pass = mCollisionParcel->getParcelFlag(PF_USE_PASS_LIST);
  885. renderCollisionSegments(mCollisionSegments, use_pass, regionp);
  886. }
  887. }
  888. }
  891. void LLViewerParcelMgr::sendParcelAccessListRequest(U32 flags)
  892. {
  893. if (!mSelected)
  894. {
  895. return;
  896. }
  898. LLViewerRegion *region = LLWorld::getInstance()->getRegionFromPosGlobal( mWestSouth );
  899. if (!region) return;
  901. LLMessageSystem *msg = gMessageSystem;
  904. if (flags & AL_BAN) 
  905. {
  906. mCurrentParcel->mBanList.clear();
  907. }
  908. if (flags & AL_ACCESS) 
  909. {
  910. mCurrentParcel->mAccessList.clear();
  911. }
  913. // Only the headers differ
  914. msg->newMessageFast(_PREHASH_ParcelAccessListRequest);
  915. msg->nextBlockFast(_PREHASH_AgentData);
  916. msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
  917. msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
  918. msg->nextBlockFast(_PREHASH_Data);
  919. msg->addS32Fast(_PREHASH_SequenceID, 0);
  920. msg->addU32Fast(_PREHASH_Flags, flags);
  921. msg->addS32("LocalID", mCurrentParcel->getLocalID() );
  922. msg->sendReliable( region->getHost() );
  923. }
  926. void LLViewerParcelMgr::sendParcelDwellRequest()
  927. {
  928. if (!mSelected)
  929. {
  930. return;
  931. }
  933. LLViewerRegion *region = LLWorld::getInstance()->getRegionFromPosGlobal( mWestSouth );
  934. if (!region) return;
  936. LLMessageSystem *msg = gMessageSystem;
  938. // Only the headers differ
  939. msg->newMessage("ParcelDwellRequest");
  940. msg->nextBlock("AgentData");
  941. msg->addUUID("AgentID", gAgent.getID() );
  942. msg->addUUID("SessionID", gAgent.getSessionID());
  943. msg->nextBlock("Data");
  944. msg->addS32("LocalID", mCurrentParcel->getLocalID());
  945. msg->addUUID("ParcelID", LLUUID::null); // filled in on simulator
  946. msg->sendReliable( region->getHost() );
  947. }
  950. void LLViewerParcelMgr::sendParcelGodForceOwner(const LLUUID& owner_id)
  951. {
  952. if (!mSelected)
  953. {
  954. LLNotificationsUtil::add("CannotSetLandOwnerNothingSelected");
  955. return;
  956. }
  958. llinfos << "Claiming " << mWestSouth << " to " << mEastNorth << llendl;
  960. // BUG: Only works for the region containing mWestSouthBottom
  961. LLVector3d east_north_region_check( mEastNorth );
  962. east_north_region_check.mdV[VX] -= 0.5;
  963. east_north_region_check.mdV[VY] -= 0.5;
  965. LLViewerRegion *region = LLWorld::getInstance()->getRegionFromPosGlobal( mWestSouth );
  966. if (!region)
  967. {
  968. // TODO: Add a force owner version of this alert.
  969. LLNotificationsUtil::add("CannotContentifyNoRegion");
  970. return;
  971. }
  973. // BUG: Make work for cross-region selections
  974. LLViewerRegion *region2 = LLWorld::getInstance()->getRegionFromPosGlobal( east_north_region_check );
  975. if (region != region2)
  976. {
  977. LLNotificationsUtil::add("CannotSetLandOwnerMultipleRegions");
  978. return;
  979. }
  981. llinfos << "Region " << region->getOriginGlobal() << llendl;
  983. LLSD payload;
  984. payload["owner_id"] = owner_id;
  985. payload["parcel_local_id"] = mCurrentParcel->getLocalID();
  986. payload["region_host"] = region->getHost().getIPandPort();
  987. LLNotification::Params params("ForceOwnerAuctionWarning");
  988. params.payload(payload).functor.function(callback_god_force_owner);
  990. if(mCurrentParcel->getAuctionID())
  991. {
  992. LLNotifications::instance().add(params);
  993. }
  994. else
  995. {
  996. LLNotifications::instance().forceResponse(params, 0);
  997. }
  998. }
  1000. bool callback_god_force_owner(const LLSD& notification, const LLSD& response)
  1001. {
  1002. S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
  1003. if(0 == option)
  1004. {
  1005. LLMessageSystem* msg = gMessageSystem;
  1006. msg->newMessage("ParcelGodForceOwner");
  1007. msg->nextBlock("AgentData");
  1008. msg->addUUID("AgentID", gAgent.getID());
  1009. msg->addUUID("SessionID", gAgent.getSessionID());
  1010. msg->nextBlock("Data");
  1011. msg->addUUID("OwnerID", notification["payload"]["owner_id"].asUUID());
  1012. msg->addS32( "LocalID", notification["payload"]["parcel_local_id"].asInteger());
  1013. msg->sendReliable(LLHost(notification["payload"]["region_host"].asString()));
  1014. }
  1015. return false;
  1016. }
  1018. void LLViewerParcelMgr::sendParcelGodForceToContent()
  1019. {
  1020. if (!mSelected)
  1021. {
  1022. LLNotificationsUtil::add("CannotContentifyNothingSelected");
  1023. return;
  1024. }
  1025. LLViewerRegion* region = LLWorld::getInstance()->getRegionFromPosGlobal( mWestSouth );
  1026. if (!region)
  1027. {
  1028. LLNotificationsUtil::add("CannotContentifyNoRegion");
  1029. return;
  1030. }
  1032. LLMessageSystem* msg = gMessageSystem;
  1033. msg->newMessage("ParcelGodMarkAsContent");
  1034. msg->nextBlock("AgentData");
  1035. msg->addUUID("AgentID", gAgent.getID());
  1036. msg->addUUID("SessionID", gAgent.getSessionID());
  1037. msg->nextBlock("ParcelData");
  1038. msg->addS32("LocalID", mCurrentParcel->getLocalID());
  1039. msg->sendReliable(region->getHost());
  1040. }
  1042. void LLViewerParcelMgr::sendParcelRelease()
  1043. {
  1044. if (!mSelected)
  1045. {
  1046.         LLNotificationsUtil::add("CannotReleaseLandNothingSelected");
  1047. return;
  1048. }
  1050. LLViewerRegion *region = LLWorld::getInstance()->getRegionFromPosGlobal( mWestSouth );
  1051. if (!region)
  1052. {
  1053. LLNotificationsUtil::add("CannotReleaseLandNoRegion");
  1054. return;
  1055. }
  1057. //U32 flags = PR_NONE;
  1058. //if (god_force) flags |= PR_GOD_FORCE;
  1060. LLMessageSystem* msg = gMessageSystem;
  1061. msg->newMessage("ParcelRelease");
  1062. msg->nextBlock("AgentData");
  1063. msg->addUUID("AgentID", gAgent.getID() );
  1064. msg->addUUID("SessionID", gAgent.getSessionID() );
  1065. msg->nextBlock("Data");
  1066. msg->addS32("LocalID", mCurrentParcel->getLocalID() );
  1067. //msg->addU32("Flags", flags);
  1068. msg->sendReliable( region->getHost() );
  1070. // Blitz selection, since the parcel might be non-rectangular, and
  1071. // we won't have appropriate parcel information.
  1072. deselectLand();
  1073. }
  1075. class LLViewerParcelMgr::ParcelBuyInfo
  1076. {
  1077. public:
  1078. LLUUID mAgent;
  1079. LLUUID mSession;
  1080. LLUUID mGroup;
  1081. BOOL mIsGroupOwned;
  1082. BOOL mRemoveContribution;
  1083. BOOL mIsClaim;
  1084. LLHost mHost;
  1086. // for parcel buys
  1087. S32 mParcelID;
  1088. S32 mPrice;
  1089. S32 mArea;
  1091. // for land claims
  1092. F32 mWest;
  1093. F32 mSouth;
  1094. F32 mEast;
  1095. F32 mNorth;
  1096. };
  1098. LLViewerParcelMgr::ParcelBuyInfo* LLViewerParcelMgr::setupParcelBuy(
  1099. const LLUUID& agent_id,
  1100. const LLUUID& session_id,
  1101. const LLUUID& group_id,
  1102. BOOL is_group_owned,
  1103. BOOL is_claim,
  1104. BOOL remove_contribution)
  1105. {
  1106. if (!mSelected || !mCurrentParcel)
  1107. {
  1108. LLNotificationsUtil::add("CannotBuyLandNothingSelected");
  1109. return NULL;
  1110. }
  1112. LLViewerRegion *region = LLWorld::getInstance()->getRegionFromPosGlobal( mWestSouth );
  1113. if (!region)
  1114. {
  1115. LLNotificationsUtil::add("CannotBuyLandNoRegion");
  1116. return NULL;
  1117. }
  1119. if (is_claim)
  1120. {
  1121. llinfos << "Claiming " << mWestSouth << " to " << mEastNorth << llendl;
  1122. llinfos << "Region " << region->getOriginGlobal() << llendl;
  1124. // BUG: Only works for the region containing mWestSouthBottom
  1125. LLVector3d east_north_region_check( mEastNorth );
  1126. east_north_region_check.mdV[VX] -= 0.5;
  1127. east_north_region_check.mdV[VY] -= 0.5;
  1129. LLViewerRegion *region2 = LLWorld::getInstance()->getRegionFromPosGlobal( east_north_region_check );
  1131. if (region != region2)
  1132. {
  1133. LLNotificationsUtil::add("CantBuyLandAcrossMultipleRegions");
  1134. return NULL;
  1135. }
  1136. }
  1139. ParcelBuyInfo* info = new ParcelBuyInfo;
  1141. info->mAgent = agent_id;
  1142. info->mSession = session_id;
  1143. info->mGroup = group_id;
  1144. info->mIsGroupOwned = is_group_owned;
  1145. info->mIsClaim = is_claim;
  1146. info->mRemoveContribution = remove_contribution;
  1147. info->mHost = region->getHost();
  1148. info->mPrice = mCurrentParcel->getSalePrice();
  1149. info->mArea = mCurrentParcel->getArea();
  1151. if (!is_claim)
  1152. {
  1153. info->mParcelID = mCurrentParcel->getLocalID();
  1154. }
  1155. else
  1156. {
  1157. // BUG: Make work for cross-region selections
  1158. LLVector3 west_south_bottom_region = region->getPosRegionFromGlobal( mWestSouth );
  1159. LLVector3 east_north_top_region = region->getPosRegionFromGlobal( mEastNorth );
  1161. info->mWest = west_south_bottom_region.mV[VX];
  1162. info->mSouth = west_south_bottom_region.mV[VY];
  1163. info->mEast = east_north_top_region.mV[VX];
  1164. info->mNorth = east_north_top_region.mV[VY];
  1165. }
  1167. return info;
  1168. }
  1170. void LLViewerParcelMgr::sendParcelBuy(ParcelBuyInfo* info)
  1171. {
  1172. // send the message
  1173. LLMessageSystem* msg = gMessageSystem;
  1174. msg->newMessage(info->mIsClaim ? "ParcelClaim" : "ParcelBuy");
  1175. msg->nextBlock("AgentData");
  1176. msg->addUUID("AgentID", info->mAgent);
  1177. msg->addUUID("SessionID", info->mSession);
  1178. msg->nextBlock("Data");
  1179. msg->addUUID("GroupID", info->mGroup);
  1180. msg->addBOOL("IsGroupOwned", info->mIsGroupOwned);
  1181. if (!info->mIsClaim)
  1182. {
  1183. msg->addBOOL("RemoveContribution", info->mRemoveContribution);
  1184. msg->addS32("LocalID", info->mParcelID);
  1185. }
  1186. msg->addBOOL("Final", TRUE); // don't allow escrow buys
  1187. if (info->mIsClaim)
  1188. {
  1189. msg->nextBlock("ParcelData");
  1190. msg->addF32("West",  info->mWest);
  1191. msg->addF32("South", info->mSouth);
  1192. msg->addF32("East",  info->mEast);
  1193. msg->addF32("North", info->mNorth);
  1194. }
  1195. else // ParcelBuy
  1196. {
  1197. msg->nextBlock("ParcelData");
  1198. msg->addS32("Price",info->mPrice);
  1199. msg->addS32("Area",info->mArea);
  1200. }
  1201. msg->sendReliable(info->mHost);
  1202. }
  1204. void LLViewerParcelMgr::deleteParcelBuy(ParcelBuyInfo* *info)
  1205. {
  1206. // Must be here because ParcelBuyInfo is local to this .cpp file
  1207. delete *info;
  1208. *info = NULL;
  1209. }
  1211. void LLViewerParcelMgr::sendParcelDeed(const LLUUID& group_id)
  1212. {
  1213. if (!mSelected || !mCurrentParcel)
  1214. {
  1215. LLNotificationsUtil::add("CannotDeedLandNothingSelected");
  1216. return;
  1217. }
  1218. if(group_id.isNull())
  1219. {
  1220. LLNotificationsUtil::add("CannotDeedLandNoGroup");
  1221. return;
  1222. }
  1223. LLViewerRegion *region = LLWorld::getInstance()->getRegionFromPosGlobal( mWestSouth );
  1224. if (!region)
  1225. {
  1226. LLNotificationsUtil::add("CannotDeedLandNoRegion");
  1227. return;
  1228. }
  1230. LLMessageSystem* msg = gMessageSystem;
  1231. msg->newMessage("ParcelDeedToGroup");
  1232. msg->nextBlock("AgentData");
  1233. msg->addUUID("AgentID", gAgent.getID() );
  1234. msg->addUUID("SessionID", gAgent.getSessionID() );
  1235. msg->nextBlock("Data");
  1236. msg->addUUID("GroupID", group_id );
  1237. msg->addS32("LocalID", mCurrentParcel->getLocalID() );
  1238. //msg->addU32("JoinNeighbors", join);
  1239. msg->sendReliable( region->getHost() );
  1240. }
  1243. /*
  1244. // *NOTE: We cannot easily make landmarks at global positions because
  1245. // global positions probably refer to a sim/local combination which
  1246. // can move over time. We could implement this by looking up the
  1247. // region global x,y, but it's easier to take it out for now.
  1248. void LLViewerParcelMgr::makeLandmarkAtSelection()
  1249. {
  1250. // Don't create for parcels you don't own
  1251. if (gAgent.getID() != mCurrentParcel->getOwnerID())
  1252. {
  1253. return;
  1254. }
  1256. LLVector3d global_center(mWestSouth);
  1257. global_center += mEastNorth;
  1258. global_center *= 0.5f;
  1260. LLViewerRegion* region;
  1261. region = LLWorld::getInstance()->getRegionFromPosGlobal(global_center);
  1263. LLVector3 west_south_bottom_region = region->getPosRegionFromGlobal( mWestSouth );
  1264. LLVector3 east_north_top_region = region->getPosRegionFromGlobal( mEastNorth );
  1266. std::string name("My Land");
  1267. std::string buffer;
  1268. S32 pos_x = (S32)floor((west_south_bottom_region.mV[VX] + east_north_top_region.mV[VX]) / 2.0f);
  1269. S32 pos_y = (S32)floor((west_south_bottom_region.mV[VY] + east_north_top_region.mV[VY]) / 2.0f);
  1270. buffer = llformat("%s in %s (%d, %d)",
  1271. name.c_str(),
  1272. region->getName().c_str(),
  1273. pos_x, pos_y);
  1274. name.assign(buffer);
  1276. create_landmark(name, "Claimed land", global_center);
  1277. }
  1278. */
  1280. const std::string& LLViewerParcelMgr::getAgentParcelName() const
  1281. {
  1282. return mAgentParcel->getName();
  1283. }
  1286. void LLViewerParcelMgr::sendParcelPropertiesUpdate(LLParcel* parcel, bool use_agent_region)
  1287. {
  1288. if(!parcel) return;
  1290. LLViewerRegion *region = use_agent_region ? gAgent.getRegion() : LLWorld::getInstance()->getRegionFromPosGlobal( mWestSouth );
  1291. if (!region) return;
  1292. //llinfos << "found region: " << region->getName() << llendl;
  1294. LLSD body;
  1295. std::string url = region->getCapability("ParcelPropertiesUpdate");
  1296. if (!url.empty())
  1297. {
  1298. // request new properties update from simulator
  1299. U32 message_flags = 0x01;
  1300. body["flags"] = ll_sd_from_U32(message_flags);
  1301. parcel->packMessage(body);
  1302. llinfos << "Sending parcel properties update via capability to: "
  1303. << url << llendl;
  1304. LLHTTPClient::post(url, body, new LLHTTPClient::Responder());
  1305. }
  1306. else
  1307. {
  1308. LLMessageSystem* msg = gMessageSystem;
  1309. msg->newMessageFast(_PREHASH_ParcelPropertiesUpdate);
  1310. msg->nextBlockFast(_PREHASH_AgentData);
  1311. msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID() );
  1312. msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
  1313. msg->nextBlockFast(_PREHASH_ParcelData);
  1314. msg->addS32Fast(_PREHASH_LocalID, parcel->getLocalID() );
  1316. U32 message_flags = 0x01;
  1317. msg->addU32("Flags", message_flags);
  1319. parcel->packMessage(msg);
  1321. msg->sendReliable( region->getHost() );
  1322. }
  1323. }
  1326. void LLViewerParcelMgr::setHoverParcel(const LLVector3d& pos)
  1327. {
  1328. static U32 last_west, last_south;
  1331. // only request parcel info when tooltip is shown
  1332. if (!gSavedSettings.getBOOL("ShowLandHoverTip"))
  1333. {
  1334. return;
  1335. }
  1337. // only request parcel info if position has changed outside of the
  1338. // last parcel grid step
  1339. U32 west_parcel_step = (U32) floor( pos.mdV[VX] / PARCEL_GRID_STEP_METERS );
  1340. U32 south_parcel_step = (U32) floor( pos.mdV[VY] / PARCEL_GRID_STEP_METERS );
  1342. if ((west_parcel_step == last_west) && (south_parcel_step == last_south))
  1343. {
  1344. return;
  1345. }
  1346. else 
  1347. {
  1348. last_west = west_parcel_step;
  1349. last_south = south_parcel_step;
  1350. }
  1352. LLViewerRegion* region = LLWorld::getInstance()->getRegionFromPosGlobal( pos );
  1353. if (!region)
  1354. {
  1355. return;
  1356. }
  1359. // Send a rectangle around the point.
  1360. // This means the parcel sent back is at least a rectangle around the point,
  1361. // which is more efficient for public land.  Fewer requests are sent.  JC
  1362. LLVector3 wsb_region = region->getPosRegionFromGlobal( pos );
  1364. F32 west  = PARCEL_GRID_STEP_METERS * floor( wsb_region.mV[VX] / PARCEL_GRID_STEP_METERS );
  1365. F32 south = PARCEL_GRID_STEP_METERS * floor( wsb_region.mV[VY] / PARCEL_GRID_STEP_METERS );
  1367. F32 east  = west  + PARCEL_GRID_STEP_METERS;
  1368. F32 north = south + PARCEL_GRID_STEP_METERS;
  1370. // Send request message
  1371. LLMessageSystem *msg = gMessageSystem;
  1372. msg->newMessageFast(_PREHASH_ParcelPropertiesRequest);
  1373. msg->nextBlockFast(_PREHASH_AgentData);
  1374. msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID() );
  1375. msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID() );
  1376. msg->nextBlockFast(_PREHASH_ParcelData);
  1377. msg->addS32Fast(_PREHASH_SequenceID, HOVERED_PARCEL_SEQ_ID );
  1378. msg->addF32Fast(_PREHASH_West, west );
  1379. msg->addF32Fast(_PREHASH_South, south );
  1380. msg->addF32Fast(_PREHASH_East, east );
  1381. msg->addF32Fast(_PREHASH_North, north );
  1382. msg->addBOOL("SnapSelection", FALSE );
  1383. msg->sendReliable( region->getHost() );
  1385. mHoverRequestResult = PARCEL_RESULT_NO_DATA;
  1386. }
  1389. // static
  1390. void LLViewerParcelMgr::processParcelOverlay(LLMessageSystem *msg, void **user)
  1391. {
  1392. if (gNoRender)
  1393. {
  1394. return;
  1395. }
  1397. // Extract the packed overlay information
  1398. S32 packed_overlay_size = msg->getSizeFast(_PREHASH_ParcelData, _PREHASH_Data);
  1400. if (packed_overlay_size <= 0)
  1401. {
  1402. llwarns << "Overlay size " << packed_overlay_size << llendl;
  1403. return;
  1404. }
  1406. S32 parcels_per_edge = LLViewerParcelMgr::getInstance()->mParcelsPerEdge;
  1407. S32 expected_size = parcels_per_edge * parcels_per_edge / PARCEL_OVERLAY_CHUNKS;
  1408. if (packed_overlay_size != expected_size)
  1409. {
  1410. llwarns << "Got parcel overlay size " << packed_overlay_size
  1411. << " expecting " << expected_size << llendl;
  1412. return;
  1413. }
  1415. S32 sequence_id;
  1416. msg->getS32Fast(_PREHASH_ParcelData, _PREHASH_SequenceID, sequence_id);
  1417. msg->getBinaryDataFast(
  1418. _PREHASH_ParcelData,
  1419. _PREHASH_Data,
  1420. sPackedOverlay,
  1421. expected_size);
  1423. LLHost host = msg->getSender();
  1424. LLViewerRegion *region = LLWorld::getInstance()->getRegion(host);
  1425. if (region)
  1426. {
  1427. region->mParcelOverlay->uncompressLandOverlay( sequence_id, sPackedOverlay );
  1428. }
  1429. }
  1431. // static
  1432. void LLViewerParcelMgr::processParcelProperties(LLMessageSystem *msg, void **user)
  1433. {
  1434. S32 request_result;
  1435. S32 sequence_id;
  1436. BOOL snap_selection = FALSE;
  1437. S32 self_count = 0;
  1438. S32 other_count = 0;
  1439. S32 public_count = 0;
  1440. S32 local_id;
  1441. LLUUID owner_id;
  1442. BOOL is_group_owned;
  1443. U32 auction_id = 0;
  1444. S32 claim_price_per_meter = 0;
  1445. S32 rent_price_per_meter = 0;
  1446. S32 claim_date = 0;
  1447. LLVector3 aabb_min;
  1448. LLVector3 aabb_max;
  1449. S32 area = 0;
  1450. S32 sw_max_prims = 0;
  1451. S32 sw_total_prims = 0;
  1452. //LLUUID buyer_id;
  1453. U8 status = 0;
  1454. S32 max_prims = 0;
  1455. S32 total_prims = 0;
  1456. S32 owner_prims = 0;
  1457. S32 group_prims = 0;
  1458. S32 other_prims = 0;
  1459. S32 selected_prims = 0;
  1460. F32 parcel_prim_bonus = 1.f;
  1461. BOOL region_push_override = false;
  1462. BOOL region_deny_anonymous_override = false;
  1463. BOOL region_deny_identified_override = false; // Deprecated
  1464. BOOL region_deny_transacted_override = false; // Deprecated
  1465. BOOL region_deny_age_unverified_override = false;
  1467. S32 other_clean_time = 0;
  1469. msg->getS32Fast(_PREHASH_ParcelData, _PREHASH_RequestResult, request_result );
  1470. msg->getS32Fast(_PREHASH_ParcelData, _PREHASH_SequenceID, sequence_id );
  1472. if (request_result == PARCEL_RESULT_NO_DATA)
  1473. {
  1474. // no valid parcel data
  1475. llinfos << "no valid parcel data" << llendl;
  1476. return;
  1477. }
  1479. // Decide where the data will go.
  1480. LLParcel* parcel = NULL;
  1481. if (sequence_id == SELECTED_PARCEL_SEQ_ID)
  1482. {
  1483. // ...selected parcels report this sequence id
  1484. LLViewerParcelMgr::getInstance()->mRequestResult = PARCEL_RESULT_SUCCESS;
  1485. parcel = LLViewerParcelMgr::getInstance()->mCurrentParcel;
  1486. }
  1487. else if (sequence_id == HOVERED_PARCEL_SEQ_ID)
  1488. {
  1489. LLViewerParcelMgr::getInstance()->mHoverRequestResult = PARCEL_RESULT_SUCCESS;
  1490. parcel = LLViewerParcelMgr::getInstance()->mHoverParcel;
  1491. }
  1492. else if (sequence_id == COLLISION_NOT_IN_GROUP_PARCEL_SEQ_ID ||
  1493.  sequence_id == COLLISION_NOT_ON_LIST_PARCEL_SEQ_ID ||
  1494.  sequence_id == COLLISION_BANNED_PARCEL_SEQ_ID)
  1495. {
  1496. LLViewerParcelMgr::getInstance()->mHoverRequestResult = PARCEL_RESULT_SUCCESS;
  1497. parcel = LLViewerParcelMgr::getInstance()->mCollisionParcel;
  1498. }
  1499. else if (sequence_id == 0 || sequence_id > LLViewerParcelMgr::getInstance()->mAgentParcelSequenceID)
  1500. {
  1501. // new agent parcel
  1502. LLViewerParcelMgr::getInstance()->mAgentParcelSequenceID = sequence_id;
  1503. parcel = LLViewerParcelMgr::getInstance()->mAgentParcel;
  1504. }
  1505. else
  1506. {
  1507. llinfos << "out of order agent parcel sequence id " << sequence_id
  1508. << " last good " << LLViewerParcelMgr::getInstance()->mAgentParcelSequenceID
  1509. << llendl;
  1510. return;
  1511. }
  1513. msg->getBOOL("ParcelData", "SnapSelection", snap_selection);
  1514. msg->getS32Fast(_PREHASH_ParcelData, _PREHASH_SelfCount, self_count);
  1515. msg->getS32Fast(_PREHASH_ParcelData, _PREHASH_OtherCount, other_count);
  1516. msg->getS32Fast(_PREHASH_ParcelData, _PREHASH_PublicCount, public_count);
  1517. msg->getS32Fast( _PREHASH_ParcelData, _PREHASH_LocalID, local_id );
  1518. msg->getUUIDFast(_PREHASH_ParcelData, _PREHASH_OwnerID, owner_id);
  1519. msg->getBOOLFast(_PREHASH_ParcelData, _PREHASH_IsGroupOwned, is_group_owned);
  1520. msg->getU32Fast(_PREHASH_ParcelData, _PREHASH_AuctionID, auction_id);
  1521. msg->getS32Fast( _PREHASH_ParcelData, _PREHASH_ClaimDate, claim_date);
  1522. msg->getS32Fast( _PREHASH_ParcelData, _PREHASH_ClaimPrice, claim_price_per_meter);
  1523. msg->getS32Fast( _PREHASH_ParcelData, _PREHASH_RentPrice, rent_price_per_meter);
  1524. msg->getVector3Fast(_PREHASH_ParcelData, _PREHASH_AABBMin, aabb_min);
  1525. msg->getVector3Fast(_PREHASH_ParcelData, _PREHASH_AABBMax, aabb_max);
  1526. msg->getS32Fast( _PREHASH_ParcelData, _PREHASH_Area, area );
  1527. //msg->getUUIDFast( _PREHASH_ParcelData, _PREHASH_BuyerID, buyer_id);
  1528. msg->getU8("ParcelData", "Status", status);
  1529. msg->getS32("ParcelData", "SimWideMaxPrims", sw_max_prims );
  1530. msg->getS32("ParcelData", "SimWideTotalPrims", sw_total_prims );
  1531. msg->getS32Fast(_PREHASH_ParcelData, _PREHASH_MaxPrims, max_prims );
  1532. msg->getS32Fast(_PREHASH_ParcelData, _PREHASH_TotalPrims, total_prims );
  1533. msg->getS32Fast(_PREHASH_ParcelData, _PREHASH_OwnerPrims, owner_prims );
  1534. msg->getS32Fast(_PREHASH_ParcelData, _PREHASH_GroupPrims, group_prims );
  1535. msg->getS32Fast(_PREHASH_ParcelData, _PREHASH_OtherPrims, other_prims );
  1536. msg->getS32Fast(_PREHASH_ParcelData, _PREHASH_SelectedPrims, selected_prims );
  1537. msg->getF32Fast(_PREHASH_ParcelData, _PREHASH_ParcelPrimBonus, parcel_prim_bonus );
  1538. msg->getBOOLFast(_PREHASH_ParcelData, _PREHASH_RegionPushOverride, region_push_override );
  1539. msg->getBOOLFast(_PREHASH_ParcelData, _PREHASH_RegionDenyAnonymous, region_deny_anonymous_override );
  1540. msg->getBOOLFast(_PREHASH_ParcelData, _PREHASH_RegionDenyIdentified, region_deny_identified_override ); // Deprecated
  1541. msg->getBOOLFast(_PREHASH_ParcelData, _PREHASH_RegionDenyTransacted, region_deny_transacted_override ); // Deprecated
  1542. if (msg->getNumberOfBlocksFast(_PREHASH_AgeVerificationBlock))
  1543. {
  1544. // this block was added later and may not be on older sims, so we have to test its existence first
  1545. msg->getBOOLFast(_PREHASH_AgeVerificationBlock, _PREHASH_RegionDenyAgeUnverified, region_deny_age_unverified_override );
  1546. }
  1548. msg->getS32("ParcelData", "OtherCleanTime", other_clean_time );
  1550. // Actually extract the data.
  1551. if (parcel)
  1552. {
  1553. parcel->init(owner_id,
  1554. FALSE, FALSE, FALSE,
  1555. claim_date, claim_price_per_meter, rent_price_per_meter,
  1556. area, other_prims, parcel_prim_bonus, is_group_owned);
  1557. parcel->setLocalID(local_id);
  1558. parcel->setAABBMin(aabb_min);
  1559. parcel->setAABBMax(aabb_max);
  1561. parcel->setAuctionID(auction_id);
  1562. parcel->setOwnershipStatus((LLParcel::EOwnershipStatus)status);
  1564. parcel->setSimWideMaxPrimCapacity(sw_max_prims);
  1565. parcel->setSimWidePrimCount(sw_total_prims);
  1566. parcel->setMaxPrimCapacity(max_prims);
  1567. parcel->setOwnerPrimCount(owner_prims);
  1568. parcel->setGroupPrimCount(group_prims);
  1569. parcel->setOtherPrimCount(other_prims);
  1570. parcel->setSelectedPrimCount(selected_prims);
  1571. parcel->setParcelPrimBonus(parcel_prim_bonus);
  1573. parcel->setCleanOtherTime(other_clean_time);
  1574. parcel->setRegionPushOverride(region_push_override);
  1575. parcel->setRegionDenyAnonymousOverride(region_deny_anonymous_override);
  1576. parcel->setRegionDenyAgeUnverifiedOverride(region_deny_age_unverified_override);
  1577. parcel->unpackMessage(msg);
  1579. if (parcel == LLViewerParcelMgr::getInstance()->mAgentParcel)
  1580. {
  1581. S32 bitmap_size = LLViewerParcelMgr::getInstance()->mParcelsPerEdge
  1582. * LLViewerParcelMgr::getInstance()->mParcelsPerEdge
  1583. / 8;
  1584. U8* bitmap = new U8[ bitmap_size ];
  1585. msg->getBinaryDataFast(_PREHASH_ParcelData, _PREHASH_Bitmap, bitmap, bitmap_size);
  1587. LLViewerParcelMgr::getInstance()->writeAgentParcelFromBitmap(bitmap);
  1588. delete[] bitmap;
  1590. // Let interesting parties know about agent parcel change.
  1591. LLViewerParcelMgr* instance = LLViewerParcelMgr::getInstance();
  1593. instance->mAgentParcelChangedSignal();
  1595. if (instance->mTeleportInProgress)
  1596. {
  1597. instance->mTeleportInProgress = FALSE;
  1598. instance->mTeleportFinishedSignal(gAgent.getPositionGlobal());
  1599. }
  1600. }
  1601. }
  1603. // Handle updating selections, if necessary.
  1604. if (sequence_id == SELECTED_PARCEL_SEQ_ID)
  1605. {
  1606. // Update selected counts
  1607. LLViewerParcelMgr::getInstance()->mCurrentParcelSelection->mSelectedSelfCount = self_count;
  1608. LLViewerParcelMgr::getInstance()->mCurrentParcelSelection->mSelectedOtherCount = other_count;
  1609. LLViewerParcelMgr::getInstance()->mCurrentParcelSelection->mSelectedPublicCount = public_count;
  1611. LLViewerParcelMgr::getInstance()->mCurrentParcelSelection->mSelectedMultipleOwners =
  1612. (request_result == PARCEL_RESULT_MULTIPLE);
  1614. // Select the whole parcel
  1615. LLViewerRegion* region = LLWorld::getInstance()->getRegion( msg->getSender() );
  1616. if (region)
  1617. {
  1618. if (!snap_selection)
  1619. {
  1620. // don't muck with the westsouth and eastnorth.
  1621. // just highlight it
  1622. LLVector3 west_south = region->getPosRegionFromGlobal(LLViewerParcelMgr::getInstance()->mWestSouth);
  1623. LLVector3 east_north = region->getPosRegionFromGlobal(LLViewerParcelMgr::getInstance()->mEastNorth);
  1625. LLViewerParcelMgr::getInstance()->resetSegments(LLViewerParcelMgr::getInstance()->mHighlightSegments);
  1626. LLViewerParcelMgr::getInstance()->writeHighlightSegments(
  1627. west_south.mV[VX],
  1628. west_south.mV[VY],
  1629. east_north.mV[VX],
  1630. east_north.mV[VY] );
  1631. LLViewerParcelMgr::getInstance()->mCurrentParcelSelection->mWholeParcelSelected = FALSE;
  1632. }
  1633. else if (0 == local_id)
  1634. {
  1635. // this is public land, just highlight the selection
  1636. LLViewerParcelMgr::getInstance()->mWestSouth = region->getPosGlobalFromRegion( aabb_min );
  1637. LLViewerParcelMgr::getInstance()->mEastNorth = region->getPosGlobalFromRegion( aabb_max );
  1639. LLViewerParcelMgr::getInstance()->resetSegments(LLViewerParcelMgr::getInstance()->mHighlightSegments);
  1640. LLViewerParcelMgr::getInstance()->writeHighlightSegments(
  1641. aabb_min.mV[VX],
  1642. aabb_min.mV[VY],
  1643. aabb_max.mV[VX],
  1644. aabb_max.mV[VY] );
  1645. LLViewerParcelMgr::getInstance()->mCurrentParcelSelection->mWholeParcelSelected = TRUE;
  1646. }
  1647. else
  1648. {
  1649. LLViewerParcelMgr::getInstance()->mWestSouth = region->getPosGlobalFromRegion( aabb_min );
  1650. LLViewerParcelMgr::getInstance()->mEastNorth = region->getPosGlobalFromRegion( aabb_max );
  1652. // Owned land, highlight the boundaries
  1653. S32 bitmap_size = LLViewerParcelMgr::getInstance()->mParcelsPerEdge
  1654. * LLViewerParcelMgr::getInstance()->mParcelsPerEdge
  1655. / 8;
  1656. U8* bitmap = new U8[ bitmap_size ];
  1657. msg->getBinaryDataFast(_PREHASH_ParcelData, _PREHASH_Bitmap, bitmap, bitmap_size);
  1659. LLViewerParcelMgr::getInstance()->resetSegments(LLViewerParcelMgr::getInstance()->mHighlightSegments);
  1660. LLViewerParcelMgr::getInstance()->writeSegmentsFromBitmap( bitmap, LLViewerParcelMgr::getInstance()->mHighlightSegments );
  1662. delete[] bitmap;
  1663. bitmap = NULL;
  1665. LLViewerParcelMgr::getInstance()->mCurrentParcelSelection->mWholeParcelSelected = TRUE;
  1666. }
  1668. // Request access list information for this land
  1669. LLViewerParcelMgr::getInstance()->sendParcelAccessListRequest(AL_ACCESS | AL_BAN);
  1671. // Request the media url filter list for this land
  1672. LLViewerParcelMgr::getInstance()->requestParcelMediaURLFilter();
  1674. // Request dwell for this land, if it's not public land.
  1675. LLViewerParcelMgr::getInstance()->mSelectedDwell = 0.f;
  1676. if (0 != local_id)
  1677. {
  1678. LLViewerParcelMgr::getInstance()->sendParcelDwellRequest();
  1679. }
  1681. LLViewerParcelMgr::getInstance()->mSelected = TRUE;
  1682. LLViewerParcelMgr::getInstance()->notifyObservers();
  1683. }
  1684. }
  1685. else if (sequence_id == COLLISION_NOT_IN_GROUP_PARCEL_SEQ_ID ||
  1686.  sequence_id == COLLISION_NOT_ON_LIST_PARCEL_SEQ_ID  ||
  1687.  sequence_id == COLLISION_BANNED_PARCEL_SEQ_ID)
  1688. {
  1689. // We're about to collide with this parcel
  1690. LLViewerParcelMgr::getInstance()->mRenderCollision = TRUE;
  1691. LLViewerParcelMgr::getInstance()->mCollisionTimer.reset();
  1693. // Differentiate this parcel if we are banned from it.
  1694. if (sequence_id == COLLISION_BANNED_PARCEL_SEQ_ID)
  1695. {
  1696. LLViewerParcelMgr::getInstance()->mCollisionBanned = BA_BANNED;
  1697. }
  1698. else if (sequence_id == COLLISION_NOT_IN_GROUP_PARCEL_SEQ_ID)
  1699. {
  1700. LLViewerParcelMgr::getInstance()->mCollisionBanned = BA_NOT_IN_GROUP;
  1701. }
  1702. else 
  1703. {
  1704. LLViewerParcelMgr::getInstance()->mCollisionBanned = BA_NOT_ON_LIST;
  1706. }
  1708. S32 bitmap_size = LLViewerParcelMgr::getInstance()->mParcelsPerEdge
  1709. * LLViewerParcelMgr::getInstance()->mParcelsPerEdge
  1710. / 8;
  1711. U8* bitmap = new U8[ bitmap_size ];
  1712. msg->getBinaryDataFast(_PREHASH_ParcelData, _PREHASH_Bitmap, bitmap, bitmap_size);
  1714. LLViewerParcelMgr::getInstance()->resetSegments(LLViewerParcelMgr::getInstance()->mCollisionSegments);
  1715. LLViewerParcelMgr::getInstance()->writeSegmentsFromBitmap( bitmap, LLViewerParcelMgr::getInstance()->mCollisionSegments );
  1717. delete[] bitmap;
  1718. bitmap = NULL;
  1720. }
  1721. else if (sequence_id == HOVERED_PARCEL_SEQ_ID)
  1722. {
  1723. LLViewerRegion *region = LLWorld::getInstance()->getRegion( msg->getSender() );
  1724. if (region)
  1725. {
  1726. LLViewerParcelMgr::getInstance()->mHoverWestSouth = region->getPosGlobalFromRegion( aabb_min );
  1727. LLViewerParcelMgr::getInstance()->mHoverEastNorth = region->getPosGlobalFromRegion( aabb_max );
  1728. }
  1729. else
  1730. {
  1731. LLViewerParcelMgr::getInstance()->mHoverWestSouth.clearVec();
  1732. LLViewerParcelMgr::getInstance()->mHoverEastNorth.clearVec();
  1733. }
  1734. }
  1735. else
  1736. {
  1737. // look for music.
  1738. if (gAudiop)
  1739. {
  1740. if (parcel)
  1741. {
  1742. std::string music_url_raw = parcel->getMusicURL();
  1744. // Trim off whitespace from front and back
  1745. std::string music_url = music_url_raw;
  1746. LLStringUtil::trim(music_url);
  1748. // On entering a new parcel, stop the last stream if the
  1749. // new parcel has a different music url.  (Empty URL counts
  1750. // as different.)
  1751. const std::string& stream_url = gAudiop->getInternetStreamURL();
  1753. if (music_url.empty() || music_url != stream_url)
  1754. {
  1755. // URL is different from one currently playing.
  1756. gAudiop->stopInternetStream();
  1758. // If there is a new music URL and it's valid, play it.
  1759. if (music_url.size() > 12)
  1760. {
  1761. if (music_url.substr(0,7) == "http://")
  1762. {
  1763. optionally_start_music(music_url);
  1764. }
  1765. else
  1766. {
  1767. llinfos << "Stopping parcel music (invalid audio stream URL)" << llendl;
  1768. // clears the URL 
  1769. gAudiop->startInternetStream(LLStringUtil::null); 
  1770. }
  1771. }
  1772. else if (!gAudiop->getInternetStreamURL().empty())
  1773. {
  1774. llinfos << "Stopping parcel music (parcel stream URL is empty)" << llendl;
  1775. gAudiop->startInternetStream(LLStringUtil::null);
  1776. }
  1777. }
  1778. }
  1779. else
  1780. {
  1781. // Public land has no music
  1782. gAudiop->stopInternetStream();
  1783. }
  1784. }//if gAudiop
  1786. // now check for video
  1787. LLViewerParcelMedia::update( parcel );
  1788. };
  1789. }
  1791. void optionally_start_music(const std::string& music_url)
  1792. {
  1793. if (gSavedSettings.getBOOL("AudioStreamingMusic") &&
  1794.     gSavedSettings.getBOOL("AudioStreamingMedia"))
  1795. {
  1796. // only play music when you enter a new parcel if the UI control for this
  1797. // was not *explicitly* stopped by the user. (part of SL-4878)
  1798. LLPanelNearByMedia* nearby_media_panel = gStatusBar->getNearbyMediaPanel();;
  1799. if ((nearby_media_panel &&
  1800.      nearby_media_panel->getParcelAudioAutoStart()) ||
  1801.     // or they have expressed no opinion in the UI, but have autoplay on...
  1802.     (!nearby_media_panel &&
  1803.      gSavedSettings.getBOOL(LLViewerMedia::AUTO_PLAY_MEDIA_SETTING) &&
  1804.  gSavedSettings.getBOOL("MediaTentativeAutoPlay")))
  1805. {
  1806. llinfos << "Starting parcel music " << music_url << llendl;
  1807. gAudiop->startInternetStream(music_url);
  1808. }
  1809. }
  1810. }
  1812. // static
  1813. void LLViewerParcelMgr::processParcelAccessListReply(LLMessageSystem *msg, void **user)
  1814. {
  1815. LLUUID agent_id;
  1816. S32 sequence_id = 0;
  1817. U32 message_flags = 0x0;
  1818. S32 parcel_id = -1;
  1820. msg->getUUIDFast(_PREHASH_Data, _PREHASH_AgentID, agent_id);
  1821. msg->getS32Fast( _PREHASH_Data, _PREHASH_SequenceID, sequence_id ); //ignored
  1822. msg->getU32Fast( _PREHASH_Data, _PREHASH_Flags, message_flags);
  1823. msg->getS32Fast( _PREHASH_Data, _PREHASH_LocalID, parcel_id);
  1825. LLParcel* parcel = LLViewerParcelMgr::getInstance()->mCurrentParcel;
  1826. if (!parcel) return;
  1828. if (parcel_id != parcel->getLocalID())
  1829. {
  1830. LL_WARNS_ONCE("") << "processParcelAccessListReply for parcel " << parcel_id
  1831. << " which isn't the selected parcel " << parcel->getLocalID()<< llendl;
  1832. return;
  1833. }
  1835. if (message_flags & AL_ACCESS)
  1836. {
  1837. parcel->unpackAccessEntries(msg, &(parcel->mAccessList) );
  1838. }
  1839. else if (message_flags & AL_BAN)
  1840. {
  1841. parcel->unpackAccessEntries(msg, &(parcel->mBanList) );
  1842. }
  1843. /*else if (message_flags & AL_RENTER)
  1844. {
  1845. parcel->unpackAccessEntries(msg, &(parcel->mRenterList) );
  1846. }*/
  1848. LLViewerParcelMgr::getInstance()->notifyObservers();
  1849. }
  1852. // static
  1853. void LLViewerParcelMgr::processParcelDwellReply(LLMessageSystem* msg, void**)
  1854. {
  1855. LLUUID agent_id;
  1856. msg->getUUID("AgentData", "AgentID", agent_id);
  1858. S32 local_id;
  1859. msg->getS32("Data", "LocalID", local_id);
  1861. LLUUID parcel_id;
  1862. msg->getUUID("Data", "ParcelID", parcel_id);
  1864. F32 dwell;
  1865. msg->getF32("Data", "Dwell", dwell);
  1867. if (local_id == LLViewerParcelMgr::getInstance()->mCurrentParcel->getLocalID())
  1868. {
  1869. LLViewerParcelMgr::getInstance()->mSelectedDwell = dwell;
  1870. LLViewerParcelMgr::getInstance()->notifyObservers();
  1871. }
  1872. }
  1875. void LLViewerParcelMgr::sendParcelAccessListUpdate(U32 which)
  1876. {
  1878. LLUUID transactionUUID;
  1879. transactionUUID.generate();
  1881. if (!mSelected)
  1882. {
  1883. return;
  1884. }
  1886. LLViewerRegion* region = LLWorld::getInstance()->getRegionFromPosGlobal( mWestSouth );
  1887. if (!region) return;
  1889. LLMessageSystem* msg = gMessageSystem;
  1891. LLParcel* parcel = mCurrentParcel;
  1892. if (!parcel) return;
  1894. if (which & AL_ACCESS)
  1895. {
  1896. S32 count = parcel->mAccessList.size();
  1897. S32 num_sections = (S32) ceil(count/PARCEL_MAX_ENTRIES_PER_PACKET);
  1898. S32 sequence_id = 1;
  1899. BOOL start_message = TRUE;
  1900. BOOL initial = TRUE;
  1902. access_map_const_iterator cit = parcel->mAccessList.begin();
  1903. access_map_const_iterator end = parcel->mAccessList.end();
  1904. while ( (cit != end) || initial ) 
  1905. {
  1906. if (start_message) 
  1907. {
  1908. msg->newMessageFast(_PREHASH_ParcelAccessListUpdate);
  1909. msg->nextBlockFast(_PREHASH_AgentData);
  1910. msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID() );
  1911. msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID() );
  1912. msg->nextBlockFast(_PREHASH_Data);
  1913. msg->addU32Fast(_PREHASH_Flags, AL_ACCESS);
  1914. msg->addS32(_PREHASH_LocalID, parcel->getLocalID() );
  1915. msg->addUUIDFast(_PREHASH_TransactionID, transactionUUID);
  1916. msg->addS32Fast(_PREHASH_SequenceID, sequence_id);
  1917. msg->addS32Fast(_PREHASH_Sections, num_sections);
  1918. start_message = FALSE;
  1920. if (initial && (cit == end))
  1921. {
  1922. // pack an empty block if there will be no data
  1923. msg->nextBlockFast(_PREHASH_List);
  1924. msg->addUUIDFast(_PREHASH_ID,  LLUUID::null );
  1925. msg->addS32Fast(_PREHASH_Time, 0 );
  1926. msg->addU32Fast(_PREHASH_Flags, 0 );
  1927. }
  1929. initial = FALSE;
  1930. sequence_id++;
  1932. }
  1934. while ( (cit != end) && (msg->getCurrentSendTotal() < MTUBYTES)) 
  1935. {
  1937. const LLAccessEntry& entry = (*cit).second;
  1939. msg->nextBlockFast(_PREHASH_List);
  1940. msg->addUUIDFast(_PREHASH_ID,  entry.mID );
  1941. msg->addS32Fast(_PREHASH_Time, entry.mTime );
  1942. msg->addU32Fast(_PREHASH_Flags, entry.mFlags );
  1943. ++cit;
  1944. }
  1946. start_message = TRUE;
  1947. msg->sendReliable( region->getHost() );
  1948. }
  1949. }
  1951. if (which & AL_BAN)
  1952. {
  1953. S32 count = parcel->mBanList.size();
  1954. S32 num_sections = (S32) ceil(count/PARCEL_MAX_ENTRIES_PER_PACKET);
  1955. S32 sequence_id = 1;
  1956. BOOL start_message = TRUE;
  1957. BOOL initial = TRUE;
  1959. access_map_const_iterator cit = parcel->mBanList.begin();
  1960. access_map_const_iterator end = parcel->mBanList.end();
  1961. while ( (cit != end) || initial ) 
  1962. {
  1963. if (start_message) 
  1964. {
  1965. msg->newMessageFast(_PREHASH_ParcelAccessListUpdate);
  1966. msg->nextBlockFast(_PREHASH_AgentData);
  1967. msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID() );
  1968. msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID() );
  1969. msg->nextBlockFast(_PREHASH_Data);
  1970. msg->addU32Fast(_PREHASH_Flags, AL_BAN);
  1971. msg->addS32(_PREHASH_LocalID, parcel->getLocalID() );
  1972. msg->addUUIDFast(_PREHASH_TransactionID, transactionUUID);
  1973. msg->addS32Fast(_PREHASH_SequenceID, sequence_id);
  1974. msg->addS32Fast(_PREHASH_Sections, num_sections);
  1975. start_message = FALSE;
  1977. if (initial && (cit == end))
  1978. {
  1979. // pack an empty block if there will be no data
  1980. msg->nextBlockFast(_PREHASH_List);
  1981. msg->addUUIDFast(_PREHASH_ID,  LLUUID::null );
  1982. msg->addS32Fast(_PREHASH_Time, 0 );
  1983. msg->addU32Fast(_PREHASH_Flags, 0 );
  1984. }
  1986. initial = FALSE;
  1987. sequence_id++;
  1989. }
  1991. while ( (cit != end) && (msg->getCurrentSendTotal() < MTUBYTES)) 
  1992. {
  1993. const LLAccessEntry& entry = (*cit).second;
  1995. msg->nextBlockFast(_PREHASH_List);
  1996. msg->addUUIDFast(_PREHASH_ID,  entry.mID );
  1997. msg->addS32Fast(_PREHASH_Time, entry.mTime );
  1998. msg->addU32Fast(_PREHASH_Flags, entry.mFlags );
  1999. ++cit;
  2000. }
  2002. start_message = TRUE;
  2003. msg->sendReliable( region->getHost() );
  2004. }
  2005. }
  2006. }
  2008. class LLParcelMediaURLFilterResponder : public LLHTTPClient::Responder
  2009. {
  2010. virtual void result(const LLSD& content)
  2011. {
  2012. LLViewerParcelMgr::getInstance()->receiveParcelMediaURLFilter(content);
  2013. }
  2014. };
  2016. void LLViewerParcelMgr::requestParcelMediaURLFilter()
  2017. {
  2018. if (!mSelected)
  2019. {
  2020. return;
  2021. }
  2023. LLViewerRegion* region = LLWorld::getInstance()->getRegionFromPosGlobal( mWestSouth );
  2024. if (!region)
  2025. {
  2026. return;
  2027. }
  2029. LLParcel* parcel = mCurrentParcel;
  2030. if (!parcel)
  2031. {
  2032. llwarns << "no parcel" << llendl;
  2033. return;
  2034. }
  2036. LLSD body;
  2037. body["local-id"] = parcel->getLocalID();
  2038. body["list"] = parcel->getMediaURLFilterList();
  2040. std::string url = region->getCapability("ParcelMediaURLFilterList");
  2041. if (!url.empty())
  2042. {
  2043. LLHTTPClient::post(url, body, new LLParcelMediaURLFilterResponder);
  2044. }
  2045. else
  2046. {
  2047. llwarns << "can't get ParcelMediaURLFilterList cap" << llendl;
  2048. }
  2049. }
  2052. void LLViewerParcelMgr::receiveParcelMediaURLFilter(const LLSD &content)
  2053. {
  2054. if (content.has("list"))
  2055. {
  2056. LLParcel* parcel = LLViewerParcelMgr::getInstance()->mCurrentParcel;
  2057. if (!parcel) return;
  2059. if (content["local-id"].asInteger() == parcel->getLocalID())
  2060. {
  2061. parcel->setMediaURLFilterList(content["list"]);
  2063. LLViewerParcelMgr::getInstance()->notifyObservers();
  2064. }
  2065. }
  2066. }
  2069. void LLViewerParcelMgr::deedLandToGroup()
  2070. {
  2071. std::string group_name;
  2072. gCacheName->getGroupName(mCurrentParcel->getGroupID(), group_name);
  2073. LLSD args;
  2074. args["AREA"] = llformat("%d", mCurrentParcel->getArea());
  2075. args["GROUP_NAME"] = group_name;
  2076. if(mCurrentParcel->getContributeWithDeed())
  2077. {
  2078. std::string first_name, last_name;
  2079. gCacheName->getName(mCurrentParcel->getOwnerID(), first_name, last_name);
  2080. args["FIRST_NAME"] = first_name;
  2081. args["LAST_NAME"] = last_name;
  2082. LLNotificationsUtil::add("DeedLandToGroupWithContribution",args, LLSD(), deedAlertCB);
  2083. }
  2084. else
  2085. {
  2086. LLNotificationsUtil::add("DeedLandToGroup",args, LLSD(), deedAlertCB);
  2087. }
  2088. }
  2090. // static
  2091. bool LLViewerParcelMgr::deedAlertCB(const LLSD& notification, const LLSD& response)
  2092. {
  2093. S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
  2094. if (option == 0)
  2095. {
  2096. LLParcel* parcel = LLViewerParcelMgr::getInstance()->getParcelSelection()->getParcel();
  2097. LLUUID group_id;
  2098. if(parcel)
  2099. {
  2100. group_id = parcel->getGroupID();
  2101. }
  2102. LLViewerParcelMgr::getInstance()->sendParcelDeed(group_id);
  2103. }
  2104. return false;
  2105. }
  2108. void LLViewerParcelMgr::startReleaseLand()
  2109. {
  2110. if (!mSelected)
  2111. {
  2112. LLNotificationsUtil::add("CannotReleaseLandNothingSelected");
  2113. return;
  2114. }
  2116. if (mRequestResult == PARCEL_RESULT_NO_DATA)
  2117. {
  2118. LLNotificationsUtil::add("CannotReleaseLandWatingForServer");
  2119. return;
  2120. }
  2122. if (mRequestResult == PARCEL_RESULT_MULTIPLE)
  2123. {
  2124. LLNotificationsUtil::add("CannotReleaseLandSelected");
  2125. return;
  2126. }
  2128. if (!isParcelOwnedByAgent(mCurrentParcel, GP_LAND_RELEASE)
  2129. && !(gAgent.canManageEstate()))
  2130. {
  2131. LLNotificationsUtil::add("CannotReleaseLandDontOwn");
  2132. return;
  2133. }
  2135. LLVector3d parcel_center = (mWestSouth + mEastNorth) / 2.0;
  2136. LLViewerRegion* region = LLWorld::getInstance()->getRegionFromPosGlobal(parcel_center);
  2137. if (!region)
  2138. {
  2139. LLNotificationsUtil::add("CannotReleaseLandRegionNotFound");
  2140. return;
  2141. }
  2142. /*
  2143. if ((region->getRegionFlags() & REGION_FLAGS_BLOCK_LAND_RESELL)
  2144. && !gAgent.isGodlike())
  2145. {
  2146. LLSD args;
  2147. args["REGION"] = region->getName();
  2148. LLNotificationsUtil::add("CannotReleaseLandNoTransfer", args);
  2149. return;
  2150. }
  2151. */
  2153. if (!mCurrentParcelSelection->mWholeParcelSelected)
  2154. {
  2155. LLNotificationsUtil::add("CannotReleaseLandPartialSelection");
  2156. return;
  2157. }
  2159. // Compute claim price
  2160. LLSD args;
  2161. args["AREA"] = llformat("%d",mCurrentParcel->getArea());
  2162. LLNotificationsUtil::add("ReleaseLandWarning", args, LLSD(), releaseAlertCB);
  2163. }
  2165. bool LLViewerParcelMgr::canAgentBuyParcel(LLParcel* parcel, bool forGroup) const
  2166. {
  2167. if (!parcel)
  2168. {
  2169. return false;
  2170. }
  2172. if (mSelected  &&  parcel == mCurrentParcel)
  2173. {
  2174. if (mRequestResult == PARCEL_RESULT_NO_DATA)
  2175. {
  2176. return false;
  2177. }
  2178. }
  2180. const LLUUID& parcelOwner = parcel->getOwnerID();
  2181. const LLUUID& authorizeBuyer = parcel->getAuthorizedBuyerID();
  2183. if (parcel->isPublic())
  2184. {
  2185. return true; // change this if want to make it gods only
  2186. }
  2188. LLViewerRegion* regionp = LLViewerParcelMgr::getInstance()->getSelectionRegion();
  2189. if (regionp)
  2190. {
  2191. U8 sim_access = regionp->getSimAccess();
  2192. const LLAgentAccess& agent_access = gAgent.getAgentAccess();
  2193. // if the region is PG, we're happy already, so do nothing
  2194. // but if we're set to avoid either mature or adult, get us outta here
  2195. if ((sim_access == SIM_ACCESS_MATURE) &&
  2196. !agent_access.canAccessMature())
  2197. {
  2198. return false;
  2199. }
  2200. else if ((sim_access == SIM_ACCESS_ADULT) &&
  2201.  !agent_access.canAccessAdult())
  2202. {
  2203. return false;
  2204. }
  2205. }
  2207. bool isForSale = parcel->getForSale()
  2208. && ((parcel->getSalePrice() > 0) || (authorizeBuyer.notNull()));
  2210. bool isEmpowered
  2211. = forGroup ? gAgent.hasPowerInActiveGroup(GP_LAND_DEED) == TRUE : true;
  2213. bool isOwner
  2214. = parcelOwner == (forGroup ? gAgent.getGroupID() : gAgent.getID());
  2216. bool isAuthorized
  2217. = (authorizeBuyer.isNull() || (gAgent.getID() == authorizeBuyer));
  2219. return isForSale && !isOwner && isAuthorized  && isEmpowered;
  2220. }
  2223. void LLViewerParcelMgr::startBuyLand(BOOL is_for_group)
  2224. {
  2225. LLFloaterBuyLand::buyLand(getSelectionRegion(), mCurrentParcelSelection, is_for_group == TRUE);
  2226. }
  2228. void LLViewerParcelMgr::startSellLand()
  2229. {
  2230. LLFloaterSellLand::sellLand(getSelectionRegion(), mCurrentParcelSelection);
  2231. }
  2233. void LLViewerParcelMgr::startDivideLand()
  2234. {
  2235. if (!mSelected)
  2236. {
  2237. LLNotificationsUtil::add("CannotDivideLandNothingSelected");
  2238. return;
  2239. }
  2241. if (mCurrentParcelSelection->mWholeParcelSelected)
  2242. {
  2243. LLNotificationsUtil::add("CannotDivideLandPartialSelection");
  2244. return;
  2245. }
  2247. LLSD payload;
  2248. payload["west_south_border"] = ll_sd_from_vector3d(mWestSouth);
  2249. payload["east_north_border"] = ll_sd_from_vector3d(mEastNorth);
  2251. LLNotificationsUtil::add("LandDivideWarning", LLSD(), payload, callbackDivideLand);
  2252. }
  2254. // static
  2255. bool LLViewerParcelMgr::callbackDivideLand(const LLSD& notification, const LLSD& response)
  2256. {
  2257. S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
  2258. LLVector3d west_south_d = ll_vector3d_from_sd(notification["payload"]["west_south_border"]);
  2259. LLVector3d east_north_d = ll_vector3d_from_sd(notification["payload"]["east_north_border"]);
  2260. LLVector3d parcel_center = (west_south_d + east_north_d) / 2.0;
  2262. LLViewerRegion* region = LLWorld::getInstance()->getRegionFromPosGlobal(parcel_center);
  2263. if (!region)
  2264. {
  2265. LLNotificationsUtil::add("CannotDivideLandNoRegion");
  2266. return false;
  2267. }
  2269. if (0 == option)
  2270. {
  2271. LLVector3 west_south = region->getPosRegionFromGlobal(west_south_d);
  2272. LLVector3 east_north = region->getPosRegionFromGlobal(east_north_d);
  2274. LLMessageSystem* msg = gMessageSystem;
  2275. msg->newMessage("ParcelDivide");
  2276. msg->nextBlock("AgentData");
  2277. msg->addUUID("AgentID", gAgent.getID());
  2278. msg->addUUID("SessionID", gAgent.getSessionID());
  2279. msg->nextBlock("ParcelData");
  2280. msg->addF32("West", west_south.mV[VX]);
  2281. msg->addF32("South", west_south.mV[VY]);
  2282. msg->addF32("East", east_north.mV[VX]);
  2283. msg->addF32("North", east_north.mV[VY]);
  2284. msg->sendReliable(region->getHost());
  2285. }
  2286. return false;
  2287. }
  2290. void LLViewerParcelMgr::startJoinLand()
  2291. {
  2292. if (!mSelected)
  2293. {
  2294. LLNotificationsUtil::add("CannotJoinLandNothingSelected");
  2295. return;
  2296. }
  2298. if (mCurrentParcelSelection->mWholeParcelSelected)
  2299. {
  2300. LLNotificationsUtil::add("CannotJoinLandEntireParcelSelected");
  2301. return;
  2302. }
  2304. if (!mCurrentParcelSelection->mSelectedMultipleOwners)
  2305. {
  2306. LLNotificationsUtil::add("CannotJoinLandSelection");
  2307. return;
  2308. }
  2310. LLSD payload;
  2311. payload["west_south_border"] = ll_sd_from_vector3d(mWestSouth);
  2312. payload["east_north_border"] = ll_sd_from_vector3d(mEastNorth);
  2314. LLNotificationsUtil::add("JoinLandWarning", LLSD(), payload, callbackJoinLand);
  2315. }
  2317. // static
  2318. bool LLViewerParcelMgr::callbackJoinLand(const LLSD& notification, const LLSD& response)
  2319. {
  2320. S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
  2321. LLVector3d west_south_d = ll_vector3d_from_sd(notification["payload"]["west_south_border"]);
  2322. LLVector3d east_north_d = ll_vector3d_from_sd(notification["payload"]["east_north_border"]);
  2323. LLVector3d parcel_center = (west_south_d + east_north_d) / 2.0;
  2325. LLViewerRegion* region = LLWorld::getInstance()->getRegionFromPosGlobal(parcel_center);
  2326. if (!region)
  2327. {
  2328. LLNotificationsUtil::add("CannotJoinLandNoRegion");
  2329. return false;
  2330. }
  2332. if (0 == option)
  2333. {
  2334. LLVector3 west_south = region->getPosRegionFromGlobal(west_south_d);
  2335. LLVector3 east_north = region->getPosRegionFromGlobal(east_north_d);
  2337. LLMessageSystem* msg = gMessageSystem;
  2338. msg->newMessage("ParcelJoin");
  2339. msg->nextBlock("AgentData");
  2340. msg->addUUID("AgentID", gAgent.getID());
  2341. msg->addUUID("SessionID", gAgent.getSessionID());
  2342. msg->nextBlock("ParcelData");
  2343. msg->addF32("West", west_south.mV[VX]);
  2344. msg->addF32("South", west_south.mV[VY]);
  2345. msg->addF32("East", east_north.mV[VX]);
  2346. msg->addF32("North", east_north.mV[VY]);
  2347. msg->sendReliable(region->getHost());
  2348. }
  2349. return false;
  2350. }
  2353. void LLViewerParcelMgr::startDeedLandToGroup()
  2354. {
  2355. if (!mSelected || !mCurrentParcel)
  2356. {
  2357. LLNotificationsUtil::add("CannotDeedLandNothingSelected");
  2358. return;
  2359. }
  2361. if (mRequestResult == PARCEL_RESULT_NO_DATA)
  2362. {
  2363. LLNotificationsUtil::add("CannotDeedLandWaitingForServer");
  2364. return;
  2365. }
  2367. if (mRequestResult == PARCEL_RESULT_MULTIPLE)
  2368. {
  2369. LLNotificationsUtil::add("CannotDeedLandMultipleSelected");
  2370. return;
  2371. }
  2373. LLVector3d parcel_center = (mWestSouth + mEastNorth) / 2.0;
  2374. LLViewerRegion* region = LLWorld::getInstance()->getRegionFromPosGlobal(parcel_center);
  2375. if (!region)
  2376. {
  2377. LLNotificationsUtil::add("CannotDeedLandNoRegion");
  2378. return;
  2379. }
  2381. /*
  2382. if(!gAgent.isGodlike())
  2383. {
  2384. if((region->getRegionFlags() & REGION_FLAGS_BLOCK_LAND_RESELL)
  2385. && (mCurrentParcel->getOwnerID() != region->getOwner()))
  2386. {
  2387. LLSD args;
  2388. args["REGION"] = region->getName();
  2389. LLNotificationsUtil::add("CannotDeedLandNoTransfer", args);
  2390. return;
  2391. }
  2392. }
  2393. */
  2395. deedLandToGroup();
  2396. }
  2397. void LLViewerParcelMgr::reclaimParcel()
  2398. {
  2399. LLParcel* parcel = LLViewerParcelMgr::getInstance()->getParcelSelection()->getParcel();
  2400. LLViewerRegion* regionp = LLViewerParcelMgr::getInstance()->getSelectionRegion();
  2401. if(parcel && parcel->getOwnerID().notNull()
  2402.    && (parcel->getOwnerID() != gAgent.getID())
  2403.    && regionp && (regionp->getOwner() == gAgent.getID()))
  2404. {
  2405. LLMessageSystem* msg = gMessageSystem;
  2406. msg->newMessage("ParcelReclaim");
  2407. msg->nextBlock("AgentData");
  2408. msg->addUUID("AgentID", gAgent.getID());
  2409. msg->addUUID("SessionID", gAgent.getSessionID());
  2410. msg->nextBlock("Data");
  2411. msg->addS32("LocalID", parcel->getLocalID());
  2412. msg->sendReliable(regionp->getHost());
  2413. }
  2414. }
  2416. // static
  2417. bool LLViewerParcelMgr::releaseAlertCB(const LLSD& notification, const LLSD& response)
  2418. {
  2419. S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
  2420. if (option == 0)
  2421. {
  2422. // Send the release message, not a force
  2423. LLViewerParcelMgr::getInstance()->sendParcelRelease();
  2424. }
  2425. return false;
  2426. }
  2428. void LLViewerParcelMgr::buyPass()
  2429. {
  2430. LLParcel* parcel = getParcelSelection()->getParcel();
  2431. if (!parcel) return;
  2433. LLViewerRegion* region = getSelectionRegion();
  2434. if (!region) return;
  2436. LLMessageSystem* msg = gMessageSystem;
  2437. msg->newMessageFast(_PREHASH_ParcelBuyPass);
  2438. msg->nextBlock("AgentData");
  2439. msg->addUUID("AgentID", gAgent.getID());
  2440. msg->addUUID("SessionID", gAgent.getSessionID());
  2441. msg->nextBlockFast(_PREHASH_ParcelData);
  2442. msg->addS32Fast(_PREHASH_LocalID, parcel->getLocalID() );
  2443. msg->sendReliable( region->getHost() );
  2444. }
  2446. //Tells whether we are allowed to buy a pass or not
  2447. BOOL LLViewerParcelMgr::isCollisionBanned()
  2448. { 
  2449. if ((mCollisionBanned == BA_ALLOWED) || (mCollisionBanned == BA_NOT_ON_LIST) || (mCollisionBanned == BA_NOT_IN_GROUP))
  2450. return FALSE;
  2451. else 
  2452. return TRUE;
  2453. }
  2455. // This implementation should mirror LLSimParcelMgr::isParcelOwnedBy
  2456. // static
  2457. BOOL LLViewerParcelMgr::isParcelOwnedByAgent(const LLParcel* parcelp, U64 group_proxy_power)
  2458. {
  2459. if (!parcelp)
  2460. {
  2461. return FALSE;
  2462. }
  2464. // Gods can always assume ownership.
  2465. if (gAgent.isGodlike())
  2466. {
  2467. return TRUE;
  2468. }
  2470. // The owner of a parcel automatically gets all powersr.
  2471. if (parcelp->getOwnerID() == gAgent.getID())
  2472. {
  2473. return TRUE;
  2474. }
  2476. // Only gods can assume 'ownership' of public land.
  2477. if (parcelp->isPublic())
  2478. {
  2479. return FALSE;
  2480. }
  2482. // Return whether or not the agent has group_proxy_power powers in the
  2483. // parcel's group.
  2484. return gAgent.hasPowerInGroup(parcelp->getOwnerID(), group_proxy_power);
  2485. }
  2487. // This implementation should mirror llSimParcelMgr::isParcelModifiableBy
  2488. // static
  2489. BOOL LLViewerParcelMgr::isParcelModifiableByAgent(const LLParcel* parcelp, U64 group_proxy_power)
  2490. {
  2491. // If the agent can assume ownership, it is probably modifiable.
  2492. BOOL rv = FALSE;
  2493. if (parcelp)
  2494. {
  2495. // *NOTE: This should only work for leased parcels, but group owned
  2496. // parcels cannot be OS_LEASED yet. Phoenix 2003-12-15.
  2497. rv = isParcelOwnedByAgent(parcelp, group_proxy_power);
  2499. // ... except for the case that the parcel is not OS_LEASED for agent-owned parcels.
  2500. if( (gAgent.getID() == parcelp->getOwnerID())
  2501. && !gAgent.isGodlike()
  2502. && (parcelp->getOwnershipStatus() != LLParcel::OS_LEASED) )
  2503. {
  2504. rv = FALSE;
  2505. }
  2506. }
  2507. return rv;
  2508. }
  2510. void sanitize_corners(const LLVector3d &corner1,
  2511. const LLVector3d &corner2,
  2512. LLVector3d &west_south_bottom,
  2513. LLVector3d &east_north_top)
  2514. {
  2515. west_south_bottom.mdV[VX] = llmin( corner1.mdV[VX], corner2.mdV[VX] );
  2516. west_south_bottom.mdV[VY] = llmin( corner1.mdV[VY], corner2.mdV[VY] );
  2517. west_south_bottom.mdV[VZ] = llmin( corner1.mdV[VZ], corner2.mdV[VZ] );
  2519. east_north_top.mdV[VX] = llmax( corner1.mdV[VX], corner2.mdV[VX] );
  2520. east_north_top.mdV[VY] = llmax( corner1.mdV[VY], corner2.mdV[VY] );
  2521. east_north_top.mdV[VZ] = llmax( corner1.mdV[VZ], corner2.mdV[VZ] );
  2522. }
  2525. void LLViewerParcelMgr::cleanupGlobals()
  2526. {
  2527. LLParcelSelection::sNullSelection = NULL;
  2528. }
  2530. LLViewerTexture* LLViewerParcelMgr::getBlockedImage() const
  2531. {
  2532. return sBlockedImage;
  2533. }
  2535. LLViewerTexture* LLViewerParcelMgr::getPassImage() const
  2536. {
  2537. return sPassImage;
  2538. }
  2540. boost::signals2::connection LLViewerParcelMgr::addAgentParcelChangedCallback(parcel_changed_callback_t cb)
  2541. {
  2542. return mAgentParcelChangedSignal.connect(cb);
  2543. }
  2544. /*
  2545.  * Set finish teleport callback. You can use it to observe all  teleport events.
  2546.  * NOTE:
  2547.  * After local( in one region) teleports we
  2548.  *  cannot rely on gAgent.getPositionGlobal(),
  2549.  *  so the new position gets passed explicitly.
  2550.  *  Use args of this callback to get global position of avatar after teleport event.
  2551.  */
  2552. boost::signals2::connection LLViewerParcelMgr::setTeleportFinishedCallback(teleport_finished_callback_t cb)
  2553. {
  2554. return mTeleportFinishedSignal.connect(cb);
  2555. }
  2557. boost::signals2::connection LLViewerParcelMgr::setTeleportFailedCallback(parcel_changed_callback_t cb)
  2558. {
  2559. return mTeleportFailedSignal.connect(cb);
  2560. }
  2562. /* Ok, we're notified that teleport has been finished.
  2563.  * We should now propagate the notification via mTeleportFinishedSignal
  2564.  * to all interested parties.
  2565.  */
  2566. void LLViewerParcelMgr::onTeleportFinished(bool local, const LLVector3d& new_pos)
  2567. {
  2568. // Treat only teleports within the same parcel as local (EXT-3139).
  2569. if (local && LLViewerParcelMgr::getInstance()->inAgentParcel(new_pos))
  2570. {
  2571. // Local teleport. We already have the agent parcel data.
  2572. // Emit the signal immediately.
  2573. getInstance()->mTeleportFinishedSignal(new_pos);
  2574. }
  2575. else
  2576. {
  2577. // Non-local teleport (inter-region or between different parcels of the same region).
  2578. // The agent parcel data has not been updated yet.
  2579. // Let's wait for the update and then emit the signal.
  2580. mTeleportInProgress = TRUE;
  2581. }
  2582. }
  2584. void LLViewerParcelMgr::onTeleportFailed()
  2585. {
  2586. mTeleportFailedSignal();
  2587. }