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

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

游戏引擎

开发平台：

C++ Builder

llviewerregion.h：源码内容
  1. /** 
  2.  * @file llviewerregion.h
  3.  * @brief Description of the LLViewerRegion class.
  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. #ifndef LL_LLVIEWERREGION_H
  34. #define LL_LLVIEWERREGION_H
  36. // A ViewerRegion is a class that contains a bunch of objects and surfaces
  37. // that are in to a particular region.
  38. #include <string>
  40. #include "lldarray.h"
  41. #include "llwind.h"
  42. #include "llcloud.h"
  43. #include "llstat.h"
  44. #include "v3dmath.h"
  45. #include "llhost.h"
  46. #include "llstring.h"
  47. #include "llregionflags.h"
  48. #include "lluuid.h"
  49. #include "lldatapacker.h"
  50. #include "llvocache.h"
  51. #include "llweb.h"
  52. #include "llcapabilityprovider.h"
  53. #include "llcapabilitylistener.h"
  54. #include "m4math.h" // LLMatrix4
  56. // Surface id's
  57. #define LAND  1
  58. #define WATER 2
  59. const U32 MAX_OBJECT_CACHE_ENTRIES = 10000;
  62. class LLEventPoll;
  63. class LLVLComposition;
  64. class LLViewerObject;
  65. class LLMessageSystem;
  66. class LLNetMap;
  67. class LLViewerParcelOverlay;
  68. class LLSurface;
  69. class LLVOCache;
  70. class LLVOCacheEntry;
  71. class LLSpatialPartition;
  72. class LLEventPump;
  74. class LLViewerRegion: public LLCapabilityProvider // implements this interface
  75. {
  76. public:
  77. //MUST MATCH THE ORDER OF DECLARATION IN CONSTRUCTOR
  78. typedef enum 
  79. {
  80. PARTITION_HUD=0,
  81. PARTITION_TERRAIN,
  82. PARTITION_WATER,
  83. PARTITION_TREE,
  84. PARTITION_PARTICLE,
  85. PARTITION_CLOUD,
  86. PARTITION_GRASS,
  87. PARTITION_VOLUME,
  88. PARTITION_BRIDGE,
  89. PARTITION_HUD_PARTICLE,
  90. PARTITION_NONE,
  91. NUM_PARTITIONS
  92. } eObjectPartitions;
  94. LLViewerRegion(const U64 &handle,
  95.    const LLHost &host,
  96.    const U32 surface_grid_width,
  97.    const U32 patch_grid_width,
  98.    const F32 region_width_meters);
  99. ~LLViewerRegion();
  101. // Call this after you have the region name and handle.
  102. void loadCache();
  104. void saveCache();
  106. void sendMessage(); // Send the current message to this region's simulator
  107. void sendReliableMessage(); // Send the current message to this region's simulator
  109. void setOriginGlobal(const LLVector3d &origin);
  110. //void setAgentOffset(const LLVector3d &offset);
  111. void updateRenderMatrix();
  113. void setAllowDamage(BOOL b) { setFlags(b, REGION_FLAGS_ALLOW_DAMAGE); }
  114. void setAllowLandmark(BOOL b) { setFlags(b, REGION_FLAGS_ALLOW_LANDMARK); }
  115. void setAllowSetHome(BOOL b) { setFlags(b, REGION_FLAGS_ALLOW_SET_HOME); }
  116. void setResetHomeOnTeleport(BOOL b) { setFlags(b, REGION_FLAGS_RESET_HOME_ON_TELEPORT); }
  117. void setSunFixed(BOOL b) { setFlags(b, REGION_FLAGS_SUN_FIXED); }
  118. void setBlockFly(BOOL b) { setFlags(b, REGION_FLAGS_BLOCK_FLY); }
  119. void setAllowDirectTeleport(BOOL b) { setFlags(b, REGION_FLAGS_ALLOW_DIRECT_TELEPORT); }
  122. inline BOOL getAllowDamage() const;
  123. inline BOOL getAllowLandmark() const;
  124. inline BOOL getAllowSetHome() const;
  125. inline BOOL getResetHomeOnTeleport() const;
  126. inline BOOL getSunFixed() const;
  127. inline BOOL getBlockFly() const;
  128. inline BOOL getAllowDirectTeleport() const;
  129. inline BOOL isPrelude() const;
  130. inline BOOL getAllowTerraform()  const;
  131. inline BOOL getRestrictPushObject() const;
  132. inline BOOL getReleaseNotesRequested() const;
  134. bool isAlive(); // can become false if circuit disconnects
  136. void setWaterHeight(F32 water_level);
  137. F32 getWaterHeight() const;
  139. BOOL isVoiceEnabled() const;
  141. void setBillableFactor(F32 billable_factor) { mBillableFactor = billable_factor; }
  142. F32 getBillableFactor()  const  { return mBillableFactor; }
  144. // Maximum number of primitives allowed, regardless of object
  145. // bonus factor.
  146. U32 getMaxTasks() const { return mMaxTasks; }
  147. void setMaxTasks(U32 max_tasks) { mMaxTasks = max_tasks; }
  149. // Draw lines in the dirt showing ownership. Return number of 
  150. // vertices drawn.
  151. S32 renderPropertyLines();
  153. // Call this whenever you change the height data in the region.
  154. // (Automatically called by LLSurfacePatch's update routine)
  155. void dirtyHeights();
  157. LLViewerParcelOverlay *getParcelOverlay() const
  158. { return mParcelOverlay; }
  160. void setRegionFlags(U32 flags);
  161. U32 getRegionFlags() const { return mRegionFlags; }
  163. void setTimeDilation(F32 time_dilation);
  164. F32  getTimeDilation() const { return mTimeDilation; }
  166. // Origin height is at zero.
  167. const LLVector3d &getOriginGlobal() const { return mOriginGlobal; }
  168. LLVector3 getOriginAgent() const;
  170. // Center is at the height of the water table.
  171. const LLVector3d &getCenterGlobal() const { return mCenterGlobal; }
  172. LLVector3 getCenterAgent() const;
  174. void setRegionNameAndZone(const std::string& name_and_zone);
  175. const std::string& getName() const { return mName; }
  176. const std::string& getZoning() const { return mZoning; }
  178. void setOwner(const LLUUID& owner_id) { mOwnerID = owner_id; }
  179. const LLUUID& getOwner() const { return mOwnerID; }
  181. // Is the current agent on the estate manager list for this region?
  182. void setIsEstateManager(BOOL b) { mIsEstateManager = b; }
  183. BOOL isEstateManager() const { return mIsEstateManager; }
  184. BOOL canManageEstate() const;
  186. void setSimAccess(U8 sim_access) { mSimAccess = sim_access; }
  187. U8 getSimAccess() const { return mSimAccess; }
  188. const std::string getSimAccessString() const;
  190. // Homestead-related getters; there are no setters as nobody should be
  191. // setting them other than the individual message handler which is a member
  192. S32 getSimClassID()                    const { return mClassID; }
  193. S32 getSimCPURatio()                   const { return mCPURatio; }
  194. const std::string& getSimColoName()    const { return mColoName; }
  195. const std::string& getSimProductSKU()  const { return mProductSKU; }
  196. const std::string& getSimProductName() const { return mProductName; }
  198. // Returns "Sandbox", "Expensive", etc.
  199. static std::string regionFlagsToString(U32 flags);
  201. // Returns translated version of "Mature", "PG", "Adult", etc.
  202. static std::string accessToString(U8 sim_access);
  204. // Returns "M", "PG", "A" etc.
  205. static std::string accessToShortString(U8 sim_access);
  207. // helper function which just makes sure all interested parties
  208. // can process the message.
  209. static void processRegionInfo(LLMessageSystem* msg, void**);
  211. void setCacheID(const LLUUID& id) { mCacheID = id; }
  213. F32 getWidth() const { return mWidth; }
  215. BOOL idleUpdate(F32 max_update_time);
  217. // Like idleUpdate, but forces everything to complete regardless of
  218. // how long it takes.
  219. void forceUpdate();
  221. void connectNeighbor(LLViewerRegion *neighborp, U32 direction);
  223. void updateNetStats();
  225. U32 getPacketsLost() const;
  227. void setHttpResponderPtrNULL() {mHttpResponderPtr = NULL ;}
  228. const LLHTTPClient::ResponderPtr getHttpResponderPtr() const {return mHttpResponderPtr ;}
  230. // Get/set named capability URLs for this region.
  231. void setSeedCapability(const std::string& url);
  232. void setCapability(const std::string& name, const std::string& url);
  233. // implements LLCapabilityProvider
  234.     virtual std::string getCapability(const std::string& name) const;
  235. static bool isSpecialCapabilityName(const std::string &name);
  236. void logActiveCapabilities() const;
  238.     /// Capability-request exception
  239.     typedef LLCapabilityListener::ArgError ArgError;
  240.     /// Get LLEventPump on which we listen for capability requests
  241.     /// (https://wiki.lindenlab.com/wiki/Viewer:Messaging/Messaging_Notes#Capabilities)
  242.     LLEventPump& getCapAPI() { return mCapabilityListener.getCapAPI(); }
  244.     /// implements LLCapabilityProvider
  245. virtual LLHost getHost() const { return mHost; }
  246. const U64  &getHandle() const  { return mHandle; }
  248. LLSurface &getLand() const { return *mLandp; }
  250. // set and get the region id
  251. const LLUUID& getRegionID() const { return mRegionID; }
  252. void setRegionID(const LLUUID& region_id) { mRegionID = region_id; }
  254. BOOL pointInRegionGlobal(const LLVector3d &point_global) const;
  255. LLVector3 getPosRegionFromGlobal(const LLVector3d &point_global) const;
  256. LLVector3 getPosRegionFromAgent(const LLVector3 &agent_pos) const;
  257. LLVector3 getPosAgentFromRegion(const LLVector3 &region_pos) const;
  258. LLVector3d getPosGlobalFromRegion(const LLVector3 &offset) const;
  260. LLVLComposition *getComposition() const { return mCompositionp; }
  261. F32 getCompositionXY(const S32 x, const S32 y) const;
  263. BOOL isOwnedSelf(const LLVector3& pos);
  265. // Owned by a group you belong to?  (officer OR member)
  266. BOOL isOwnedGroup(const LLVector3& pos);
  268. // deal with map object updates in the world.
  269. void updateCoarseLocations(LLMessageSystem* msg);
  271. F32 getLandHeightRegion(const LLVector3& region_pos);
  273. void getInfo(LLSD& info);
  275. // handle a full update message
  276. void cacheFullUpdate(LLViewerObject* objectp, LLDataPackerBinaryBuffer &dp);
  277. LLDataPacker *getDP(U32 local_id, U32 crc);
  278. void requestCacheMisses();
  279. void addCacheMissFull(const U32 local_id);
  281. void dumpCache();
  283. void unpackRegionHandshake();
  285. void calculateCenterGlobal();
  286. void calculateCameraDistance();
  288. friend std::ostream& operator<<(std::ostream &s, const LLViewerRegion &region);
  289.     /// implements LLCapabilityProvider
  290.     virtual std::string getDescription() const;
  292. LLSpatialPartition* getSpatialPartition(U32 type);
  293. public:
  294. struct CompareDistance
  295. {
  296. bool operator()(const LLViewerRegion* const& lhs, const LLViewerRegion* const& rhs)
  297. {
  298. return lhs->mCameraDistanceSquared < rhs->mCameraDistanceSquared; 
  299. }
  300. };
  302. void showReleaseNotes();
  304. protected:
  305. void disconnectAllNeighbors();
  306. void initStats();
  307. void setFlags(BOOL b, U32 flags);
  309. public:
  310. LLWind  mWind;
  311. LLCloudLayer mCloudLayer;
  312. LLViewerParcelOverlay *mParcelOverlay;
  314. LLStat mBitStat;
  315. LLStat mPacketsStat;
  316. LLStat mPacketsLostStat;
  318. LLMatrix4 mRenderMatrix;
  320. // These arrays are maintained in parallel. Ideally they'd be combined into a
  321. // single array of an aggrigate data type but for compatibility with the old
  322. // messaging system in which the previous message only sends and parses the 
  323. // positions stored in the first array so they're maintained separately until 
  324. // we stop supporting the old CoarseLocationUpdate message.
  325. LLDynamicArray<U32> mMapAvatars;
  326. LLDynamicArray<LLUUID> mMapAvatarIDs;
  328. private:
  329. // The surfaces and other layers
  330. LLSurface* mLandp;
  332. // Region geometry data
  333. LLVector3d mOriginGlobal; // Location of southwest corner of region (meters)
  334. LLVector3d mCenterGlobal; // Location of center in world space (meters)
  335. F32 mWidth; // Width of region on a side (meters)
  337. U64 mHandle;
  338. LLHost mHost;
  340. // The unique ID for this region.
  341. LLUUID mRegionID;
  343. F32 mTimeDilation; // time dilation of physics simulation on simulator
  345. // simulator name
  346. std::string mName;
  347. std::string mZoning;
  349. // region/estate owner - usually null.
  350. LLUUID mOwnerID;
  352. // Is this agent on the estate managers list for this region?
  353. BOOL mIsEstateManager;
  355. // Network statistics for the region's circuit...
  356. LLTimer mLastNetUpdate;
  357. U32 mPacketsIn;
  358. U32 mBitsIn;
  359. U32 mLastBitsIn;
  360. U32 mLastPacketsIn;
  361. U32 mPacketsOut;
  362. U32 mLastPacketsOut;
  363. S32 mPacketsLost;
  364. S32 mLastPacketsLost;
  365. U32 mPingDelay;
  366. F32 mDeltaTime; // Time since last measurement of lastPackets, Bits, etc
  368. // Misc
  369. LLVLComposition *mCompositionp; // Composition layer for the surface
  371. U32 mRegionFlags; // includes damage flags
  372. U8 mSimAccess;
  373. F32  mBillableFactor;
  374. U32 mMaxTasks; // max prim count
  375. F32 mCameraDistanceSquared; // updated once per frame
  377. // Information for Homestead / CR-53
  378. S32 mClassID;
  379. S32 mCPURatio;
  380. std::string mColoName;
  381. std::string mProductSKU;
  382. std::string mProductName;
  385. // Maps local ids to cache entries.
  386. // Regions can have order 10,000 objects, so assume
  387. // a structure of size 2^14 = 16,000
  388. BOOL mCacheLoaded;
  389. typedef std::map<U32, LLVOCacheEntry *> cache_map_t;
  390. cache_map_t      mCacheMap;
  391. LLVOCacheEntry mCacheStart;
  392. LLVOCacheEntry mCacheEnd;
  393. U32 mCacheEntriesCount;
  394. LLDynamicArray<U32> mCacheMissFull;
  395. LLDynamicArray<U32> mCacheMissCRC;
  396. // time?
  397. // LRU info?
  399. // Cache ID is unique per-region, across renames, moving locations,
  400. // etc.
  401. LLUUID mCacheID;
  403. typedef std::map<std::string, std::string> CapabilityMap;
  404. CapabilityMap mCapabilities;
  406. LLEventPoll* mEventPoll;
  408.     /// Post an event to this LLCapabilityListener to invoke a capability message on
  409.     /// this LLViewerRegion's server
  410.     /// (https://wiki.lindenlab.com/wiki/Viewer:Messaging/Messaging_Notes#Capabilities)
  411.     LLCapabilityListener mCapabilityListener;
  413. private:
  414. bool mAlive; // can become false if circuit disconnects
  416. //spatial partitions for objects in this region
  417. std::vector<LLSpatialPartition*> mObjectPartition;
  419. LLHTTPClient::ResponderPtr  mHttpResponderPtr ;
  421. BOOL mReleaseNotesRequested;
  422. };
  424. inline BOOL LLViewerRegion::getAllowDamage() const
  425. {
  426. return ((mRegionFlags & REGION_FLAGS_ALLOW_DAMAGE) !=0);
  427. }
  429. inline BOOL LLViewerRegion::getAllowLandmark() const
  430. {
  431. return ((mRegionFlags & REGION_FLAGS_ALLOW_LANDMARK) !=0);
  432. }
  434. inline BOOL LLViewerRegion::getAllowSetHome() const
  435. {
  436. return ((mRegionFlags & REGION_FLAGS_ALLOW_SET_HOME) != 0);
  437. }
  439. inline BOOL LLViewerRegion::getResetHomeOnTeleport() const
  440. {
  441. return ((mRegionFlags & REGION_FLAGS_RESET_HOME_ON_TELEPORT) !=0);
  442. }
  444. inline BOOL LLViewerRegion::getSunFixed() const
  445. {
  446. return ((mRegionFlags & REGION_FLAGS_SUN_FIXED) !=0);
  447. }
  449. inline BOOL LLViewerRegion::getBlockFly() const
  450. {
  451. return ((mRegionFlags & REGION_FLAGS_BLOCK_FLY) !=0);
  452. }
  454. inline BOOL LLViewerRegion::getAllowDirectTeleport() const
  455. {
  456. return ((mRegionFlags & REGION_FLAGS_ALLOW_DIRECT_TELEPORT) !=0);
  457. }
  459. inline BOOL LLViewerRegion::isPrelude() const
  460. {
  461. return is_prelude( mRegionFlags );
  462. }
  464. inline BOOL LLViewerRegion::getAllowTerraform() const
  465. {
  466. return ((mRegionFlags & REGION_FLAGS_BLOCK_TERRAFORM) == 0);
  467. }
  469. inline BOOL LLViewerRegion::getRestrictPushObject() const
  470. {
  471. return ((mRegionFlags & REGION_FLAGS_RESTRICT_PUSHOBJECT) != 0);
  472. }
  474. inline BOOL LLViewerRegion::getReleaseNotesRequested() const
  475. {
  476. return mReleaseNotesRequested;
  477. }
  479. #endif