merge from texture-pipeline

1 files changed, 385 insertions, 789 deletions

diff --git a/indra/newview/llworldmap.cpp b/indra/newview/llworldmap.cpp
index 355d4141c3..66cb02ce99 100644
--- a/indra/newview/llworldmap.cpp
+++ b/indra/newview/llworldmap.cpp
@@ -34,57 +34,81 @@
 
 #include "llworldmap.h"
 
-#include "llregionhandle.h"
+#include "llworldmapmessage.h"
 #include "message.h"
-
-#include "llagent.h"
-#include "llmapresponders.h"
-#include "llviewercontrol.h"
-#include "llfloaterworldmap.h"
 #include "lltracker.h"
 #include "llviewertexturelist.h"
-#include "llviewerregion.h"
-#include "llregionflags.h"
 #include "lltrans.h"
 
-const F32 REQUEST_ITEMS_TIMER =  10.f * 60.f; // 10 minutes
+// Timers to temporise database requests
+const F32 AGENTS_UPDATE_TIMER = 60.0;			// Seconds between 2 agent requests for a region
+const F32 REQUEST_ITEMS_TIMER = 10.f * 60.f;	// Seconds before we consider re-requesting item data for the grid
+
+//---------------------------------------------------------------------------
+// LLItemInfo
+//---------------------------------------------------------------------------
 
-// For DEV-17507, do lazy image loading in llworldmapview.cpp instead,
-// limiting requests to currently visible regions and minimizing the
-// number of textures being requested simultaneously.
-//
-// Uncomment IMMEDIATE_IMAGE_LOAD to restore the old behavior
-//
-//#define IMMEDIATE_IMAGE_LOAD
 LLItemInfo::LLItemInfo(F32 global_x, F32 global_y,
 					   const std::string& name, 
-					   LLUUID id,
-					   S32 extra, S32 extra2)
+					   LLUUID id)
 :	mName(name),
 	mToolTip(""),
 	mPosGlobal(global_x, global_y, 40.0),
 	mID(id),
-	mSelected(FALSE),
-	mExtra(extra),
-	mExtra2(extra2)
+	mCount(1)
+//	mSelected(false)
+//	mColor()
 {
-	mRegionHandle = to_region_handle(mPosGlobal);
 }
 
-LLSimInfo::LLSimInfo()
-:	mHandle(0),
+//---------------------------------------------------------------------------
+// LLSimInfo
+//---------------------------------------------------------------------------
+
+LLSimInfo::LLSimInfo(U64 handle)
+:	mHandle(handle),
 	mName(),
 	mAgentsUpdateTime(0),
-	mShowAgentLocations(FALSE),
 	mAccess(0x0),
 	mRegionFlags(0x0),
-	mWaterHeight(0.f),
-	mAlpha(-1.f)
+	mFirstAgentRequest(true)
+//	mWaterHeight(0.f)
+{
+}
+
+void LLSimInfo::setLandForSaleImage (LLUUID image_id) 
 {
+	mMapImageID = image_id;
+
+	// Fetch the image
+	if (mMapImageID.notNull())
+	{
+		mOverlayImage = LLViewerTextureManager::getFetchedTexture(mMapImageID, MIPMAP_TRUE, LLViewerTexture::BOOST_MAP, LLViewerTexture::LOD_TEXTURE);
+		mOverlayImage->setAddressMode(LLTexUnit::TAM_CLAMP);
+	}
+	else
+	{
+		mOverlayImage = NULL;
+	}
 }
 
+LLPointer<LLViewerFetchedTexture> LLSimInfo::getLandForSaleImage () 
+{
+	if (mOverlayImage.isNull() && mMapImageID.notNull())
+	{
+		// Fetch the image if it hasn't been done yet (unlikely but...)
+		mOverlayImage = LLViewerTextureManager::getFetchedTexture(mMapImageID, MIPMAP_TRUE, LLViewerTexture::BOOST_MAP, LLViewerTexture::LOD_TEXTURE);
+		mOverlayImage->setAddressMode(LLTexUnit::TAM_CLAMP);
+	}
+	if (!mOverlayImage.isNull())
+	{
+		// Boost the fetch level when we try to access that image
+		mOverlayImage->setBoostLevel(LLViewerTexture::BOOST_MAP);
+	}
+	return mOverlayImage;
+}
 
-LLVector3d LLSimInfo::getGlobalPos(LLVector3 local_pos) const
+LLVector3d LLSimInfo::getGlobalPos(const LLVector3& local_pos) const
 {
 	LLVector3d pos = from_region_handle(mHandle);
 	pos.mdV[VX] += local_pos.mV[VX];
@@ -93,128 +117,184 @@ LLVector3d LLSimInfo::getGlobalPos(LLVector3 local_pos) const
 	return pos;
 }
 
+LLVector3d LLSimInfo::getGlobalOrigin() const
+{
+	return from_region_handle(mHandle);
+}
 LLVector3 LLSimInfo::getLocalPos(LLVector3d global_pos) const
 {
 	LLVector3d sim_origin = from_region_handle(mHandle);
 	return LLVector3(global_pos - sim_origin);
 }
 
+void LLSimInfo::clearImage()
+{
+	if (!mOverlayImage.isNull())
+	{
+		mOverlayImage->setBoostLevel(0);
+		mOverlayImage = NULL;
+	}
+}
 
