llworldmap.h
上传用户:king477883
上传日期:2021-03-01
资源大小:9553k
文件大小:14k
源码类别:

游戏引擎

开发平台:

C++ Builder

  1. /** 
  2.  * @file llworldmap.h
  3.  * @brief Underlying data storage for the map of the entire world.
  4.  *
  5.  * $LicenseInfo:firstyear=2003&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2003-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.  */
  32. #ifndef LL_LLWORLDMAP_H
  33. #define LL_LLWORLDMAP_H
  34. #include "llworldmipmap.h"
  35. #include <boost/function.hpp>
  36. #include "v3dmath.h"
  37. #include "lluuid.h"
  38. #include "llpointer.h"
  39. #include "llsingleton.h"
  40. #include "llviewerregion.h"
  41. #include "llviewertexture.h"
  42. // Description of objects like hubs, events, land for sale, people and more (TBD).
  43. // Note: we don't store a "type" in there so we need to store instances of this class in 
  44. // well known objects (i.e. list of objects which type is "well known").
  45. class LLItemInfo
  46. {
  47. public:
  48. LLItemInfo(F32 global_x, F32 global_y, const std::string& name, LLUUID id);
  49. // Setters
  50. void setTooltip(std::string& tooltip) { mToolTip = tooltip; }
  51. void setElevation(F64 z) { mPosGlobal.mdV[VZ] = z; }
  52. void setCount(S32 count) { mCount = count; }
  53. // void setSelected(bool selected) { mSelected = selected; }
  54. // void setColor(LLColor4 color) { mColor = color; }
  55. // Accessors
  56. const LLVector3d& getGlobalPosition() const { return mPosGlobal; } 
  57. const std::string& getName() const { return mName; }
  58. const std::string& getToolTip() const { return mToolTip; }
  59. const LLUUID& getUUID() const { return mID; }
  60. S32 getCount() const { return mCount; }
  61. U64 getRegionHandle() const { return to_region_handle(mPosGlobal); } // Build the handle on the fly
  62. bool isName(const std::string& name) const { return (mName == name); } // True if name same as item's name
  63. // bool isSelected() const { return mSelected; }
  64. private:
  65. std::string mName; // Name of the individual item
  66. std::string mToolTip; // Tooltip : typically, something to be displayed to the user when selecting this item
  67. LLVector3d mPosGlobal; // Global world position
  68. LLUUID mID; // UUID of the item
  69. S32 mCount; // Number of elements in item (e.g. people count)
  70. // Currently not used but might prove useful one day so we comment out 
  71. // bool mSelected; // Selected or not: updated by the viewer UI, not the simulator or asset DB
  72. // LLColor4 mColor; // Color of the item
  73. };
  74. // Info per region
  75. // Such records are stored in a global map hold by the LLWorldMap and indexed by region handles. 
  76. // To avoid creating too many of them, they are requested in "blocks" corresponding to areas covered by the screen. 
  77. // Unfortunately, when the screen covers the whole world (zoomed out), that can translate in requesting info for 
  78. // every sim on the grid... Not good...
  79. // To avoid this, the code implements a cut-off threshold for overlay graphics and, therefore, all LLSimInfo. 
  80. // In other words, when zooming out too much, we simply stop requesting LLSimInfo and
  81. // LLItemInfo and just display the map tiles. 
  82. // As they are stored in different structures (LLSimInfo and LLWorldMipmap), this strategy is now workable.
  83. class LLSimInfo
  84. {
  85. public:
  86. LLSimInfo(U64 handle);
  87. // Convert local region coordinates into world coordinates
  88. LLVector3d getGlobalPos(const LLVector3& local_pos) const;
  89. // Get the world coordinates of the SW corner of that region
  90. LLVector3d getGlobalOrigin() const;
  91. LLVector3 getLocalPos(LLVector3d global_pos) const;
  92. void clearImage(); // Clears the reference to the Land for sale image for that region
  93. void dropImagePriority(); // Drops the boost level of the Land for sale image for that region
  94. void updateAgentCount(F64 time); // Send an item request for agent count on that region if time's up
  95. // Setters
  96. void setName(std::string& name) { mName = name; }
  97. void setAccess (U32 accesscode) { mAccess = accesscode; }
  98. void setRegionFlags (U32 region_flags) { mRegionFlags = region_flags; }
  99. void setLandForSaleImage (LLUUID image_id);
  100. // void setWaterHeight (F32 water_height) { mWaterHeight = water_height; }
  101. // Accessors
  102. std::string getName() const { return mName; }
  103. const std::string getFlagsString() const { return LLViewerRegion::regionFlagsToString(mRegionFlags); }
  104. const std::string getAccessString() const { return LLViewerRegion::accessToString((U8)mAccess); }
  105. const S32 getAgentCount() const; // Compute the total agents count
  106. LLPointer<LLViewerFetchedTexture> getLandForSaleImage(); // Get the overlay image, fetch it if necessary
  107. bool isName(const std::string& name) const;
  108. bool isDown() { return (mAccess == SIM_ACCESS_DOWN); }
  109. bool isPG() { return (mAccess <= SIM_ACCESS_PG); }
  110. // Debug only
  111. void dump() const; // Print the region info to the standard output
  112. // Items lists handling
  113. typedef std::vector<LLItemInfo> item_info_list_t;
  114. void clearItems();
  115. void insertTeleHub(const LLItemInfo& item) { mTelehubs.push_back(item); }
  116. void insertInfoHub(const LLItemInfo& item) { mInfohubs.push_back(item); }
  117. void insertPGEvent(const LLItemInfo& item) { mPGEvents.push_back(item); }
  118. void insertMatureEvent(const LLItemInfo& item) { mMatureEvents.push_back(item); }
  119. void insertAdultEvent(const LLItemInfo& item) { mAdultEvents.push_back(item); }
  120. void insertLandForSale(const LLItemInfo& item) { mLandForSale.push_back(item); }
  121. void insertLandForSaleAdult(const LLItemInfo& item) { mLandForSaleAdult.push_back(item); }
  122. void insertAgentLocation(const LLItemInfo& item);
  123. const LLSimInfo::item_info_list_t& getTeleHub() const { return mTelehubs; }
  124. const LLSimInfo::item_info_list_t& getInfoHub() const { return mInfohubs; }
  125. const LLSimInfo::item_info_list_t& getPGEvent() const { return mPGEvents; }
  126. const LLSimInfo::item_info_list_t& getMatureEvent() const { return mMatureEvents; }
  127. const LLSimInfo::item_info_list_t& getAdultEvent() const { return mAdultEvents; }
  128. const LLSimInfo::item_info_list_t& getLandForSale() const { return mLandForSale; }
  129. const LLSimInfo::item_info_list_t& getLandForSaleAdult() const { return mLandForSaleAdult; }
  130. const LLSimInfo::item_info_list_t& getAgentLocation() const { return mAgentLocations; }
  131. private:
  132. U64 mHandle; // This is a hash of the X and Y world coordinates of the SW corner of the sim
  133. std::string mName; // Region name
  134. F64 mAgentsUpdateTime; // Time stamp giving the last time the agents information was requested for that region
  135. bool mFirstAgentRequest; // Init agent request flag
  136. U32  mAccess; // Down/up and maturity rating of the region
  137. U32 mRegionFlags; // Tell us if the siminfo has been received (if non 0) and what kind of region it is (Sandbox, allow damage)
  138. // Currently not used but might prove useful one day so we comment out 
  139. // F32 mWaterHeight; // Water height on the region (not actively used)
  140. // Handling the "land for sale / land for auction" overlay image
  141. LLUUID mMapImageID; // Image ID of the overlay image
  142. LLPointer<LLViewerFetchedTexture> mOverlayImage; // Reference to the overlay image
  143. // Items for this region
  144. // Those are data received through item requests (as opposed to block requests for the rest of the data)
  145. item_info_list_t mTelehubs; // List of tele hubs in the region
  146. item_info_list_t mInfohubs; // List of info hubs in the region
  147. item_info_list_t mPGEvents; // List of PG events in the region
  148. item_info_list_t mMatureEvents; // List of Mature events in the region
  149. item_info_list_t mAdultEvents; // List of Adult events in the region (AO)
  150. item_info_list_t mLandForSale; // List of Land for sales in the region
  151. item_info_list_t mLandForSaleAdult; // List of Adult Land for sales in the region (AO)
  152. item_info_list_t mAgentLocations; // List of agents in the region
  153. };
  154. // We request region data on the world by "blocks" of (MAP_BLOCK_SIZE x MAP_BLOCK_SIZE) regions
  155. // This is to reduce the number of requests to the asset DB and get things in big "blocks"
  156. const S32 MAP_MAX_SIZE = 2048;
  157. const S32 MAP_BLOCK_SIZE = 4;
  158. const S32 MAP_BLOCK_RES = (MAP_MAX_SIZE / MAP_BLOCK_SIZE);
  159. class LLWorldMap : public LLSingleton<LLWorldMap>
  160. {
  161. public:
  162. LLWorldMap();
  163. ~LLWorldMap();
  164. // Clear all: list of region info, tiles, blocks and items
  165. void reset();
  166. void clearImageRefs(); // Clears the image references
  167. void dropImagePriorities(); // Drops the priority of the images being fetched
  168. void reloadItems(bool force = false); // Reload the items (people, hub, etc...)
  169. // Region Map access
  170. typedef std::map<U64, LLSimInfo*> sim_info_map_t;
  171. const LLWorldMap::sim_info_map_t& getRegionMap() const { return mSimInfoMap; }
  172. void updateRegions(S32 x0, S32 y0, S32 x1, S32 y1); // Requests region info for a rectangle of regions (in grid coordinates)
  173. // Insert a region and items in the map global instance
  174. // Note: x_world and y_world in world coordinates (meters)
  175. static bool insertRegion(U32 x_world, U32 y_world, std::string& name, LLUUID& uuid, U32 accesscode, U32 region_flags);
  176. static bool insertItem(U32 x_world, U32 y_world, std::string& name, LLUUID& uuid, U32 type, S32 extra, S32 extra2);
  177. // Get info on sims (region) : note that those methods only search the range of loaded sims (the one that are being browsed)
  178. // *not* the entire world. So a NULL return does not mean a down or unexisting region, just an out of range region.
  179. LLSimInfo* simInfoFromHandle(const U64 handle);
  180. LLSimInfo* simInfoFromPosGlobal(const LLVector3d& pos_global);
  181. LLSimInfo* simInfoFromName(const std::string& sim_name);
  182. // Gets simulator name from a global position, returns true if found
  183. bool simNameFromPosGlobal(const LLVector3d& pos_global, std::string& outSimName );
  184. // Debug only
  185. void dump(); // Print the world info to the standard output
  186. // Track handling
  187. void cancelTracking() { mIsTrackingLocation = false; mIsTrackingFound = false; mIsInvalidLocation = false; mIsTrackingDoubleClick = false; mIsTrackingCommit = false; }
  188. void setTracking(const LLVector3d& loc) { mIsTrackingLocation = true; mTrackingLocation = loc; mIsTrackingFound = false; mIsInvalidLocation = false; mIsTrackingDoubleClick = false; mIsTrackingCommit = false;}
  189. void setTrackingInvalid() { mIsTrackingFound = true; mIsInvalidLocation = true;  }
  190. void setTrackingValid()   { mIsTrackingFound = true; mIsInvalidLocation = false; }
  191. void setTrackingDoubleClick() { mIsTrackingDoubleClick = true; }
  192. void setTrackingCommit() { mIsTrackingCommit = true; }
  193. bool isTracking() { return mIsTrackingLocation; }
  194. bool isTrackingValidLocation()   { return mIsTrackingFound && !mIsInvalidLocation; }
  195. bool isTrackingInvalidLocation() { return mIsTrackingFound &&  mIsInvalidLocation; }
  196. bool isTrackingDoubleClick() { return mIsTrackingDoubleClick; }
  197. bool isTrackingCommit() { return mIsTrackingCommit; }
  198. bool isTrackingInRectangle(F64 x0, F64 y0, F64 x1, F64 y1);
  199. LLVector3d getTrackedPositionGlobal() const { return mTrackingLocation; }
  200. // World Mipmap delegation: currently used when drawing the mipmap
  201. void equalizeBoostLevels();
  202. LLPointer<LLViewerFetchedTexture> getObjectsTile(U32 grid_x, U32 grid_y, S32 level, bool load = true) { return mWorldMipmap.getObjectsTile(grid_x, grid_y, level, load); }
  203. private:
  204. bool clearItems(bool force = false); // Clears the item lists
  205. void clearSimFlags(); // Clears the block flags indicating that we've already requested region infos
  206. // Create a region record corresponding to the handle, insert it in the region map and returns a pointer
  207. LLSimInfo* createSimInfoFromHandle(const U64 handle);
  208. // Map from region-handle to region info
  209. sim_info_map_t mSimInfoMap;
  210. // Holds the tiled mipmap of the world. This is the structure that contains the images used for rendering.
  211. LLWorldMipmap mWorldMipmap;
  212. // The World is divided in "blocks" of (MAP_BLOCK_SIZE x MAP_BLOCK_SIZE) regions that get requested at once.
  213. // This boolean table avoids "blocks" to be requested multiple times. 
  214. // Issue: Not sure this scheme is foolproof though as I've seen
  215. // cases where a block is never retrieved and, because of this boolean being set, never re-requested
  216. bool * mMapBlockLoaded; // Telling us if the block of regions has been requested or not
  217. // Track location data : used while there's nothing tracked yet by LLTracker
  218. bool mIsTrackingLocation; // True when we're tracking a point
  219. bool mIsTrackingFound; // True when the tracking position has been found, valid or not
  220. bool mIsInvalidLocation; // The region is down or the location does not correspond to an existing region
  221. bool mIsTrackingDoubleClick; // User double clicked to set the location (i.e. teleport when found please...)
  222. bool mIsTrackingCommit; // User used the search or landmark fields to set the location
  223. LLVector3d mTrackingLocation; // World global position being tracked
  224. // General grid items request timing flags (used for events,hubs and land for sale)
  225. LLTimer mRequestTimer;
  226. bool mFirstRequest;
  227. };
  228. #endif