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

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

游戏引擎

开发平台：

C++ Builder

llworld.cpp：源码内容
  1. /** 
  2.  * @file llworld.cpp
  3.  * @brief Initial test structure to organize viewer regions
  4.  *
  5.  * $LicenseInfo:firstyear=2001&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2001-2010, Linden Research, Inc.
  8.  * 
  9.  * Second Life Viewer Source Code
  10.  * The source code in this file ("Source Code") is provided by Linden Lab
  11.  * to you under the terms of the GNU General Public License, version 2.0
  12.  * ("GPL"), unless you have obtained a separate licensing agreement
  13.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  14.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  15.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  16.  * 
  17.  * There are special exceptions to the terms and conditions of the GPL as
  18.  * it is applied to this Source Code. View the full text of the exception
  19.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  20.  * online at
  21.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  22.  * 
  23.  * By copying, modifying or distributing this software, you acknowledge
  24.  * that you have read and understood your obligations described above,
  25.  * and agree to abide by those obligations.
  26.  * 
  27.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  28.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  29.  * COMPLETENESS OR PERFORMANCE.
  30.  * $/LicenseInfo$
  31.  */
  33. #include "llviewerprecompiledheaders.h"
  35. #include "llworld.h"
  36. #include "llrender.h"
  38. #include "indra_constants.h"
  39. #include "llstl.h"
  41. #include "llagent.h"
  42. #include "llviewercontrol.h"
  43. #include "lldrawpool.h"
  44. #include "llglheaders.h"
  45. #include "llhttpnode.h"
  46. #include "llregionhandle.h"
  47. #include "llsurface.h"
  48. #include "llviewercamera.h"
  49. #include "llviewertexture.h"
  50. #include "llviewertexturelist.h"
  51. #include "llviewernetwork.h"
  52. #include "llviewerobjectlist.h"
  53. #include "llviewerparceloverlay.h"
  54. #include "llviewerregion.h"
  55. #include "llviewerstats.h"
  56. #include "llvlcomposition.h"
  57. #include "llvoavatar.h"
  58. #include "llvowater.h"
  59. #include "message.h"
  60. #include "pipeline.h"
  61. #include "llappviewer.h" // for do_disconnect()
  63. //
  64. // Globals
  65. //
  66. U32 gAgentPauseSerialNum = 0;
  68. //
  69. // Constants
  70. //
  71. const S32 MAX_NUMBER_OF_CLOUDS = 750;
  72. const S32 WORLD_PATCH_SIZE = 16;
  74. extern LLColor4U MAX_WATER_COLOR;
  76. const U32 LLWorld::mWidth = 256;
  78. // meters/point, therefore mWidth * mScale = meters per edge
  79. const F32 LLWorld::mScale = 1.f;
  81. const F32 LLWorld::mWidthInMeters = mWidth * mScale;
  83. //
  84. // Functions
  85. //
  87. // allocate the stack
  88. LLWorld::LLWorld() :
  89. mLandFarClip(DEFAULT_FAR_PLANE),
  90. mLastPacketsIn(0),
  91. mLastPacketsOut(0),
  92. mLastPacketsLost(0),
  93. mSpaceTimeUSec(0)
  94. {
  95. for (S32 i = 0; i < 8; i++)
  96. {
  97. mEdgeWaterObjects[i] = NULL;
  98. }
  100. if (gNoRender)
  101. {
  102. return;
  103. }
  105. LLPointer<LLImageRaw> raw = new LLImageRaw(1,1,4);
  106. U8 *default_texture = raw->getData();
  107. *(default_texture++) = MAX_WATER_COLOR.mV[0];
  108. *(default_texture++) = MAX_WATER_COLOR.mV[1];
  109. *(default_texture++) = MAX_WATER_COLOR.mV[2];
  110. *(default_texture++) = MAX_WATER_COLOR.mV[3];
  112. mDefaultWaterTexturep = LLViewerTextureManager::getLocalTexture(raw.get(), FALSE);
  113. gGL.getTexUnit(0)->bind(mDefaultWaterTexturep);
  114. mDefaultWaterTexturep->setAddressMode(LLTexUnit::TAM_CLAMP);
  116. }
  119. void LLWorld::destroyClass()
  120. {
  121. mHoleWaterObjects.clear();
  122. gObjectList.destroy();
  123. for(region_list_t::iterator region_it = mRegionList.begin(); region_it != mRegionList.end(); )
  124. {
  125. LLViewerRegion* region_to_delete = *region_it++;
  126. removeRegion(region_to_delete->getHost());
  127. }
  128. LLViewerPartSim::getInstance()->destroyClass();
  129. }
  132. LLViewerRegion* LLWorld::addRegion(const U64 &region_handle, const LLHost &host)
  133. {
  134. LLMemType mt(LLMemType::MTYPE_REGIONS);
  136. LLViewerRegion *regionp = getRegionFromHandle(region_handle);
  137. if (regionp)
  138. {
  139. LLHost old_host = regionp->getHost();
  140. // region already exists!
  141. if (host == old_host && regionp->isAlive())
  142. {
  143. // This is a duplicate for the same host and it's alive, don't bother.
  144. return regionp;
  145. }
  147. if (host != old_host)
  148. {
  149. llwarns << "LLWorld::addRegion exists, but old host " << old_host
  150. << " does not match new host " << host << llendl;
  151. }
  152. if (!regionp->isAlive())
  153. {
  154. llwarns << "LLWorld::addRegion exists, but isn't alive" << llendl;
  155. }
  157. // Kill the old host, and then we can continue on and add the new host.  We have to kill even if the host
  158. // matches, because all the agent state for the new camera is completely different.
  159. removeRegion(old_host);
  160. }
  162. U32 iindex = 0;
  163. U32 jindex = 0;
  164. from_region_handle(region_handle, &iindex, &jindex);
  165. S32 x = (S32)(iindex/mWidth);
  166. S32 y = (S32)(jindex/mWidth);
  167. llinfos << "Adding new region (" << x << ":" << y << ")" << llendl;
  168. llinfos << "Host: " << host << llendl;
  170. LLVector3d origin_global;
  172. origin_global = from_region_handle(region_handle);
  174. regionp = new LLViewerRegion(region_handle,
  175.     host,
  176. mWidth,
  177. WORLD_PATCH_SIZE,
  178. getRegionWidthInMeters() );
  179. if (!regionp)
  180. {
  181. llerrs << "Unable to create new region!" << llendl;
  182. }
  184. regionp->mCloudLayer.create(regionp);
  185. regionp->mCloudLayer.setWidth((F32)mWidth);
  186. regionp->mCloudLayer.setWindPointer(&regionp->mWind);
  188. mRegionList.push_back(regionp);
  189. mActiveRegionList.push_back(regionp);
  190. mCulledRegionList.push_back(regionp);
  193. // Find all the adjacent regions, and attach them.
  194. // Generate handles for all of the adjacent regions, and attach them in the correct way.
  195. // connect the edges
  196. F32 adj_x = 0.f;
  197. F32 adj_y = 0.f;
  198. F32 region_x = 0.f;
  199. F32 region_y = 0.f;
  200. U64 adj_handle = 0;
  202. F32 width = getRegionWidthInMeters();
  204. LLViewerRegion *neighborp;
  205. from_region_handle(region_handle, &region_x, &region_y);
  207. // Iterate through all directions, and connect neighbors if there.
  208. S32 dir;
  209. for (dir = 0; dir < 8; dir++)
  210. {
  211. adj_x = region_x + width * gDirAxes[dir][0];
  212. adj_y = region_y + width * gDirAxes[dir][1];
  213. to_region_handle(adj_x, adj_y, &adj_handle);
  215. neighborp = getRegionFromHandle(adj_handle);
  216. if (neighborp)
  217. {
  218. //llinfos << "Connecting " << region_x << ":" << region_y << " -> " << adj_x << ":" << adj_y << llendl;
  219. regionp->connectNeighbor(neighborp, dir);
  220. }
  221. }
  223. updateWaterObjects();
  225. return regionp;
  226. }
  229. void LLWorld::removeRegion(const LLHost &host)
  230. {
  231. F32 x, y;
  233. LLViewerRegion *regionp = getRegion(host);
  234. if (!regionp)
  235. {
  236. llwarns << "Trying to remove region that doesn't exist!" << llendl;
  237. return;
  238. }
  240. if (regionp == gAgent.getRegion())
  241. {
  242. for (region_list_t::iterator iter = mRegionList.begin();
  243.  iter != mRegionList.end(); ++iter)
  244. {
  245. LLViewerRegion* reg = *iter;
  246. llwarns << "RegionDump: " << reg->getName()
  247. << " " << reg->getHost()
  248. << " " << reg->getOriginGlobal()
  249. << llendl;
  250. }
  252. llwarns << "Agent position global " << gAgent.getPositionGlobal() 
  253. << " agent " << gAgent.getPositionAgent()
  254. << llendl;
  256. llwarns << "Regions visited " << gAgent.getRegionsVisited() << llendl;
  258. llwarns << "gFrameTimeSeconds " << gFrameTimeSeconds << llendl;
  260. llwarns << "Disabling region " << regionp->getName() << " that agent is in!" << llendl;
  261. LLAppViewer::instance()->forceDisconnect("You have been disconnected from the region you were in.");
  262. return;
  263. }
  265. from_region_handle(regionp->getHandle(), &x, &y);
  266. llinfos << "Removing region " << x << ":" << y << llendl;
  268. mRegionList.remove(regionp);
  269. mActiveRegionList.remove(regionp);
  270. mCulledRegionList.remove(regionp);
  271. mVisibleRegionList.remove(regionp);
  273. delete regionp;
  275. updateWaterObjects();
  276. }
  279. LLViewerRegion* LLWorld::getRegion(const LLHost &host)
  280. {
  281. for (region_list_t::iterator iter = mRegionList.begin();
  282.  iter != mRegionList.end(); ++iter)
  283. {
  284. LLViewerRegion* regionp = *iter;
  285. if (regionp->getHost() == host)
  286. {
  287. return regionp;
  288. }
  289. }
  290. return NULL;
  291. }
  293. LLViewerRegion* LLWorld::getRegionFromPosAgent(const LLVector3 &pos)
  294. {
  295. return getRegionFromPosGlobal(gAgent.getPosGlobalFromAgent(pos));
  296. }
  298. LLViewerRegion* LLWorld::getRegionFromPosGlobal(const LLVector3d &pos)
  299. {
  300. for (region_list_t::iterator iter = mRegionList.begin();
  301.  iter != mRegionList.end(); ++iter)
  302. {
  303. LLViewerRegion* regionp = *iter;
  304. if (regionp->pointInRegionGlobal(pos))
  305. {
  306. return regionp;
  307. }
  308. }
  309. return NULL;
  310. }
  313. LLVector3d LLWorld::clipToVisibleRegions(const LLVector3d &start_pos, const LLVector3d &end_pos)
  314. {
  315. if (positionRegionValidGlobal(end_pos))
  316. {
  317. return end_pos;
  318. }
  320. LLViewerRegion* regionp = getRegionFromPosGlobal(start_pos);
  321. if (!regionp) 
  322. {
  323. return start_pos;
  324. }
  326. LLVector3d delta_pos = end_pos - start_pos;
  327. LLVector3d delta_pos_abs;
  328. delta_pos_abs.setVec(delta_pos);
  329. delta_pos_abs.abs();
  331. LLVector3 region_coord = regionp->getPosRegionFromGlobal(end_pos);
  332. F64 clip_factor = 1.0;
  333. F32 region_width = regionp->getWidth();
  334. if (region_coord.mV[VX] < 0.f)
  335. {
  336. if (region_coord.mV[VY] < region_coord.mV[VX])
  337. {
  338. // clip along y -
  339. clip_factor = -(region_coord.mV[VY] / delta_pos_abs.mdV[VY]);
  340. }
  341. else
  342. {
  343. // clip along x -
  344. clip_factor = -(region_coord.mV[VX] / delta_pos_abs.mdV[VX]);
  345. }
  346. }
  347. else if (region_coord.mV[VX] > region_width)
  348. {
  349. if (region_coord.mV[VY] > region_coord.mV[VX])
  350. {
  351. // clip along y +
  352. clip_factor = (region_coord.mV[VY] - region_width) / delta_pos_abs.mdV[VY];
  353. }
  354. else
  355. {
  356. //clip along x +
  357. clip_factor = (region_coord.mV[VX] - region_width) / delta_pos_abs.mdV[VX];
  358. }
  359. }
  360. else if (region_coord.mV[VY] < 0.f)
  361. {
  362. // clip along y -
  363. clip_factor = -(region_coord.mV[VY] / delta_pos_abs.mdV[VY]);
  364. }
  365. else if (region_coord.mV[VY] > region_width)
  366. { 
  367. // clip along y +
  368. clip_factor = (region_coord.mV[VY] - region_width) / delta_pos_abs.mdV[VY];
  369. }
  371. // clamp to within region dimensions
  372. LLVector3d final_region_pos = LLVector3d(region_coord) - (delta_pos * clip_factor);
  373. final_region_pos.mdV[VX] = llclamp(final_region_pos.mdV[VX], 0.0,
  374.    (F64)(region_width - F_ALMOST_ZERO));
  375. final_region_pos.mdV[VY] = llclamp(final_region_pos.mdV[VY], 0.0,
  376.    (F64)(region_width - F_ALMOST_ZERO));
  377. final_region_pos.mdV[VZ] = llclamp(final_region_pos.mdV[VZ], 0.0,
  378.    (F64)(LLWorld::getInstance()->getRegionMaxHeight() - F_ALMOST_ZERO));
  379. return regionp->getPosGlobalFromRegion(LLVector3(final_region_pos));
  380. }
  382. LLViewerRegion* LLWorld::getRegionFromHandle(const U64 &handle)
  383. {
  384. for (region_list_t::iterator iter = mRegionList.begin();
  385.  iter != mRegionList.end(); ++iter)
  386. {
  387. LLViewerRegion* regionp = *iter;
  388. if (regionp->getHandle() == handle)
  389. {
  390. return regionp;
  391. }
  392. }
  393. return NULL;
  394. }
  397. void LLWorld::updateAgentOffset(const LLVector3d &offset_global)
  398. {
  399. #if 0
  400. for (region_list_t::iterator iter = mRegionList.begin();
  401.  iter != mRegionList.end(); ++iter)
  402. {
  403. LLViewerRegion* regionp = *iter;
  404. regionp->setAgentOffset(offset_global);
  405. }
  406. #endif
  407. }
  410. BOOL LLWorld::positionRegionValidGlobal(const LLVector3d &pos_global)
  411. {
  412. for (region_list_t::iterator iter = mRegionList.begin();
  413.  iter != mRegionList.end(); ++iter)
  414. {
  415. LLViewerRegion* regionp = *iter;
  416. if (regionp->pointInRegionGlobal(pos_global))
  417. {
  418. return TRUE;
  419. }
  420. }
  421. return FALSE;
  422. }
  425. // Allow objects to go up to their radius underground.
  426. F32 LLWorld::getMinAllowedZ(LLViewerObject* object)
  427. {
  428. F32 land_height = resolveLandHeightGlobal(object->getPositionGlobal());
  429. F32 radius = 0.5f * object->getScale().length();
  430. return land_height - radius;
  431. }
  434. LLViewerRegion* LLWorld::resolveRegionGlobal(LLVector3 &pos_region, const LLVector3d &pos_global)
  435. {
  436. LLViewerRegion *regionp = getRegionFromPosGlobal(pos_global);
  438. if (regionp)
  439. {
  440. pos_region = regionp->getPosRegionFromGlobal(pos_global);
  441. return regionp;
  442. }
  444. return NULL;
  445. }
  448. LLViewerRegion* LLWorld::resolveRegionAgent(LLVector3 &pos_region, const LLVector3 &pos_agent)
  449. {
  450. LLVector3d pos_global = gAgent.getPosGlobalFromAgent(pos_agent);
  451. LLViewerRegion *regionp = getRegionFromPosGlobal(pos_global);
  453. if (regionp)
  454. {
  455. pos_region = regionp->getPosRegionFromGlobal(pos_global);
  456. return regionp;
  457. }
  459. return NULL;
  460. }
  463. F32 LLWorld::resolveLandHeightAgent(const LLVector3 &pos_agent)
  464. {
  465. LLVector3d pos_global = gAgent.getPosGlobalFromAgent(pos_agent);
  466. return resolveLandHeightGlobal(pos_global);
  467. }
  470. F32 LLWorld::resolveLandHeightGlobal(const LLVector3d &pos_global)
  471. {
  472. LLViewerRegion *regionp = getRegionFromPosGlobal(pos_global);
  473. if (regionp)
  474. {
  475. return regionp->getLand().resolveHeightGlobal(pos_global);
  476. }
  477. return 0.0f;
  478. }
  481. // Takes a line defined by "point_a" and "point_b" and determines the closest (to point_a) 
  482. // point where the the line intersects an object or the land surface.  Stores the results
  483. // in "intersection" and "intersection_normal" and returns a scalar value that represents
  484. // the normalized distance along the line from "point_a" to "intersection".
  485. //
  486. // Currently assumes point_a and point_b only differ in z-direction, 
  487. // but it may eventually become more general.
  488. F32 LLWorld::resolveStepHeightGlobal(const LLVOAvatar* avatarp, const LLVector3d &point_a, const LLVector3d &point_b, 
  489.    LLVector3d &intersection, LLVector3 &intersection_normal,
  490.    LLViewerObject **viewerObjectPtr)
  491. {
  492. // initialize return value to null
  493. if (viewerObjectPtr)
  494. {
  495. *viewerObjectPtr = NULL;
  496. }
  498. LLViewerRegion *regionp = getRegionFromPosGlobal(point_a);
  499. if (!regionp)
  500. {
  501. // We're outside the world 
  502. intersection = 0.5f * (point_a + point_b);
  503. intersection_normal.setVec(0.0f, 0.0f, 1.0f);
  504. return 0.5f;
  505. }
  507. // calculate the length of the segment
  508. F32 segment_length = (F32)((point_a - point_b).length());
  509. if (0.0f == segment_length)
  510. {
  511. intersection = point_a;
  512. intersection_normal.setVec(0.0f, 0.0f, 1.0f);
  513. return segment_length;
  514. }
  516. // get land height
  517. // Note: we assume that the line is parallel to z-axis here
  518. LLVector3d land_intersection = point_a;
  519. F32 normalized_land_distance;
  521. land_intersection.mdV[VZ] = regionp->getLand().resolveHeightGlobal(point_a);
  522. normalized_land_distance = (F32)(point_a.mdV[VZ] - land_intersection.mdV[VZ]) / segment_length;
  523. intersection = land_intersection;
  524. intersection_normal = resolveLandNormalGlobal(land_intersection);
  526. if (avatarp && !avatarp->mFootPlane.isExactlyClear())
  527. {
  528. LLVector3 foot_plane_normal(avatarp->mFootPlane.mV);
  529. LLVector3 start_pt = avatarp->getRegion()->getPosRegionFromGlobal(point_a);
  530. // added 0.05 meters to compensate for error in foot plane reported by Havok
  531. F32 norm_dist_from_plane = ((start_pt * foot_plane_normal) - avatarp->mFootPlane.mV[VW]) + 0.05f;
  532. norm_dist_from_plane = llclamp(norm_dist_from_plane / segment_length, 0.f, 1.f);
  533. if (norm_dist_from_plane < normalized_land_distance)
  534. {
  535. // collided with object before land
  536. normalized_land_distance = norm_dist_from_plane;
  537. intersection = point_a;
  538. intersection.mdV[VZ] -= norm_dist_from_plane * segment_length;
  539. intersection_normal = foot_plane_normal;
  540. }
  541. else
  542. {
  543. intersection = land_intersection;
  544. intersection_normal = resolveLandNormalGlobal(land_intersection);
  545. }
  546. }
  548. return normalized_land_distance;
  549. }
  552. LLSurfacePatch * LLWorld::resolveLandPatchGlobal(const LLVector3d &pos_global)
  553. {
  554. //  returns a pointer to the patch at this location
  555. LLViewerRegion *regionp = getRegionFromPosGlobal(pos_global);
  556. if (!regionp)
  557. {
  558. return NULL;
  559. }
  561. return regionp->getLand().resolvePatchGlobal(pos_global);
  562. }
  565. LLVector3 LLWorld::resolveLandNormalGlobal(const LLVector3d &pos_global)
  566. {
  567. LLViewerRegion *regionp = getRegionFromPosGlobal(pos_global);
  568. if (!regionp)
  569. {
  570. return LLVector3::z_axis;
  571. }
  573. return regionp->getLand().resolveNormalGlobal(pos_global);
  574. }
  577. void LLWorld::updateVisibilities()
  578. {
  579. F32 cur_far_clip = LLViewerCamera::getInstance()->getFar();
  581. LLViewerCamera::getInstance()->setFar(mLandFarClip);
  583. F32 diagonal_squared = F_SQRT2 * F_SQRT2 * mWidth * mWidth;
  584. // Go through the culled list and check for visible regions
  585. for (region_list_t::iterator iter = mCulledRegionList.begin();
  586.  iter != mCulledRegionList.end(); )
  587. {
  588. region_list_t::iterator curiter = iter++;
  589. LLViewerRegion* regionp = *curiter;
  590. F32 height = regionp->getLand().getMaxZ() - regionp->getLand().getMinZ();
  591. F32 radius = 0.5f*fsqrtf(height * height + diagonal_squared);
  592. if (!regionp->getLand().hasZData()
  593. || LLViewerCamera::getInstance()->sphereInFrustum(regionp->getCenterAgent(), radius))
  594. {
  595. mCulledRegionList.erase(curiter);
  596. mVisibleRegionList.push_back(regionp);
  597. }
  598. }
  600. // Update all of the visible regions 
  601. for (region_list_t::iterator iter = mVisibleRegionList.begin();
  602.  iter != mVisibleRegionList.end(); )
  603. {
  604. region_list_t::iterator curiter = iter++;
  605. LLViewerRegion* regionp = *curiter;
  606. if (!regionp->getLand().hasZData())
  607. {
  608. continue;
  609. }
  611. F32 height = regionp->getLand().getMaxZ() - regionp->getLand().getMinZ();
  612. F32 radius = 0.5f*fsqrtf(height * height + diagonal_squared);
  613. if (LLViewerCamera::getInstance()->sphereInFrustum(regionp->getCenterAgent(), radius))
  614. {
  615. regionp->calculateCameraDistance();
  616. if (!gNoRender)
  617. {
  618. regionp->getLand().updatePatchVisibilities(gAgent);
  619. }
  620. }
  621. else
  622. {
  623. mVisibleRegionList.erase(curiter);
  624. mCulledRegionList.push_back(regionp);
  625. }
  626. }
  628. // Sort visible regions
  629. mVisibleRegionList.sort(LLViewerRegion::CompareDistance());
  631. LLViewerCamera::getInstance()->setFar(cur_far_clip);
  632. }
  634. void LLWorld::updateRegions(F32 max_update_time)
  635. {
  636. LLMemType mt_ur(LLMemType::MTYPE_IDLE_UPDATE_REGIONS);
  637. LLTimer update_timer;
  638. BOOL did_one = FALSE;
  640. // Perform idle time updates for the regions (and associated surfaces)
  641. for (region_list_t::iterator iter = mRegionList.begin();
  642.  iter != mRegionList.end(); ++iter)
  643. {
  644. LLViewerRegion* regionp = *iter;
  645. F32 max_time = max_update_time - update_timer.getElapsedTimeF32();
  646. if (did_one && max_time <= 0.f)
  647. break;
  648. max_time = llmin(max_time, max_update_time*.1f);
  649. did_one |= regionp->idleUpdate(max_update_time);
  650. }
  651. }
  653. void LLWorld::updateParticles()
  654. {
  655. LLViewerPartSim::getInstance()->updateSimulation();
  656. }
  658. void LLWorld::updateClouds(const F32 dt)
  659. {
  660. if (gSavedSettings.getBOOL("FreezeTime") ||
  661. !gSavedSettings.getBOOL("SkyUseClassicClouds"))
  662. {
  663. // don't move clouds in snapshot mode
  664. return;
  665. }
  666. if (mActiveRegionList.size())
  667. {
  668. // Update all the cloud puff positions, and timer based stuff
  669. // such as death decay
  670. for (region_list_t::iterator iter = mActiveRegionList.begin();
  671.  iter != mActiveRegionList.end(); ++iter)
  672. {
  673. LLViewerRegion* regionp = *iter;
  674. regionp->mCloudLayer.updatePuffs(dt);
  675. }
  677. // Reshuffle who owns which puffs
  678. for (region_list_t::iterator iter = mActiveRegionList.begin();
  679.  iter != mActiveRegionList.end(); ++iter)
  680. {
  681. LLViewerRegion* regionp = *iter;
  682. regionp->mCloudLayer.updatePuffOwnership();
  683. }
  685. // Add new puffs
  686. for (region_list_t::iterator iter = mActiveRegionList.begin();
  687.  iter != mActiveRegionList.end(); ++iter)
  688. {
  689. LLViewerRegion* regionp = *iter;
  690. regionp->mCloudLayer.updatePuffCount();
  691. }
  692. }
  693. }
  695. LLCloudGroup* LLWorld::findCloudGroup(const LLCloudPuff &puff)
  696. {
  697. if (mActiveRegionList.size())
  698. {
  699. // Update all the cloud puff positions, and timer based stuff
  700. // such as death decay
  701. for (region_list_t::iterator iter = mActiveRegionList.begin();
  702.  iter != mActiveRegionList.end(); ++iter)
  703. {
  704. LLViewerRegion* regionp = *iter;
  705. LLCloudGroup *groupp = regionp->mCloudLayer.findCloudGroup(puff);
  706. if (groupp)
  707. {
  708. return groupp;
  709. }
  710. }
  711. }
  712. return NULL;
  713. }
  716. void LLWorld::renderPropertyLines()
  717. {
  718. S32 region_count = 0;
  719. S32 vertex_count = 0;
  721. for (region_list_t::iterator iter = mVisibleRegionList.begin();
  722.  iter != mVisibleRegionList.end(); ++iter)
  723. {
  724. LLViewerRegion* regionp = *iter;
  725. region_count++;
  726. vertex_count += regionp->renderPropertyLines();
  727. }
  728. }
  731. void LLWorld::updateNetStats()
  732. {
  733. F32 bits = 0.f;
  734. U32 packets = 0;
  736. for (region_list_t::iterator iter = mActiveRegionList.begin();
  737.  iter != mActiveRegionList.end(); ++iter)
  738. {
  739. LLViewerRegion* regionp = *iter;
  740. regionp->updateNetStats();
  741. bits += regionp->mBitStat.getCurrent();
  742. packets += llfloor( regionp->mPacketsStat.getCurrent() );
  743. }
  745. S32 packets_in = gMessageSystem->mPacketsIn - mLastPacketsIn;
  746. S32 packets_out = gMessageSystem->mPacketsOut - mLastPacketsOut;
  747. S32 packets_lost = gMessageSystem->mDroppedPackets - mLastPacketsLost;
  749. S32 actual_in_bits = gMessageSystem->mPacketRing.getAndResetActualInBits();
  750. S32 actual_out_bits = gMessageSystem->mPacketRing.getAndResetActualOutBits();
  751. LLViewerStats::getInstance()->mActualInKBitStat.addValue(actual_in_bits/1024.f);
  752. LLViewerStats::getInstance()->mActualOutKBitStat.addValue(actual_out_bits/1024.f);
  753. LLViewerStats::getInstance()->mKBitStat.addValue(bits/1024.f);
  754. LLViewerStats::getInstance()->mPacketsInStat.addValue(packets_in);
  755. LLViewerStats::getInstance()->mPacketsOutStat.addValue(packets_out);
  756. LLViewerStats::getInstance()->mPacketsLostStat.addValue(gMessageSystem->mDroppedPackets);
  757. if (packets_in)
  758. {
  759. LLViewerStats::getInstance()->mPacketsLostPercentStat.addValue(100.f*((F32)packets_lost/(F32)packets_in));
  760. }
  761. else
  762. {
  763. LLViewerStats::getInstance()->mPacketsLostPercentStat.addValue(0.f);
  764. }
  766. mLastPacketsIn = gMessageSystem->mPacketsIn;
  767. mLastPacketsOut = gMessageSystem->mPacketsOut;
  768. mLastPacketsLost = gMessageSystem->mDroppedPackets;
  769. }
  772. void LLWorld::printPacketsLost()
  773. {
  774. llinfos << "Simulators:" << llendl;
  775. llinfos << "----------" << llendl;
  777. LLCircuitData *cdp = NULL;
  778. for (region_list_t::iterator iter = mActiveRegionList.begin();
  779.  iter != mActiveRegionList.end(); ++iter)
  780. {
  781. LLViewerRegion* regionp = *iter;
  782. cdp = gMessageSystem->mCircuitInfo.findCircuit(regionp->getHost());
  783. if (cdp)
  784. {
  785. LLVector3d range = regionp->getCenterGlobal() - gAgent.getPositionGlobal();
  787. llinfos << regionp->getHost() << ", range: " << range.length()
  788. << " packets lost: " << cdp->getPacketsLost() << llendl;
  789. }
  790. }
  791. }
  793. void LLWorld::processCoarseUpdate(LLMessageSystem* msg, void** user_data)
  794. {
  795. LLViewerRegion* region = LLWorld::getInstance()->getRegion(msg->getSender());
  796. if( region )
  797. {
  798. region->updateCoarseLocations(msg);
  799. }
  800. }
  802. F32 LLWorld::getLandFarClip() const
  803. {
  804. return mLandFarClip;
  805. }
  807. void LLWorld::setLandFarClip(const F32 far_clip)
  808. {
  809. mLandFarClip = far_clip;
  810. }
  813. void LLWorld::updateWaterObjects()
  814. {
  815. if (!gAgent.getRegion())
  816. {
  817. return;
  818. }
  819. if (mRegionList.empty())
  820. {
  821. llwarns << "No regions!" << llendl;
  822. return;
  823. }
  825. // First, determine the min and max "box" of water objects
  826. S32 min_x = 0;
  827. S32 min_y = 0;
  828. S32 max_x = 0;
  829. S32 max_y = 0;
  830. U32 region_x, region_y;
  832. S32 rwidth = 256;
  834. // We only want to fill in water for stuff that's near us, say, within 256 or 512m
  835. S32 range = LLViewerCamera::getInstance()->getFar() > 256.f ? 512 : 256;
  837. LLViewerRegion* regionp = gAgent.getRegion();
  838. from_region_handle(regionp->getHandle(), &region_x, &region_y);
  840. min_x = (S32)region_x - range;
  841. min_y = (S32)region_y - range;
  842. max_x = (S32)region_x + range;
  843. max_y = (S32)region_y + range;
  845. F32 height = 0.f;
  847. for (region_list_t::iterator iter = mRegionList.begin();
  848.  iter != mRegionList.end(); ++iter)
  849. {
  850. LLViewerRegion* regionp = *iter;
  851. LLVOWater* waterp = regionp->getLand().getWaterObj();
  852. height += regionp->getWaterHeight();
  853. if (waterp)
  854. {
  855. gObjectList.updateActive(waterp);
  856. }
  857. }
  859. for (std::list<LLVOWater*>::iterator iter = mHoleWaterObjects.begin();
  860.  iter != mHoleWaterObjects.end(); ++ iter)
  861. {
  862. LLVOWater* waterp = *iter;
  863. gObjectList.killObject(waterp);
  864. }
  865. mHoleWaterObjects.clear();
  867. // Now, get a list of the holes
  868. S32 x, y;
  869. for (x = min_x; x <= max_x; x += rwidth)
  870. {
  871. for (y = min_y; y <= max_y; y += rwidth)
  872. {
  873. U64 region_handle = to_region_handle(x, y);
  874. if (!getRegionFromHandle(region_handle))
  875. {
  876. LLVOWater* waterp = (LLVOWater *)gObjectList.createObjectViewer(LLViewerObject::LL_VO_WATER, gAgent.getRegion());
  877. waterp->setUseTexture(FALSE);
  878. waterp->setPositionGlobal(LLVector3d(x + rwidth/2,
  879.  y + rwidth/2,
  880.  256.f+DEFAULT_WATER_HEIGHT));
  881. waterp->setScale(LLVector3((F32)rwidth, (F32)rwidth, 512.f));
  882. gPipeline.createObject(waterp);
  883. mHoleWaterObjects.push_back(waterp);
  884. }
  885. }
  886. }
  888. // Update edge water objects
  889. S32 wx, wy;
  890. S32 center_x, center_y;
  891. wx = (max_x - min_x) + rwidth;
  892. wy = (max_y - min_y) + rwidth;
  893. center_x = min_x + (wx >> 1);
  894. center_y = min_y + (wy >> 1);
  896. S32 add_boundary[4] = {
  897. 512 - (max_x - region_x),
  898. 512 - (max_y - region_y),
  899. 512 - (region_x - min_x),
  900. 512 - (region_y - min_y) };
  902. S32 dir;
  903. for (dir = 0; dir < 8; dir++)
  904. {
  905. S32 dim[2] = { 0 };
  906. switch (gDirAxes[dir][0])
  907. {
  908. case -1: dim[0] = add_boundary[2]; break;
  909. case  0: dim[0] = wx; break;
  910. default: dim[0] = add_boundary[0]; break;
  911. }
  912. switch (gDirAxes[dir][1])
  913. {
  914. case -1: dim[1] = add_boundary[3]; break;
  915. case  0: dim[1] = wy; break;
  916. default: dim[1] = add_boundary[1]; break;
  917. }
  919. // Resize and reshape the water objects
  920. const S32 water_center_x = center_x + llround((wx + dim[0]) * 0.5f * gDirAxes[dir][0]);
  921. const S32 water_center_y = center_y + llround((wy + dim[1]) * 0.5f * gDirAxes[dir][1]);
  923. LLVOWater* waterp = mEdgeWaterObjects[dir];
  924. if (!waterp || waterp->isDead())
  925. {
  926. // The edge water objects can be dead because they're attached to the region that the
  927. // agent was in when they were originally created.
  928. mEdgeWaterObjects[dir] = (LLVOWater *)gObjectList.createObjectViewer(LLViewerObject::LL_VO_WATER,
  929.  gAgent.getRegion());
  930. waterp = mEdgeWaterObjects[dir];
  931. waterp->setUseTexture(FALSE);
  932. waterp->setIsEdgePatch(TRUE);
  933. gPipeline.createObject(waterp);
  934. }
  936. waterp->setRegion(gAgent.getRegion());
  937. LLVector3d water_pos(water_center_x, water_center_y, 
  938. DEFAULT_WATER_HEIGHT+256.f);
  939. LLVector3 water_scale((F32) dim[0], (F32) dim[1], 512.f);
  941. //stretch out to horizon
  942. water_scale.mV[0] += fabsf(2048.f * gDirAxes[dir][0]);
  943. water_scale.mV[1] += fabsf(2048.f * gDirAxes[dir][1]);
  945. water_pos.mdV[0] += 1024.f * gDirAxes[dir][0];
  946. water_pos.mdV[1] += 1024.f * gDirAxes[dir][1];
  948. waterp->setPositionGlobal(water_pos);
  949. waterp->setScale(water_scale);
  951. gObjectList.updateActive(waterp);
  952. }
  953. }
  955. void LLWorld::shiftRegions(const LLVector3& offset)
  956. {
  957. for (region_list_t::const_iterator i = getRegionList().begin(); i != getRegionList().end(); ++i)
  958. {
  959. LLViewerRegion* region = *i;
  960. region->updateRenderMatrix();
  961. }
  963. LLViewerPartSim::getInstance()->shift(offset);
  964. }
  966. LLViewerTexture* LLWorld::getDefaultWaterTexture()
  967. {
  968. return mDefaultWaterTexturep;
  969. }
  971. void LLWorld::setSpaceTimeUSec(const U64 space_time_usec)
  972. {
  973. mSpaceTimeUSec = space_time_usec;
  974. }
  976. U64 LLWorld::getSpaceTimeUSec() const
  977. {
  978. return mSpaceTimeUSec;
  979. }
  981. void LLWorld::requestCacheMisses()
  982. {
  983. for (region_list_t::iterator iter = mRegionList.begin();
  984.  iter != mRegionList.end(); ++iter)
  985. {
  986. LLViewerRegion* regionp = *iter;
  987. regionp->requestCacheMisses();
  988. }
  989. }
  991. void LLWorld::getInfo(LLSD& info)
  992. {
  993. LLSD region_info;
  994. for (region_list_t::iterator iter = mRegionList.begin();
  995.  iter != mRegionList.end(); ++iter)
  996. {
  997. LLViewerRegion* regionp = *iter;
  998. regionp->getInfo(region_info);
  999. info["World"].append(region_info);
  1000. }
  1001. }
  1003. void LLWorld::disconnectRegions()
  1004. {
  1005. LLMessageSystem* msg = gMessageSystem;
  1006. for (region_list_t::iterator iter = mRegionList.begin();
  1007.  iter != mRegionList.end(); ++iter)
  1008. {
  1009. LLViewerRegion* regionp = *iter;
  1010. if (regionp == gAgent.getRegion())
  1011. {
  1012. // Skip the main agent
  1013. continue;
  1014. }
  1016. llinfos << "Sending AgentQuitCopy to: " << regionp->getHost() << llendl;
  1017. msg->newMessageFast(_PREHASH_AgentQuitCopy);
  1018. msg->nextBlockFast(_PREHASH_AgentData);
  1019. msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
  1020. msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
  1021. msg->nextBlockFast(_PREHASH_FuseBlock);
  1022. msg->addU32Fast(_PREHASH_ViewerCircuitCode, gMessageSystem->mOurCircuitCode);
  1023. msg->sendMessage(regionp->getHost());
  1024. }
  1025. }
  1028. void process_enable_simulator(LLMessageSystem *msg, void **user_data)
  1029. {
  1030. // enable the appropriate circuit for this simulator and 
  1031. // add its values into the gSimulator structure
  1032. U64 handle;
  1033. U32 ip_u32;
  1034. U16 port;
  1036. msg->getU64Fast(_PREHASH_SimulatorInfo, _PREHASH_Handle, handle);
  1037. msg->getIPAddrFast(_PREHASH_SimulatorInfo, _PREHASH_IP, ip_u32);
  1038. msg->getIPPortFast(_PREHASH_SimulatorInfo, _PREHASH_Port, port);
  1040. // which simulator should we modify?
  1041. LLHost sim(ip_u32, port);
  1043. // Viewer trusts the simulator.
  1044. msg->enableCircuit(sim, TRUE);
  1045. LLWorld::getInstance()->addRegion(handle, sim);
  1047. // give the simulator a message it can use to get ip and port
  1048. llinfos << "simulator_enable() Enabling " << sim << " with code " << msg->getOurCircuitCode() << llendl;
  1049. msg->newMessageFast(_PREHASH_UseCircuitCode);
  1050. msg->nextBlockFast(_PREHASH_CircuitCode);
  1051. msg->addU32Fast(_PREHASH_Code, msg->getOurCircuitCode());
  1052. msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
  1053. msg->addUUIDFast(_PREHASH_ID, gAgent.getID());
  1054. msg->sendReliable(sim);
  1055. }
  1057. class LLEstablishAgentCommunication : public LLHTTPNode
  1058. {
  1059. LOG_CLASS(LLEstablishAgentCommunication);
  1060. public:
  1061.   virtual void describe(Description& desc) const
  1062. {
  1063. desc.shortInfo("seed capability info for a region");
  1064. desc.postAPI();
  1065. desc.input(
  1066. "{ seed-capability: ..., sim-ip: ..., sim-port }");
  1067. desc.source(__FILE__, __LINE__);
  1068. }
  1070. virtual void post(ResponsePtr response, const LLSD& context, const LLSD& input) const
  1071. {
  1072. if (!input["body"].has("agent-id") ||
  1073. !input["body"].has("sim-ip-and-port") ||
  1074. !input["body"].has("seed-capability"))
  1075. {
  1076. llwarns << "invalid parameters" << llendl;
  1077.             return;
  1078. }
  1080. LLHost sim(input["body"]["sim-ip-and-port"].asString());
  1082. LLViewerRegion* regionp = LLWorld::getInstance()->getRegion(sim);
  1083. if (!regionp)
  1084. {
  1085. llwarns << "Got EstablishAgentCommunication for unknown region "
  1086. << sim << llendl;
  1087. return;
  1088. }
  1089. regionp->setSeedCapability(input["body"]["seed-capability"]);
  1090. }
  1091. };
  1093. // disable the circuit to this simulator
  1094. // Called in response to "DisableSimulator" message.
  1095. void process_disable_simulator(LLMessageSystem *mesgsys, void **user_data)
  1096. {
  1097. LLHost host = mesgsys->getSender();
  1099. //llinfos << "Disabling simulator with message from " << host << llendl;
  1100. LLWorld::getInstance()->removeRegion(host);
  1102. mesgsys->disableCircuit(host);
  1103. }
  1106. void process_region_handshake(LLMessageSystem* msg, void** user_data)
  1107. {
  1108. LLHost host = msg->getSender();
  1109. LLViewerRegion* regionp = LLWorld::getInstance()->getRegion(host);
  1110. if (!regionp)
  1111. {
  1112. llwarns << "Got region handshake for unknown region "
  1113. << host << llendl;
  1114. return;
  1115. }
  1117. regionp->unpackRegionHandshake();
  1118. }
  1121. void send_agent_pause()
  1122. {
  1123. // *NOTE:Mani Pausing the mainloop timeout. Otherwise a long modal event may cause
  1124. // the thread monitor to timeout.
  1125. LLAppViewer::instance()->pauseMainloopTimeout();
  1127. // Note: used to check for LLWorld initialization before it became a singleton.
  1128. // Rather than just remove this check I'm changing it to assure that the message 
  1129. // system has been initialized. -MG
  1130. if (!gMessageSystem)
  1131. {
  1132. return;
  1133. }
  1135. gMessageSystem->newMessageFast(_PREHASH_AgentPause);
  1136. gMessageSystem->nextBlockFast(_PREHASH_AgentData);
  1137. gMessageSystem->addUUIDFast(_PREHASH_AgentID, gAgentID);
  1138. gMessageSystem->addUUIDFast(_PREHASH_SessionID, gAgentSessionID);
  1140. gAgentPauseSerialNum++;
  1141. gMessageSystem->addU32Fast(_PREHASH_SerialNum, gAgentPauseSerialNum);
  1143. for (LLWorld::region_list_t::const_iterator iter = LLWorld::getInstance()->getRegionList().begin();
  1144.  iter != LLWorld::getInstance()->getRegionList().end(); ++iter)
  1145. {
  1146. LLViewerRegion* regionp = *iter;
  1147. gMessageSystem->sendReliable(regionp->getHost());
  1148. }
  1150. gObjectList.mWasPaused = TRUE;
  1151. }
  1154. void send_agent_resume()
  1155. {
  1156. // Note: used to check for LLWorld initialization before it became a singleton.
  1157. // Rather than just remove this check I'm changing it to assure that the message 
  1158. // system has been initialized. -MG
  1159. if (!gMessageSystem)
  1160. {
  1161. return;
  1162. }
  1164. gMessageSystem->newMessageFast(_PREHASH_AgentResume);
  1165. gMessageSystem->nextBlockFast(_PREHASH_AgentData);
  1166. gMessageSystem->addUUIDFast(_PREHASH_AgentID, gAgentID);
  1167. gMessageSystem->addUUIDFast(_PREHASH_SessionID, gAgentSessionID);
  1169. gAgentPauseSerialNum++;
  1170. gMessageSystem->addU32Fast(_PREHASH_SerialNum, gAgentPauseSerialNum);
  1173. for (LLWorld::region_list_t::const_iterator iter = LLWorld::getInstance()->getRegionList().begin();
  1174.  iter != LLWorld::getInstance()->getRegionList().end(); ++iter)
  1175. {
  1176. LLViewerRegion* regionp = *iter;
  1177. gMessageSystem->sendReliable(regionp->getHost());
  1178. }
  1180. // Reset the FPS counter to avoid an invalid fps
  1181. LLViewerStats::getInstance()->mFPSStat.start();
  1183. LLAppViewer::instance()->resumeMainloopTimeout();
  1184. }
  1186. static LLVector3d unpackLocalToGlobalPosition(U32 compact_local, const LLVector3d& region_origin)
  1187. {
  1188. LLVector3d pos_global;
  1189. LLVector3 pos_local;
  1190. U8 bits;
  1192. bits = compact_local & 0xFF;
  1193. pos_local.mV[VZ] = F32(bits) * 4.f;
  1194. compact_local >>= 8;
  1196. bits = compact_local & 0xFF;
  1197. pos_local.mV[VY] = (F32)bits;
  1198. compact_local >>= 8;
  1200. bits = compact_local & 0xFF;
  1201. pos_local.mV[VX] = (F32)bits;
  1203. pos_global.setVec( pos_local );
  1204. pos_global += region_origin;
  1205. return pos_global;
  1206. }
  1208. void LLWorld::getAvatars(std::vector<LLUUID>* avatar_ids, std::vector<LLVector3d>* positions, const LLVector3d& relative_to, F32 radius) const
  1209. {
  1210. if(avatar_ids != NULL)
  1211. {
  1212. avatar_ids->clear();
  1213. }
  1214. if(positions != NULL)
  1215. {
  1216. positions->clear();
  1217. }
  1218. for (LLWorld::region_list_t::const_iterator iter = LLWorld::getInstance()->getRegionList().begin();
  1219. iter != LLWorld::getInstance()->getRegionList().end(); ++iter)
  1220. {
  1221. LLViewerRegion* regionp = *iter;
  1222. const LLVector3d& origin_global = regionp->getOriginGlobal();
  1223. S32 count = regionp->mMapAvatars.count();
  1224. for (S32 i = 0; i < count; i++)
  1225. {
  1226. LLVector3d pos_global = unpackLocalToGlobalPosition(regionp->mMapAvatars.get(i), origin_global);
  1227. if(dist_vec(pos_global, relative_to) <= radius)
  1228. {
  1229. if(positions != NULL)
  1230. {
  1231. positions->push_back(pos_global);
  1232. }
  1233. if(avatar_ids != NULL)
  1234. {
  1235. avatar_ids->push_back(regionp->mMapAvatarIDs.get(i));
  1236. }
  1237. }
  1238. }
  1239. }
  1240. }
  1243. LLHTTPRegistration<LLEstablishAgentCommunication>
  1244. gHTTPRegistrationEstablishAgentCommunication(
  1245. "/message/EstablishAgentCommunication");