-
-//---------------------------------------------------------------------------
-// World Map
-//---------------------------------------------------------------------------
-
-LLWorldMap::LLWorldMap() :
-	mIsTrackingUnknownLocation( FALSE ),
-	mInvalidLocation( FALSE ),
-	mIsTrackingDoubleClick( FALSE ),
-	mIsTrackingCommit( FALSE ),
-	mUnknownLocation( 0, 0, 0 ),
-	mRequestLandForSale(true),
-	mCurrentMap(0),
-	mMinX(U32_MAX),
-	mMaxX(U32_MIN),
-	mMinY(U32_MAX),
-	mMaxY(U32_MIN),
-	mNeighborMap(NULL),
-	mTelehubCoverageMap(NULL),
-	mNeighborMapWidth(0),
-	mNeighborMapHeight(0),
-	mSLURLRegionName(),
-	mSLURLRegionHandle(0),
-	mSLURL(),
-	mSLURLCallback(0),
-	mSLURLTeleport(false)
-{
-	for (S32 map=0; map<MAP_SIM_IMAGE_TYPES; ++map)
+void LLSimInfo::dropImagePriority()
+{
+	if (!mOverlayImage.isNull())
 	{
-		mMapLoaded[map] = FALSE;
-		mMapBlockLoaded[map] = new BOOL[MAP_BLOCK_RES*MAP_BLOCK_RES];
-		for (S32 idx=0; idx<MAP_BLOCK_RES*MAP_BLOCK_RES; ++idx)
-		{
-			mMapBlockLoaded[map][idx] = FALSE;
-		}
+		mOverlayImage->setBoostLevel(0);
 	}
 }
 
+// Update the agent count for that region
+void LLSimInfo::updateAgentCount(F64 time)
+{
+	if ((time - mAgentsUpdateTime > AGENTS_UPDATE_TIMER) || mFirstAgentRequest)
+	{
+		LLWorldMapMessage::getInstance()->sendItemRequest(MAP_ITEM_AGENT_LOCATIONS, mHandle);
+		mAgentsUpdateTime = time;
+		mFirstAgentRequest = false;
+	}
+}
 
-LLWorldMap::~LLWorldMap()
+// Get the total agents count
+const S32 LLSimInfo::getAgentCount() const
 {
-	reset();
-	for (S32 map=0; map<MAP_SIM_IMAGE_TYPES; ++map)
+	S32 total_agent_count = 0;
+	for (LLSimInfo::item_info_list_t::const_iterator it = mAgentLocations.begin(); it != mAgentLocations.end(); ++it)
 	{
-		delete[] mMapBlockLoaded[map];
+		total_agent_count += it->getCount();
 	}
+	return total_agent_count;
 }
 
+bool LLSimInfo::isName(const std::string& name) const
+{
+	return (LLStringUtil::compareInsensitive(name, mName) == 0);
+}
 
-void LLWorldMap::reset()
+void LLSimInfo::dump() const
 {
-	for_each(mSimInfoMap.begin(), mSimInfoMap.end(), DeletePairedPointer());
-	mSimInfoMap.clear();
+	U32 x_pos, y_pos;
+	from_region_handle(mHandle, &x_pos, &y_pos);
+
+	LL_INFOS("World Map") << x_pos << "," << y_pos
+		<< " " << mName 
+		<< " " << (S32)mAccess
+		<< " " << std::hex << mRegionFlags << std::dec
+//		<< " " << mWaterHeight
+		<< LL_ENDL;
+}
+
+void LLSimInfo::clearItems()
+{
+	mTelehubs.clear();
+	mInfohubs.clear();
+	mPGEvents.clear();
+	mMatureEvents.clear();
+	mAdultEvents.clear();
+	mLandForSale.clear();
+	mLandForSaleAdult.clear();
+//  We persist the agent count though as it is updated on a frequent basis
+// 	mAgentLocations.clear();
+}
+
+void LLSimInfo::insertAgentLocation(const LLItemInfo& item) 
+{
+	std::string name = item.getName();
 
-	for (S32 m=0; m<MAP_SIM_IMAGE_TYPES; ++m)
+	// Find the last item in the list with a different name and erase them
+	item_info_list_t::iterator lastiter;
+	for (lastiter = mAgentLocations.begin(); lastiter != mAgentLocations.end(); ++lastiter)
+	{
+		LLItemInfo& info = *lastiter;
+		if (info.isName(name))
+		{
+			break;
+		}
+	}
+	if (lastiter != mAgentLocations.begin())
 	{
-		mMapLoaded[m] = FALSE;
+		mAgentLocations.erase(mAgentLocations.begin(), lastiter);
 	}
 
+	// Now append the new location
+	mAgentLocations.push_back(item); 
+}
+
+//---------------------------------------------------------------------------
+// World Map
+//---------------------------------------------------------------------------
+
+LLWorldMap::LLWorldMap() :
+	mIsTrackingLocation( false ),
+	mIsTrackingFound( false ),
+	mIsInvalidLocation( false ),
+	mIsTrackingDoubleClick( false ),
+	mIsTrackingCommit( false ),
+	mTrackingLocation( 0, 0, 0 ),
+	mFirstRequest(true)
+{
+	//LL_INFOS("World Map") << "Creating the World Map -> LLWorldMap::LLWorldMap()" << LL_ENDL;
+	mMapBlockLoaded = new bool[MAP_BLOCK_RES*MAP_BLOCK_RES];
 	clearSimFlags();
-	
-	eraseItems();
+}
 
-	mMinX = U32_MAX;
-	mMaxX = U32_MIN;
 
-	mMinY = U32_MAX;
-	mMaxY = U32_MIN;
+LLWorldMap::~LLWorldMap()
+{
+	//LL_INFOS("World Map") << "Destroying the World Map -> LLWorldMap::~LLWorldMap()" << LL_ENDL;
+	reset();
+	delete[] mMapBlockLoaded;
+}
 
-	delete [] mNeighborMap;
-	mNeighborMap = NULL;
-	delete [] mTelehubCoverageMap;
-	mTelehubCoverageMap = NULL;
 
-	mNeighborMapWidth = 0;
-	mNeighborMapHeight = 0;
+void LLWorldMap::reset()
+{
+	clearItems(true);		// Clear the items lists
+	clearImageRefs();		// Clear the world mipmap and the land for sale tiles
+	clearSimFlags();		// Clear the block info flags array 
 
-	for (S32 i=0; i<MAP_SIM_IMAGE_TYPES; i++)
-	{
-		mMapLayers[i].clear();
-	}
+	// Finally, clear the region map itself
+	for_each(mSimInfoMap.begin(), mSimInfoMap.end(), DeletePairedPointer());
+	mSimInfoMap.clear();
 }
 
-void LLWorldMap::eraseItems()
+// Returns true if the items have been cleared
+bool LLWorldMap::clearItems(bool force)
 {
-	if (mRequestTimer.getElapsedTimeF32() > REQUEST_ITEMS_TIMER)
+	bool clear = false;
+	if ((mRequestTimer.getElapsedTimeF32() > REQUEST_ITEMS_TIMER) || mFirstRequest || force)
 	{
 		mRequestTimer.reset();
 
-		mTelehubs.clear();
-		mInfohubs.clear();
-		mPGEvents.clear();
-		mMatureEvents.clear();
-		mAdultEvents.clear();
-		mLandForSale.clear();
+		LLSimInfo* sim_info = NULL;
+		for (sim_info_map_t::iterator it = mSimInfoMap.begin(); it != mSimInfoMap.end(); ++it)
+		{
+			sim_info = it->second;
+			if (sim_info)
+			{
+				sim_info->clearItems();
+			}
+		}
+		clear = true;
+		mFirstRequest = false;
 	}
-// 	mAgentLocationsMap.clear(); // persists
-// 	mNumAgents.clear(); // persists
+	return clear;
 }
 
-
 void LLWorldMap::clearImageRefs()
 {
+	// We clear the reference to the images we're holding.
+	// Images hold by the world mipmap first
+	mWorldMipmap.reset();
+
+	// Images hold by the region map
+	LLSimInfo* sim_info = NULL;
 	for (sim_info_map_t::iterator it = mSimInfoMap.begin(); it != mSimInfoMap.end(); ++it)
 	{
-		LLSimInfo* info = (*it).second;
-		if (info->mCurrentImage)
-		{
-			info->mCurrentImage->setBoostLevel(0);
-			info->mCurrentImage = NULL;
-		}
-		if (info->mOverlayImage)
+		sim_info = it->second;
+		if (sim_info)
 		{
-			info->mOverlayImage->setBoostLevel(0);
-			info->mOverlayImage = NULL;
+			sim_info->clearImage();
 		}
 	}
 }
@@ -222,15 +302,25 @@ void LLWorldMap::clearImageRefs()
 // Doesn't clear the already-loaded sim infos, just re-requests them
 void LLWorldMap::clearSimFlags()
 {
-	for (S32 map=0; map<MAP_SIM_IMAGE_TYPES; ++map)
+	for (S32 idx=0; idx<MAP_BLOCK_RES*MAP_BLOCK_RES; ++idx)
 	{
-		for (S32 idx=0; idx<MAP_BLOCK_RES*MAP_BLOCK_RES; ++idx)
-		{
-			mMapBlockLoaded[map][idx] = FALSE;
-		}
+		mMapBlockLoaded[idx] = false;
 	}
 }
 
+LLSimInfo* LLWorldMap::createSimInfoFromHandle(const U64 handle)
+{
+	LLSimInfo* sim_info = new LLSimInfo(handle);
+	mSimInfoMap[handle] = sim_info;
+	return sim_info;
+}
+
+void LLWorldMap::equalizeBoostLevels()
+{
+	mWorldMipmap.equalizeBoostLevels();
+	return;
+}
+
 LLSimInfo* LLWorldMap::simInfoFromPosGlobal(const LLVector3d& pos_global)
 {
 	U64 handle = to_region_handle(pos_global);
@@ -242,11 +332,7 @@ LLSimInfo* LLWorldMap::simInfoFromHandle(const U64 handle)
 	sim_info_map_t::iterator it = mSimInfoMap.find(handle);
 	if (it != mSimInfoMap.end())
 	{
-		LLSimInfo* sim_info = (*it).second;
-		if (sim_info)
-		{
-			return sim_info;
-		}
+		return it->second;
 	}
 	return NULL;
 }
@@ -257,763 +343,273 @@ LLSimInfo* LLWorldMap::simInfoFromName(const std::string& sim_name)
 	LLSimInfo* sim_info = NULL;
 	if (!sim_name.empty())
 	{
-		for (sim_info_map_t::iterator it = mSimInfoMap.begin(); it != mSimInfoMap.end(); ++it)
+		// Iterate through the entire sim info map and compare the name
+		sim_info_map_t::iterator it;
+		for (it = mSimInfoMap.begin(); it != mSimInfoMap.end(); ++it)
 		{
-			sim_info = (*it).second;
-			if (sim_info
-				&& (0 == LLStringUtil::compareInsensitive(sim_name, sim_info->mName)) )
+			sim_info = it->second;
+			if (sim_info && sim_info->isName(sim_name) )
 			{
+				// break out of loop if success
 				break;
 			}
-			sim_info = NULL;
 		}
+		// If we got to the end, we haven't found the sim. Reset the ouput value to NULL.
+		if (it == mSimInfoMap.end())
+			sim_info = NULL;
 	}
 	return sim_info;
 }
 
 bool LLWorldMap::simNameFromPosGlobal(const LLVector3d& pos_global, std::string & outSimName )
 {
-	bool gotSimName = true;
+	LLSimInfo* sim_info = simInfoFromPosGlobal(pos_global);
 
-	U64 handle = to_region_handle(pos_global);
-
-	sim_info_map_t::iterator it = mSimInfoMap.find(handle);
-	if (it != mSimInfoMap.end())
+	if (sim_info)
 	{
-		LLSimInfo* info = (*it).second;
-		outSimName = info->mName;
+		outSimName = sim_info->getName();
 	}
 	else
 	{
-		gotSimName = false;
 		outSimName = "(unknown region)";
 	}
 
-	return gotSimName;
+	return (sim_info != NULL);
 }
 
