PATH-580: BUGFIX Adding functionality to detect when the region's capabilities have not yet been loading and deferring requests for the navmesh query until the capabilities are fully loaded.

9 files changed, 1606 insertions, 1550 deletions

diff --git a/indra/newview/llfloaterpathfindingconsole.cpp b/indra/newview/llfloaterpathfindingconsole.cpp
index e89d0c2cab..ca78042c2b 100644
--- a/indra/newview/llfloaterpathfindingconsole.cpp
+++ b/indra/newview/llfloaterpathfindingconsole.cpp
@@ -605,6 +605,9 @@ void LLFloaterPathfindingConsole::onNavMeshZoneCB(LLPathfindingNavMeshZone::ENav
 	case LLPathfindingNavMeshZone::kNavMeshZoneRequestUnknown :
 		setConsoleState(kConsoleStateUnknown);
 		break;
+	case LLPathfindingNavMeshZone::kNavMeshZoneRequestWaiting :
+		setConsoleState(kConsoleStateRegionLoading);
+		break;
 	case LLPathfindingNavMeshZone::kNavMeshZoneRequestChecking :
 		setConsoleState(kConsoleStateCheckingVersion);
 		break;
@@ -723,6 +726,7 @@ void LLFloaterPathfindingConsole::updateControlsOnConsoleState()
 	{
 	case kConsoleStateUnknown :
 	case kConsoleStateRegionNotEnabled :
+	case kConsoleStateRegionLoading :
 		mShowLabel->setEnabled(FALSE);
 		mShowWorldCheckBox->setEnabled(FALSE);
 		mShowWorldMovablesOnlyCheckBox->setEnabled(FALSE);
@@ -857,6 +861,11 @@ void LLFloaterPathfindingConsole::updateStatusOnConsoleState()
 		viewerStatusText = getString("navmesh_viewer_status_region_not_enabled");
 		viewerStyleParams.color = errorColor;
 		break;
+	case kConsoleStateRegionLoading :
+		simulatorStatusText = getString("navmesh_simulator_status_unknown");
+		viewerStatusText = getString("navmesh_viewer_status_region_loading");
+		viewerStyleParams.color = warningColor;
+		break;
 	case kConsoleStateCheckingVersion :
 		simulatorStatusText = getString("navmesh_simulator_status_unknown");
 		viewerStatusText = getString("navmesh_viewer_status_checking_version");
diff --git a/indra/newview/llfloaterpathfindingconsole.h b/indra/newview/llfloaterpathfindingconsole.h
index fcb13955c3..3fdadfafad 100644
--- a/indra/newview/llfloaterpathfindingconsole.h
+++ b/indra/newview/llfloaterpathfindingconsole.h
@@ -103,6 +103,7 @@ private:
 		kConsoleStateUnknown,
 		kConsoleStateLibraryNotImplemented,
 		kConsoleStateRegionNotEnabled,
+		kConsoleStateRegionLoading,
 		kConsoleStateCheckingVersion,
 		kConsoleStateDownloading,
 		kConsoleStateHasNavMesh,
diff --git a/indra/newview/llpathfindingmanager.cpp b/indra/newview/llpathfindingmanager.cpp
index cefff175a3..e754e77588 100644
--- a/indra/newview/llpathfindingmanager.cpp
+++ b/indra/newview/llpathfindingmanager.cpp
@@ -1,982 +1,1002 @@
-/** 

- * @file llpathfindingmanager.cpp

- * @author William Todd Stinson

- * @brief A state manager for the various pathfinding states.

- *

- * $LicenseInfo:firstyear=2002&license=viewerlgpl$

- * Second Life Viewer Source Code

- * Copyright (C) 2010, Linden Research, Inc.

- * 

- * This library is free software; you can redistribute it and/or

- * modify it under the terms of the GNU Lesser General Public

- * License as published by the Free Software Foundation;

- * version 2.1 of the License only.

- * 

- * This library is distributed in the hope that it will be useful,

- * but WITHOUT ANY WARRANTY; without even the implied warranty of

- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

- * Lesser General Public License for more details.

- * 

- * You should have received a copy of the GNU Lesser General Public

- * License along with this library; if not, write to the Free Software

- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

- * 

- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA

- * $/LicenseInfo$

- */

-

-#include <string>

-#include <vector>

-

-#include "llviewerprecompiledheaders.h"

-#include "llsd.h"

-#include "lluuid.h"

-#include "llpathfindingmanager.h"

-#include "llsingleton.h"

-#include "llhttpclient.h"

-#include "llagent.h"

-#include "llviewerregion.h"

-#include "llpathfindingnavmesh.h"

-#include "llpathfindingnavmeshstatus.h"

-#include "llpathfindinglinkset.h"

-#include "llpathfindinglinksetlist.h"

-#include "llpathfindingcharacterlist.h"

-#include "llhttpnode.h"

-

-#include <boost/function.hpp>

-#include <boost/signals2.hpp>

-

-#define CAP_SERVICE_RETRIEVE_NAVMESH  "RetrieveNavMeshSrc"

-

-#define CAP_SERVICE_NAVMESH_STATUS "NavMeshGenerationStatus"

-

-#define CAP_SERVICE_AGENT_STATE     "AgentPreferences"

-#define ALTER_NAVMESH_OBJECTS_FIELD "alter_navmesh_objects"

-#define DEPRECATED_ALTER_NAVMESH_OBJECTS_FIELD "alter_permanent_objects"

-

-#define CAP_SERVICE_OBJECT_LINKSETS  "ObjectNavMeshProperties"

-#define CAP_SERVICE_TERRAIN_LINKSETS "TerrainNavMeshProperties"

-

-#define CAP_SERVICE_CHARACTERS  "CharacterProperties"

-

-#define SIM_MESSAGE_NAVMESH_STATUS_UPDATE "/message/NavMeshStatusUpdate"

-#define SIM_MESSAGE_AGENT_STATE_UPDATE    "/message/AgentPreferencesUpdate"

-#define SIM_MESSAGE_BODY_FIELD            "body"

-

-//---------------------------------------------------------------------------

-// LLNavMeshSimStateChangeNode

-//---------------------------------------------------------------------------

-

-class LLNavMeshSimStateChangeNode : public LLHTTPNode

-{

-public:

-	virtual void post(ResponsePtr pResponse, const LLSD &pContext, const LLSD &pInput) const;

-};

-

-LLHTTPRegistration<LLNavMeshSimStateChangeNode> gHTTPRegistrationNavMeshSimStateChangeNode(SIM_MESSAGE_NAVMESH_STATUS_UPDATE);

-

-//---------------------------------------------------------------------------

-// LLAgentStateChangeNode

-//---------------------------------------------------------------------------

-

-class LLAgentStateChangeNode : public LLHTTPNode

-{

-public:

-	virtual void post(ResponsePtr pResponse, const LLSD &pContext, const LLSD &pInput) const;

-};

-

-LLHTTPRegistration<LLAgentStateChangeNode> gHTTPRegistrationAgentStateChangeNode(SIM_MESSAGE_AGENT_STATE_UPDATE);

-

-//---------------------------------------------------------------------------

-// NavMeshStatusResponder

-//---------------------------------------------------------------------------

-

-class NavMeshStatusResponder : public LLHTTPClient::Responder

-{

-public:

-	NavMeshStatusResponder(const std::string &pCapabilityURL, LLViewerRegion *pRegion);

-	virtual ~NavMeshStatusResponder();

-

-	virtual void result(const LLSD &pContent);

-	virtual void error(U32 pStatus, const std::string& pReason);

-

-protected:

-

-private:

-	std::string    mCapabilityURL;

-	LLViewerRegion *mRegion;

-	LLUUID         mRegionUUID;

-};

-

-//---------------------------------------------------------------------------

-// NavMeshResponder

-//---------------------------------------------------------------------------

-

-class NavMeshResponder : public LLHTTPClient::Responder

-{

-public:

-	NavMeshResponder(const std::string &pCapabilityURL, U32 pNavMeshVersion, LLPathfindingNavMeshPtr pNavMeshPtr);

-	virtual ~NavMeshResponder();

-

-	virtual void result(const LLSD &pContent);

-	virtual void error(U32 pStatus, const std::string& pReason);

-

-protected:

-

-private:

-	std::string             mCapabilityURL;

-	U32                     mNavMeshVersion;

-	LLPathfindingNavMeshPtr mNavMeshPtr;

-};

-

-//---------------------------------------------------------------------------

-// AgentStateResponder

-//---------------------------------------------------------------------------

-

-class AgentStateResponder : public LLHTTPClient::Responder

-{

-public:

-	AgentStateResponder(const std::string &pCapabilityURL, LLPathfindingManager::EAgentState pRequestedAgentState = LLPathfindingManager::kAgentStateUnknown);

-	virtual ~AgentStateResponder();

-

-	virtual void result(const LLSD &pContent);

-	virtual void error(U32 pStatus, const std::string& pReason);

-

-protected:

-

-private:

-	std::string                       mCapabilityURL;

-	LLPathfindingManager::EAgentState mRequestedAgentState;

-};

-

-//---------------------------------------------------------------------------

-// LinksetsResponder

-//---------------------------------------------------------------------------

-

-class LinksetsResponder

-{

-public:

-	LinksetsResponder(LLPathfindingManager::request_id_t pRequestId, LLPathfindingManager::linksets_callback_t pLinksetsCallback, bool pIsObjectRequested, bool pIsTerrainRequested);

-	virtual ~LinksetsResponder();

-	

-	void handleObjectLinksetsResult(const LLSD &pContent);

-	void handleObjectLinksetsError(U32 pStatus, const std::string &pReason, const std::string &pURL);

-	void handleTerrainLinksetsResult(const LLSD &pContent);

-	void handleTerrainLinksetsError(U32 pStatus, const std::string &pReason, const std::string &pURL);

-	

-protected:

-

-private:

-	void sendCallback();

-

-	typedef enum

-	{

-		kNotRequested,

-		kWaiting,

-		kReceivedGood,

-		kReceivedError

-	} EMessagingState;

-	

-	LLPathfindingManager::request_id_t        mRequestId;

-	LLPathfindingManager::linksets_callback_t mLinksetsCallback;

-	

-	EMessagingState                           mObjectMessagingState;

-	EMessagingState                           mTerrainMessagingState;

-	

-	LLPathfindingLinksetListPtr               mObjectLinksetListPtr;

-	LLPathfindingLinksetPtr                   mTerrainLinksetPtr;

-};

-

-typedef boost::shared_ptr<LinksetsResponder> LinksetsResponderPtr;

-

-//---------------------------------------------------------------------------

-// ObjectLinksetsResponder

-//---------------------------------------------------------------------------

-

-class ObjectLinksetsResponder : public LLHTTPClient::Responder

-{

-public:

-	ObjectLinksetsResponder(const std::string &pCapabilityURL, LinksetsResponderPtr pLinksetsResponsderPtr);

-	virtual ~ObjectLinksetsResponder();

-	

-	virtual void result(const LLSD &pContent);

-	virtual void error(U32 pStatus, const std::string &pReason);

-	

-protected:

-	

-private:

-	std::string          mCapabilityURL;

-	LinksetsResponderPtr mLinksetsResponsderPtr;

-};

-

-//---------------------------------------------------------------------------

-// TerrainLinksetsResponder

-//---------------------------------------------------------------------------

-

-class TerrainLinksetsResponder : public LLHTTPClient::Responder

-{

-public:

-	TerrainLinksetsResponder(const std::string &pCapabilityURL, LinksetsResponderPtr pLinksetsResponsderPtr);

-	virtual ~TerrainLinksetsResponder();

-	

-	virtual void result(const LLSD &pContent);

-	virtual void error(U32 pStatus, const std::string &pReason);

-	

-protected:

-	

-private:

-	std::string          mCapabilityURL;

-	LinksetsResponderPtr mLinksetsResponsderPtr;

-};

-

-//---------------------------------------------------------------------------

-// CharactersResponder

-//---------------------------------------------------------------------------

-

-class CharactersResponder : public LLHTTPClient::Responder

-{

-public:

-	CharactersResponder(const std::string &pCapabilityURL, LLPathfindingManager::request_id_t pRequestId, LLPathfindingManager::characters_callback_t pCharactersCallback);

-	virtual ~CharactersResponder();

-	

-	virtual void result(const LLSD &pContent);

-	virtual void error(U32 pStatus, const std::string &pReason);

-	

-protected:

-	

-private:

-	std::string                                 mCapabilityURL;

-	LLPathfindingManager::request_id_t          mRequestId;

-	LLPathfindingManager::characters_callback_t mCharactersCallback;

-};

-

-//---------------------------------------------------------------------------

-// LLPathfindingManager

-//---------------------------------------------------------------------------

-

-LLPathfindingManager::LLPathfindingManager()

-	: LLSingleton<LLPathfindingManager>(),

-	mNavMeshMap(),

-	mAgentStateSignal(),

-	mAgentState(kAgentStateUnknown),

-	mLastKnownNonErrorAgentState(kAgentStateUnknown)

-{

-}

-

-LLPathfindingManager::~LLPathfindingManager()

-{

-}

-

-bool LLPathfindingManager::isPathfindingEnabledForCurrentRegion() const

-{

-	return isPathfindingEnabledForRegion(getCurrentRegion());

-}

-

-bool LLPathfindingManager::isPathfindingEnabledForRegion(LLViewerRegion *pRegion) const

-{

-	std::string retrieveNavMeshURL = getRetrieveNavMeshURLForRegion(pRegion);

-	return !retrieveNavMeshURL.empty();

-}

-

-#ifdef DEPRECATED_UNVERSIONED_NAVMESH

-bool LLPathfindingManager::isPathfindingNavMeshVersioningEnabledForCurrentRegionXXX() const

-{

-	std::string navMeshStatusURL = getNavMeshStatusURLForRegion(getCurrentRegion());

-	return !navMeshStatusURL.empty();

-}

-#endif // DEPRECATED_UNVERSIONED_NAVMESH

-

-bool LLPathfindingManager::isAllowAlterPermanent()

-{

-	return (!isPathfindingEnabledForCurrentRegion() || (getAgentState() == kAgentStateUnfrozen));

-}

-

-bool LLPathfindingManager::isAllowViewTerrainProperties() const

-{

-	LLViewerRegion* region = getCurrentRegion();

-	return (gAgent.isGodlike() || ((region != NULL) && region->canManageEstate()));

-}

-

-LLPathfindingNavMesh::navmesh_slot_t LLPathfindingManager::registerNavMeshListenerForRegion(LLViewerRegion *pRegion, LLPathfindingNavMesh::navmesh_callback_t pNavMeshCallback)

-{

-	LLPathfindingNavMeshPtr navMeshPtr = getNavMeshForRegion(pRegion);

-	return navMeshPtr->registerNavMeshListener(pNavMeshCallback);

-}

-

-void LLPathfindingManager::requestGetNavMeshForRegion(LLViewerRegion *pRegion)

-{

-	LLPathfindingNavMeshPtr navMeshPtr = getNavMeshForRegion(pRegion);

-

-	if ((pRegion == NULL) || !isPathfindingEnabledForRegion(pRegion))

-	{

-		navMeshPtr->handleNavMeshNotEnabled();

-	}

-	else

-	{

-		std::string navMeshStatusURL = getNavMeshStatusURLForRegion(pRegion);

-#ifdef DEPRECATED_UNVERSIONED_NAVMESH

-		if (navMeshStatusURL.empty())

-		{

-			LLPathfindingNavMeshStatus navMeshStatus = navMeshPtr->getNavMeshStatusXXX();

-			navMeshStatus.incrementNavMeshVersionXXX();

-			sendRequestGetNavMeshForRegion(navMeshPtr, pRegion, navMeshStatus);

-		}

-		else

-		{

-			navMeshPtr->handleNavMeshCheckVersion();

-			LLHTTPClient::ResponderPtr navMeshStatusResponder = new NavMeshStatusResponder(navMeshStatusURL, pRegion);

-			LLHTTPClient::get(navMeshStatusURL, navMeshStatusResponder);

-		}

-#else // DEPRECATED_UNVERSIONED_NAVMESH

-		llassert(!navMeshStatusURL.empty());

-		navMeshPtr->handleNavMeshCheckVersion();

-		LLHTTPClient::ResponderPtr navMeshStatusResponder = new NavMeshStatusResponder(navMeshStatusURL, pRegion);

-		LLHTTPClient::get(navMeshStatusURL, navMeshStatusResponder);

-#endif // DEPRECATED_UNVERSIONED_NAVMESH

-	}

-}

-

-LLPathfindingManager::agent_state_slot_t LLPathfindingManager::registerAgentStateListener(agent_state_callback_t pAgentStateCallback)

-{

-	return mAgentStateSignal.connect(pAgentStateCallback);

-}

-

-LLPathfindingManager::EAgentState LLPathfindingManager::getAgentState()

-{

-	if (!isPathfindingEnabledForCurrentRegion())

-	{

-		setAgentState(kAgentStateNotEnabled);

-	}

-	else

-	{

-		if (!isValidAgentState(mAgentState))

-		{

-			requestGetAgentState();

-		}

-	}

-

-	return mAgentState;

-}

-

-LLPathfindingManager::EAgentState LLPathfindingManager::getLastKnownNonErrorAgentState() const

-{

-	return mLastKnownNonErrorAgentState;

-}

-

-void LLPathfindingManager::requestSetAgentState(EAgentState pRequestedAgentState)

-{

-	llassert(isValidAgentState(pRequestedAgentState));

-	std::string agentStateURL = getAgentStateURLForCurrentRegion();

-

-	if (agentStateURL.empty())

-	{

-		setAgentState(kAgentStateNotEnabled);

-	}

-	else

-	{

-		LLSD request;

-		request[ALTER_NAVMESH_OBJECTS_FIELD] = static_cast<LLSD::Boolean>(pRequestedAgentState == kAgentStateUnfrozen);

-#ifdef DEPRECATED_ALTER_NAVMESH_OBJECTS_FIELD

-		request[DEPRECATED_ALTER_NAVMESH_OBJECTS_FIELD] = static_cast<LLSD::Boolean>(pRequestedAgentState == kAgentStateUnfrozen);

-#endif // DEPRECATED_ALTER_NAVMESH_OBJECTS_FIELD

-

-		LLHTTPClient::ResponderPtr responder = new AgentStateResponder(agentStateURL, pRequestedAgentState);

-		LLHTTPClient::post(agentStateURL, request, responder);

-	}

-}

-

-LLPathfindingManager::ERequestStatus LLPathfindingManager::requestGetLinksets(request_id_t pRequestId, linksets_callback_t pLinksetsCallback) const

-{

-	ERequestStatus status;

-

-	std::string objectLinksetsURL = getObjectLinksetsURLForCurrentRegion();

-	std::string terrainLinksetsURL = getTerrainLinksetsURLForCurrentRegion();

-	if (objectLinksetsURL.empty() || terrainLinksetsURL.empty())

-	{

-		status = kRequestNotEnabled;

-	}

-	else

-	{

-		bool doRequestTerrain = isAllowViewTerrainProperties();

-		LinksetsResponderPtr linksetsResponderPtr(new LinksetsResponder(pRequestId, pLinksetsCallback, true, doRequestTerrain));

-		

-		LLHTTPClient::ResponderPtr objectLinksetsResponder = new ObjectLinksetsResponder(objectLinksetsURL, linksetsResponderPtr);

-		LLHTTPClient::get(objectLinksetsURL, objectLinksetsResponder);

-

-		if (doRequestTerrain)

-		{

-			LLHTTPClient::ResponderPtr terrainLinksetsResponder = new TerrainLinksetsResponder(terrainLinksetsURL, linksetsResponderPtr);

-			LLHTTPClient::get(terrainLinksetsURL, terrainLinksetsResponder);

-		}

-

-		status = kRequestStarted;

-	}

-

-	return status;

-}

-

-LLPathfindingManager::ERequestStatus LLPathfindingManager::requestSetLinksets(request_id_t pRequestId, LLPathfindingLinksetListPtr pLinksetList, LLPathfindingLinkset::ELinksetUse pLinksetUse, S32 pA, S32 pB, S32 pC, S32 pD, linksets_callback_t pLinksetsCallback) const

-{

-	ERequestStatus status = kRequestNotEnabled;

-

-	std::string objectLinksetsURL = getObjectLinksetsURLForCurrentRegion();

-	std::string terrainLinksetsURL = getTerrainLinksetsURLForCurrentRegion();

-	if (objectLinksetsURL.empty() || terrainLinksetsURL.empty())

-	{

-		status = kRequestNotEnabled;

-	}

-	else

-	{

-		LLSD objectPostData = pLinksetList->encodeObjectFields(pLinksetUse, pA, pB, pC, pD);

-		LLSD terrainPostData;

-		if (isAllowViewTerrainProperties())

-		{

-			terrainPostData = pLinksetList->encodeTerrainFields(pLinksetUse, pA, pB, pC, pD);

-		}

-

-		if (objectPostData.isUndefined() && terrainPostData.isUndefined())

-		{

-			status = kRequestCompleted;

-		}

-		else

-		{

-			LinksetsResponderPtr linksetsResponderPtr(new LinksetsResponder(pRequestId, pLinksetsCallback, !objectPostData.isUndefined(), !terrainPostData.isUndefined()));

-

-			if (!objectPostData.isUndefined())

-			{

-				LLHTTPClient::ResponderPtr objectLinksetsResponder = new ObjectLinksetsResponder(objectLinksetsURL, linksetsResponderPtr);

-				LLHTTPClient::put(objectLinksetsURL, objectPostData, objectLinksetsResponder);

-			}

-			

-			if (!terrainPostData.isUndefined())

-			{

-				LLHTTPClient::ResponderPtr terrainLinksetsResponder = new TerrainLinksetsResponder(terrainLinksetsURL, linksetsResponderPtr);

-				LLHTTPClient::put(terrainLinksetsURL, terrainPostData, terrainLinksetsResponder);

-			}

-

-			status = kRequestStarted;

-		}

-	}

-

-	return status;

-}

-

-LLPathfindingManager::ERequestStatus LLPathfindingManager::requestGetCharacters(request_id_t pRequestId, characters_callback_t pCharactersCallback) const

-{

-	ERequestStatus status;

-

-	std::string charactersURL = getCharactersURLForCurrentRegion();

-	if (charactersURL.empty())

-	{

-		status = kRequestNotEnabled;

-	}

-	else

-	{

-		LLHTTPClient::ResponderPtr charactersResponder = new CharactersResponder(charactersURL, pRequestId, pCharactersCallback);

-		LLHTTPClient::get(charactersURL, charactersResponder);

-

-		status = kRequestStarted;

-	}

-

-	return status;

-}

-

-void LLPathfindingManager::sendRequestGetNavMeshForRegion(LLPathfindingNavMeshPtr navMeshPtr, LLViewerRegion *pRegion, const LLPathfindingNavMeshStatus &pNavMeshStatus)

-{

-	if ((pRegion == NULL) || !pRegion->isAlive())

-	{

-		navMeshPtr->handleNavMeshNotEnabled();

-	}

-	else

-	{

-		std::string navMeshURL = getRetrieveNavMeshURLForRegion(pRegion);

-

-		if (navMeshURL.empty())

-		{

-			navMeshPtr->handleNavMeshNotEnabled();

-		}

-		else

-		{

-			navMeshPtr->handleNavMeshStart(pNavMeshStatus);

-			LLHTTPClient::ResponderPtr responder = new NavMeshResponder(navMeshURL, pNavMeshStatus.getVersion(), navMeshPtr);

-

-			LLSD postData;

-			LLHTTPClient::post(navMeshURL, postData, responder);

-		}

-	}

-}

-

-void LLPathfindingManager::handleNavMeshStatusRequest(const LLPathfindingNavMeshStatus &pNavMeshStatus, LLViewerRegion *pRegion)

-{

-	LLPathfindingNavMeshPtr navMeshPtr = getNavMeshForRegion(pNavMeshStatus.getRegionUUID());

-

-	if (!pNavMeshStatus.isValid())

-	{

-		navMeshPtr->handleNavMeshError();

-	}

-	else

-	{

-		if (navMeshPtr->hasNavMeshVersion(pNavMeshStatus))

-		{

-			navMeshPtr->handleRefresh(pNavMeshStatus);

-		}

-		else

-		{

-			sendRequestGetNavMeshForRegion(navMeshPtr, pRegion, pNavMeshStatus);

-		}

-	}

-}

-

-void LLPathfindingManager::handleNavMeshStatusUpdate(const LLPathfindingNavMeshStatus &pNavMeshStatus)

-{

-	LLPathfindingNavMeshPtr navMeshPtr = getNavMeshForRegion(pNavMeshStatus.getRegionUUID());

-

-	if (!pNavMeshStatus.isValid())

-	{

-		navMeshPtr->handleNavMeshError();

-	}

-	else

-	{

-		navMeshPtr->handleNavMeshNewVersion(pNavMeshStatus);

-	}

-}

-

-LLPathfindingNavMeshPtr LLPathfindingManager::getNavMeshForRegion(const LLUUID &pRegionUUID)

-{

-	LLPathfindingNavMeshPtr navMeshPtr;

-	NavMeshMap::iterator navMeshIter = mNavMeshMap.find(pRegionUUID);

-	if (navMeshIter == mNavMeshMap.end())

-	{

-		navMeshPtr = LLPathfindingNavMeshPtr(new LLPathfindingNavMesh(pRegionUUID));

-		mNavMeshMap.insert(std::pair<LLUUID, LLPathfindingNavMeshPtr>(pRegionUUID, navMeshPtr));

-	}

-	else

-	{

-		navMeshPtr = navMeshIter->second;

-	}

-

-	return navMeshPtr;

-}

-

-LLPathfindingNavMeshPtr LLPathfindingManager::getNavMeshForRegion(LLViewerRegion *pRegion)

-{

-	LLUUID regionUUID;

-	if (pRegion != NULL)

-	{

-		regionUUID = pRegion->getRegionID();

-	}

-

-	return getNavMeshForRegion(regionUUID);

-}

-

-bool LLPathfindingManager::isValidAgentState(EAgentState pAgentState)

-{

-	return ((pAgentState == kAgentStateFrozen) || (pAgentState == kAgentStateUnfrozen));

-}

-

-void LLPathfindingManager::requestGetAgentState()

-{

-	std::string agentStateURL = getAgentStateURLForCurrentRegion();

-

-	if (agentStateURL.empty())

-	{

-		setAgentState(kAgentStateNotEnabled);

-	}

-	else

-	{

-		LLHTTPClient::ResponderPtr responder = new AgentStateResponder(agentStateURL);

-		LLHTTPClient::get(agentStateURL, responder);

-	}

-}

-

-void LLPathfindingManager::setAgentState(EAgentState pAgentState)

-{

-	mAgentState = pAgentState;

-

-	if (mAgentState != kAgentStateError)

-	{

-		mLastKnownNonErrorAgentState = mAgentState;

-	}

-

-	mAgentStateSignal(mAgentState);

-}

-

-void LLPathfindingManager::handleAgentStateResult(const LLSD &pContent, EAgentState pRequestedAgentState)

-{

-#ifndef DEPRECATED_ALTER_NAVMESH_OBJECTS_FIELD

-	llassert(pContent.has(ALTER_NAVMESH_OBJECTS_FIELD));

-	llassert(pContent.get(ALTER_NAVMESH_OBJECTS_FIELD).isBoolean());

-	EAgentState agentState = (pContent.get(ALTER_NAVMESH_OBJECTS_FIELD).asBoolean() ? kAgentStateUnfrozen : kAgentStateFrozen);

-#else // DEPRECATED_ALTER_NAVMESH_OBJECTS_FIELD

-	EAgentState agentState = kAgentStateUnknown;

-	if (pContent.has(ALTER_NAVMESH_OBJECTS_FIELD))

-	{

-		llassert(pContent.get(ALTER_NAVMESH_OBJECTS_FIELD).isBoolean());

-		agentState = (pContent.get(ALTER_NAVMESH_OBJECTS_FIELD).asBoolean() ? kAgentStateUnfrozen : kAgentStateFrozen);

-	}

-	else

-	{

-		llassert(pContent.has(DEPRECATED_ALTER_NAVMESH_OBJECTS_FIELD));

-		llassert(pContent.get(DEPRECATED_ALTER_NAVMESH_OBJECTS_FIELD).isBoolean());

-		agentState = (pContent.get(DEPRECATED_ALTER_NAVMESH_OBJECTS_FIELD).asBoolean() ? kAgentStateUnfrozen : kAgentStateFrozen);

-	}

-#endif // DEPRECATED_ALTER_NAVMESH_OBJECTS_FIELD

-

-	if (isValidAgentState(pRequestedAgentState) && (agentState != pRequestedAgentState))

-	{

-		agentState = kAgentStateError;

-		llassert(0);

-	}

-

-	setAgentState(agentState);

-}

-

-void LLPathfindingManager::handleAgentStateError(U32 pStatus, const std::string &pReason, const std::string &pURL)

-{

-	llwarns << "error with request to URL '" << pURL << "' because " << pReason << " (statusCode:" << pStatus << ")" << llendl;

-	setAgentState(kAgentStateError);

-}

-

-void LLPathfindingManager::handleAgentStateUpdate(const LLSD &pContent)

-{

-	llassert(pContent.has(ALTER_NAVMESH_OBJECTS_FIELD));

-	llassert(pContent.get(ALTER_NAVMESH_OBJECTS_FIELD).isBoolean());

-	EAgentState agentState = (pContent.get(ALTER_NAVMESH_OBJECTS_FIELD).asBoolean() ? kAgentStateUnfrozen : kAgentStateFrozen);

-

-	setAgentState(agentState);

-}

-

-std::string LLPathfindingManager::getNavMeshStatusURLForRegion(LLViewerRegion *pRegion) const

-{

-	return getCapabilityURLForRegion(pRegion, CAP_SERVICE_NAVMESH_STATUS);

-}

-

-std::string LLPathfindingManager::getRetrieveNavMeshURLForRegion(LLViewerRegion *pRegion) const

-{

-	return getCapabilityURLForRegion(pRegion, CAP_SERVICE_RETRIEVE_NAVMESH);

-}

-

-std::string LLPathfindingManager::getAgentStateURLForCurrentRegion() const

-{

-	return getCapabilityURLForCurrentRegion(CAP_SERVICE_AGENT_STATE);

-}

-

-std::string LLPathfindingManager::getObjectLinksetsURLForCurrentRegion() const

-{

-	return getCapabilityURLForCurrentRegion(CAP_SERVICE_OBJECT_LINKSETS);

-}

-

-std::string LLPathfindingManager::getTerrainLinksetsURLForCurrentRegion() const

-{

-	return getCapabilityURLForCurrentRegion(CAP_SERVICE_TERRAIN_LINKSETS);

-}

-

-std::string LLPathfindingManager::getCharactersURLForCurrentRegion() const

-{

-	return getCapabilityURLForCurrentRegion(CAP_SERVICE_CHARACTERS);

-}

-

-std::string LLPathfindingManager::getCapabilityURLForCurrentRegion(const std::string &pCapabilityName) const

-{

-	return getCapabilityURLForRegion(getCurrentRegion(), pCapabilityName);

-}

-

-std::string LLPathfindingManager::getCapabilityURLForRegion(LLViewerRegion *pRegion, const std::string &pCapabilityName) const

-{

-	std::string capabilityURL("");

-

-	if (pRegion != NULL)

-	{

-		capabilityURL = pRegion->getCapability(pCapabilityName);

-	}

-

-	if (capabilityURL.empty())

-	{

-		llwarns << "cannot find capability '" << pCapabilityName << "' for current region '"

-			<< ((pRegion != NULL) ? pRegion->getName() : "<null>") << "'" << llendl;

-	}

-

-	return capabilityURL;

-}

-

-LLViewerRegion *LLPathfindingManager::getCurrentRegion() const

-{

-	return gAgent.getRegion();

-}

-

-//---------------------------------------------------------------------------

-// LLNavMeshSimStateChangeNode

-//---------------------------------------------------------------------------

-

-void LLNavMeshSimStateChangeNode::post(ResponsePtr pResponse, const LLSD &pContext, const LLSD &pInput) const

-{

-#ifdef XXX_STINSON_DEBUG_NAVMESH_ZONE

-	llinfos << "STINSON DEBUG: Received NavMeshStatusUpdate: " << pInput << llendl;

-#endif // XXX_STINSON_DEBUG_NAVMESH_ZONE

-	llassert(pInput.has(SIM_MESSAGE_BODY_FIELD));

-	llassert(pInput.get(SIM_MESSAGE_BODY_FIELD).isMap());

-	LLPathfindingNavMeshStatus navMeshStatus(pInput.get(SIM_MESSAGE_BODY_FIELD));

-	LLPathfindingManager::getInstance()->handleNavMeshStatusUpdate(navMeshStatus);

-}

-

-//---------------------------------------------------------------------------

-// LLAgentStateChangeNode

-//---------------------------------------------------------------------------

-

-void LLAgentStateChangeNode::post(ResponsePtr pResponse, const LLSD &pContext, const LLSD &pInput) const

-{

-#ifdef XXX_STINSON_DEBUG_NAVMESH_ZONE

-	llinfos << "STINSON DEBUG: Received AgentPreferencesUpdate: " << pInput << llendl;

-#endif // XXX_STINSON_DEBUG_NAVMESH_ZONE

-	llassert(pInput.has(SIM_MESSAGE_BODY_FIELD));

-	llassert(pInput.get(SIM_MESSAGE_BODY_FIELD).isMap());

-	LLPathfindingManager::getInstance()->handleAgentStateUpdate(pInput.get(SIM_MESSAGE_BODY_FIELD));

-}

-

-//---------------------------------------------------------------------------

-// NavMeshStatusResponder

-//---------------------------------------------------------------------------

-

-NavMeshStatusResponder::NavMeshStatusResponder(const std::string &pCapabilityURL, LLViewerRegion *pRegion)

-	: LLHTTPClient::Responder(),

-	mCapabilityURL(pCapabilityURL),

-	mRegion(pRegion),

-	mRegionUUID()

-{

-	if (mRegion != NULL)

-	{

-		mRegionUUID = mRegion->getRegionID();

-	}

-}

-

-NavMeshStatusResponder::~NavMeshStatusResponder()

-{

-}

-

-void NavMeshStatusResponder::result(const LLSD &pContent)

-{

-#ifdef XXX_STINSON_DEBUG_NAVMESH_ZONE

-	llinfos << "STINSON DEBUG: Received requested NavMeshStatus: " << pContent << llendl;

-#endif // XXX_STINSON_DEBUG_NAVMESH_ZONE

-	LLPathfindingNavMeshStatus navMeshStatus(mRegionUUID, pContent);

-	LLPathfindingManager::getInstance()->handleNavMeshStatusRequest(navMeshStatus, mRegion);

-}

-

-void NavMeshStatusResponder::error(U32 pStatus, const std::string& pReason)

-{

-	llwarns << "error with request to URL '" << mCapabilityURL << "' because " << pReason << " (statusCode:" << pStatus << ")" << llendl;

-	LLPathfindingNavMeshStatus navMeshStatus(mRegionUUID);

-	LLPathfindingManager::getInstance()->handleNavMeshStatusRequest(navMeshStatus, mRegion);

-}

-

-//---------------------------------------------------------------------------

-// NavMeshResponder

-//---------------------------------------------------------------------------

-

-NavMeshResponder::NavMeshResponder(const std::string &pCapabilityURL, U32 pNavMeshVersion, LLPathfindingNavMeshPtr pNavMeshPtr)

-	: LLHTTPClient::Responder(),

-	mCapabilityURL(pCapabilityURL),

-	mNavMeshVersion(pNavMeshVersion),

-	mNavMeshPtr(pNavMeshPtr)

-{

-}

-

-NavMeshResponder::~NavMeshResponder()

-{

-}

-

-void NavMeshResponder::result(const LLSD &pContent)

-{

-	mNavMeshPtr->handleNavMeshResult(pContent, mNavMeshVersion);

-}

-

-void NavMeshResponder::error(U32 pStatus, const std::string& pReason)

-{

-	mNavMeshPtr->handleNavMeshError(pStatus, pReason, mCapabilityURL, mNavMeshVersion);

-}

-

-//---------------------------------------------------------------------------

-// AgentStateResponder

-//---------------------------------------------------------------------------

-

-AgentStateResponder::AgentStateResponder(const std::string &pCapabilityURL, LLPathfindingManager::EAgentState pRequestedAgentState)

-	: LLHTTPClient::Responder(),

-	mCapabilityURL(pCapabilityURL),

-	mRequestedAgentState(pRequestedAgentState)

-{

-}

-

-AgentStateResponder::~AgentStateResponder()

-{

-}

-

-void AgentStateResponder::result(const LLSD &pContent)

-{

-	LLPathfindingManager::getInstance()->handleAgentStateResult(pContent, mRequestedAgentState);

-}

-

-void AgentStateResponder::error(U32 pStatus, const std::string &pReason)

-{

-	LLPathfindingManager::getInstance()->handleAgentStateError(pStatus, pReason, mCapabilityURL);

-}

-

-//---------------------------------------------------------------------------

-// LinksetsResponder

-//---------------------------------------------------------------------------

-

-LinksetsResponder::LinksetsResponder(LLPathfindingManager::request_id_t pRequestId, LLPathfindingManager::linksets_callback_t pLinksetsCallback, bool pIsObjectRequested, bool pIsTerrainRequested)

-	: mRequestId(pRequestId),

-	mLinksetsCallback(pLinksetsCallback),

-	mObjectMessagingState(pIsObjectRequested ? kWaiting : kNotRequested),

-	mTerrainMessagingState(pIsTerrainRequested ? kWaiting : kNotRequested),

-	mObjectLinksetListPtr(),

-	mTerrainLinksetPtr()

-{

-}

-

-LinksetsResponder::~LinksetsResponder()

-{

-}

-

-void LinksetsResponder::handleObjectLinksetsResult(const LLSD &pContent)

-{

-	mObjectLinksetListPtr = LLPathfindingLinksetListPtr(new LLPathfindingLinksetList(pContent));

-

-	mObjectMessagingState = kReceivedGood;

-	if (mTerrainMessagingState != kWaiting)

-	{

-		sendCallback();

-	}

-}

-

-void LinksetsResponder::handleObjectLinksetsError(U32 pStatus, const std::string &pReason, const std::string &pURL)

-{

-	llwarns << "error with request to URL '" << pURL << "' because " << pReason << " (statusCode:" << pStatus << ")" << llendl;

-	mObjectMessagingState = kReceivedError;

-	if (mTerrainMessagingState != kWaiting)

-	{

-		sendCallback();

-	}

-}

-

-void LinksetsResponder::handleTerrainLinksetsResult(const LLSD &pContent)

-{

-	mTerrainLinksetPtr = LLPathfindingLinksetPtr(new LLPathfindingLinkset(pContent));

-

-	mTerrainMessagingState = kReceivedGood;

-	if (mObjectMessagingState != kWaiting)

-	{

-		sendCallback();

-	}

-}

-

-void LinksetsResponder::handleTerrainLinksetsError(U32 pStatus, const std::string &pReason, const std::string &pURL)

-{

-	mTerrainMessagingState = kReceivedError;

-	if (mObjectMessagingState != kWaiting)

-	{

-		sendCallback();

-	}

-}

-	

-void LinksetsResponder::sendCallback()

-{

-	llassert(mObjectMessagingState != kWaiting);

-	llassert(mTerrainMessagingState != kWaiting);

-	LLPathfindingManager::ERequestStatus requestStatus =

-		((((mObjectMessagingState == kReceivedGood) || (mObjectMessagingState == kNotRequested)) &&

-		  ((mTerrainMessagingState == kReceivedGood) || (mTerrainMessagingState == kNotRequested))) ?

-		 LLPathfindingManager::kRequestCompleted : LLPathfindingManager::kRequestError);

-

-	if (mObjectMessagingState != kReceivedGood)

-	{

-		mObjectLinksetListPtr = LLPathfindingLinksetListPtr(new LLPathfindingLinksetList());

-	}

-

-	if (mTerrainMessagingState == kReceivedGood)

-	{

-		mObjectLinksetListPtr->insert(std::pair<std::string, LLPathfindingLinksetPtr>(mTerrainLinksetPtr->getUUID().asString(), mTerrainLinksetPtr));

-	}

-

-	mLinksetsCallback(mRequestId, requestStatus, mObjectLinksetListPtr);

-}

-

-//---------------------------------------------------------------------------

-// ObjectLinksetsResponder

-//---------------------------------------------------------------------------

-

-ObjectLinksetsResponder::ObjectLinksetsResponder(const std::string &pCapabilityURL, LinksetsResponderPtr pLinksetsResponsderPtr)

-	: LLHTTPClient::Responder(),

-	mCapabilityURL(pCapabilityURL),

-	mLinksetsResponsderPtr(pLinksetsResponsderPtr)

-{

-}

-

-ObjectLinksetsResponder::~ObjectLinksetsResponder()

-{

-}

-

-void ObjectLinksetsResponder::result(const LLSD &pContent)

-{

-	mLinksetsResponsderPtr->handleObjectLinksetsResult(pContent);

-}

-

-void ObjectLinksetsResponder::error(U32 pStatus, const std::string &pReason)

-{

-	mLinksetsResponsderPtr->handleObjectLinksetsError(pStatus, pReason, mCapabilityURL);

-}

-	

-//---------------------------------------------------------------------------

-// TerrainLinksetsResponder

-//---------------------------------------------------------------------------

-

-TerrainLinksetsResponder::TerrainLinksetsResponder(const std::string &pCapabilityURL, LinksetsResponderPtr pLinksetsResponsderPtr)

-	: LLHTTPClient::Responder(),

-	mCapabilityURL(pCapabilityURL),

-	mLinksetsResponsderPtr(pLinksetsResponsderPtr)

-{

-}

-

-TerrainLinksetsResponder::~TerrainLinksetsResponder()

-{

-}

-

-void TerrainLinksetsResponder::result(const LLSD &pContent)

-{

-	mLinksetsResponsderPtr->handleTerrainLinksetsResult(pContent);

-}

-

-void TerrainLinksetsResponder::error(U32 pStatus, const std::string &pReason)

-{

-	mLinksetsResponsderPtr->handleTerrainLinksetsError(pStatus, pReason, mCapabilityURL);

-}

-	

-//---------------------------------------------------------------------------

-// CharactersResponder

-//---------------------------------------------------------------------------

-

-CharactersResponder::CharactersResponder(const std::string &pCapabilityURL, LLPathfindingManager::request_id_t pRequestId, LLPathfindingManager::characters_callback_t pCharactersCallback)

-	: LLHTTPClient::Responder(),

-	mCapabilityURL(pCapabilityURL),

-	mRequestId(pRequestId),

-	mCharactersCallback(pCharactersCallback)

-{

-}

-

-CharactersResponder::~CharactersResponder()

-{

-}

-

-void CharactersResponder::result(const LLSD &pContent)

-{

-	LLPathfindingCharacterListPtr characterListPtr = LLPathfindingCharacterListPtr(new LLPathfindingCharacterList(pContent));

-	mCharactersCallback(mRequestId, LLPathfindingManager::kRequestCompleted, characterListPtr);

-}

-

-void CharactersResponder::error(U32 pStatus, const std::string &pReason)

-{

-	llwarns << "error with request to URL '" << mCapabilityURL << "' because " << pReason << " (statusCode:" << pStatus << ")" << llendl;

-

-	LLPathfindingCharacterListPtr characterListPtr;

-	mCharactersCallback(mRequestId, LLPathfindingManager::kRequestError, characterListPtr);

-}

+/**
+ * @file llpathfindingmanager.cpp
+ * @author William Todd Stinson
+ * @brief A state manager for the various pathfinding states.
+ *
+ * $LicenseInfo:firstyear=2002&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2010, Linden Research, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#include <string>
+#include <vector>
+
+#include "llviewerprecompiledheaders.h"
+#include "llsd.h"
+#include "lluuid.h"
+#include "llpathfindingmanager.h"
+#include "llsingleton.h"
+#include "llhttpclient.h"
+#include "llagent.h"
+#include "llviewerregion.h"
+#include "llpathfindingnavmesh.h"
+#include "llpathfindingnavmeshstatus.h"
+#include "llpathfindinglinkset.h"
+#include "llpathfindinglinksetlist.h"
+#include "llpathfindingcharacterlist.h"
+#include "llhttpnode.h"
+
+#include <boost/function.hpp>
+#include <boost/signals2.hpp>
+
+#define CAP_SERVICE_RETRIEVE_NAVMESH  "RetrieveNavMeshSrc"
+
+#define CAP_SERVICE_NAVMESH_STATUS "NavMeshGenerationStatus"
+
+#define CAP_SERVICE_AGENT_STATE     "AgentPreferences"
+#define ALTER_NAVMESH_OBJECTS_FIELD "alter_navmesh_objects"
+#define DEPRECATED_ALTER_NAVMESH_OBJECTS_FIELD "alter_permanent_objects"
+
+#define CAP_SERVICE_OBJECT_LINKSETS  "ObjectNavMeshProperties"
+#define CAP_SERVICE_TERRAIN_LINKSETS "TerrainNavMeshProperties"
+
+#define CAP_SERVICE_CHARACTERS  "CharacterProperties"
+
+#define SIM_MESSAGE_NAVMESH_STATUS_UPDATE "/message/NavMeshStatusUpdate"
+#define SIM_MESSAGE_AGENT_STATE_UPDATE    "/message/AgentPreferencesUpdate"
+#define SIM_MESSAGE_BODY_FIELD            "body"
+
+//---------------------------------------------------------------------------
+// LLNavMeshSimStateChangeNode
+//---------------------------------------------------------------------------
+
+class LLNavMeshSimStateChangeNode : public LLHTTPNode
+{
+public:
+	virtual void post(ResponsePtr pResponse, const LLSD &pContext, const LLSD &pInput) const;
+};
+
+LLHTTPRegistration<LLNavMeshSimStateChangeNode> gHTTPRegistrationNavMeshSimStateChangeNode(SIM_MESSAGE_NAVMESH_STATUS_UPDATE);
+
+//---------------------------------------------------------------------------
+// LLAgentStateChangeNode
+//---------------------------------------------------------------------------
+
+class LLAgentStateChangeNode : public LLHTTPNode
+{
+public:
+	virtual void post(ResponsePtr pResponse, const LLSD &pContext, const LLSD &pInput) const;
+};
+
+LLHTTPRegistration<LLAgentStateChangeNode> gHTTPRegistrationAgentStateChangeNode(SIM_MESSAGE_AGENT_STATE_UPDATE);
+
+//---------------------------------------------------------------------------
+// NavMeshStatusResponder
+//---------------------------------------------------------------------------
+
+class NavMeshStatusResponder : public LLHTTPClient::Responder
+{
+public:
+	NavMeshStatusResponder(const std::string &pCapabilityURL, LLViewerRegion *pRegion);
+	virtual ~NavMeshStatusResponder();
+
+	virtual void result(const LLSD &pContent);
+	virtual void error(U32 pStatus, const std::string& pReason);
+
+protected:
+
+private:
+	std::string    mCapabilityURL;
+	LLViewerRegion *mRegion;
+	LLUUID         mRegionUUID;
+};
+
+//---------------------------------------------------------------------------
+// NavMeshResponder
+//---------------------------------------------------------------------------
+
+class NavMeshResponder : public LLHTTPClient::Responder
+{
+public:
+	NavMeshResponder(const std::string &pCapabilityURL, U32 pNavMeshVersion, LLPathfindingNavMeshPtr pNavMeshPtr);
+	virtual ~NavMeshResponder();
+
+	virtual void result(const LLSD &pContent);
+	virtual void error(U32 pStatus, const std::string& pReason);
+
+protected:
+
+private:
+	std::string             mCapabilityURL;
+	U32                     mNavMeshVersion;
+	LLPathfindingNavMeshPtr mNavMeshPtr;
+};
+
+//---------------------------------------------------------------------------
+// AgentStateResponder
+//---------------------------------------------------------------------------
+
+class AgentStateResponder : public LLHTTPClient::Responder
+{
+public:
+	AgentStateResponder(const std::string &pCapabilityURL, LLPathfindingManager::EAgentState pRequestedAgentState = LLPathfindingManager::kAgentStateUnknown);
+	virtual ~AgentStateResponder();
+
+	virtual void result(const LLSD &pContent);
+	virtual void error(U32 pStatus, const std::string& pReason);
+
+protected:
+
+private:
+	std::string                       mCapabilityURL;
+	LLPathfindingManager::EAgentState mRequestedAgentState;
+};
+
+//---------------------------------------------------------------------------
+// LinksetsResponder
+//---------------------------------------------------------------------------
+
+class LinksetsResponder
+{
+public:
+	LinksetsResponder(LLPathfindingManager::request_id_t pRequestId, LLPathfindingManager::linksets_callback_t pLinksetsCallback, bool pIsObjectRequested, bool pIsTerrainRequested);
+	virtual ~LinksetsResponder();
+
+	void handleObjectLinksetsResult(const LLSD &pContent);
+	void handleObjectLinksetsError(U32 pStatus, const std::string &pReason, const std::string &pURL);
+	void handleTerrainLinksetsResult(const LLSD &pContent);
+	void handleTerrainLinksetsError(U32 pStatus, const std::string &pReason, const std::string &pURL);
+
+protected:
+
+private:
+	void sendCallback();
+
+	typedef enum
+	{
+		kNotRequested,
+		kWaiting,
+		kReceivedGood,
+		kReceivedError
+	} EMessagingState;
+
+	LLPathfindingManager::request_id_t        mRequestId;
+	LLPathfindingManager::linksets_callback_t mLinksetsCallback;
+
+	EMessagingState                           mObjectMessagingState;
+	EMessagingState                           mTerrainMessagingState;
+
+	LLPathfindingLinksetListPtr               mObjectLinksetListPtr;
+	LLPathfindingLinksetPtr                   mTerrainLinksetPtr;
+};
+
+typedef boost::shared_ptr<LinksetsResponder> LinksetsResponderPtr;
+
+//---------------------------------------------------------------------------
+// ObjectLinksetsResponder
+//---------------------------------------------------------------------------
+
+class ObjectLinksetsResponder : public LLHTTPClient::Responder
+{
+public:
+	ObjectLinksetsResponder(const std::string &pCapabilityURL, LinksetsResponderPtr pLinksetsResponsderPtr);
+	virtual ~ObjectLinksetsResponder();
+
+	virtual void result(const LLSD &pContent);
+	virtual void error(U32 pStatus, const std::string &pReason);
+
+protected:
+
+private:
+	std::string          mCapabilityURL;
+	LinksetsResponderPtr mLinksetsResponsderPtr;
+};
+
+//---------------------------------------------------------------------------
+// TerrainLinksetsResponder
+//---------------------------------------------------------------------------
+
+class TerrainLinksetsResponder : public LLHTTPClient::Responder
+{
+public:
+	TerrainLinksetsResponder(const std::string &pCapabilityURL, LinksetsResponderPtr pLinksetsResponsderPtr);
+	virtual ~TerrainLinksetsResponder();
+
+	virtual void result(const LLSD &pContent);
+	virtual void error(U32 pStatus, const std::string &pReason);
+
+protected:
+
+private:
+	std::string          mCapabilityURL;
+	LinksetsResponderPtr mLinksetsResponsderPtr;
+};
+
+//---------------------------------------------------------------------------
+// CharactersResponder
+//---------------------------------------------------------------------------
+
+class CharactersResponder : public LLHTTPClient::Responder
+{
+public:
+	CharactersResponder(const std::string &pCapabilityURL, LLPathfindingManager::request_id_t pRequestId, LLPathfindingManager::characters_callback_t pCharactersCallback);
+	virtual ~CharactersResponder();
+
+	virtual void result(const LLSD &pContent);
+	virtual void error(U32 pStatus, const std::string &pReason);
+
+protected:
+
+private:
+	std::string                                 mCapabilityURL;
+	LLPathfindingManager::request_id_t          mRequestId;
+	LLPathfindingManager::characters_callback_t mCharactersCallback;
+};
+
+//---------------------------------------------------------------------------
+// LLPathfindingManager
+//---------------------------------------------------------------------------
+
+LLPathfindingManager::LLPathfindingManager()
+	: LLSingleton<LLPathfindingManager>(),
+	mNavMeshMap(),
+	mAgentStateSignal(),
+	mAgentState(kAgentStateUnknown),
+	mLastKnownNonErrorAgentState(kAgentStateUnknown)
+{
+}
+
+LLPathfindingManager::~LLPathfindingManager()
+{
+}
+
+bool LLPathfindingManager::isPathfindingEnabledForCurrentRegion() const
+{
+	return isPathfindingEnabledForRegion(getCurrentRegion());
+}
+
+bool LLPathfindingManager::isPathfindingEnabledForRegion(LLViewerRegion *pRegion) const
+{
+	std::string retrieveNavMeshURL = getRetrieveNavMeshURLForRegion(pRegion);
+	return !retrieveNavMeshURL.empty();
+}
+
+#ifdef DEPRECATED_UNVERSIONED_NAVMESH
+bool LLPathfindingManager::isPathfindingNavMeshVersioningEnabledForCurrentRegionXXX() const
+{
+	std::string navMeshStatusURL = getNavMeshStatusURLForRegion(getCurrentRegion());
+	return !navMeshStatusURL.empty();
+}
+#endif // DEPRECATED_UNVERSIONED_NAVMESH
+
+bool LLPathfindingManager::isAllowAlterPermanent()
+{
+	return (!isPathfindingEnabledForCurrentRegion() || (getAgentState() == kAgentStateUnfrozen));
+}
+
+bool LLPathfindingManager::isAllowViewTerrainProperties() const
+{
+	LLViewerRegion* region = getCurrentRegion();
+	return (gAgent.isGodlike() || ((region != NULL) && region->canManageEstate()));
+}
+
+LLPathfindingNavMesh::navmesh_slot_t LLPathfindingManager::registerNavMeshListenerForRegion(LLViewerRegion *pRegion, LLPathfindingNavMesh::navmesh_callback_t pNavMeshCallback)
+{
+	LLPathfindingNavMeshPtr navMeshPtr = getNavMeshForRegion(pRegion);
+	return navMeshPtr->registerNavMeshListener(pNavMeshCallback);
+}
+
+void LLPathfindingManager::requestGetNavMeshForRegion(LLViewerRegion *pRegion)
+{
+	LLPathfindingNavMeshPtr navMeshPtr = getNavMeshForRegion(pRegion);
+
+	if (pRegion == NULL)
+	{
+		navMeshPtr->handleNavMeshNotEnabled();
+	}
+	else if (!pRegion->capabilitiesReceived())
+	{
+		navMeshPtr->handleNavMeshWaitForRegionLoad();
+		pRegion->setCapabilitiesReceivedCallback(boost::bind(&LLPathfindingManager::handleDeferredGetNavMeshForRegion, this, _1));
+	}
+	else if (!isPathfindingEnabledForRegion(pRegion))
+	{
+		navMeshPtr->handleNavMeshNotEnabled();
+	}
+	else
+	{
+		std::string navMeshStatusURL = getNavMeshStatusURLForRegion(pRegion);
+#ifdef DEPRECATED_UNVERSIONED_NAVMESH
+		if (navMeshStatusURL.empty())
+		{
+			LLPathfindingNavMeshStatus navMeshStatus = navMeshPtr->getNavMeshStatusXXX();
+			navMeshStatus.incrementNavMeshVersionXXX();
+			sendRequestGetNavMeshForRegion(navMeshPtr, pRegion, navMeshStatus);
+		}
+		else
+		{
+			navMeshPtr->handleNavMeshCheckVersion();
+			LLHTTPClient::ResponderPtr navMeshStatusResponder = new NavMeshStatusResponder(navMeshStatusURL, pRegion);
+			LLHTTPClient::get(navMeshStatusURL, navMeshStatusResponder);
+		}
+#else // DEPRECATED_UNVERSIONED_NAVMESH
+		llassert(!navMeshStatusURL.empty());
+		navMeshPtr->handleNavMeshCheckVersion();
+		LLHTTPClient::ResponderPtr navMeshStatusResponder = new NavMeshStatusResponder(navMeshStatusURL, pRegion);
+		LLHTTPClient::get(navMeshStatusURL, navMeshStatusResponder);
+#endif // DEPRECATED_UNVERSIONED_NAVMESH
+	}
+}
+
+LLPathfindingManager::agent_state_slot_t LLPathfindingManager::registerAgentStateListener(agent_state_callback_t pAgentStateCallback)
+{
+	return mAgentStateSignal.connect(pAgentStateCallback);
+}
+
+LLPathfindingManager::EAgentState LLPathfindingManager::getAgentState()
+{
+	if (!isPathfindingEnabledForCurrentRegion())
+	{
+		setAgentState(kAgentStateNotEnabled);
+	}
+	else
+	{
+		if (!isValidAgentState(mAgentState))
+		{
+			requestGetAgentState();
+		}
+	}
+
+	return mAgentState;
+}
+
+LLPathfindingManager::EAgentState LLPathfindingManager::getLastKnownNonErrorAgentState() const
+{
+	return mLastKnownNonErrorAgentState;
+}
+
+void LLPathfindingManager::requestSetAgentState(EAgentState pRequestedAgentState)
+{
+	llassert(isValidAgentState(pRequestedAgentState));
+	std::string agentStateURL = getAgentStateURLForCurrentRegion();
+
+	if (agentStateURL.empty())
+	{
+		setAgentState(kAgentStateNotEnabled);
+	}
+	else
+	{
+		LLSD request;
+		request[ALTER_NAVMESH_OBJECTS_FIELD] = static_cast<LLSD::Boolean>(pRequestedAgentState == kAgentStateUnfrozen);
+#ifdef DEPRECATED_ALTER_NAVMESH_OBJECTS_FIELD
+		request[DEPRECATED_ALTER_NAVMESH_OBJECTS_FIELD] = static_cast<LLSD::Boolean>(pRequestedAgentState == kAgentStateUnfrozen);
+#endif // DEPRECATED_ALTER_NAVMESH_OBJECTS_FIELD
+
+		LLHTTPClient::ResponderPtr responder = new AgentStateResponder(agentStateURL, pRequestedAgentState);
+		LLHTTPClient::post(agentStateURL, request, responder);
+	}
+}
+
+LLPathfindingManager::ERequestStatus LLPathfindingManager::requestGetLinksets(request_id_t pRequestId, linksets_callback_t pLinksetsCallback) const
+{
+	ERequestStatus status;
+
+	std::string objectLinksetsURL = getObjectLinksetsURLForCurrentRegion();
+	std::string terrainLinksetsURL = getTerrainLinksetsURLForCurrentRegion();
+	if (objectLinksetsURL.empty() || terrainLinksetsURL.empty())
+	{
+		status = kRequestNotEnabled;
+	}
+	else
+	{
+		bool doRequestTerrain = isAllowViewTerrainProperties();
+		LinksetsResponderPtr linksetsResponderPtr(new LinksetsResponder(pRequestId, pLinksetsCallback, true, doRequestTerrain));
+
+		LLHTTPClient::ResponderPtr objectLinksetsResponder = new ObjectLinksetsResponder(objectLinksetsURL, linksetsResponderPtr);
+		LLHTTPClient::get(objectLinksetsURL, objectLinksetsResponder);
+
+		if (doRequestTerrain)
+		{
+			LLHTTPClient::ResponderPtr terrainLinksetsResponder = new TerrainLinksetsResponder(terrainLinksetsURL, linksetsResponderPtr);
+			LLHTTPClient::get(terrainLinksetsURL, terrainLinksetsResponder);
+		}
+
+		status = kRequestStarted;
+	}
+
+	return status;
+}
+
+LLPathfindingManager::ERequestStatus LLPathfindingManager::requestSetLinksets(request_id_t pRequestId, LLPathfindingLinksetListPtr pLinksetList, LLPathfindingLinkset::ELinksetUse pLinksetUse, S32 pA, S32 pB, S32 pC, S32 pD, linksets_callback_t pLinksetsCallback) const
+{
+	ERequestStatus status = kRequestNotEnabled;
+
+	std::string objectLinksetsURL = getObjectLinksetsURLForCurrentRegion();
+	std::string terrainLinksetsURL = getTerrainLinksetsURLForCurrentRegion();
+	if (objectLinksetsURL.empty() || terrainLinksetsURL.empty())
+	{
+		status = kRequestNotEnabled;
+	}
+	else
+	{
+		LLSD objectPostData = pLinksetList->encodeObjectFields(pLinksetUse, pA, pB, pC, pD);
+		LLSD terrainPostData;
+		if (isAllowViewTerrainProperties())
+		{
+			terrainPostData = pLinksetList->encodeTerrainFields(pLinksetUse, pA, pB, pC, pD);
+		}
+
+		if (objectPostData.isUndefined() && terrainPostData.isUndefined())
+		{
+			status = kRequestCompleted;
+		}
+		else
+		{
+			LinksetsResponderPtr linksetsResponderPtr(new LinksetsResponder(pRequestId, pLinksetsCallback, !objectPostData.isUndefined(), !terrainPostData.isUndefined()));
+
+			if (!objectPostData.isUndefined())
+			{
+				LLHTTPClient::ResponderPtr objectLinksetsResponder = new ObjectLinksetsResponder(objectLinksetsURL, linksetsResponderPtr);
+				LLHTTPClient::put(objectLinksetsURL, objectPostData, objectLinksetsResponder);
+			}
+
+			if (!terrainPostData.isUndefined())
+			{
+				LLHTTPClient::ResponderPtr terrainLinksetsResponder = new TerrainLinksetsResponder(terrainLinksetsURL, linksetsResponderPtr);
+				LLHTTPClient::put(terrainLinksetsURL, terrainPostData, terrainLinksetsResponder);
+			}
+
+			status = kRequestStarted;
+		}
+	}
+
+	return status;
+}
+
+LLPathfindingManager::ERequestStatus LLPathfindingManager::requestGetCharacters(request_id_t pRequestId, characters_callback_t pCharactersCallback) const
+{
+	ERequestStatus status;
+
+	std::string charactersURL = getCharactersURLForCurrentRegion();
+	if (charactersURL.empty())
+	{
+		status = kRequestNotEnabled;
+	}
+	else
+	{
+		LLHTTPClient::ResponderPtr charactersResponder = new CharactersResponder(charactersURL, pRequestId, pCharactersCallback);
+		LLHTTPClient::get(charactersURL, charactersResponder);
+
+		status = kRequestStarted;
+	}
+
+	return status;
+}
+
+void LLPathfindingManager::sendRequestGetNavMeshForRegion(LLPathfindingNavMeshPtr navMeshPtr, LLViewerRegion *pRegion, const LLPathfindingNavMeshStatus &pNavMeshStatus)
+{
+	if ((pRegion == NULL) || !pRegion->isAlive())
+	{
+		navMeshPtr->handleNavMeshNotEnabled();
+	}
+	else
+	{
+		std::string navMeshURL = getRetrieveNavMeshURLForRegion(pRegion);
+
+		if (navMeshURL.empty())
+		{
+			navMeshPtr->handleNavMeshNotEnabled();
+		}
+		else
+		{
+			navMeshPtr->handleNavMeshStart(pNavMeshStatus);
+			LLHTTPClient::ResponderPtr responder = new NavMeshResponder(navMeshURL, pNavMeshStatus.getVersion(), navMeshPtr);
+
+			LLSD postData;
+			LLHTTPClient::post(navMeshURL, postData, responder);
+		}
+	}
+}
+
+void LLPathfindingManager::handleDeferredGetNavMeshForRegion(const LLUUID &pRegionUUID)
+{
+	LLViewerRegion *currentRegion = getCurrentRegion();
+
+	if ((currentRegion != NULL) && (currentRegion->getRegionID() == pRegionUUID))
+	{
+		requestGetNavMeshForRegion(currentRegion);
+	}
+}
+
+void LLPathfindingManager::handleNavMeshStatusRequest(const LLPathfindingNavMeshStatus &pNavMeshStatus, LLViewerRegion *pRegion)
+{
+	LLPathfindingNavMeshPtr navMeshPtr = getNavMeshForRegion(pNavMeshStatus.getRegionUUID());
+
+	if (!pNavMeshStatus.isValid())
+	{
+		navMeshPtr->handleNavMeshError();
+	}
+	else
+	{
+		if (navMeshPtr->hasNavMeshVersion(pNavMeshStatus))
+		{
+			navMeshPtr->handleRefresh(pNavMeshStatus);
+		}
+		else
+		{
+			sendRequestGetNavMeshForRegion(navMeshPtr, pRegion, pNavMeshStatus);
+		}
+	}
+}
+
+void LLPathfindingManager::handleNavMeshStatusUpdate(const LLPathfindingNavMeshStatus &pNavMeshStatus)
+{
+	LLPathfindingNavMeshPtr navMeshPtr = getNavMeshForRegion(pNavMeshStatus.getRegionUUID());
+
+	if (!pNavMeshStatus.isValid())
+	{
+		navMeshPtr->handleNavMeshError();
+	}
+	else
+	{
+		navMeshPtr->handleNavMeshNewVersion(pNavMeshStatus);
+	}
+}
+
+LLPathfindingNavMeshPtr LLPathfindingManager::getNavMeshForRegion(const LLUUID &pRegionUUID)
+{
+	LLPathfindingNavMeshPtr navMeshPtr;
+	NavMeshMap::iterator navMeshIter = mNavMeshMap.find(pRegionUUID);
+	if (navMeshIter == mNavMeshMap.end())
+	{
+		navMeshPtr = LLPathfindingNavMeshPtr(new LLPathfindingNavMesh(pRegionUUID));
+		mNavMeshMap.insert(std::pair<LLUUID, LLPathfindingNavMeshPtr>(pRegionUUID, navMeshPtr));
+	}
+	else
+	{
+		navMeshPtr = navMeshIter->second;
+	}
+
+	return navMeshPtr;
+}
+
+LLPathfindingNavMeshPtr LLPathfindingManager::getNavMeshForRegion(LLViewerRegion *pRegion)
+{
+	LLUUID regionUUID;
+	if (pRegion != NULL)
+	{
+		regionUUID = pRegion->getRegionID();
+	}
+
+	return getNavMeshForRegion(regionUUID);
+}
+
+bool LLPathfindingManager::isValidAgentState(EAgentState pAgentState)
+{
+	return ((pAgentState == kAgentStateFrozen) || (pAgentState == kAgentStateUnfrozen));
+}
+
+void LLPathfindingManager::requestGetAgentState()
+{
+	std::string agentStateURL = getAgentStateURLForCurrentRegion();
+
+	if (agentStateURL.empty())
+	{
+		setAgentState(kAgentStateNotEnabled);
+	}
+	else
+	{
+		LLHTTPClient::ResponderPtr responder = new AgentStateResponder(agentStateURL);
+		LLHTTPClient::get(agentStateURL, responder);
+	}
+}
+
+void LLPathfindingManager::setAgentState(EAgentState pAgentState)
+{
+	mAgentState = pAgentState;
+
+	if (mAgentState != kAgentStateError)
+	{
+		mLastKnownNonErrorAgentState = mAgentState;
+	}
+
+	mAgentStateSignal(mAgentState);
+}
+
+void LLPathfindingManager::handleAgentStateResult(const LLSD &pContent, EAgentState pRequestedAgentState)
+{
+#ifndef DEPRECATED_ALTER_NAVMESH_OBJECTS_FIELD
+	llassert(pContent.has(ALTER_NAVMESH_OBJECTS_FIELD));
+	llassert(pContent.get(ALTER_NAVMESH_OBJECTS_FIELD).isBoolean());
+	EAgentState agentState = (pContent.get(ALTER_NAVMESH_OBJECTS_FIELD).asBoolean() ? kAgentStateUnfrozen : kAgentStateFrozen);
+#else // DEPRECATED_ALTER_NAVMESH_OBJECTS_FIELD
+	EAgentState agentState = kAgentStateUnknown;
+	if (pContent.has(ALTER_NAVMESH_OBJECTS_FIELD))
+	{
+		llassert(pContent.get(ALTER_NAVMESH_OBJECTS_FIELD).isBoolean());
+		agentState = (pContent.get(ALTER_NAVMESH_OBJECTS_FIELD).asBoolean() ? kAgentStateUnfrozen : kAgentStateFrozen);
+	}
+	else
+	{
+		llassert(pContent.has(DEPRECATED_ALTER_NAVMESH_OBJECTS_FIELD));
+		llassert(pContent.get(DEPRECATED_ALTER_NAVMESH_OBJECTS_FIELD).isBoolean());
+		agentState = (pContent.get(DEPRECATED_ALTER_NAVMESH_OBJECTS_FIELD).asBoolean() ? kAgentStateUnfrozen : kAgentStateFrozen);
+	}
+#endif // DEPRECATED_ALTER_NAVMESH_OBJECTS_FIELD
+
+	if (isValidAgentState(pRequestedAgentState) && (agentState != pRequestedAgentState))
+	{
+		agentState = kAgentStateError;
+		llassert(0);
+	}
+
+	setAgentState(agentState);
+}
+
+void LLPathfindingManager::handleAgentStateError(U32 pStatus, const std::string &pReason, const std::string &pURL)
+{
+	llwarns << "error with request to URL '" << pURL << "' because " << pReason << " (statusCode:" << pStatus << ")" << llendl;
+	setAgentState(kAgentStateError);
+}
+
+void LLPathfindingManager::handleAgentStateUpdate(const LLSD &pContent)
+{
+	llassert(pContent.has(ALTER_NAVMESH_OBJECTS_FIELD));
+	llassert(pContent.get(ALTER_NAVMESH_OBJECTS_FIELD).isBoolean());
+	EAgentState agentState = (pContent.get(ALTER_NAVMESH_OBJECTS_FIELD).asBoolean() ? kAgentStateUnfrozen : kAgentStateFrozen);
+
+	setAgentState(agentState);
+}
+
+std::string LLPathfindingManager::getNavMeshStatusURLForRegion(LLViewerRegion *pRegion) const
+{
+	return getCapabilityURLForRegion(pRegion, CAP_SERVICE_NAVMESH_STATUS);
+}
+
+std::string LLPathfindingManager::getRetrieveNavMeshURLForRegion(LLViewerRegion *pRegion) const
+{
+	return getCapabilityURLForRegion(pRegion, CAP_SERVICE_RETRIEVE_NAVMESH);
+}
+
+std::string LLPathfindingManager::getAgentStateURLForCurrentRegion() const
+{
+	return getCapabilityURLForCurrentRegion(CAP_SERVICE_AGENT_STATE);
+}
+
+std::string LLPathfindingManager::getObjectLinksetsURLForCurrentRegion() const
+{
+	return getCapabilityURLForCurrentRegion(CAP_SERVICE_OBJECT_LINKSETS);
+}
+
+std::string LLPathfindingManager::getTerrainLinksetsURLForCurrentRegion() const
+{
+	return getCapabilityURLForCurrentRegion(CAP_SERVICE_TERRAIN_LINKSETS);
+}
+
+std::string LLPathfindingManager::getCharactersURLForCurrentRegion() const
+{
+	return getCapabilityURLForCurrentRegion(CAP_SERVICE_CHARACTERS);
+}
+
+std::string LLPathfindingManager::getCapabilityURLForCurrentRegion(const std::string &pCapabilityName) const
+{
+	return getCapabilityURLForRegion(getCurrentRegion(), pCapabilityName);
+}
+
+std::string LLPathfindingManager::getCapabilityURLForRegion(LLViewerRegion *pRegion, const std::string &pCapabilityName) const
+{
+	std::string capabilityURL("");
+
+	if (pRegion != NULL)
+	{
+		capabilityURL = pRegion->getCapability(pCapabilityName);
+	}
+
+	if (capabilityURL.empty())
+	{
+		llwarns << "cannot find capability '" << pCapabilityName << "' for current region '"
+			<< ((pRegion != NULL) ? pRegion->getName() : "<null>") << "'" << llendl;
+	}
+
+	return capabilityURL;
+}
+
+LLViewerRegion *LLPathfindingManager::getCurrentRegion() const
+{
+	return gAgent.getRegion();
+}
+
+//---------------------------------------------------------------------------
+// LLNavMeshSimStateChangeNode
+//---------------------------------------------------------------------------
+
+void LLNavMeshSimStateChangeNode::post(ResponsePtr pResponse, const LLSD &pContext, const LLSD &pInput) const
+{
+#ifdef XXX_STINSON_DEBUG_NAVMESH_ZONE
+	llinfos << "STINSON DEBUG: Received NavMeshStatusUpdate: " << pInput << llendl;
+#endif // XXX_STINSON_DEBUG_NAVMESH_ZONE
+	llassert(pInput.has(SIM_MESSAGE_BODY_FIELD));
+	llassert(pInput.get(SIM_MESSAGE_BODY_FIELD).isMap());
+	LLPathfindingNavMeshStatus navMeshStatus(pInput.get(SIM_MESSAGE_BODY_FIELD));
+	LLPathfindingManager::getInstance()->handleNavMeshStatusUpdate(navMeshStatus);
+}
+
+//---------------------------------------------------------------------------
+// LLAgentStateChangeNode
+//---------------------------------------------------------------------------
+
+void LLAgentStateChangeNode::post(ResponsePtr pResponse, const LLSD &pContext, const LLSD &pInput) const
+{
+#ifdef XXX_STINSON_DEBUG_NAVMESH_ZONE
+	llinfos << "STINSON DEBUG: Received AgentPreferencesUpdate: " << pInput << llendl;
+#endif // XXX_STINSON_DEBUG_NAVMESH_ZONE
+	llassert(pInput.has(SIM_MESSAGE_BODY_FIELD));
+	llassert(pInput.get(SIM_MESSAGE_BODY_FIELD).isMap());
+	LLPathfindingManager::getInstance()->handleAgentStateUpdate(pInput.get(SIM_MESSAGE_BODY_FIELD));
+}
+
+//---------------------------------------------------------------------------
+// NavMeshStatusResponder
+//---------------------------------------------------------------------------
+
+NavMeshStatusResponder::NavMeshStatusResponder(const std::string &pCapabilityURL, LLViewerRegion *pRegion)
+	: LLHTTPClient::Responder(),
+	mCapabilityURL(pCapabilityURL),
+	mRegion(pRegion),
+	mRegionUUID()
+{
+	if (mRegion != NULL)
+	{
+		mRegionUUID = mRegion->getRegionID();
+	}
+}
+
+NavMeshStatusResponder::~NavMeshStatusResponder()
+{
+}
+
+void NavMeshStatusResponder::result(const LLSD &pContent)
+{
+#ifdef XXX_STINSON_DEBUG_NAVMESH_ZONE
+	llinfos << "STINSON DEBUG: Received requested NavMeshStatus: " << pContent << llendl;
+#endif // XXX_STINSON_DEBUG_NAVMESH_ZONE
+	LLPathfindingNavMeshStatus navMeshStatus(mRegionUUID, pContent);
+	LLPathfindingManager::getInstance()->handleNavMeshStatusRequest(navMeshStatus, mRegion);
+}
+
+void NavMeshStatusResponder::error(U32 pStatus, const std::string& pReason)
+{
+	llwarns << "error with request to URL '" << mCapabilityURL << "' because " << pReason << " (statusCode:" << pStatus << ")" << llendl;
+	LLPathfindingNavMeshStatus navMeshStatus(mRegionUUID);
+	LLPathfindingManager::getInstance()->handleNavMeshStatusRequest(navMeshStatus, mRegion);
+}
+
+//---------------------------------------------------------------------------
+// NavMeshResponder
+//---------------------------------------------------------------------------
+
+NavMeshResponder::NavMeshResponder(const std::string &pCapabilityURL, U32 pNavMeshVersion, LLPathfindingNavMeshPtr pNavMeshPtr)
+	: LLHTTPClient::Responder(),
+	mCapabilityURL(pCapabilityURL),
+	mNavMeshVersion(pNavMeshVersion),
+	mNavMeshPtr(pNavMeshPtr)
+{
+}
+
+NavMeshResponder::~NavMeshResponder()
+{
+}
+
+void NavMeshResponder::result(const LLSD &pContent)
+{
+	mNavMeshPtr->handleNavMeshResult(pContent, mNavMeshVersion);
+}
+
+void NavMeshResponder::error(U32 pStatus, const std::string& pReason)
+{
+	mNavMeshPtr->handleNavMeshError(pStatus, pReason, mCapabilityURL, mNavMeshVersion);
+}
+
+//---------------------------------------------------------------------------
+// AgentStateResponder
+//---------------------------------------------------------------------------
+
+AgentStateResponder::AgentStateResponder(const std::string &pCapabilityURL, LLPathfindingManager::EAgentState pRequestedAgentState)
+	: LLHTTPClient::Responder(),
+	mCapabilityURL(pCapabilityURL),
+	mRequestedAgentState(pRequestedAgentState)
+{
+}
+
+AgentStateResponder::~AgentStateResponder()
+{
+}
+
+void AgentStateResponder::result(const LLSD &pContent)
+{
+	LLPathfindingManager::getInstance()->handleAgentStateResult(pContent, mRequestedAgentState);
+}
+
+void AgentStateResponder::error(U32 pStatus, const std::string &pReason)
+{
+	LLPathfindingManager::getInstance()->handleAgentStateError(pStatus, pReason, mCapabilityURL);
+}
+
+//---------------------------------------------------------------------------
+// LinksetsResponder
+//---------------------------------------------------------------------------
+
+LinksetsResponder::LinksetsResponder(LLPathfindingManager::request_id_t pRequestId, LLPathfindingManager::linksets_callback_t pLinksetsCallback, bool pIsObjectRequested, bool pIsTerrainRequested)
+	: mRequestId(pRequestId),
+	mLinksetsCallback(pLinksetsCallback),
+	mObjectMessagingState(pIsObjectRequested ? kWaiting : kNotRequested),
+	mTerrainMessagingState(pIsTerrainRequested ? kWaiting : kNotRequested),
+	mObjectLinksetListPtr(),
+	mTerrainLinksetPtr()
+{
+}
+
+LinksetsResponder::~LinksetsResponder()
+{
+}
+
+void LinksetsResponder::handleObjectLinksetsResult(const LLSD &pContent)
+{
+	mObjectLinksetListPtr = LLPathfindingLinksetListPtr(new LLPathfindingLinksetList(pContent));
+
+	mObjectMessagingState = kReceivedGood;
+	if (mTerrainMessagingState != kWaiting)
+	{
+		sendCallback();
+	}
+}
+
+void LinksetsResponder::handleObjectLinksetsError(U32 pStatus, const std::string &pReason, const std::string &pURL)
+{
+	llwarns << "error with request to URL '" << pURL << "' because " << pReason << " (statusCode:" << pStatus << ")" << llendl;
+	mObjectMessagingState = kReceivedError;
+	if (mTerrainMessagingState != kWaiting)
+	{
+		sendCallback();
+	}
+}
+
+void LinksetsResponder::handleTerrainLinksetsResult(const LLSD &pContent)
+{
+	mTerrainLinksetPtr = LLPathfindingLinksetPtr(new LLPathfindingLinkset(pContent));
+
+	mTerrainMessagingState = kReceivedGood;
+	if (mObjectMessagingState != kWaiting)
+	{
+		sendCallback();
+	}
+}
+
+void LinksetsResponder::handleTerrainLinksetsError(U32 pStatus, const std::string &pReason, const std::string &pURL)
+{
+	mTerrainMessagingState = kReceivedError;
+	if (mObjectMessagingState != kWaiting)
+	{
+		sendCallback();
+	}
+}
+
+void LinksetsResponder::sendCallback()
+{
+	llassert(mObjectMessagingState != kWaiting);
+	llassert(mTerrainMessagingState != kWaiting);
+	LLPathfindingManager::ERequestStatus requestStatus =
+		((((mObjectMessagingState == kReceivedGood) || (mObjectMessagingState == kNotRequested)) &&
+		  ((mTerrainMessagingState == kReceivedGood) || (mTerrainMessagingState == kNotRequested))) ?
+		 LLPathfindingManager::kRequestCompleted : LLPathfindingManager::kRequestError);
+
+	if (mObjectMessagingState != kReceivedGood)
+	{
+		mObjectLinksetListPtr = LLPathfindingLinksetListPtr(new LLPathfindingLinksetList());
+	}
+
+	if (mTerrainMessagingState == kReceivedGood)
+	{
+		mObjectLinksetListPtr->insert(std::pair<std::string, LLPathfindingLinksetPtr>(mTerrainLinksetPtr->getUUID().asString(), mTerrainLinksetPtr));
+	}
+
+	mLinksetsCallback(mRequestId, requestStatus, mObjectLinksetListPtr);
+}
+
+//---------------------------------------------------------------------------
+// ObjectLinksetsResponder
+//---------------------------------------------------------------------------
+
+ObjectLinksetsResponder::ObjectLinksetsResponder(const std::string &pCapabilityURL, LinksetsResponderPtr pLinksetsResponsderPtr)
+	: LLHTTPClient::Responder(),
+	mCapabilityURL(pCapabilityURL),
+	mLinksetsResponsderPtr(pLinksetsResponsderPtr)
+{
+}
+
+ObjectLinksetsResponder::~ObjectLinksetsResponder()
+{
+}
+
+void ObjectLinksetsResponder::result(const LLSD &pContent)
+{
+	mLinksetsResponsderPtr->handleObjectLinksetsResult(pContent);
+}
+
+void ObjectLinksetsResponder::error(U32 pStatus, const std::string &pReason)
+{
+	mLinksetsResponsderPtr->handleObjectLinksetsError(pStatus, pReason, mCapabilityURL);
+}
+
+//---------------------------------------------------------------------------
+// TerrainLinksetsResponder
+//---------------------------------------------------------------------------
+
+TerrainLinksetsResponder::TerrainLinksetsResponder(const std::string &pCapabilityURL, LinksetsResponderPtr pLinksetsResponsderPtr)
+	: LLHTTPClient::Responder(),
+	mCapabilityURL(pCapabilityURL),
+	mLinksetsResponsderPtr(pLinksetsResponsderPtr)
+{
+}
+
+TerrainLinksetsResponder::~TerrainLinksetsResponder()
+{
+}
+
+void TerrainLinksetsResponder::result(const LLSD &pContent)
+{
+	mLinksetsResponsderPtr->handleTerrainLinksetsResult(pContent);
+}
+
+void TerrainLinksetsResponder::error(U32 pStatus, const std::string &pReason)
+{
+	mLinksetsResponsderPtr->handleTerrainLinksetsError(pStatus, pReason, mCapabilityURL);
+}
+
+//---------------------------------------------------------------------------
+// CharactersResponder
+//---------------------------------------------------------------------------
+
+CharactersResponder::CharactersResponder(const std::string &pCapabilityURL, LLPathfindingManager::request_id_t pRequestId, LLPathfindingManager::characters_callback_t pCharactersCallback)
+	: LLHTTPClient::Responder(),
+	mCapabilityURL(pCapabilityURL),
+	mRequestId(pRequestId),
+	mCharactersCallback(pCharactersCallback)
+{
+}
+
+CharactersResponder::~CharactersResponder()
+{
+}
+
+void CharactersResponder::result(const LLSD &pContent)
+{
+	LLPathfindingCharacterListPtr characterListPtr = LLPathfindingCharacterListPtr(new LLPathfindingCharacterList(pContent));
+	mCharactersCallback(mRequestId, LLPathfindingManager::kRequestCompleted, characterListPtr);
+}
+
+void CharactersResponder::error(U32 pStatus, const std::string &pReason)
+{
+	llwarns << "error with request to URL '" << mCapabilityURL << "' because " << pReason << " (statusCode:" << pStatus << ")" << llendl;
+
+	LLPathfindingCharacterListPtr characterListPtr;
+	mCharactersCallback(mRequestId, LLPathfindingManager::kRequestError, characterListPtr);
+}
+
diff --git a/indra/newview/llpathfindingmanager.h b/indra/newview/llpathfindingmanager.h
index 795ee88f3d..9797c783b5 100644
--- a/indra/newview/llpathfindingmanager.h
+++ b/indra/newview/llpathfindingmanager.h
@@ -1,143 +1,146 @@
-/** 

- * @file llpathfindingmanager.h

- * @author William Todd Stinson

- * @brief A state manager for the various pathfinding states.

- *

- * $LicenseInfo:firstyear=2002&license=viewerlgpl$

- * Second Life Viewer Source Code

- * Copyright (C) 2010, Linden Research, Inc. 

- * 

- * This library is free software; you can redistribute it and/or

- * modify it under the terms of the GNU Lesser General Public

- * License as published by the Free Software Foundation;

- * version 2.1 of the License only.

- * 

- * This library is distributed in the hope that it will be useful,

- * but WITHOUT ANY WARRANTY; without even the implied warranty of

- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

- * Lesser General Public License for more details.

- * 

- * You should have received a copy of the GNU Lesser General Public

- * License along with this library; if not, write to the Free Software

- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

- * 

- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA

- * $/LicenseInfo$

- */

-

-#ifndef LL_LLPATHFINDINGMANAGER_H

-#define LL_LLPATHFINDINGMANAGER_H

-

-#include "llsingleton.h"

-#include "lluuid.h"

-#include "llpathfindingnavmesh.h"

-#include "llpathfindinglinkset.h"

-#include "llpathfindinglinksetlist.h"

-#include "llpathfindingcharacterlist.h"

-

-#include <string>

-#include <map>

-

-#include <boost/function.hpp>

-#include <boost/signals2.hpp>

-

-class LLFloater;

-class LLViewerRegion;

-class LLPathfindingNavMeshStatus;

-

-class LLPathfindingManager : public LLSingleton<LLPathfindingManager>

-{

-	friend class LLNavMeshSimStateChangeNode;

-	friend class LLAgentStateChangeNode;

-	friend class NavMeshStatusResponder;

-	friend class AgentStateResponder;

-public:

-	typedef std::map<LLUUID, LLPathfindingNavMeshPtr> NavMeshMap;

-

-	typedef enum {

-		kAgentStateUnknown,

-		kAgentStateFrozen,

-		kAgentStateUnfrozen,

-		kAgentStateNotEnabled,

-		kAgentStateError

-	} EAgentState;

-

-	typedef boost::function<void (EAgentState)>         agent_state_callback_t;

-	typedef boost::signals2::signal<void (EAgentState)> agent_state_signal_t;

-	typedef boost::signals2::connection                 agent_state_slot_t;

-

-	typedef enum {

-		kRequestStarted,

-		kRequestCompleted,

-		kRequestNotEnabled,

-		kRequestError

-	} ERequestStatus;

-

-	typedef U32 request_id_t;

-

-	typedef boost::function<void (request_id_t, ERequestStatus, LLPathfindingLinksetListPtr)>   linksets_callback_t;

-	typedef boost::function<void (request_id_t, ERequestStatus, LLPathfindingCharacterListPtr)> characters_callback_t;

-

-	LLPathfindingManager();

-	virtual ~LLPathfindingManager();

-

-	bool isPathfindingEnabledForCurrentRegion() const;

-	bool isPathfindingEnabledForRegion(LLViewerRegion *pRegion) const;

-#ifdef DEPRECATED_UNVERSIONED_NAVMESH

-	bool isPathfindingNavMeshVersioningEnabledForCurrentRegionXXX() const;

-#endif // DEPRECATED_UNVERSIONED_NAVMESH

-

-	bool isAllowAlterPermanent();

-	bool isAllowViewTerrainProperties() const;

-

-	LLPathfindingNavMesh::navmesh_slot_t registerNavMeshListenerForRegion(LLViewerRegion *pRegion, LLPathfindingNavMesh::navmesh_callback_t pNavMeshCallback);

-	void requestGetNavMeshForRegion(LLViewerRegion *pRegion);

-

-	agent_state_slot_t registerAgentStateListener(agent_state_callback_t pAgentStateCallback);

-	EAgentState        getAgentState();

-	EAgentState        getLastKnownNonErrorAgentState() const;

-	void               requestSetAgentState(EAgentState pAgentState);

-

-	ERequestStatus requestGetLinksets(request_id_t pRequestId, linksets_callback_t pLinksetsCallback) const;

-	ERequestStatus requestSetLinksets(request_id_t pRequestId, LLPathfindingLinksetListPtr pLinksetList, LLPathfindingLinkset::ELinksetUse pLinksetUse, S32 pA, S32 pB, S32 pC, S32 pD, linksets_callback_t pLinksetsCallback) const;

-

-	ERequestStatus requestGetCharacters(request_id_t pRequestId, characters_callback_t pCharactersCallback) const;

-

-protected:

-

-private:

-	void sendRequestGetNavMeshForRegion(LLPathfindingNavMeshPtr navMeshPtr, LLViewerRegion *pRegion, const LLPathfindingNavMeshStatus &pNavMeshStatus);

-

-	void handleNavMeshStatusRequest(const LLPathfindingNavMeshStatus &pNavMeshStatus, LLViewerRegion *pRegion);

-	void handleNavMeshStatusUpdate(const LLPathfindingNavMeshStatus &pNavMeshStatus);

-

-	LLPathfindingNavMeshPtr getNavMeshForRegion(const LLUUID &pRegionUUID);

-	LLPathfindingNavMeshPtr getNavMeshForRegion(LLViewerRegion *pRegion);

-

-	static bool isValidAgentState(EAgentState pAgentState);

-

-	void requestGetAgentState();

-	void setAgentState(EAgentState pAgentState);

-	void handleAgentStateResult(const LLSD &pContent, EAgentState pRequestedAgentState);

-	void handleAgentStateError(U32 pStatus, const std::string &pReason, const std::string &pURL);

-	void handleAgentStateUpdate(const LLSD &pContent);

-

-	std::string getNavMeshStatusURLForRegion(LLViewerRegion *pRegion) const;

-	std::string getRetrieveNavMeshURLForRegion(LLViewerRegion *pRegion) const;

-	std::string getAgentStateURLForCurrentRegion() const;

-	std::string getObjectLinksetsURLForCurrentRegion() const;

-	std::string getTerrainLinksetsURLForCurrentRegion() const;

-	std::string getCharactersURLForCurrentRegion() const;

-

-	std::string    getCapabilityURLForCurrentRegion(const std::string &pCapabilityName) const;

-	std::string    getCapabilityURLForRegion(LLViewerRegion *pRegion, const std::string &pCapabilityName) const;

-	LLViewerRegion *getCurrentRegion() const;

-

-	NavMeshMap           mNavMeshMap;

-

-	agent_state_signal_t mAgentStateSignal;

-	EAgentState          mAgentState;

-	EAgentState          mLastKnownNonErrorAgentState;

-};

-

-#endif // LL_LLPATHFINDINGMANAGER_H

+/**
+ * @file llpathfindingmanager.h
+ * @author William Todd Stinson
+ * @brief A state manager for the various pathfinding states.
+ *
+ * $LicenseInfo:firstyear=2002&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2010, Linden Research, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#ifndef LL_LLPATHFINDINGMANAGER_H
+#define LL_LLPATHFINDINGMANAGER_H
+
+#include "llsingleton.h"
+#include "lluuid.h"
+#include "llpathfindingnavmesh.h"
+#include "llpathfindinglinkset.h"
+#include "llpathfindinglinksetlist.h"
+#include "llpathfindingcharacterlist.h"
+
+#include <string>
+#include <map>
+
+#include <boost/function.hpp>
+#include <boost/signals2.hpp>
+
+class LLFloater;
+class LLViewerRegion;
+class LLPathfindingNavMeshStatus;
+
+class LLPathfindingManager : public LLSingleton<LLPathfindingManager>
+{
+	friend class LLNavMeshSimStateChangeNode;
+	friend class LLAgentStateChangeNode;
+	friend class NavMeshStatusResponder;
+	friend class AgentStateResponder;
+public:
+	typedef std::map<LLUUID, LLPathfindingNavMeshPtr> NavMeshMap;
+
+	typedef enum {
+		kAgentStateUnknown,
+		kAgentStateFrozen,
+		kAgentStateUnfrozen,
+		kAgentStateNotEnabled,
+		kAgentStateError
+	} EAgentState;
+
+	typedef boost::function<void (EAgentState)>         agent_state_callback_t;
+	typedef boost::signals2::signal<void (EAgentState)> agent_state_signal_t;
+	typedef boost::signals2::connection                 agent_state_slot_t;
+
+	typedef enum {
+		kRequestStarted,
+		kRequestCompleted,
+		kRequestNotEnabled,
+		kRequestError
+	} ERequestStatus;
+
+	typedef U32 request_id_t;
+
+	typedef boost::function<void (request_id_t, ERequestStatus, LLPathfindingLinksetListPtr)>   linksets_callback_t;
+	typedef boost::function<void (request_id_t, ERequestStatus, LLPathfindingCharacterListPtr)> characters_callback_t;
+
+	LLPathfindingManager();
+	virtual ~LLPathfindingManager();
+
+	bool isPathfindingEnabledForCurrentRegion() const;
+	bool isPathfindingEnabledForRegion(LLViewerRegion *pRegion) const;
+#ifdef DEPRECATED_UNVERSIONED_NAVMESH
+	bool isPathfindingNavMeshVersioningEnabledForCurrentRegionXXX() const;
+#endif // DEPRECATED_UNVERSIONED_NAVMESH
+
+	bool isAllowAlterPermanent();
+	bool isAllowViewTerrainProperties() const;
+
+	LLPathfindingNavMesh::navmesh_slot_t registerNavMeshListenerForRegion(LLViewerRegion *pRegion, LLPathfindingNavMesh::navmesh_callback_t pNavMeshCallback);
+	void requestGetNavMeshForRegion(LLViewerRegion *pRegion);
+
+	agent_state_slot_t registerAgentStateListener(agent_state_callback_t pAgentStateCallback);
+	EAgentState        getAgentState();
+	EAgentState        getLastKnownNonErrorAgentState() const;
+	void               requestSetAgentState(EAgentState pAgentState);
+
+	ERequestStatus requestGetLinksets(request_id_t pRequestId, linksets_callback_t pLinksetsCallback) const;
+	ERequestStatus requestSetLinksets(request_id_t pRequestId, LLPathfindingLinksetListPtr pLinksetList, LLPathfindingLinkset::ELinksetUse pLinksetUse, S32 pA, S32 pB, S32 pC, S32 pD, linksets_callback_t pLinksetsCallback) const;
+
+	ERequestStatus requestGetCharacters(request_id_t pRequestId, characters_callback_t pCharactersCallback) const;
+
+protected:
+
+private:
+	void sendRequestGetNavMeshForRegion(LLPathfindingNavMeshPtr navMeshPtr, LLViewerRegion *pRegion, const LLPathfindingNavMeshStatus &pNavMeshStatus);
+
+	void handleDeferredGetNavMeshForRegion(const LLUUID &pRegionUUID);
+
+	void handleNavMeshStatusRequest(const LLPathfindingNavMeshStatus &pNavMeshStatus, LLViewerRegion *pRegion);
+	void handleNavMeshStatusUpdate(const LLPathfindingNavMeshStatus &pNavMeshStatus);
+
+	LLPathfindingNavMeshPtr getNavMeshForRegion(const LLUUID &pRegionUUID);
+	LLPathfindingNavMeshPtr getNavMeshForRegion(LLViewerRegion *pRegion);
+
+	static bool isValidAgentState(EAgentState pAgentState);
+
+	void requestGetAgentState();
+	void setAgentState(EAgentState pAgentState);
+	void handleAgentStateResult(const LLSD &pContent, EAgentState pRequestedAgentState);
+	void handleAgentStateError(U32 pStatus, const std::string &pReason, const std::string &pURL);
+	void handleAgentStateUpdate(const LLSD &pContent);
+
+	std::string getNavMeshStatusURLForRegion(LLViewerRegion *pRegion) const;
+	std::string getRetrieveNavMeshURLForRegion(LLViewerRegion *pRegion) const;
+	std::string getAgentStateURLForCurrentRegion() const;
+	std::string getObjectLinksetsURLForCurrentRegion() const;
+	std::string getTerrainLinksetsURLForCurrentRegion() const;
+	std::string getCharactersURLForCurrentRegion() const;
+
+	std::string    getCapabilityURLForCurrentRegion(const std::string &pCapabilityName) const;
+	std::string    getCapabilityURLForRegion(LLViewerRegion *pRegion, const std::string &pCapabilityName) const;
+	LLViewerRegion *getCurrentRegion() const;
+
+	NavMeshMap           mNavMeshMap;
+
+	agent_state_signal_t mAgentStateSignal;
+	EAgentState          mAgentState;
+	EAgentState          mLastKnownNonErrorAgentState;
+};
+
+#endif // LL_LLPATHFINDINGMANAGER_H
+
diff --git a/indra/newview/llpathfindingnavmesh.cpp b/indra/newview/llpathfindingnavmesh.cpp
index 10e9abaf0c..4e4e9fceef 100644
--- a/indra/newview/llpathfindingnavmesh.cpp
+++ b/indra/newview/llpathfindingnavmesh.cpp
@@ -1,195 +1,201 @@
-/** 

- * @file llpathfindingnavmesh.cpp

- * @author William Todd Stinson

- * @brief A class for representing the navmesh of a pathfinding region.

- *

- * $LicenseInfo:firstyear=2002&license=viewerlgpl$

- * Second Life Viewer Source Code

- * Copyright (C) 2010, Linden Research, Inc.

- * 

- * This library is free software; you can redistribute it and/or

- * modify it under the terms of the GNU Lesser General Public

- * License as published by the Free Software Foundation;

- * version 2.1 of the License only.

- * 

- * This library is distributed in the hope that it will be useful,

- * but WITHOUT ANY WARRANTY; without even the implied warranty of

- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

- * Lesser General Public License for more details.

- * 

- * You should have received a copy of the GNU Lesser General Public

- * License along with this library; if not, write to the Free Software

- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

- * 

- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA

- * $/LicenseInfo$

- */

-

-#include "llviewerprecompiledheaders.h"

-#include "lluuid.h"

-#include "llpathfindingnavmesh.h"

-#include "llpathfindingnavmeshstatus.h"

-#include "llsdserialize.h"

-

-#include <string>

-

-#define NAVMESH_VERSION_FIELD "navmesh_version"

-#define NAVMESH_DATA_FIELD    "navmesh_data"

-

-//---------------------------------------------------------------------------

-// LLPathfindingNavMesh

-//---------------------------------------------------------------------------

-

-LLPathfindingNavMesh::LLPathfindingNavMesh(const LLUUID &pRegionUUID)

-	: mNavMeshStatus(pRegionUUID),

-	mNavMeshRequestStatus(kNavMeshRequestUnknown),

-	mNavMeshSignal(),

-	mNavMeshData()

-	

-{

-}

-

-LLPathfindingNavMesh::~LLPathfindingNavMesh()

-{

-}

-

-LLPathfindingNavMesh::navmesh_slot_t LLPathfindingNavMesh::registerNavMeshListener(navmesh_callback_t pNavMeshCallback)

-{

-	return mNavMeshSignal.connect(pNavMeshCallback);

-}

-

-bool LLPathfindingNavMesh::hasNavMeshVersion(const LLPathfindingNavMeshStatus &pNavMeshStatus) const

-{

-	return ((mNavMeshStatus.getVersion() == pNavMeshStatus.getVersion()) &&

-		((mNavMeshRequestStatus == kNavMeshRequestStarted) || (mNavMeshRequestStatus == kNavMeshRequestCompleted) ||

-		((mNavMeshRequestStatus == kNavMeshRequestChecking) && !mNavMeshData.empty())));

-}

-

-void LLPathfindingNavMesh::handleNavMeshCheckVersion()

-{

-	setRequestStatus(kNavMeshRequestChecking);

-}

-

-void LLPathfindingNavMesh::handleRefresh(const LLPathfindingNavMeshStatus &pNavMeshStatus)

-{

-	llassert(mNavMeshStatus.getRegionUUID() == pNavMeshStatus.getRegionUUID());

-	llassert(mNavMeshStatus.getVersion() == pNavMeshStatus.getVersion());

-	mNavMeshStatus = pNavMeshStatus;

-	if (mNavMeshRequestStatus == kNavMeshRequestChecking)

-	{

-		llassert(!mNavMeshData.empty());

-		setRequestStatus(kNavMeshRequestCompleted);

-	}

-	else

-	{

-		sendStatus();

-	}

-}

-

-void LLPathfindingNavMesh::handleNavMeshNewVersion(const LLPathfindingNavMeshStatus &pNavMeshStatus)

-{

-	llassert(mNavMeshStatus.getRegionUUID() == pNavMeshStatus.getRegionUUID());

-	if (mNavMeshStatus.getVersion() == pNavMeshStatus.getVersion())

-	{

-		mNavMeshStatus = pNavMeshStatus;

-		sendStatus();

-	}

-	else

-	{

-		mNavMeshData.clear();

-		mNavMeshStatus = pNavMeshStatus;

-		setRequestStatus(kNavMeshRequestNeedsUpdate);

-	}

-}

-

-void LLPathfindingNavMesh::handleNavMeshStart(const LLPathfindingNavMeshStatus &pNavMeshStatus)

-{

-	llassert(mNavMeshStatus.getRegionUUID() == pNavMeshStatus.getRegionUUID());

-	mNavMeshStatus = pNavMeshStatus;

-	setRequestStatus(kNavMeshRequestStarted);

-}

-

-void LLPathfindingNavMesh::handleNavMeshResult(const LLSD &pContent, U32 pNavMeshVersion)

-{

-	if (pContent.has(NAVMESH_VERSION_FIELD))

-	{

-		llassert(pContent.get(NAVMESH_VERSION_FIELD).isInteger());

-		llassert(pContent.get(NAVMESH_VERSION_FIELD).asInteger() >= 0);

-		U32 embeddedNavMeshVersion = static_cast<U32>(pContent.get(NAVMESH_VERSION_FIELD).asInteger());

-		llassert(embeddedNavMeshVersion == pNavMeshVersion); // stinson 03/13/2012 : does this ever occur?

-		if (embeddedNavMeshVersion != pNavMeshVersion)

-		{

-			llwarns << "Mismatch between expected and embedded navmesh versions occurred" << llendl;

-			pNavMeshVersion = embeddedNavMeshVersion;

-		}

-	}

-		

-	if (mNavMeshStatus.getVersion() == pNavMeshVersion)

-	{

-		ENavMeshRequestStatus status;

-		if ( pContent.has(NAVMESH_DATA_FIELD) )

-		{

-			const LLSD::Binary &value = pContent.get(NAVMESH_DATA_FIELD).asBinary();

-			unsigned int binSize = value.size();

-			std::string newStr(reinterpret_cast<const char *>(&value[0]), binSize);

-			std::istringstream streamdecomp( newStr );                 

-			unsigned int decompBinSize = 0;

-			bool valid = false;

-			U8* pUncompressedNavMeshContainer = unzip_llsdNavMesh( valid, decompBinSize, streamdecomp, binSize ) ;

-			if ( !valid )

-			{

-				llwarns << "Unable to decompress the navmesh llsd." << llendl;

-				status = kNavMeshRequestError;

-			}

-			else

-			{

-				llassert(pUncompressedNavMeshContainer);

-				mNavMeshData.resize( decompBinSize );

-				memcpy( &mNavMeshData[0], &pUncompressedNavMeshContainer[0], decompBinSize );

-				status = kNavMeshRequestCompleted;

-			}					

-			if ( pUncompressedNavMeshContainer )

-			{

-				free( pUncompressedNavMeshContainer );

-			}

-		}

-		else

-		{

-			llwarns << "No mesh data received" << llendl;

-			status = kNavMeshRequestError;

-		}

-		setRequestStatus(status);

-	}

-}

-

-void LLPathfindingNavMesh::handleNavMeshNotEnabled()

-{

-	mNavMeshData.clear();

-	setRequestStatus(kNavMeshRequestNotEnabled);

-}

-

-void LLPathfindingNavMesh::handleNavMeshError()

-{

-	mNavMeshData.clear();

-	setRequestStatus(kNavMeshRequestError);

-}

-

-void LLPathfindingNavMesh::handleNavMeshError(U32 pStatus, const std::string &pReason, const std::string &pURL, U32 pNavMeshVersion)

-{

-	llwarns << "error with request to URL '" << pURL << "' because " << pReason << " (statusCode:" << pStatus << ")" << llendl;

-	if (mNavMeshStatus.getVersion() == pNavMeshVersion)

-	{

-		handleNavMeshError();

-	}

-}

-

-void LLPathfindingNavMesh::setRequestStatus(ENavMeshRequestStatus pNavMeshRequestStatus)

-{

-	mNavMeshRequestStatus = pNavMeshRequestStatus;

-	sendStatus();

-}

-

-void LLPathfindingNavMesh::sendStatus()

-{

-	mNavMeshSignal(mNavMeshRequestStatus, mNavMeshStatus, mNavMeshData);

-}

+/**
+ * @file llpathfindingnavmesh.cpp
+ * @author William Todd Stinson
+ * @brief A class for representing the navmesh of a pathfinding region.
+ *
+ * $LicenseInfo:firstyear=2002&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2010, Linden Research, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#include "llviewerprecompiledheaders.h"
+#include "lluuid.h"
+#include "llpathfindingnavmesh.h"
+#include "llpathfindingnavmeshstatus.h"
+#include "llsdserialize.h"
+
+#include <string>
+
+#define NAVMESH_VERSION_FIELD "navmesh_version"
+#define NAVMESH_DATA_FIELD    "navmesh_data"
+
+//---------------------------------------------------------------------------
+// LLPathfindingNavMesh
+//---------------------------------------------------------------------------
+
+LLPathfindingNavMesh::LLPathfindingNavMesh(const LLUUID &pRegionUUID)
+	: mNavMeshStatus(pRegionUUID),
+	mNavMeshRequestStatus(kNavMeshRequestUnknown),
+	mNavMeshSignal(),
+	mNavMeshData()
+
+{
+}
+
+LLPathfindingNavMesh::~LLPathfindingNavMesh()
+{
+}
+
+LLPathfindingNavMesh::navmesh_slot_t LLPathfindingNavMesh::registerNavMeshListener(navmesh_callback_t pNavMeshCallback)
+{
+	return mNavMeshSignal.connect(pNavMeshCallback);
+}
+
+bool LLPathfindingNavMesh::hasNavMeshVersion(const LLPathfindingNavMeshStatus &pNavMeshStatus) const
+{
+	return ((mNavMeshStatus.getVersion() == pNavMeshStatus.getVersion()) &&
+		((mNavMeshRequestStatus == kNavMeshRequestStarted) || (mNavMeshRequestStatus == kNavMeshRequestCompleted) ||
+		((mNavMeshRequestStatus == kNavMeshRequestChecking) && !mNavMeshData.empty())));
+}
+
+void LLPathfindingNavMesh::handleNavMeshWaitForRegionLoad()
+{
+	setRequestStatus(kNavMeshRequestWaiting);
+}
+
+void LLPathfindingNavMesh::handleNavMeshCheckVersion()
+{
+	setRequestStatus(kNavMeshRequestChecking);
+}
+
+void LLPathfindingNavMesh::handleRefresh(const LLPathfindingNavMeshStatus &pNavMeshStatus)
+{
+	llassert(mNavMeshStatus.getRegionUUID() == pNavMeshStatus.getRegionUUID());
+	llassert(mNavMeshStatus.getVersion() == pNavMeshStatus.getVersion());
+	mNavMeshStatus = pNavMeshStatus;
+	if (mNavMeshRequestStatus == kNavMeshRequestChecking)
+	{
+		llassert(!mNavMeshData.empty());
+		setRequestStatus(kNavMeshRequestCompleted);
+	}
+	else
+	{
+		sendStatus();
+	}
+}
+
+void LLPathfindingNavMesh::handleNavMeshNewVersion(const LLPathfindingNavMeshStatus &pNavMeshStatus)
+{
+	llassert(mNavMeshStatus.getRegionUUID() == pNavMeshStatus.getRegionUUID());
+	if (mNavMeshStatus.getVersion() == pNavMeshStatus.getVersion())
+	{
+		mNavMeshStatus = pNavMeshStatus;
+		sendStatus();
+	}
+	else
+	{
+		mNavMeshData.clear();
+		mNavMeshStatus = pNavMeshStatus;
+		setRequestStatus(kNavMeshRequestNeedsUpdate);
+	}
+}
+
+void LLPathfindingNavMesh::handleNavMeshStart(const LLPathfindingNavMeshStatus &pNavMeshStatus)
+{
+	llassert(mNavMeshStatus.getRegionUUID() == pNavMeshStatus.getRegionUUID());
+	mNavMeshStatus = pNavMeshStatus;
+	setRequestStatus(kNavMeshRequestStarted);
+}
+
+void LLPathfindingNavMesh::handleNavMeshResult(const LLSD &pContent, U32 pNavMeshVersion)
+{
+	if (pContent.has(NAVMESH_VERSION_FIELD))
+	{
+		llassert(pContent.get(NAVMESH_VERSION_FIELD).isInteger());
+		llassert(pContent.get(NAVMESH_VERSION_FIELD).asInteger() >= 0);
+		U32 embeddedNavMeshVersion = static_cast<U32>(pContent.get(NAVMESH_VERSION_FIELD).asInteger());
+		llassert(embeddedNavMeshVersion == pNavMeshVersion); // stinson 03/13/2012 : does this ever occur?
+		if (embeddedNavMeshVersion != pNavMeshVersion)
+		{
+			llwarns << "Mismatch between expected and embedded navmesh versions occurred" << llendl;
+			pNavMeshVersion = embeddedNavMeshVersion;
+		}
+	}
+
+	if (mNavMeshStatus.getVersion() == pNavMeshVersion)
+	{
+		ENavMeshRequestStatus status;
+		if ( pContent.has(NAVMESH_DATA_FIELD) )
+		{
+			const LLSD::Binary &value = pContent.get(NAVMESH_DATA_FIELD).asBinary();
+			unsigned int binSize = value.size();
+			std::string newStr(reinterpret_cast<const char *>(&value[0]), binSize);
+			std::istringstream streamdecomp( newStr );
+			unsigned int decompBinSize = 0;
+			bool valid = false;
+			U8* pUncompressedNavMeshContainer = unzip_llsdNavMesh( valid, decompBinSize, streamdecomp, binSize ) ;
+			if ( !valid )
+			{
+				llwarns << "Unable to decompress the navmesh llsd." << llendl;
+				status = kNavMeshRequestError;
+			}
+			else
+			{
+				llassert(pUncompressedNavMeshContainer);
+				mNavMeshData.resize( decompBinSize );
+				memcpy( &mNavMeshData[0], &pUncompressedNavMeshContainer[0], decompBinSize );
+				status = kNavMeshRequestCompleted;
+			}
+			if ( pUncompressedNavMeshContainer )
+			{
+				free( pUncompressedNavMeshContainer );
+			}
+		}
+		else
+		{
+			llwarns << "No mesh data received" << llendl;
+			status = kNavMeshRequestError;
+		}
+		setRequestStatus(status);
+	}
+}
+
+void LLPathfindingNavMesh::handleNavMeshNotEnabled()
+{
+	mNavMeshData.clear();
+	setRequestStatus(kNavMeshRequestNotEnabled);
+}
+
+void LLPathfindingNavMesh::handleNavMeshError()
+{
+	mNavMeshData.clear();
+	setRequestStatus(kNavMeshRequestError);
+}
+
+void LLPathfindingNavMesh::handleNavMeshError(U32 pStatus, const std::string &pReason, const std::string &pURL, U32 pNavMeshVersion)
+{
+	llwarns << "error with request to URL '" << pURL << "' because " << pReason << " (statusCode:" << pStatus << ")" << llendl;
+	if (mNavMeshStatus.getVersion() == pNavMeshVersion)
+	{
+		handleNavMeshError();
+	}
+}
+
+void LLPathfindingNavMesh::setRequestStatus(ENavMeshRequestStatus pNavMeshRequestStatus)
+{
+	mNavMeshRequestStatus = pNavMeshRequestStatus;
+	sendStatus();
+}
+
+void LLPathfindingNavMesh::sendStatus()
+{
+	mNavMeshSignal(mNavMeshRequestStatus, mNavMeshStatus, mNavMeshData);
+}
+
diff --git a/indra/newview/llpathfindingnavmesh.h b/indra/newview/llpathfindingnavmesh.h
index 290f7a2cdf..55fdd9aaa7 100644
--- a/indra/newview/llpathfindingnavmesh.h
+++ b/indra/newview/llpathfindingnavmesh.h
@@ -1,95 +1,98 @@
-/** 

- * @file llpathfindingnavmesh.h

- * @author William Todd Stinson

- * @brief A class for representing the navmesh of a pathfinding region.

- *

- * $LicenseInfo:firstyear=2002&license=viewerlgpl$

- * Second Life Viewer Source Code

- * Copyright (C) 2010, Linden Research, Inc. 

- * 

- * This library is free software; you can redistribute it and/or

- * modify it under the terms of the GNU Lesser General Public

- * License as published by the Free Software Foundation;

- * version 2.1 of the License only.

- * 

- * This library is distributed in the hope that it will be useful,

- * but WITHOUT ANY WARRANTY; without even the implied warranty of

- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

- * Lesser General Public License for more details.

- * 

- * You should have received a copy of the GNU Lesser General Public

- * License along with this library; if not, write to the Free Software

- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

- * 

- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA

- * $/LicenseInfo$

- */

-

-#ifndef LL_LLPATHFINDINGNAVMESH_H

-#define LL_LLPATHFINDINGNAVMESH_H

-

-#include "llsd.h"

-

-#include <string>

-

-#include <boost/shared_ptr.hpp>

-#include <boost/function.hpp>

-#include <boost/signals2.hpp>

-

-#include "llpathfindingnavmeshstatus.h"

-

-class LLUUID;

-class LLPathfindingNavMesh;

-

-typedef boost::shared_ptr<LLPathfindingNavMesh> LLPathfindingNavMeshPtr;

-

-class LLPathfindingNavMesh

-{

-public:

-	typedef enum {

-		kNavMeshRequestUnknown,

-		kNavMeshRequestChecking,

-		kNavMeshRequestNeedsUpdate,

-		kNavMeshRequestStarted,

-		kNavMeshRequestCompleted,

-		kNavMeshRequestNotEnabled,

-		kNavMeshRequestError

-	} ENavMeshRequestStatus;

-

-	typedef boost::function<void (ENavMeshRequestStatus, const LLPathfindingNavMeshStatus &, const LLSD::Binary &)>         navmesh_callback_t;

-	typedef boost::signals2::signal<void (ENavMeshRequestStatus, const LLPathfindingNavMeshStatus &, const LLSD::Binary &)> navmesh_signal_t;

-	typedef boost::signals2::connection                                                                                     navmesh_slot_t;

-

-	LLPathfindingNavMesh(const LLUUID &pRegionUUID);

-	virtual ~LLPathfindingNavMesh();

-

-	navmesh_slot_t registerNavMeshListener(navmesh_callback_t pNavMeshCallback);

-

-#ifdef DEPRECATED_UNVERSIONED_NAVMESH

-	const LLPathfindingNavMeshStatus &getNavMeshStatusXXX() const {return mNavMeshStatus;};

-#endif // DEPRECATED_UNVERSIONED_NAVMESH

-

-	bool hasNavMeshVersion(const LLPathfindingNavMeshStatus &pNavMeshStatus) const;

-

-	void handleNavMeshCheckVersion();

-	void handleRefresh(const LLPathfindingNavMeshStatus &pNavMeshStatus);

-	void handleNavMeshNewVersion(const LLPathfindingNavMeshStatus &pNavMeshStatus);

-	void handleNavMeshStart(const LLPathfindingNavMeshStatus &pNavMeshStatus);

-	void handleNavMeshResult(const LLSD &pContent, U32 pNavMeshVersion);

-	void handleNavMeshNotEnabled();

-	void handleNavMeshError();

-	void handleNavMeshError(U32 pStatus, const std::string &pReason, const std::string &pURL, U32 pNavMeshVersion);

-

-protected:

-

-private:

-	void setRequestStatus(ENavMeshRequestStatus pNavMeshRequestStatus);

-	void sendStatus();

-

-	LLPathfindingNavMeshStatus mNavMeshStatus;

-	ENavMeshRequestStatus      mNavMeshRequestStatus;

-	navmesh_signal_t           mNavMeshSignal;

-	LLSD::Binary               mNavMeshData;

-};

-

-#endif // LL_LLPATHFINDINGNAVMESH_H

+/**
+ * @file llpathfindingnavmesh.h
+ * @author William Todd Stinson
+ * @brief A class for representing the navmesh of a pathfinding region.
+ *
+ * $LicenseInfo:firstyear=2002&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2010, Linden Research, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#ifndef LL_LLPATHFINDINGNAVMESH_H
+#define LL_LLPATHFINDINGNAVMESH_H
+
+#include "llsd.h"
+
+#include <string>
+
+#include <boost/shared_ptr.hpp>
+#include <boost/function.hpp>
+#include <boost/signals2.hpp>
+
+#include "llpathfindingnavmeshstatus.h"
+
+class LLUUID;
+class LLPathfindingNavMesh;
+
+typedef boost::shared_ptr<LLPathfindingNavMesh> LLPathfindingNavMeshPtr;
+
+class LLPathfindingNavMesh
+{
+public:
+	typedef enum {
+		kNavMeshRequestUnknown,
+		kNavMeshRequestWaiting,
+		kNavMeshRequestChecking,
+		kNavMeshRequestNeedsUpdate,
+		kNavMeshRequestStarted,
+		kNavMeshRequestCompleted,
+		kNavMeshRequestNotEnabled,
+		kNavMeshRequestError
+	} ENavMeshRequestStatus;
+
+	typedef boost::function<void (ENavMeshRequestStatus, const LLPathfindingNavMeshStatus &, const LLSD::Binary &)>         navmesh_callback_t;
+	typedef boost::signals2::signal<void (ENavMeshRequestStatus, const LLPathfindingNavMeshStatus &, const LLSD::Binary &)> navmesh_signal_t;
+	typedef boost::signals2::connection                                                                                     navmesh_slot_t;
+
+	LLPathfindingNavMesh(const LLUUID &pRegionUUID);
+	virtual ~LLPathfindingNavMesh();
+
+	navmesh_slot_t registerNavMeshListener(navmesh_callback_t pNavMeshCallback);
+
+#ifdef DEPRECATED_UNVERSIONED_NAVMESH
+	const LLPathfindingNavMeshStatus &getNavMeshStatusXXX() const {return mNavMeshStatus;};
+#endif // DEPRECATED_UNVERSIONED_NAVMESH
+
+	bool hasNavMeshVersion(const LLPathfindingNavMeshStatus &pNavMeshStatus) const;
+
+	void handleNavMeshWaitForRegionLoad();
+	void handleNavMeshCheckVersion();
+	void handleRefresh(const LLPathfindingNavMeshStatus &pNavMeshStatus);
+	void handleNavMeshNewVersion(const LLPathfindingNavMeshStatus &pNavMeshStatus);
+	void handleNavMeshStart(const LLPathfindingNavMeshStatus &pNavMeshStatus);
+	void handleNavMeshResult(const LLSD &pContent, U32 pNavMeshVersion);
+	void handleNavMeshNotEnabled();
+	void handleNavMeshError();
+	void handleNavMeshError(U32 pStatus, const std::string &pReason, const std::string &pURL, U32 pNavMeshVersion);
+
+protected:
+
+private:
+	void setRequestStatus(ENavMeshRequestStatus pNavMeshRequestStatus);
+	void sendStatus();
+
+	LLPathfindingNavMeshStatus mNavMeshStatus;
+	ENavMeshRequestStatus      mNavMeshRequestStatus;
+	navmesh_signal_t           mNavMeshSignal;
+	LLSD::Binary               mNavMeshData;
+};
+
+#endif // LL_LLPATHFINDINGNAVMESH_H
+
diff --git a/indra/newview/llpathfindingnavmeshzone.cpp b/indra/newview/llpathfindingnavmeshzone.cpp
index 9c7b493701..f7872f6e29 100644
--- a/indra/newview/llpathfindingnavmeshzone.cpp
+++ b/indra/newview/llpathfindingnavmeshzone.cpp
@@ -206,6 +206,7 @@ void LLPathfindingNavMeshZone::handleNavMeshLocation()
 void LLPathfindingNavMeshZone::updateStatus()
 {
 	bool hasRequestUnknown = false;
+	bool hasRequestWaiting = false;
 	bool hasRequestChecking = false;
 	bool hasRequestNeedsUpdate = false;
 	bool hasRequestStarted = false;
@@ -228,6 +229,9 @@ void LLPathfindingNavMeshZone::updateStatus()
 		case LLPathfindingNavMesh::kNavMeshRequestUnknown :
 			hasRequestUnknown = true;
 			break;
+		case LLPathfindingNavMesh::kNavMeshRequestWaiting :
+			hasRequestWaiting = true;
+			break;
 		case LLPathfindingNavMesh::kNavMeshRequestChecking :
 			hasRequestChecking = true;
 			break;
@@ -254,7 +258,14 @@ void LLPathfindingNavMeshZone::updateStatus()
 	}
 
 	ENavMeshZoneRequestStatus zoneRequestStatus = kNavMeshZoneRequestUnknown;
-	if (hasRequestNeedsUpdate)
+	if (hasRequestWaiting)
+	{
+		zoneRequestStatus = kNavMeshZoneRequestWaiting;
+#ifdef XXX_STINSON_DEBUG_NAVMESH_ZONE
+		llinfos << "STINSON DEBUG: Navmesh zone update is WAITING" << llendl;
+#endif // XXX_STINSON_DEBUG_NAVMESH_ZONE
+	}
+	else if (hasRequestNeedsUpdate)
 	{
 		zoneRequestStatus = kNavMeshZoneRequestNeedsUpdate;
 #ifdef XXX_STINSON_DEBUG_NAVMESH_ZONE
diff --git a/indra/newview/llpathfindingnavmeshzone.h b/indra/newview/llpathfindingnavmeshzone.h
index 7f83e9d37b..8c330559a9 100644
--- a/indra/newview/llpathfindingnavmeshzone.h
+++ b/indra/newview/llpathfindingnavmeshzone.h
@@ -1,134 +1,136 @@
-/** 

- * @file llpathfindingnavmeshzone.h

- * @author William Todd Stinson

- * @brief A class for representing the zone of navmeshes containing and possible surrounding the current region.

- *

- * $LicenseInfo:firstyear=2002&license=viewerlgpl$

- * Second Life Viewer Source Code

- * Copyright (C) 2010, Linden Research, Inc. 

- * 

- * This library is free software; you can redistribute it and/or

- * modify it under the terms of the GNU Lesser General Public

- * License as published by the Free Software Foundation;

- * version 2.1 of the License only.

- * 

- * This library is distributed in the hope that it will be useful,

- * but WITHOUT ANY WARRANTY; without even the implied warranty of

- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

- * Lesser General Public License for more details.

- * 

- * You should have received a copy of the GNU Lesser General Public

- * License along with this library; if not, write to the Free Software

- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

- * 

- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA

- * $/LicenseInfo$

- */

-

-#ifndef LL_LLPATHFINDINGNAVMESHZONE_H

-#define LL_LLPATHFINDINGNAVMESHZONE_H

-

-#include "llsd.h"

-#include "lluuid.h"

-#include "llpathfindingnavmesh.h"

-#include "llpathfindingnavmeshstatus.h"

-

-#include <vector>

-

-#include <boost/shared_ptr.hpp>

-#include <boost/function.hpp>

-#include <boost/signals2.hpp>

-

-class LLPathfindingNavMeshStatus;

-

-//#define XXX_STINSON_DEBUG_NAVMESH_ZONE

-

-class LLPathfindingNavMeshZone

-{

-public:

-	typedef enum {

-		kNavMeshZoneRequestUnknown,

-		kNavMeshZoneRequestChecking,

-		kNavMeshZoneRequestNeedsUpdate,

-		kNavMeshZoneRequestStarted,

-		kNavMeshZoneRequestCompleted,

-		kNavMeshZoneRequestNotEnabled,

-		kNavMeshZoneRequestError

-	} ENavMeshZoneRequestStatus;

-

-	typedef enum {

-		kNavMeshZonePending,

-		kNavMeshZoneBuilding,

-		kNavMeshZoneSomePending,

-		kNavMeshZoneSomeBuilding,

-		kNavMeshZonePendingAndBuilding,

-		kNavMeshZoneComplete

-	} ENavMeshZoneStatus;

-

-	typedef boost::function<void (ENavMeshZoneRequestStatus)>         navmesh_zone_callback_t;

-	typedef boost::signals2::signal<void (ENavMeshZoneRequestStatus)> navmesh_zone_signal_t;

-	typedef boost::signals2::connection                                                   navmesh_zone_slot_t;

-

-	LLPathfindingNavMeshZone();

-	virtual ~LLPathfindingNavMeshZone();

-

-	navmesh_zone_slot_t registerNavMeshZoneListener(navmesh_zone_callback_t pNavMeshZoneCallback);

-	void initialize();

-

-	void enable();

-	void disable();

-	void refresh();

-

-	ENavMeshZoneStatus getNavMeshZoneStatus() const;

-

-protected:

-

-private:

-	typedef boost::function<void (void)> navmesh_location_callback_t;

-	class NavMeshLocation

-	{

-	public:

-		NavMeshLocation(S32 pDirection, navmesh_location_callback_t pLocationCallback);

-		virtual ~NavMeshLocation();

-

-		void enable();

-		void refresh();

-		void disable();

-

-		LLPathfindingNavMesh::ENavMeshRequestStatus getRequestStatus() const;

-		LLPathfindingNavMeshStatus::ENavMeshStatus  getNavMeshStatus() const;

-#ifdef XXX_STINSON_DEBUG_NAVMESH_ZONE

-		const LLUUID &getRegionUUID() const {return mRegionUUID;};

-		S32          getDirection() const {return mDirection;};

-#endif // XXX_STINSON_DEBUG_NAVMESH_ZONE

-

-	protected:

-

-	private:

-		void           handleNavMesh(LLPathfindingNavMesh::ENavMeshRequestStatus pNavMeshRequestStatus, const LLPathfindingNavMeshStatus &pNavMeshStatus, const LLSD::Binary &pNavMeshData);

-

-		void           clear();

-		LLViewerRegion *getRegion() const;

-

-		S32                                         mDirection;

-		LLUUID                                      mRegionUUID;

-		bool                                        mHasNavMesh;

-		U32                                         mNavMeshVersion;

-		LLPathfindingNavMeshStatus::ENavMeshStatus  mNavMeshStatus;

-		navmesh_location_callback_t                 mLocationCallback;

-		LLPathfindingNavMesh::ENavMeshRequestStatus mRequestStatus;

-		LLPathfindingNavMesh::navmesh_slot_t        mNavMeshSlot;

-	};

-

-	typedef boost::shared_ptr<NavMeshLocation> NavMeshLocationPtr;

-	typedef std::vector<NavMeshLocationPtr> NavMeshLocationPtrs;

-

-	void handleNavMeshLocation();

-	void updateStatus();

-

-	NavMeshLocationPtrs       mNavMeshLocationPtrs;

-	ENavMeshZoneRequestStatus mNavMeshZoneRequestStatus;

-	navmesh_zone_signal_t     mNavMeshZoneSignal;

-};

-

-#endif // LL_LLPATHFINDINGNAVMESHZONE_H

+/**
+ * @file llpathfindingnavmeshzone.h
+ * @author William Todd Stinson
+ * @brief A class for representing the zone of navmeshes containing and possible surrounding the current region.
+ *
+ * $LicenseInfo:firstyear=2002&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2010, Linden Research, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#ifndef LL_LLPATHFINDINGNAVMESHZONE_H
+#define LL_LLPATHFINDINGNAVMESHZONE_H
+
+#include "llsd.h"
+#include "lluuid.h"
+#include "llpathfindingnavmesh.h"
+#include "llpathfindingnavmeshstatus.h"
+
+#include <vector>
+
+#include <boost/shared_ptr.hpp>
+#include <boost/function.hpp>
+#include <boost/signals2.hpp>
+
+class LLPathfindingNavMeshStatus;
+
+//#define XXX_STINSON_DEBUG_NAVMESH_ZONE
+
+class LLPathfindingNavMeshZone
+{
+public:
+	typedef enum {
+		kNavMeshZoneRequestUnknown,
+		kNavMeshZoneRequestWaiting,
+		kNavMeshZoneRequestChecking,
+		kNavMeshZoneRequestNeedsUpdate,
+		kNavMeshZoneRequestStarted,
+		kNavMeshZoneRequestCompleted,
+		kNavMeshZoneRequestNotEnabled,
+		kNavMeshZoneRequestError
+	} ENavMeshZoneRequestStatus;
+
+	typedef enum {
+		kNavMeshZonePending,
+		kNavMeshZoneBuilding,
+		kNavMeshZoneSomePending,
+		kNavMeshZoneSomeBuilding,
+		kNavMeshZonePendingAndBuilding,
+		kNavMeshZoneComplete
+	} ENavMeshZoneStatus;
+
+	typedef boost::function<void (ENavMeshZoneRequestStatus)>         navmesh_zone_callback_t;
+	typedef boost::signals2::signal<void (ENavMeshZoneRequestStatus)> navmesh_zone_signal_t;
+	typedef boost::signals2::connection                                                   navmesh_zone_slot_t;
+
+	LLPathfindingNavMeshZone();
+	virtual ~LLPathfindingNavMeshZone();
+
+	navmesh_zone_slot_t registerNavMeshZoneListener(navmesh_zone_callback_t pNavMeshZoneCallback);
+	void initialize();
+
+	void enable();
+	void disable();
+	void refresh();
+
+	ENavMeshZoneStatus getNavMeshZoneStatus() const;
+
+protected:
+
+private:
+	typedef boost::function<void (void)> navmesh_location_callback_t;
+	class NavMeshLocation
+	{
+	public:
+		NavMeshLocation(S32 pDirection, navmesh_location_callback_t pLocationCallback);
+		virtual ~NavMeshLocation();
+
+		void enable();
+		void refresh();
+		void disable();
+
+		LLPathfindingNavMesh::ENavMeshRequestStatus getRequestStatus() const;
+		LLPathfindingNavMeshStatus::ENavMeshStatus  getNavMeshStatus() const;
+#ifdef XXX_STINSON_DEBUG_NAVMESH_ZONE
+		const LLUUID &getRegionUUID() const {return mRegionUUID;};
+		S32          getDirection() const {return mDirection;};
+#endif // XXX_STINSON_DEBUG_NAVMESH_ZONE
+
+	protected:
+
+	private:
+		void           handleNavMesh(LLPathfindingNavMesh::ENavMeshRequestStatus pNavMeshRequestStatus, const LLPathfindingNavMeshStatus &pNavMeshStatus, const LLSD::Binary &pNavMeshData);
+
+		void           clear();
+		LLViewerRegion *getRegion() const;
+
+		S32                                         mDirection;
+		LLUUID                                      mRegionUUID;
+		bool                                        mHasNavMesh;
+		U32                                         mNavMeshVersion;
+		LLPathfindingNavMeshStatus::ENavMeshStatus  mNavMeshStatus;
+		navmesh_location_callback_t                 mLocationCallback;
+		LLPathfindingNavMesh::ENavMeshRequestStatus mRequestStatus;
+		LLPathfindingNavMesh::navmesh_slot_t        mNavMeshSlot;
+	};
+
+	typedef boost::shared_ptr<NavMeshLocation> NavMeshLocationPtr;
+	typedef std::vector<NavMeshLocationPtr> NavMeshLocationPtrs;
+
+	void handleNavMeshLocation();
+	void updateStatus();
+
+	NavMeshLocationPtrs       mNavMeshLocationPtrs;
+	ENavMeshZoneRequestStatus mNavMeshZoneRequestStatus;
+	navmesh_zone_signal_t     mNavMeshZoneSignal;
+};
+
+#endif // LL_LLPATHFINDINGNAVMESHZONE_H
+
diff --git a/indra/newview/skins/default/xui/en/floater_pathfinding_console.xml b/indra/newview/skins/default/xui/en/floater_pathfinding_console.xml
index a951106640..54d44be015 100644
--- a/indra/newview/skins/default/xui/en/floater_pathfinding_console.xml
+++ b/indra/newview/skins/default/xui/en/floater_pathfinding_console.xml
@@ -14,6 +14,7 @@
   <floater.string name="navmesh_viewer_status_unknown"></floater.string>
   <floater.string name="navmesh_viewer_status_library_not_implemented">Cannot find pathing library implementation.</floater.string>
   <floater.string name="navmesh_viewer_status_region_not_enabled">This region is not enabled for pathfinding.</floater.string>
+  <floater.string name="navmesh_viewer_status_region_loading">Waiting for the region to finish loading.</floater.string>
   <floater.string name="navmesh_viewer_status_checking_version">Checking the status of the navmesh.</floater.string>
   <floater.string name="navmesh_viewer_status_downloading">Downloading the navmesh.</floater.string>
   <floater.string name="navmesh_viewer_status_updating">The navmesh has changed on the server. Downloading the latest navmesh.</floater.string>