PATH-292: Adding the ability to view and edit pathfinding attributes of the terrain.

9 files changed, 384 insertions, 130 deletions

diff --git a/indra/newview/llfloaterpathfindinglinksets.cpp b/indra/newview/llfloaterpathfindinglinksets.cpp
index 6dd9a7ced3..cabbe1d130 100644
--- a/indra/newview/llfloaterpathfindinglinksets.cpp
+++ b/indra/newview/llfloaterpathfindinglinksets.cpp
@@ -610,7 +610,7 @@ void LLFloaterPathfindingLinksets::updateScrollList()
 				linksetIter != mLinksetsListPtr->end(); ++linksetIter)

 			{

 				const LLPathfindingLinksetPtr linksetPtr(linksetIter->second);

-				std::string linksetName = linksetPtr->getName();

+				std::string linksetName = (linksetPtr->isTerrain() ? getString("linkset_terrain_name") : linksetPtr->getName());

 				std::string linksetDescription = linksetPtr->getDescription();

 				LLStringUtil::toUpper(linksetName);

 				LLStringUtil::toUpper(linksetDescription);

@@ -643,22 +643,43 @@ void LLFloaterPathfindingLinksets::updateScrollList()
 LLSD LLFloaterPathfindingLinksets::buildScrollListElement(const LLPathfindingLinksetPtr pLinksetPtr, const LLVector3 &pAvatarPosition)

 {

 	LLSD columns;

-

-	columns[0]["column"] = "name";

-	columns[0]["value"] = pLinksetPtr->getName();

-	columns[0]["font"] = "SANSSERIF";

-

-	columns[1]["column"] = "description";

-	columns[1]["value"] = pLinksetPtr->getDescription();

-	columns[1]["font"] = "SANSSERIF";

-

-	columns[2]["column"] = "land_impact";

-	columns[2]["value"] = llformat("%1d", pLinksetPtr->getLandImpact());

-	columns[2]["font"] = "SANSSERIF";

-

-	columns[3]["column"] = "dist_from_you";

-	columns[3]["value"] = llformat("%1.0f m", dist_vec(pAvatarPosition, pLinksetPtr->getLocation()));

-	columns[3]["font"] = "SANSSERIF";

+	

+	if (pLinksetPtr->isTerrain())

+	{

+		columns[0]["column"] = "name";

+		columns[0]["value"] = getString("linkset_terrain_name");

+		columns[0]["font"] = "SANSSERIF";

+		

+		columns[1]["column"] = "description";

+		columns[1]["value"] = getString("linkset_terrain_description");

+		columns[1]["font"] = "SANSSERIF";

+		

+		columns[2]["column"] = "land_impact";

+		columns[2]["value"] = getString("linkset_terrain_land_impact");

+		columns[2]["font"] = "SANSSERIF";

+		

+		columns[3]["column"] = "dist_from_you";

+		columns[3]["value"] = getString("linkset_terrain_dist_from_you");

+		columns[3]["font"] = "SANSSERIF";

+	}

+	else

+	{

+		columns[0]["column"] = "name";

+		columns[0]["value"] = pLinksetPtr->getName();

+		columns[0]["font"] = "SANSSERIF";

+		

+		columns[1]["column"] = "description";

+		columns[1]["value"] = pLinksetPtr->getDescription();

+		columns[1]["font"] = "SANSSERIF";

+		

+		columns[2]["column"] = "land_impact";

+		columns[2]["value"] = llformat("%1d", pLinksetPtr->getLandImpact());

+		columns[2]["font"] = "SANSSERIF";

+		

+		columns[3]["column"] = "dist_from_you";

+		columns[3]["value"] = llformat("%1.0f m", dist_vec(pAvatarPosition, pLinksetPtr->getLocation()));

+		columns[3]["font"] = "SANSSERIF";

+	}

 

 	columns[4]["column"] = "linkset_use";

 	std::string linksetUse;

diff --git a/indra/newview/llpathfindinglinkset.cpp b/indra/newview/llpathfindinglinkset.cpp
index d775ec2fef..9df9968332 100644
--- a/indra/newview/llpathfindinglinkset.cpp
+++ b/indra/newview/llpathfindinglinkset.cpp
@@ -51,8 +51,26 @@
 const S32 LLPathfindingLinkset::MIN_WALKABILITY_VALUE(0);

 const S32 LLPathfindingLinkset::MAX_WALKABILITY_VALUE(100);

 

+LLPathfindingLinkset::LLPathfindingLinkset(const LLSD& pTerrainLinksetItem)

+	: mUUID(),

+	mIsTerrain(true),

+	mName(),

+	mDescription(),

+	mLandImpact(0U),

+	mLocation(LLVector3::zero),

+	mIsLocked(TRUE),

+	mLinksetUse(kUnknown),

+	mWalkabilityCoefficientA(MIN_WALKABILITY_VALUE),

+	mWalkabilityCoefficientB(MIN_WALKABILITY_VALUE),

+	mWalkabilityCoefficientC(MIN_WALKABILITY_VALUE),

+	mWalkabilityCoefficientD(MIN_WALKABILITY_VALUE)

+{

+	parsePathfindingData(pTerrainLinksetItem);

+}

+

 LLPathfindingLinkset::LLPathfindingLinkset(const std::string &pUUID, const LLSD& pLinksetItem)

 	: mUUID(pUUID),

+	mIsTerrain(false),

 	mName(),

 	mDescription(),

 	mLandImpact(0U),

@@ -64,66 +82,8 @@ LLPathfindingLinkset::LLPathfindingLinkset(const std::string &pUUID, const LLSD&
 	mWalkabilityCoefficientC(MIN_WALKABILITY_VALUE),

 	mWalkabilityCoefficientD(MIN_WALKABILITY_VALUE)

 {

-	llassert(pLinksetItem.has(LINKSET_NAME_FIELD));

-	llassert(pLinksetItem.get(LINKSET_NAME_FIELD).isString());

-	mName = pLinksetItem.get(LINKSET_NAME_FIELD).asString();

-

-	llassert(pLinksetItem.has(LINKSET_DESCRIPTION_FIELD));

-	llassert(pLinksetItem.get(LINKSET_DESCRIPTION_FIELD).isString());

-	mDescription = pLinksetItem.get(LINKSET_DESCRIPTION_FIELD).asString();

-

-	llassert(pLinksetItem.has(LINKSET_LAND_IMPACT_FIELD));

-	llassert(pLinksetItem.get(LINKSET_LAND_IMPACT_FIELD).isInteger());

-	llassert(pLinksetItem.get(LINKSET_LAND_IMPACT_FIELD).asInteger() >= 0);

-	mLandImpact = pLinksetItem.get(LINKSET_LAND_IMPACT_FIELD).asInteger();

-

-	if (pLinksetItem.has(LINKSET_MODIFIABLE_FIELD))

-	{

-		llassert(pLinksetItem.get(LINKSET_MODIFIABLE_FIELD).isBoolean());

-		mIsLocked = !pLinksetItem.get(LINKSET_MODIFIABLE_FIELD).asBoolean();

-	}

-

-	llassert(pLinksetItem.has(LINKSET_PHANTOM_FIELD));

-	llassert(pLinksetItem.get(LINKSET_PHANTOM_FIELD).isBoolean());

-	bool isPhantom = pLinksetItem.get(LINKSET_PHANTOM_FIELD).asBoolean();

-

-	llassert(pLinksetItem.has(LINKSET_PERMANENT_FIELD));

-	llassert(pLinksetItem.get(LINKSET_PERMANENT_FIELD).isBoolean());

-	bool isPermanent = pLinksetItem.get(LINKSET_PERMANENT_FIELD).asBoolean();

-

-	llassert(pLinksetItem.has(LINKSET_WALKABLE_FIELD));

-	llassert(pLinksetItem.get(LINKSET_WALKABLE_FIELD).isBoolean());

-	bool isWalkable = pLinksetItem.get(LINKSET_WALKABLE_FIELD).asBoolean();

-

-	mLinksetUse = getLinksetUse(isPhantom, isPermanent, isWalkable);

-

-	llassert(pLinksetItem.has(LINKSET_WALKABILITY_A_FIELD));

-	llassert(pLinksetItem.get(LINKSET_WALKABILITY_A_FIELD).isInteger());

-	mWalkabilityCoefficientA = pLinksetItem.get(LINKSET_WALKABILITY_A_FIELD).asInteger();

-	llassert(mWalkabilityCoefficientA >= MIN_WALKABILITY_VALUE);

-	llassert(mWalkabilityCoefficientA <= MAX_WALKABILITY_VALUE);

-

-	llassert(pLinksetItem.has(LINKSET_WALKABILITY_B_FIELD));

-	llassert(pLinksetItem.get(LINKSET_WALKABILITY_B_FIELD).isInteger());

-	mWalkabilityCoefficientB = pLinksetItem.get(LINKSET_WALKABILITY_B_FIELD).asInteger();

-	llassert(mWalkabilityCoefficientB >= MIN_WALKABILITY_VALUE);

-	llassert(mWalkabilityCoefficientB <= MAX_WALKABILITY_VALUE);

-

-	llassert(pLinksetItem.has(LINKSET_WALKABILITY_C_FIELD));

-	llassert(pLinksetItem.get(LINKSET_WALKABILITY_C_FIELD).isInteger());

-	mWalkabilityCoefficientC = pLinksetItem.get(LINKSET_WALKABILITY_C_FIELD).asInteger();

-	llassert(mWalkabilityCoefficientC >= MIN_WALKABILITY_VALUE);

-	llassert(mWalkabilityCoefficientC <= MAX_WALKABILITY_VALUE);

-

-	llassert(pLinksetItem.has(LINKSET_WALKABILITY_D_FIELD));

-	llassert(pLinksetItem.get(LINKSET_WALKABILITY_D_FIELD).isInteger());

-	mWalkabilityCoefficientD = pLinksetItem.get(LINKSET_WALKABILITY_D_FIELD).asInteger();

-	llassert(mWalkabilityCoefficientD >= MIN_WALKABILITY_VALUE);

-	llassert(mWalkabilityCoefficientD <= MAX_WALKABILITY_VALUE);

-

-	llassert(pLinksetItem.has(LINKSET_POSITION_FIELD));

-	llassert(pLinksetItem.get(LINKSET_POSITION_FIELD).isArray());

-	mLocation.setValue(pLinksetItem.get(LINKSET_POSITION_FIELD));

+	parseObjectData(pLinksetItem);

+	parsePathfindingData(pLinksetItem);

 }

 

 LLPathfindingLinkset::LLPathfindingLinkset(const LLPathfindingLinkset& pOther)

@@ -166,7 +126,7 @@ LLSD LLPathfindingLinkset::encodeAlteredFields(ELinksetUse pLinksetUse, S32 pA,
 {

 	LLSD itemData;

 

-	if ((pLinksetUse != kUnknown) && (mLinksetUse != pLinksetUse))

+	if (!isTerrain() && (pLinksetUse != kUnknown) && (mLinksetUse != pLinksetUse))

 	{

 		if (!mIsLocked)

 		{

@@ -199,6 +159,76 @@ LLSD LLPathfindingLinkset::encodeAlteredFields(ELinksetUse pLinksetUse, S32 pA,
 	return itemData;

 }

 

+void LLPathfindingLinkset::parseObjectData(const LLSD &pLinksetItem)

+{

+	llassert(pLinksetItem.has(LINKSET_NAME_FIELD));

+	llassert(pLinksetItem.get(LINKSET_NAME_FIELD).isString());

+	mName = pLinksetItem.get(LINKSET_NAME_FIELD).asString();

+	

+	llassert(pLinksetItem.has(LINKSET_DESCRIPTION_FIELD));

+	llassert(pLinksetItem.get(LINKSET_DESCRIPTION_FIELD).isString());

+	mDescription = pLinksetItem.get(LINKSET_DESCRIPTION_FIELD).asString();

+	

+	llassert(pLinksetItem.has(LINKSET_LAND_IMPACT_FIELD));

+	llassert(pLinksetItem.get(LINKSET_LAND_IMPACT_FIELD).isInteger());

+	llassert(pLinksetItem.get(LINKSET_LAND_IMPACT_FIELD).asInteger() >= 0);

+	mLandImpact = pLinksetItem.get(LINKSET_LAND_IMPACT_FIELD).asInteger();

+	

+	if (pLinksetItem.has(LINKSET_MODIFIABLE_FIELD))

+	{

+		llassert(pLinksetItem.get(LINKSET_MODIFIABLE_FIELD).isBoolean());

+		mIsLocked = !pLinksetItem.get(LINKSET_MODIFIABLE_FIELD).asBoolean();

+	}

+	

+	llassert(pLinksetItem.has(LINKSET_POSITION_FIELD));

+	llassert(pLinksetItem.get(LINKSET_POSITION_FIELD).isArray());

+	mLocation.setValue(pLinksetItem.get(LINKSET_POSITION_FIELD));

+}

+

+void LLPathfindingLinkset::parsePathfindingData(const LLSD &pLinksetItem)

+{

+	bool isPhantom = false;

+	if (pLinksetItem.has(LINKSET_PHANTOM_FIELD))

+	{

+		llassert(pLinksetItem.get(LINKSET_PHANTOM_FIELD).isBoolean());

+		isPhantom = pLinksetItem.get(LINKSET_PHANTOM_FIELD).asBoolean();

+	}

+	

+	llassert(pLinksetItem.has(LINKSET_PERMANENT_FIELD));

+	llassert(pLinksetItem.get(LINKSET_PERMANENT_FIELD).isBoolean());

+	bool isPermanent = pLinksetItem.get(LINKSET_PERMANENT_FIELD).asBoolean();

+	

+	llassert(pLinksetItem.has(LINKSET_WALKABLE_FIELD));

+	llassert(pLinksetItem.get(LINKSET_WALKABLE_FIELD).isBoolean());

+	bool isWalkable = pLinksetItem.get(LINKSET_WALKABLE_FIELD).asBoolean();

+	

+	mLinksetUse = getLinksetUse(isPhantom, isPermanent, isWalkable);

+	

+	llassert(pLinksetItem.has(LINKSET_WALKABILITY_A_FIELD));

+	llassert(pLinksetItem.get(LINKSET_WALKABILITY_A_FIELD).isInteger());

+	mWalkabilityCoefficientA = pLinksetItem.get(LINKSET_WALKABILITY_A_FIELD).asInteger();

+	llassert(mWalkabilityCoefficientA >= MIN_WALKABILITY_VALUE);

+	llassert(mWalkabilityCoefficientA <= MAX_WALKABILITY_VALUE);

+	

+	llassert(pLinksetItem.has(LINKSET_WALKABILITY_B_FIELD));

+	llassert(pLinksetItem.get(LINKSET_WALKABILITY_B_FIELD).isInteger());

+	mWalkabilityCoefficientB = pLinksetItem.get(LINKSET_WALKABILITY_B_FIELD).asInteger();

+	llassert(mWalkabilityCoefficientB >= MIN_WALKABILITY_VALUE);

+	llassert(mWalkabilityCoefficientB <= MAX_WALKABILITY_VALUE);

+	

+	llassert(pLinksetItem.has(LINKSET_WALKABILITY_C_FIELD));

+	llassert(pLinksetItem.get(LINKSET_WALKABILITY_C_FIELD).isInteger());

+	mWalkabilityCoefficientC = pLinksetItem.get(LINKSET_WALKABILITY_C_FIELD).asInteger();

+	llassert(mWalkabilityCoefficientC >= MIN_WALKABILITY_VALUE);

+	llassert(mWalkabilityCoefficientC <= MAX_WALKABILITY_VALUE);

+	

+	llassert(pLinksetItem.has(LINKSET_WALKABILITY_D_FIELD));

+	llassert(pLinksetItem.get(LINKSET_WALKABILITY_D_FIELD).isInteger());

+	mWalkabilityCoefficientD = pLinksetItem.get(LINKSET_WALKABILITY_D_FIELD).asInteger();

+	llassert(mWalkabilityCoefficientD >= MIN_WALKABILITY_VALUE);

+	llassert(mWalkabilityCoefficientD <= MAX_WALKABILITY_VALUE);

+}

+

 LLPathfindingLinkset::ELinksetUse LLPathfindingLinkset::getLinksetUse(bool pIsPhantom, bool pIsPermanent, bool pIsWalkable)

 {

 	return (pIsPhantom ? (pIsPermanent ? (pIsWalkable ? kMaterialVolume : kExclusionVolume) : kDynamicPhantom) :

diff --git a/indra/newview/llpathfindinglinkset.h b/indra/newview/llpathfindinglinkset.h
index ea6cf710b1..3f9217fa3c 100644
--- a/indra/newview/llpathfindinglinkset.h
+++ b/indra/newview/llpathfindinglinkset.h
@@ -52,12 +52,14 @@ public:
 		kDynamicPhantom

 	} ELinksetUse;

 

+	LLPathfindingLinkset(const LLSD &pTerrainLinksetItem);

 	LLPathfindingLinkset(const std::string &pUUID, const LLSD &pLinksetItem);

 	LLPathfindingLinkset(const LLPathfindingLinkset& pOther);

 	virtual ~LLPathfindingLinkset();

 

 	LLPathfindingLinkset& operator = (const LLPathfindingLinkset& pOther);

 

+	inline bool               isTerrain() const                   {return mIsTerrain;};

 	inline const LLUUID&      getUUID() const                     {return mUUID;};

 	inline const std::string& getName() const                     {return mName;};

 	inline const std::string& getDescription() const              {return mDescription;};

@@ -77,6 +79,8 @@ public:
 protected:

 

 private:

+	void                      parseObjectData(const LLSD &pLinksetItem);

+	void                      parsePathfindingData(const LLSD &pLinksetItem);

 	static ELinksetUse        getLinksetUse(bool pIsPhantom, bool pIsPermanent, bool pIsWalkable);

 	static BOOL               isPhantom(ELinksetUse pLinksetUse);

 	static BOOL               isPermanent(ELinksetUse pLinksetUse);

@@ -86,6 +90,7 @@ private:
 	static const S32 MAX_WALKABILITY_VALUE;

 

 	LLUUID       mUUID;

+	bool         mIsTerrain;

 	std::string  mName;

 	std::string  mDescription;

 	U32          mLandImpact;

diff --git a/indra/newview/llpathfindinglinksetlist.cpp b/indra/newview/llpathfindinglinksetlist.cpp
index 7facf88c40..57febbf0f2 100644
--- a/indra/newview/llpathfindinglinksetlist.cpp
+++ b/indra/newview/llpathfindinglinksetlist.cpp
@@ -83,20 +83,40 @@ void LLPathfindingLinksetList::update(const LLPathfindingLinksetList &pUpdateLin
 	}

 }

 

-LLSD LLPathfindingLinksetList::encodeAlteredFields(LLPathfindingLinkset::ELinksetUse pLinksetUse, S32 pA, S32 pB, S32 pC, S32 pD) const

+LLSD LLPathfindingLinksetList::encodeObjectFields(LLPathfindingLinkset::ELinksetUse pLinksetUse, S32 pA, S32 pB, S32 pC, S32 pD) const

 {

 	LLSD listData;

 

 	for (LLPathfindingLinksetMap::const_iterator linksetIter = begin(); linksetIter != end(); ++linksetIter)

 	{

 		const LLPathfindingLinksetPtr linksetPtr = linksetIter->second;

-		LLSD linksetData = linksetPtr->encodeAlteredFields(pLinksetUse, pA, pB, pC, pD);

-		if (!linksetData.isUndefined())

+		if (!linksetPtr->isTerrain())

 		{

-			const std::string& uuid(linksetIter->first);

-			listData[uuid] = linksetData;

+			LLSD linksetData = linksetPtr->encodeAlteredFields(pLinksetUse, pA, pB, pC, pD);

+			if (!linksetData.isUndefined())

+			{

+				const std::string& uuid(linksetIter->first);

+				listData[uuid] = linksetData;

+			}

 		}

 	}

 

 	return listData;

 }

+

+LLSD LLPathfindingLinksetList::encodeTerrainFields(LLPathfindingLinkset::ELinksetUse pLinksetUse, S32 pA, S32 pB, S32 pC, S32 pD) const

+{

+	LLSD terrainData;

+	

+	for (LLPathfindingLinksetMap::const_iterator linksetIter = begin(); linksetIter != end(); ++linksetIter)

+	{

+		const LLPathfindingLinksetPtr linksetPtr = linksetIter->second;

+		if (linksetPtr->isTerrain())

+		{

+			terrainData = linksetPtr->encodeAlteredFields(pLinksetUse, pA, pB, pC, pD);

+			break;

+		}

+	}

+	

+	return terrainData;

+}

diff --git a/indra/newview/llpathfindinglinksetlist.h b/indra/newview/llpathfindinglinksetlist.h
index 443f331770..813c4ec46c 100644
--- a/indra/newview/llpathfindinglinksetlist.h
+++ b/indra/newview/llpathfindinglinksetlist.h
@@ -49,7 +49,8 @@ public:
 

 	void update(const LLPathfindingLinksetList &pUpdateLinksetList);

 

-	LLSD encodeAlteredFields(LLPathfindingLinkset::ELinksetUse pLinksetUse, S32 pA, S32 pB, S32 pC, S32 pD) const;

+	LLSD encodeObjectFields(LLPathfindingLinkset::ELinksetUse pLinksetUse, S32 pA, S32 pB, S32 pC, S32 pD) const;

+	LLSD encodeTerrainFields(LLPathfindingLinkset::ELinksetUse pLinksetUse, S32 pA, S32 pB, S32 pC, S32 pD) const;

 

 protected:

 

diff --git a/indra/newview/llpathfindingmanager.cpp b/indra/newview/llpathfindingmanager.cpp
index 7cfa07718b..3a96ed72e5 100644
--- a/indra/newview/llpathfindingmanager.cpp
+++ b/indra/newview/llpathfindingmanager.cpp
@@ -44,7 +44,8 @@
 #define CAP_SERVICE_AGENT_STATE       "AgentPreferences"

 #define ALTER_PERMANENT_OBJECTS_FIELD "alter_permanent_objects"

 

-#define CAP_SERVICE_LINKSETS          "ObjectNavMeshProperties"

+#define CAP_SERVICE_OBJECT_LINKSETS   "ObjectNavMeshProperties"

+#define CAP_SERVICE_TERRAIN_LINKSETS  "TerrainNavMeshProperties"

 

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

 // AgentStateResponder

@@ -70,20 +71,79 @@ private:
 // LinksetsResponder

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

 

-class LinksetsResponder : public LLHTTPClient::Responder

+class LinksetsResponder

 {

 public:

-	LinksetsResponder(const std::string &pCapabilityURL, LLPathfindingManager::linksets_callback_t pLinksetsCallback);

+	LinksetsResponder(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::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;

-	LLPathfindingManager::linksets_callback_t mLinksetsCallback;

+	std::string          mCapabilityURL;

+	LinksetsResponderPtr mLinksetsResponsderPtr;

 };

 

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

@@ -163,15 +223,21 @@ LLPathfindingManager::ELinksetsRequestStatus LLPathfindingManager::requestGetLin
 {

 	ELinksetsRequestStatus status;

 

-	std::string linksetsURL = getLinksetsURLForCurrentRegion();

-	if (linksetsURL.empty())

+	std::string objectLinksetsURL = getObjectLinksetsURLForCurrentRegion();

+	std::string terrainLinksetsURL = getTerrainLinksetsURLForCurrentRegion();

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

 	{

 		status = kLinksetsRequestNotEnabled;

 	}

 	else

 	{

-		LLHTTPClient::ResponderPtr responder = new LinksetsResponder(linksetsURL, pLinksetsCallback);

-		LLHTTPClient::get(linksetsURL, responder);

+		LinksetsResponderPtr linksetsResponderPtr(new LinksetsResponder(pLinksetsCallback, true, true));

+		

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

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

+		

+		LLHTTPClient::get(objectLinksetsURL, objectLinksetsResponder);

+		LLHTTPClient::get(terrainLinksetsURL, terrainLinksetsResponder);

 		status = kLinksetsRequestStarted;

 	}

 

@@ -180,24 +246,38 @@ LLPathfindingManager::ELinksetsRequestStatus LLPathfindingManager::requestGetLin
 

 LLPathfindingManager::ELinksetsRequestStatus LLPathfindingManager::requestSetLinksets(LLPathfindingLinksetListPtr pLinksetList, LLPathfindingLinkset::ELinksetUse pLinksetUse, S32 pA, S32 pB, S32 pC, S32 pD, linksets_callback_t pLinksetsCallback) const

 {

-	ELinksetsRequestStatus status;

+	ELinksetsRequestStatus status = kLinksetsRequestNotEnabled;

 

-	std::string linksetsURL = getLinksetsURLForCurrentRegion();

-	if (linksetsURL.empty())

+	std::string objectLinksetsURL = getObjectLinksetsURLForCurrentRegion();

+	std::string terrainLinksetsURL = getTerrainLinksetsURLForCurrentRegion();

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

 	{

 		status = kLinksetsRequestNotEnabled;

 	}

 	else

 	{

-		LLHTTPClient::ResponderPtr responder = new LinksetsResponder(linksetsURL, pLinksetsCallback);

-		LLSD postData = pLinksetList->encodeAlteredFields(pLinksetUse, pA, pB, pC, pD);

-		if (postData.isUndefined())

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

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

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

 		{

 			status = kLinksetsRequestCompleted;

 		}

 		else

 		{

-			LLHTTPClient::put(linksetsURL, postData, responder);

+			LinksetsResponderPtr linksetsResponderPtr(new LinksetsResponder(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 = kLinksetsRequestStarted;

 		}

 	}

@@ -258,19 +338,6 @@ void LLPathfindingManager::handleAgentStateError(U32 pStatus, const std::string
 	setAgentState(kAgentStateError);

 }

 

-void LLPathfindingManager::handleLinksetsResult(const LLSD &pContent, linksets_callback_t pLinksetsCallback) const

-{

-	LLPathfindingLinksetListPtr linksetListPtr(new LLPathfindingLinksetList(pContent));

-	pLinksetsCallback(kLinksetsRequestCompleted, linksetListPtr);

-}

-

-void LLPathfindingManager::handleLinksetsError(U32 pStatus, const std::string &pReason, const std::string &pURL, linksets_callback_t pLinksetsCallback) const

-{

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

-	LLPathfindingLinksetListPtr linksetListPtr(new LLPathfindingLinksetList());

-	pLinksetsCallback(kLinksetsRequestError, linksetListPtr);

-}

-

 std::string LLPathfindingManager::getRetrieveNavMeshURLForCurrentRegion() const

 {

 	return getCapabilityURLForCurrentRegion(CAP_SERVICE_RETRIEVE_NAVMESH);

@@ -281,9 +348,14 @@ std::string LLPathfindingManager::getAgentStateURLForCurrentRegion() const
 	return getCapabilityURLForCurrentRegion(CAP_SERVICE_AGENT_STATE);

 }

 

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

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

 {

-	return getCapabilityURLForCurrentRegion(CAP_SERVICE_LINKSETS);

+	return getCapabilityURLForCurrentRegion(CAP_SERVICE_OBJECT_LINKSETS);

+}

+

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

+{

+	return getCapabilityURLForCurrentRegion(CAP_SERVICE_TERRAIN_LINKSETS);

 }

 

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

@@ -334,10 +406,12 @@ void AgentStateResponder::error(U32 pStatus, const std::string &pReason)
 // LinksetsResponder

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

 

-LinksetsResponder::LinksetsResponder(const std::string &pCapabilityURL, LLPathfindingManager::linksets_callback_t pLinksetsCallback)

-	: LLHTTPClient::Responder(),

-	mCapabilityURL(pCapabilityURL),

-	mLinksetsCallback(pLinksetsCallback)

+LinksetsResponder::LinksetsResponder(LLPathfindingManager::linksets_callback_t pLinksetsCallback, bool pIsObjectRequested, bool pIsTerrainRequested)

+	: mLinksetsCallback(pLinksetsCallback),

+	mObjectMessagingState(pIsObjectRequested ? kWaiting : kNotRequested),

+	mTerrainMessagingState(pIsTerrainRequested ? kWaiting : kNotRequested),

+	mObjectLinksetListPtr(),

+	mTerrainLinksetPtr()

 {

 }

 

@@ -345,12 +419,113 @@ LinksetsResponder::~LinksetsResponder()
 {

 }

 

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

+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::ELinksetsRequestStatus requestStatus =

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

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

+		 LLPathfindingManager::kLinksetsRequestCompleted : LLPathfindingManager::kLinksetsRequestError);

+

+	if (mObjectMessagingState != kReceivedGood)

+	{

+		mObjectLinksetListPtr = LLPathfindingLinksetListPtr(new LLPathfindingLinksetList());

+	}

+

+	if (mTerrainMessagingState == kReceivedGood)

+	{

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

+	}

+

+	mLinksetsCallback(requestStatus, mObjectLinksetListPtr);

+}

+

+//---------------------------------------------------------------------------

+// ObjectLinksetsResponder

+//---------------------------------------------------------------------------

+

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

+	: 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)

+: mCapabilityURL(pCapabilityURL),

+mLinksetsResponsderPtr(pLinksetsResponsderPtr)

+{

+}

+

+TerrainLinksetsResponder::~TerrainLinksetsResponder()

+{

+}

+

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

 {

-	LLPathfindingManager::getInstance()->handleLinksetsResult(pContent, mLinksetsCallback);

+	mLinksetsResponsderPtr->handleTerrainLinksetsResult(pContent);

 }

 

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

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

 {

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

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

 }

diff --git a/indra/newview/llpathfindingmanager.h b/indra/newview/llpathfindingmanager.h
index cef2b7c058..4b6fd49640 100644
--- a/indra/newview/llpathfindingmanager.h
+++ b/indra/newview/llpathfindingmanager.h
@@ -5,7 +5,7 @@
  *

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

  * Second Life Viewer Source Code

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

+ * 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

@@ -42,7 +42,6 @@ class LLFloater;
 class LLPathfindingManager : public LLSingleton<LLPathfindingManager>

 {

 	friend class AgentStateResponder;

-	friend class LinksetsResponder;

 public:

 	typedef enum {

 		kAgentStateUnknown,

@@ -90,12 +89,10 @@ private:
 	void handleAgentStateResult(const LLSD &pContent, EAgentState pRequestedAgentState);

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

 

-	void handleLinksetsResult(const LLSD &pContent, linksets_callback_t pLinksetsCallback) const;

-	void handleLinksetsError(U32 pStatus, const std::string &pReason, const std::string &pURL, linksets_callback_t pLinksetsCallback) const;

-

 	std::string getRetrieveNavMeshURLForCurrentRegion() const;

 	std::string getAgentStateURLForCurrentRegion() const;

-	std::string getLinksetsURLForCurrentRegion() const;

+	std::string getObjectLinksetsURLForCurrentRegion() const;

+	std::string getTerrainLinksetsURLForCurrentRegion() const;

 

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

 

diff --git a/indra/newview/llviewerregion.cpp b/indra/newview/llviewerregion.cpp
index 1fd794fd78..6e422a5821 100644
--- a/indra/newview/llviewerregion.cpp
+++ b/indra/newview/llviewerregion.cpp
@@ -1546,6 +1546,7 @@ void LLViewerRegionImpl::buildCapabilityNames(LLSD& capabilityNames)
 	capabilityNames.append("SetDisplayName");
 	capabilityNames.append("SimConsoleAsync");
 	capabilityNames.append("StartGroupProposal");
+	capabilityNames.append("TerrainNavMeshProperties");
 	capabilityNames.append("TextureStats");
 	capabilityNames.append("UntrustedSimulatorMessage");
 	capabilityNames.append("UpdateAgentInformation");
diff --git a/indra/newview/skins/default/xui/en/floater_pathfinding_linksets.xml b/indra/newview/skins/default/xui/en/floater_pathfinding_linksets.xml
index f7e78a91cc..a7c902e45a 100644
--- a/indra/newview/skins/default/xui/en/floater_pathfinding_linksets.xml
+++ b/indra/newview/skins/default/xui/en/floater_pathfinding_linksets.xml
@@ -22,6 +22,10 @@
   <floater.string name="linksets_messaging_complete_none_found">No pathfinding linksets</floater.string>
   <floater.string name="linksets_messaging_complete_available">[NUM_SELECTED] linksets selected out of [NUM_TOTAL]</floater.string>
   <floater.string name="linksets_messaging_not_enabled">This region is not enabled for pathfinding.</floater.string>
+  <floater.string name="linkset_terrain_name">[Terrain]</floater.string>
+  <floater.string name="linkset_terrain_description">--</floater.string>
+  <floater.string name="linkset_terrain_land_impact">--</floater.string>
+  <floater.string name="linkset_terrain_dist_from_you">--</floater.string>
   <floater.string name="linkset_use_walkable">Walkable</floater.string>
   <floater.string name="linkset_use_static_obstacle">Static obstacle</floater.string>
   <floater.string name="linkset_use_dynamic_obstacle">Dynamic obstacle</floater.string>