-void LLWorldMap::setCurrentLayer(S32 layer, bool request_layer)
+void LLWorldMap::reloadItems(bool force)
 {
-	mCurrentMap = layer;
-	if (!mMapLoaded[layer] || request_layer)
+	//LL_INFOS("World Map") << "LLWorldMap::reloadItems()" << LL_ENDL;
+	if (clearItems(force))
 	{
-		sendMapLayerRequest();
+		LLWorldMapMessage::getInstance()->sendItemRequest(MAP_ITEM_TELEHUB);
+		LLWorldMapMessage::getInstance()->sendItemRequest(MAP_ITEM_PG_EVENT);
+		LLWorldMapMessage::getInstance()->sendItemRequest(MAP_ITEM_MATURE_EVENT);
+		LLWorldMapMessage::getInstance()->sendItemRequest(MAP_ITEM_ADULT_EVENT);
+		LLWorldMapMessage::getInstance()->sendItemRequest(MAP_ITEM_LAND_FOR_SALE);
 	}
-
-	if (mTelehubs.size() == 0 ||
-		mInfohubs.size() == 0)
-	{
-		// Request for telehubs
-		sendItemRequest(MAP_ITEM_TELEHUB);
-	}
-
-	if (mPGEvents.size() == 0)
-	{
-		// Request for events
-		sendItemRequest(MAP_ITEM_PG_EVENT);
-	}
-
-	if (mMatureEvents.size() == 0)
-	{
-		// Request for events (mature)
-		sendItemRequest(MAP_ITEM_MATURE_EVENT);
-	}
-
-	if (mAdultEvents.size() == 0)
-	{
-		// Request for events (adult)
-		sendItemRequest(MAP_ITEM_ADULT_EVENT);
-	}
-
-	if (mLandForSale.size() == 0)
-	{
-		// Request for Land For Sale
-		sendItemRequest(MAP_ITEM_LAND_FOR_SALE);
-	}
-	
-	if (mLandForSaleAdult.size() == 0)
-	{
-		// Request for Land For Sale
-		sendItemRequest(MAP_ITEM_LAND_FOR_SALE_ADULT);
-	}
-
-	clearImageRefs();
-	clearSimFlags();
 }
 
-void LLWorldMap::sendItemRequest(U32 type, U64 handle)
-{
-	LLMessageSystem* msg = gMessageSystem;
-	S32 layer = mCurrentMap;
-
-	msg->newMessageFast(_PREHASH_MapItemRequest);
-	msg->nextBlockFast(_PREHASH_AgentData);
-	msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
-	msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
-	msg->addU32Fast(_PREHASH_Flags, layer);
-	msg->addU32Fast(_PREHASH_EstateID, 0); // Filled in on sim
-	msg->addBOOLFast(_PREHASH_Godlike, FALSE); // Filled in on sim
-
-	msg->nextBlockFast(_PREHASH_RequestData);
-	msg->addU32Fast(_PREHASH_ItemType, type);
-	msg->addU64Fast(_PREHASH_RegionHandle, handle); // If zero, filled in on sim
-
-	gAgent.sendReliableMessage();
-}
 
-// public
-void LLWorldMap::sendMapLayerRequest()
+// static public
+// Insert a region in the region map
+// returns true if region inserted, false otherwise
+bool LLWorldMap::insertRegion(U32 x_world, U32 y_world, std::string& name, LLUUID& image_id, U32 accesscode, U32 region_flags)
 {
-	if (!gAgent.getRegion()) return;
-
-	LLSD body;
-	body["Flags"] = mCurrentMap;
-	std::string url = gAgent.getRegion()->getCapability(
-		gAgent.isGodlike() ? "MapLayerGod" : "MapLayer");
-
-	if (!url.empty())
+	// This region doesn't exist
+	if (accesscode == 255)
 	{
-		llinfos << "LLWorldMap::sendMapLayerRequest via capability" << llendl;
-		LLHTTPClient::post(url, body, new LLMapLayerResponder());
+		// Checks if the track point is in it and invalidates it if it is
+		if (LLWorldMap::getInstance()->isTrackingInRectangle( x_world, y_world, x_world + REGION_WIDTH_UNITS, y_world + REGION_WIDTH_UNITS))
+		{
+			LLWorldMap::getInstance()->setTrackingInvalid();
+		}
+		// return failure to insert
+		return false;
 	}
 	else
 	{
-		llinfos << "LLWorldMap::sendMapLayerRequest via message system" << llendl;
-		LLMessageSystem* msg = gMessageSystem;
-		S32 layer = mCurrentMap;
-
-		// Request for layer
-		msg->newMessageFast(_PREHASH_MapLayerRequest);
-		msg->nextBlockFast(_PREHASH_AgentData);
-		msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
-		msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
-		msg->addU32Fast(_PREHASH_Flags, layer);
-		msg->addU32Fast(_PREHASH_EstateID, 0); // Filled in on sim
-		msg->addBOOLFast(_PREHASH_Godlike, FALSE); // Filled in on sim
-		gAgent.sendReliableMessage();
-
-		if (mRequestLandForSale)
+		U64 handle = to_region_handle(x_world, y_world);
+ 		//LL_INFOS("World Map") << "Map sim : " << name << ", ID : " << image_id.getString() << LL_ENDL;
+		// Insert the region in the region map of the world map
+		// Loading the LLSimInfo object with what we got and insert it in the map
+		LLSimInfo* siminfo = LLWorldMap::getInstance()->simInfoFromHandle(handle);
+		if (siminfo == NULL)
 		{
-			msg->newMessageFast(_PREHASH_MapLayerRequest);
-			msg->nextBlockFast(_PREHASH_AgentData);
-			msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
-			msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
-			msg->addU32Fast(_PREHASH_Flags, 2);
-			msg->addU32Fast(_PREHASH_EstateID, 0); // Filled in on sim
-			msg->addBOOLFast(_PREHASH_Godlike, FALSE); // Filled in on sim
-			gAgent.sendReliableMessage();
+			siminfo = LLWorldMap::getInstance()->createSimInfoFromHandle(handle);
 		}
+		siminfo->setName(name);
+		siminfo->setAccess(accesscode);
+		siminfo->setRegionFlags(region_flags);
+	//	siminfo->setWaterHeight((F32) water_height);
+		siminfo->setLandForSaleImage(image_id);
+
+		// Handle the location tracking (for teleport, UI feedback and info display)
+		if (LLWorldMap::getInstance()->isTrackingInRectangle( x_world, y_world, x_world + REGION_WIDTH_UNITS, y_world + REGION_WIDTH_UNITS))
+		{
+			if (siminfo->isDown())
+			{
+				// We were tracking this location, but it's no available
+				LLWorldMap::getInstance()->setTrackingInvalid();
+			}
+			else
+			{
+				// We were tracking this location, and it does exist and is available
+				LLWorldMap::getInstance()->setTrackingValid();
+			}
+		}
+		// return insert region success
+		return true;
 	}
 }
 
-// public
-void LLWorldMap::sendNamedRegionRequest(std::string region_name)
-{
-	LLMessageSystem* msg = gMessageSystem;
-	S32 layer = mCurrentMap;
-
-	// Request for layer
-	msg->newMessageFast(_PREHASH_MapNameRequest);
-	msg->nextBlockFast(_PREHASH_AgentData);
-	msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
-	msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
-	msg->addU32Fast(_PREHASH_Flags, layer);
-	msg->addU32Fast(_PREHASH_EstateID, 0); // Filled in on sim
-	msg->addBOOLFast(_PREHASH_Godlike, FALSE); // Filled in on sim
-	msg->nextBlockFast(_PREHASH_NameData);
-	msg->addStringFast(_PREHASH_Name, region_name);
-	gAgent.sendReliableMessage();
-}
-// public
-void LLWorldMap::sendNamedRegionRequest(std::string region_name, 
-		url_callback_t callback,
-		const std::string& callback_url,
-		bool teleport)	// immediately teleport when result returned
-{
-	mSLURLRegionName = region_name;
-	mSLURLRegionHandle = 0;
-	mSLURL = callback_url;
-	mSLURLCallback = callback;
-	mSLURLTeleport = teleport;
-
-	sendNamedRegionRequest(region_name);
-}
-
-void LLWorldMap::sendHandleRegionRequest(U64 region_handle, 
-		url_callback_t callback,
-		const std::string& callback_url,
-		bool teleport)	// immediately teleport when result returned
-{
-	mSLURLRegionName.clear();
-	mSLURLRegionHandle = region_handle;
-	mSLURL = callback_url;
-	mSLURLCallback = callback;
-	mSLURLTeleport = teleport;
-
-	U32 global_x;
-	U32 global_y;
-	from_region_handle(region_handle, &global_x, &global_y);
-	U16 grid_x = (U16)(global_x / REGION_WIDTH_UNITS);
-	U16 grid_y = (U16)(global_y / REGION_WIDTH_UNITS);
-	
-	sendMapBlockRequest(grid_x, grid_y, grid_x, grid_y, true);
-}
-
-// public
-void LLWorldMap::sendMapBlockRequest(U16 min_x, U16 min_y, U16 max_x, U16 max_y, bool return_nonexistent)
-{
-	S32 layer = mCurrentMap;
-	LLMessageSystem* msg = gMessageSystem;
-	msg->newMessageFast(_PREHASH_MapBlockRequest);
-	msg->nextBlockFast(_PREHASH_AgentData);
-	msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
-	msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
-	U32 flags = layer;
-	flags |= (return_nonexistent ? 0x10000 : 0);
-	msg->addU32Fast(_PREHASH_Flags, flags);
-	msg->addU32Fast(_PREHASH_EstateID, 0); // Filled in on sim
-	msg->addBOOLFast(_PREHASH_Godlike, FALSE); // Filled in on sim
-	msg->nextBlockFast(_PREHASH_PositionData);
-	msg->addU16Fast(_PREHASH_MinX, min_x);
-	msg->addU16Fast(_PREHASH_MinY, min_y);
-	msg->addU16Fast(_PREHASH_MaxX, max_x);
-	msg->addU16Fast(_PREHASH_MaxY, max_y);
-	gAgent.sendReliableMessage();
-
-	if (mRequestLandForSale)
-	{
-		msg->newMessageFast(_PREHASH_MapBlockRequest);
-		msg->nextBlockFast(_PREHASH_AgentData);
-		msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
-		msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
-		msg->addU32Fast(_PREHASH_Flags, 2);
-		msg->addU32Fast(_PREHASH_EstateID, 0); // Filled in on sim
-		msg->addBOOLFast(_PREHASH_Godlike, FALSE); // Filled in on sim
-		msg->nextBlockFast(_PREHASH_PositionData);
-		msg->addU16Fast(_PREHASH_MinX, min_x);
-		msg->addU16Fast(_PREHASH_MinY, min_y);
-		msg->addU16Fast(_PREHASH_MaxX, max_x);
-		msg->addU16Fast(_PREHASH_MaxY, max_y);
-		gAgent.sendReliableMessage();
-	}
-}
-
-// public static
-void LLWorldMap::processMapLayerReply(LLMessageSystem* msg, void**)
+// static public
+// Insert an item in the relevant region map
+// returns true if item inserted, false otherwise
+bool LLWorldMap::insertItem(U32 x_world, U32 y_world, std::string& name, LLUUID& uuid, U32 type, S32 extra, S32 extra2)
 {
-	llinfos << "LLWorldMap::processMapLayerReply from message system" << llendl;
-
-	U32 agent_flags;
-	msg->getU32Fast(_PREHASH_AgentData, _PREHASH_Flags, agent_flags);
-
-	if (agent_flags != (U32)LLWorldMap::getInstance()->mCurrentMap)
-	{
-		llwarns << "Invalid or out of date map image type returned!" << llendl;
-		return;
-	}
+	// Create an item record for the received object
+	LLItemInfo new_item((F32)x_world, (F32)y_world, name, uuid);
 
-	LLUUID image_id;
-	//U32 left, right, top, bottom;
+	// Compute a region handle based on the objects coordinates
+	LLVector3d	pos((F32)x_world, (F32)y_world, 40.0);
+	U64 handle = to_region_handle(pos);
 
-	S32 num_blocks = msg->getNumberOfBlocksFast(_PREHASH_LayerData);
-
-	LLWorldMap::getInstance()->mMapLayers[agent_flags].clear();
-
-	BOOL adjust = FALSE;
-	for (S32 block=0; block<num_blocks; ++block)
+	// Get the region record for that handle or NULL if we haven't browsed it yet
+	LLSimInfo* siminfo = LLWorldMap::getInstance()->simInfoFromHandle(handle);
+	if (siminfo == NULL)
 	{
-		LLWorldMapLayer new_layer;
-		new_layer.LayerDefined = TRUE;
-		msg->getUUIDFast(_PREHASH_LayerData, _PREHASH_ImageID, new_layer.LayerImageID, block);
-		new_layer.LayerImage = LLViewerTextureManager::getFetchedTexture(new_layer.LayerImageID, MIPMAP_TRUE, LLViewerTexture::BOOST_NONE, LLViewerTexture::LOD_TEXTURE);
-
-		gGL.getTexUnit(0)->bind(new_layer.LayerImage);
-		new_layer.LayerImage->setAddressMode(LLTexUnit::TAM_CLAMP);
-		
-		U32 left, right, top, bottom;
-		msg->getU32Fast(_PREHASH_LayerData, _PREHASH_Left, left, block);
-		msg->getU32Fast(_PREHASH_LayerData, _PREHASH_Right, right, block);
-		msg->getU32Fast(_PREHASH_LayerData, _PREHASH_Top, top, block);
-		msg->getU32Fast(_PREHASH_LayerData, _PREHASH_Bottom, bottom, block);
-
-		new_layer.LayerExtents.mLeft = left;
-		new_layer.LayerExtents.mRight = right;
-		new_layer.LayerExtents.mBottom = bottom;
-		new_layer.LayerExtents.mTop = top;
-
-		F32 x_meters = F32(left*REGION_WIDTH_UNITS);
-		F32 y_meters = F32(bottom*REGION_WIDTH_UNITS);
-		adjust = LLWorldMap::getInstance()->extendAABB(U32(x_meters), U32(y_meters), 
-							   U32(x_meters+REGION_WIDTH_UNITS*new_layer.LayerExtents.getWidth()),
-							   U32(y_meters+REGION_WIDTH_UNITS*new_layer.LayerExtents.getHeight())) || adjust;
-
-		LLWorldMap::getInstance()->mMapLayers[agent_flags].push_back(new_layer);
+		siminfo = LLWorldMap::getInstance()->createSimInfoFromHandle(handle);
 	}
 
-	LLWorldMap::getInstance()->mMapLoaded[agent_flags] = TRUE;
-	if(adjust) gFloaterWorldMap->adjustZoomSliderBounds();
-}
-
-// public static
-void LLWorldMap::processMapBlockReply(LLMessageSystem* msg, void**)
-{
-	U32 agent_flags;
-	msg->getU32Fast(_PREHASH_AgentData, _PREHASH_Flags, agent_flags);
-
-	if ((S32)agent_flags < 0 || agent_flags >= MAP_SIM_IMAGE_TYPES)
+	//LL_INFOS("World Map") << "Process item : type = " << type << LL_ENDL;
+	switch (type)
 	{
-		llwarns << "Invalid map image type returned! " << agent_flags << llendl;
-		return;
-	}
-
-	S32 num_blocks = msg->getNumberOfBlocksFast(_PREHASH_Data);
-
-	bool found_null_sim = false;
-
-	BOOL adjust = FALSE;
-	for (S32 block=0; block<num_blocks; ++block)
-	{
-		U16 x_regions;
-		U16 y_regions;
-		std::string name;
-		U8 accesscode;
-		U32 region_flags;
-		U8 water_height;
-		U8 agents;
-		LLUUID image_id;
-		msg->getU16Fast(_PREHASH_Data, _PREHASH_X, x_regions, block);
-		msg->getU16Fast(_PREHASH_Data, _PREHASH_Y, y_regions, block);
-		msg->getStringFast(_PREHASH_Data, _PREHASH_Name, name, block);
-		msg->getU8Fast(_PREHASH_Data, _PREHASH_Access, accesscode, block);
-		msg->getU32Fast(_PREHASH_Data, _PREHASH_RegionFlags, region_flags, block);
-		msg->getU8Fast(_PREHASH_Data, _PREHASH_WaterHeight, water_height, block);
-		msg->getU8Fast(_PREHASH_Data, _PREHASH_Agents, agents, block);
-		msg->getUUIDFast(_PREHASH_Data, _PREHASH_MapImageID, image_id, block);
-
-		U32 x_meters = x_regions * REGION_WIDTH_UNITS;
-		U32 y_meters = y_regions * REGION_WIDTH_UNITS;
-
-		U64 handle = to_region_handle(x_meters, y_meters);
-
-		if (accesscode == 255)
-		{
-			// This region doesn't exist
-			if (LLWorldMap::getInstance()->mIsTrackingUnknownLocation &&
-				LLWorldMap::getInstance()->mUnknownLocation.mdV[0] >= x_meters &&
-				LLWorldMap::getInstance()->mUnknownLocation.mdV[0] < x_meters + 256 &&
-				LLWorldMap::getInstance()->mUnknownLocation.mdV[1] >= y_meters &&
-				LLWorldMap::getInstance()->mUnknownLocation.mdV[1] < y_meters + 256)
-			{
-				// We were tracking this location, but it doesn't exist
-				LLWorldMap::getInstance()->mInvalidLocation = TRUE;
-			}
-
-			found_null_sim = true;
-		}
-		else
+		case MAP_ITEM_TELEHUB: // telehubs
 		{
-			adjust = LLWorldMap::getInstance()->extendAABB(x_meters, 
-										y_meters, 
-										x_meters+REGION_WIDTH_UNITS,
-										y_meters+REGION_WIDTH_UNITS) || adjust;
-
-// 			llinfos << "Map sim " << name << " image layer " << agent_flags << " ID " << image_id.getString() << llendl;
-			
-			LLSimInfo* siminfo = new LLSimInfo();
-			sim_info_map_t::iterator iter = LLWorldMap::getInstance()->mSimInfoMap.find(handle);
-			if (iter != LLWorldMap::getInstance()->mSimInfoMap.end())
-			{
-				LLSimInfo* oldinfo = iter->second;
-				for (S32 image=0; image<MAP_SIM_IMAGE_TYPES; ++image)
-				{
-					siminfo->mMapImageID[image] = oldinfo->mMapImageID[image];
-				}
-				delete oldinfo;
-			}
-			LLWorldMap::getInstance()->mSimInfoMap[handle] = siminfo;
-
-			siminfo->mHandle = handle;
-			siminfo->mName.assign( name );
-			siminfo->mAccess = accesscode;
-			siminfo->mRegionFlags = region_flags;
-			siminfo->mWaterHeight = (F32) water_height;
-			siminfo->mMapImageID[agent_flags] = image_id;
-
-#ifdef IMMEDIATE_IMAGE_LOAD
-			siminfo->mCurrentImage = LLViewerTextureManager::getFetchedTexture(siminfo->mMapImageID[LLWorldMap::getInstance()->mCurrentMap], 
-				MIPMAP_TRUE, LLViewerTexture::BOOST_NONE, LLViewerTexture::LOD_TEXTURE);
-			siminfo->mCurrentImage->setAddressMode(LLTexUnit::TAM_CLAMP);
-#endif
+			/* Merov: we are not using the hub color anymore for display so commenting that out
+			// Telehub color
+			U32 X = x_world / REGION_WIDTH_UNITS;
+			U32 Y = y_world / REGION_WIDTH_UNITS;
+			F32 red = fmod((F32)X * 0.11f, 1.f) * 0.8f;
+			F32 green = fmod((F32)Y * 0.11f, 1.f) * 0.8f;
+			F32 blue = fmod(1.5f * (F32)(X + Y) * 0.11f, 1.f) * 0.8f;
+			F32 add_amt = (X % 2) ? 0.15f : -0.15f;
+			add_amt += (Y % 2) ? -0.15f : 0.15f;
+			LLColor4 color(red + add_amt, green + add_amt, blue + add_amt);
+			new_item.setColor(color);
+			*/
 			
-			if (siminfo->mMapImageID[2].notNull())
+			// extra2 specifies whether this is an infohub or a telehub.
+			if (extra2)
 			{
-#ifdef IMMEDIATE_IMAGE_LOAD
-				siminfo->mOverlayImage = LLViewerTextureManager::getFetchedTexture(siminfo->mMapImageID[2], MIPMAP_TRUE, LLViewerTexture::BOOST_NONE, LLViewerTexture::LOD_TEXTURE);
-#endif
+				siminfo->insertInfoHub(new_item);
 			}
 			else
 			{
-				siminfo->mOverlayImage = NULL;
-			}
-
-			if (LLWorldMap::getInstance()->mIsTrackingUnknownLocation &&
-				LLWorldMap::getInstance()->mUnknownLocation.mdV[0] >= x_meters &&
-				LLWorldMap::getInstance()->mUnknownLocation.mdV[0] < x_meters + 256 &&
-				LLWorldMap::getInstance()->mUnknownLocation.mdV[1] >= y_meters &&
-				LLWorldMap::getInstance()->mUnknownLocation.mdV[1] < y_meters + 256)
-			{
-				if (siminfo->mAccess == SIM_ACCESS_DOWN)
-				{
-					// We were tracking this location, but it doesn't exist
-					LLWorldMap::getInstance()->mInvalidLocation = true;
-				}
-				else
-				{
-					// We were tracking this location, and it does exist
-					bool is_tracking_dbl = LLWorldMap::getInstance()->mIsTrackingDoubleClick == TRUE;
-					gFloaterWorldMap->trackLocation(LLWorldMap::getInstance()->mUnknownLocation);
-					if (is_tracking_dbl)
-					{
-						LLVector3d pos_global = LLTracker::getTrackedPositionGlobal();
-						gAgent.teleportViaLocation( pos_global );
-					}
-				}
+				siminfo->insertTeleHub(new_item);
 			}
+			break;
 		}
-				
-		if(LLWorldMap::getInstance()->mSLURLCallback != NULL)
+		case MAP_ITEM_PG_EVENT: // events
+		case MAP_ITEM_MATURE_EVENT:
+		case MAP_ITEM_ADULT_EVENT:
 		{
-			// Server returns definitive capitalization, SLURL might not have that.
-			if ((LLStringUtil::compareInsensitive(LLWorldMap::getInstance()->mSLURLRegionName, name)==0)
-				|| (LLWorldMap::getInstance()->mSLURLRegionHandle == handle))
+			std::string timeStr = "["+ LLTrans::getString ("TimeHour")+"]:["
+					                   +LLTrans::getString ("TimeMin")+"] ["
+									   +LLTrans::getString ("TimeAMPM")+"]";
+			LLSD substitution;
+			substitution["datetime"] = (S32) extra;
+			LLStringUtil::format (timeStr, substitution);				
+			new_item.setTooltip(timeStr);
+
+			// HACK: store Z in extra2
+			new_item.setElevation((F64)extra2);
+			if (type == MAP_ITEM_PG_EVENT)
 			{
-				url_callback_t callback = LLWorldMap::getInstance()->mSLURLCallback;
-
-				LLWorldMap::getInstance()->mSLURLCallback = NULL;
-				LLWorldMap::getInstance()->mSLURLRegionName.clear();
-				LLWorldMap::getInstance()->mSLURLRegionHandle = 0;
-
-				callback(handle, LLWorldMap::getInstance()->mSLURL, image_id, LLWorldMap::getInstance()->mSLURLTeleport);
+				siminfo->insertPGEvent(new_item);
 			}
-		}
-	}
-
-	if(adjust) gFloaterWorldMap->adjustZoomSliderBounds();
-	gFloaterWorldMap->updateSims(found_null_sim);
-}
-
-// public static
-void LLWorldMap::processMapItemReply(LLMessageSystem* msg, void**)
-{
-	U32 type;
-	msg->getU32Fast(_PREHASH_RequestData, _PREHASH_ItemType, type);
-
-	S32 num_blocks = msg->getNumberOfBlocks("Data");
-
-	for (S32 block=0; block<num_blocks; ++block)
-	{
-		U32 X, Y;
-		std::string name;
-		S32 extra, extra2;
-		LLUUID uuid;
-		msg->getU32Fast(_PREHASH_Data, _PREHASH_X, X, block);
-		msg->getU32Fast(_PREHASH_Data, _PREHASH_Y, Y, block);
-		msg->getStringFast(_PREHASH_Data, _PREHASH_Name, name, block);
-		msg->getUUIDFast(_PREHASH_Data, _PREHASH_ID, uuid, block);
-		msg->getS32Fast(_PREHASH_Data, _PREHASH_Extra, extra, block);
-		msg->getS32Fast(_PREHASH_Data, _PREHASH_Extra2, extra2, block);
-
-		F32 world_x = (F32)X;
-		X /= REGION_WIDTH_UNITS;
-		F32 world_y = (F32)Y;
-		Y /= REGION_WIDTH_UNITS;
-		
-		LLItemInfo new_item(world_x, world_y, name, uuid, extra, extra2);
-		LLSimInfo* siminfo = LLWorldMap::getInstance()->simInfoFromHandle(new_item.mRegionHandle);
-
-		switch (type)
-		{
-			case MAP_ITEM_TELEHUB: // telehubs
+			else if (type == MAP_ITEM_MATURE_EVENT)
 			{
-				// Telehub color, store in extra as 4 U8's
-				U8 *color = (U8 *)&new_item.mExtra;
-
-				F32 red = fmod((F32)X * 0.11f, 1.f) * 0.8f;
-				F32 green = fmod((F32)Y * 0.11f, 1.f) * 0.8f;
-				F32 blue = fmod(1.5f * (F32)(X + Y) * 0.11f, 1.f) * 0.8f;
-				F32 add_amt = (X % 2) ? 0.15f : -0.15f;
-				add_amt += (Y % 2) ? -0.15f : 0.15f;
-				color[0] = U8((red + add_amt) * 255);
-				color[1] = U8((green + add_amt) * 255);
-				color[2] = U8((blue + add_amt) * 255);
-				color[3] = 255;
-				
-				// extra2 specifies whether this is an infohub or a telehub.
-				if (extra2)
-				{
-					LLWorldMap::getInstance()->mInfohubs.push_back(new_item);
-				}
-				else
-				{
-					LLWorldMap::getInstance()->mTelehubs.push_back(new_item);
-				}
-
-				break;
+				siminfo->insertMatureEvent(new_item);
 			}
-			case MAP_ITEM_PG_EVENT: // events
-			case MAP_ITEM_MATURE_EVENT:
-			case MAP_ITEM_ADULT_EVENT:
+			else if (type == MAP_ITEM_ADULT_EVENT)
 			{
-				std::string timeStr = "["+ LLTrans::getString ("TimeHour")+"]:["
-					                   +LLTrans::getString ("TimeMin")+"] ["
-									   +LLTrans::getString ("TimeAMPM")+"]";
-				LLSD substitution;
-				substitution["datetime"] = (S32) extra;
-				LLStringUtil::format (timeStr, substitution);
-				new_item.mToolTip = timeStr;
-
-				// HACK: store Z in extra2
-				new_item.mPosGlobal.mdV[VZ] = (F64)extra2;
-				if (type == MAP_ITEM_PG_EVENT)
-				{
-					LLWorldMap::getInstance()->mPGEvents.push_back(new_item);
-				}
-				else if (type == MAP_ITEM_MATURE_EVENT)
-				{
-					LLWorldMap::getInstance()->mMatureEvents.push_back(new_item);
-				}
-				else if (type == MAP_ITEM_ADULT_EVENT)
-				{
-					LLWorldMap::getInstance()->mAdultEvents.push_back(new_item);
-				}
-
-				break;
+				siminfo->insertAdultEvent(new_item);
 			}
-			case MAP_ITEM_LAND_FOR_SALE: // land for sale
-			case MAP_ITEM_LAND_FOR_SALE_ADULT: // adult land for sale 
+			break;
+		}
+		case MAP_ITEM_LAND_FOR_SALE:		// land for sale
+		case MAP_ITEM_LAND_FOR_SALE_ADULT:	// adult land for sale 
+		{
+			std::string tooltip = llformat("%d sq. m. L$%d", extra, extra2);
+			new_item.setTooltip(tooltip);
+			if (type == MAP_ITEM_LAND_FOR_SALE)
 			{
-				new_item.mToolTip = llformat("%d sq. m. L$%d", new_item.mExtra, new_item.mExtra2);
-				if (type == MAP_ITEM_LAND_FOR_SALE)
-				{
-					LLWorldMap::getInstance()->mLandForSale.push_back(new_item);
-				}
-				else if (type == MAP_ITEM_LAND_FOR_SALE_ADULT)
-				{
-					LLWorldMap::getInstance()->mLandForSaleAdult.push_back(new_item);
-				}
-				break;
+				siminfo->insertLandForSale(new_item);
 			}
-			case MAP_ITEM_CLASSIFIED: // classifieds
+			else if (type == MAP_ITEM_LAND_FOR_SALE_ADULT)
 			{
-				//DEPRECATED: no longer used
-				break;
+				siminfo->insertLandForSaleAdult(new_item);
 			}
-			case MAP_ITEM_AGENT_LOCATIONS: // agent locations
+			break;
+		}
+		case MAP_ITEM_CLASSIFIED: // classifieds
+		{
+			//DEPRECATED: no longer used
+			break;
+		}
+		case MAP_ITEM_AGENT_LOCATIONS: // agent locations
+		{
+// 				LL_INFOS("World Map") << "New Location " << new_item.mName << LL_ENDL;
+			if (extra > 0)
 			{
-				if (!siminfo)
-				{
-					llinfos << "siminfo missing for " << new_item.mPosGlobal.mdV[0] << ", " << new_item.mPosGlobal.mdV[1] << llendl;
-					break;
-				}
-// 				llinfos << "New Location " << new_item.mName << llendl;
-
-				item_info_list_t& agentcounts = LLWorldMap::getInstance()->mAgentLocationsMap[new_item.mRegionHandle];
-
-				// Find the last item in the list with a different name and erase them
-				item_info_list_t::iterator lastiter;
-				for (lastiter = agentcounts.begin(); lastiter!=agentcounts.end(); ++lastiter)
-				{
-					const LLItemInfo& info = *lastiter;
-					if (info.mName == new_item.mName)
-					{
-						break;
-					}
-				}
-				if (lastiter != agentcounts.begin())
-				{
-					agentcounts.erase(agentcounts.begin(), lastiter);
-				}
-				// Now append the new location
-				if (new_item.mExtra > 0)
-				{
-					agentcounts.push_back(new_item);
-				}
-				break;
+				new_item.setCount(extra);
+				siminfo->insertAgentLocation(new_item);
 			}
-			default:
-				break;
-		};
-	}
-}
-
-void LLWorldMap::dump()
-{
-	for (sim_info_map_t::iterator it = mSimInfoMap.begin(); it != mSimInfoMap.end(); ++it)
-	{
-		U64 handle = (*it).first;
-		LLSimInfo* info = (*it).second;
-
-		U32 x_pos, y_pos;
-		from_region_handle(handle, &x_pos, &y_pos);
-
-		llinfos << x_pos << "," << y_pos
-			<< " " << info->mName 
-			<< " " << (S32)info->mAccess
-			<< " " << std::hex << info->mRegionFlags << std::dec
-			<< " " << info->mWaterHeight
-			//<< " " << info->mTelehubName
-			//<< " " << info->mTelehubPosition
-			<< llendl;
-
-		if (info->mCurrentImage)
-		{
-			llinfos << "image discard " << (S32)info->mCurrentImage->getDiscardLevel()
-					<< " fullwidth " << info->mCurrentImage->getFullWidth()
-					<< " fullheight " << info->mCurrentImage->getFullHeight()
-					<< " maxvirt " << info->mCurrentImage->getMaxVirtualSize()
-					//<< " maxdisc " << (S32)info->mCurrentImage->getMaxDiscardLevel()
-					<< llendl;
+			break;
 		}
+		default:
+			break;
 	}
+	return true;
 }
 
-
-BOOL LLWorldMap::extendAABB(U32 min_x, U32 min_y, U32 max_x, U32 max_y)
+bool LLWorldMap::isTrackingInRectangle(F64 x0, F64 y0, F64 x1, F64 y1)
 {
-	BOOL rv = FALSE;
-	if (min_x < mMinX)
-	{
-		rv = TRUE;
-		mMinX = min_x;
-	}
-	if (min_y < mMinY)
-	{
-		rv = TRUE;
-		mMinY = min_y;
-	}
-	if (max_x > mMaxX)
-	{
-		rv = TRUE;
-		mMaxX = max_x;
-	}
-	if (max_y > mMaxY)
-	{
-		rv = TRUE;
-		mMaxY = max_y;
-	}
-	lldebugs << "World map aabb: (" << mMinX << ", " << mMinY << "), ("
-			 << mMaxX << ", " << mMaxY << ")" << llendl;
-	return rv;
+	if (!mIsTrackingLocation)
+		return false;
+	return ((mTrackingLocation[0] >= x0) && (mTrackingLocation[0] < x1) && (mTrackingLocation[1] >= y0) && (mTrackingLocation[1] < y1));
 }
 
-
-U32 LLWorldMap::getWorldWidth() const
+// Drop priority of all images being fetched by the map
+void LLWorldMap::dropImagePriorities()
 {
-	return mMaxX - mMinX;
-}
-
-
-U32 LLWorldMap::getWorldHeight() const
-{
-	return mMaxY - mMinY;
-}
-
-BOOL LLWorldMap::coveredByTelehub(LLSimInfo* infop)
-{
-	/*if (!mTelehubCoverageMap)
+	// Drop the download of tiles priority to nil
+	mWorldMipmap.dropBoostLevels();
+	// Same for the "land for sale" tiles per region
+	for (sim_info_map_t::iterator it = mSimInfoMap.begin(); it != mSimInfoMap.end(); ++it)
 	{
-		return FALSE;
+		LLSimInfo* info = it->second;
+		info->dropImagePriority();
 	}
-	U32 x_pos, y_pos;
-	from_region_handle(infop->mHandle, &x_pos, &y_pos);
-	x_pos /= REGION_WIDTH_UNITS;
-	y_pos /= REGION_WIDTH_UNITS;
-
-	S32 index = x_pos - (mMinX / REGION_WIDTH_UNITS - 1) + (mNeighborMapWidth * (y_pos - (mMinY / REGION_WIDTH_UNITS - 1)));
-	return mTelehubCoverageMap[index] != 0;	*/
-	return FALSE;
 }
 
-void LLWorldMap::updateTelehubCoverage()
+// Load all regions in a given rectangle (in region grid coordinates, i.e. world / 256 meters)
+void LLWorldMap::updateRegions(S32 x0, S32 y0, S32 x1, S32 y1)
 {
-	/*S32 neighbor_width = getWorldWidth() / REGION_WIDTH_UNITS + 2;
-	S32 neighbor_height = getWorldHeight() / REGION_WIDTH_UNITS + 2;
-	if (neighbor_width > mNeighborMapWidth || neighbor_height > mNeighborMapHeight)
-	{
-		mNeighborMapWidth = neighbor_width;
-		mNeighborMapHeight = neighbor_height;
-		delete mNeighborMap;
-		delete mTelehubCoverageMap;
-
-		mNeighborMap = new U8[mNeighborMapWidth * mNeighborMapHeight];
-		mTelehubCoverageMap = new U8[mNeighborMapWidth * mNeighborMapHeight];
-	}
-
-	memset(mNeighborMap, 0, mNeighborMapWidth * mNeighborMapHeight * sizeof(U8));
-	memset(mTelehubCoverageMap, 0, mNeighborMapWidth * mNeighborMapHeight * sizeof(U8));
+	// Convert those boundaries to the corresponding (MAP_BLOCK_SIZE x MAP_BLOCK_SIZE) block coordinates
+	x0 = x0 / MAP_BLOCK_SIZE;
+	x1 = x1 / MAP_BLOCK_SIZE;
+	y0 = y0 / MAP_BLOCK_SIZE;
+	y1 = y1 / MAP_BLOCK_SIZE;
 
-	// leave 1 sim border
-	S32 min_x = (mMinX / REGION_WIDTH_UNITS) - 1;
-	S32 min_y = (mMinY / REGION_WIDTH_UNITS) - 1;
-
- 	std::map<U64, LLSimInfo*>::const_iterator it;
-	for (it = mSimInfoMap.begin(); it != mSimInfoMap.end(); ++it)
+	// Load the region info those blocks
+	for (S32 block_x = llmax(x0, 0); block_x <= llmin(x1, MAP_BLOCK_RES-1); ++block_x)
 	{
-		U64 handle = (*it).first;
-		//LLSimInfo* info = (*it).second;
-
-		U32 x_pos, y_pos;
-		from_region_handle(handle, &x_pos, &y_pos);
-		x_pos /= REGION_WIDTH_UNITS;
-		y_pos /= REGION_WIDTH_UNITS;
-		x_pos -= min_x;
-		y_pos -= min_y;
-
-		S32 index = x_pos + (mNeighborMapWidth * y_pos);
-		mNeighborMap[index - 1]++;
-		mNeighborMap[index + 1]++;
-		mNeighborMap[index - mNeighborMapWidth]++;
-		mNeighborMap[index + mNeighborMapWidth]++;
-	}
-
-	for (it = mSimInfoMap.begin(); it != mSimInfoMap.end(); ++it)
-	{
-		U64 handle = (*it).first;
-		LLSimInfo* info = (*it).second;
-
-		U32 x_pos, y_pos;
-		from_region_handle(handle, &x_pos, &y_pos);
-		x_pos /= REGION_WIDTH_UNITS;
-		y_pos /= REGION_WIDTH_UNITS;
-		x_pos -= min_x;
-		y_pos -= min_y;
-
-		S32 index = x_pos + (mNeighborMapWidth * y_pos);
-
-		if (!info->mTelehubName.empty() && mNeighborMap[index])
+		for (S32 block_y = llmax(y0, 0); block_y <= llmin(y1, MAP_BLOCK_RES-1); ++block_y)
 		{
-			S32 x_start = llmax(0, S32(x_pos - 5));
-			S32 x_span = llmin(mNeighborMapWidth - 1, (S32)(x_pos + 5)) - x_start + 1;
-			S32 y_start = llmax(0, (S32)y_pos - 5);
-			S32 y_end = llmin(mNeighborMapHeight - 1, (S32)(y_pos + 5));
-			for (S32 y_index = y_start; y_index <= y_end; y_index++)
+			S32 offset = block_x | (block_y * MAP_BLOCK_RES);
+			if (!mMapBlockLoaded[offset])
 			{
-				memset(&mTelehubCoverageMap[x_start + y_index * mNeighborMapWidth], 0xff, sizeof(U8) * x_span);
+ 				//LL_INFOS("World Map") << "Loading Block (" << block_x << "," << block_y << ")" << LL_ENDL;
+				LLWorldMapMessage::getInstance()->sendMapBlockRequest(block_x * MAP_BLOCK_SIZE, block_y * MAP_BLOCK_SIZE, (block_x * MAP_BLOCK_SIZE) + MAP_BLOCK_SIZE - 1, (block_y * MAP_BLOCK_SIZE) + MAP_BLOCK_SIZE - 1);
+				mMapBlockLoaded[offset] = true;
 			}
 		}
 	}
+}
 
-	for (it = mSimInfoMap.begin(); it != mSimInfoMap.end(); ++it)
+void LLWorldMap::dump()
+{
+	LL_INFOS("World Map") << "LLWorldMap::dump()" << LL_ENDL;
+	for (sim_info_map_t::iterator it = mSimInfoMap.begin(); it != mSimInfoMap.end(); ++it)
 	{
-		U64 handle = (*it).first;
-		//LLSimInfo* info = (*it).second;
-
-		U32 x_pos, y_pos;
-		from_region_handle(handle, &x_pos, &y_pos);
-		x_pos /= REGION_WIDTH_UNITS;
-		y_pos /= REGION_WIDTH_UNITS;
-
-		S32 index = x_pos - min_x + (mNeighborMapWidth * (y_pos - min_y));
-		mTelehubCoverageMap[index] *= mNeighborMap[index];
-	}*/
+		LLSimInfo* info = it->second;
+		if (info)
+		{
+			info->dump();
+		}
+	}
 }
+