From 516ad5b3c234321daf01294d6e03bdc4be019d36 Mon Sep 17 00:00:00 2001 From: Todd Stinson Date: Fri, 17 Feb 2012 19:03:16 -0800 Subject: PATH-292: Implementing the new freeze/unfreeze functionality on the basic panel. --- indra/newview/llpathfindingmanager.cpp | 181 +++++++++++++++++++++++++++++++++ 1 file changed, 181 insertions(+) create mode 100644 indra/newview/llpathfindingmanager.cpp (limited to 'indra/newview/llpathfindingmanager.cpp') diff --git a/indra/newview/llpathfindingmanager.cpp b/indra/newview/llpathfindingmanager.cpp new file mode 100644 index 0000000000..e46ec0e171 --- /dev/null +++ b/indra/newview/llpathfindingmanager.cpp @@ -0,0 +1,181 @@ +/** + * @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 + +#include + +#include "llviewerprecompiledheaders.h" +#include "llpathfindingmanager.h" +#include "llsingleton.h" +#include "llhttpclient.h" +#include "llagent.h" +#include "llviewerregion.h" + +#define CAP_SERVICE_RETRIEVE_NAVMESH "RetrieveNavMeshSrc" + +#define CAP_SERVICE_AGENT_STATE "AgentPreferences" +#define ALTER_PERMANENT_OBJECTS_FIELD "alter_permanent_objects" + +//--------------------------------------------------------------------------- +// AgentStateResponder +//--------------------------------------------------------------------------- + +class AgentStateResponder : public LLHTTPClient::Responder +{ +public: + AgentStateResponder(LLPathfindingManager::agent_state_callback_t pAgentStateCB, const std::string &pCapabilityURL); + virtual ~AgentStateResponder(); + + virtual void result(const LLSD &pContent); + virtual void error(U32 pStatus, const std::string& pReason); + +protected: + +private: + LLPathfindingManager::agent_state_callback_t mAgentStateCB; + std::string mCapabilityURL; +}; + +//--------------------------------------------------------------------------- +// LLPathfindingManager +//--------------------------------------------------------------------------- + +LLPathfindingManager::LLPathfindingManager() +{ +} + +LLPathfindingManager::~LLPathfindingManager() +{ +} + +bool LLPathfindingManager::isPathfindingEnabledForCurrentRegion() const +{ + std::string retrieveNavMeshURL = getRetrieveNavMeshURLForCurrentRegion(); + return !retrieveNavMeshURL.empty(); +} + +void LLPathfindingManager::requestGetAgentState(agent_state_callback_t pAgentStateCB) const +{ + std::string agentStateURL = getAgentStateURLForCurrentRegion(); + + if (agentStateURL.empty()) + { + pAgentStateCB(kAgentStateError); + } + else + { + LLHTTPClient::ResponderPtr responder = new AgentStateResponder(pAgentStateCB, agentStateURL); + LLHTTPClient::get(agentStateURL, responder); + } +} + +void LLPathfindingManager::requestSetAgentState(EAgentState pAgentState, agent_state_callback_t pAgentStateCB) const +{ + std::string agentStateURL = getAgentStateURLForCurrentRegion(); + + if (agentStateURL.empty()) + { + pAgentStateCB(kAgentStateError); + } + else + { + LLSD request; + request[ALTER_PERMANENT_OBJECTS_FIELD] = static_cast(pAgentState == kAgentStateUnfrozen); + + LLHTTPClient::ResponderPtr responder = new AgentStateResponder(pAgentStateCB, agentStateURL); + LLHTTPClient::post(agentStateURL, request, responder); + } +} + +void LLPathfindingManager::handleAgentStateResult(const LLSD &pContent, agent_state_callback_t pAgentStateCB) const +{ + llassert(pContent.has(ALTER_PERMANENT_OBJECTS_FIELD)); + llassert(pContent.get(ALTER_PERMANENT_OBJECTS_FIELD).isBoolean()); + EAgentState agentState = (pContent.get(ALTER_PERMANENT_OBJECTS_FIELD).asBoolean() ? kAgentStateUnfrozen : kAgentStateFrozen); + + pAgentStateCB(agentState); +} + +void LLPathfindingManager::handleAgentStateError(U32 pStatus, const std::string &pReason, const std::string &pURL, agent_state_callback_t pAgentStateCB) const +{ + llwarns << "error with request to URL '" << pURL << "' because " << pReason << " (statusCode:" << pStatus << ")" << llendl; + pAgentStateCB(kAgentStateError); +} + +std::string LLPathfindingManager::getRetrieveNavMeshURLForCurrentRegion() const +{ + return getCapabilityURLForCurrentRegion(CAP_SERVICE_RETRIEVE_NAVMESH); +} + +std::string LLPathfindingManager::getAgentStateURLForCurrentRegion() const +{ + return getCapabilityURLForCurrentRegion(CAP_SERVICE_AGENT_STATE); +} + +std::string LLPathfindingManager::getCapabilityURLForCurrentRegion(const std::string &pCapabilityName) const +{ + std::string capabilityURL(""); + + LLViewerRegion* region = gAgent.getRegion(); + if (region != NULL) + { + capabilityURL = region->getCapability(pCapabilityName); + } + + if (capabilityURL.empty()) + { + llwarns << "cannot find capability '" << pCapabilityName << "' for current region '" + << ((region != NULL) ? region->getName() : "") << "'" << llendl; + } + + return capabilityURL; +} + +//--------------------------------------------------------------------------- +// AgentStateResponder +//--------------------------------------------------------------------------- + +AgentStateResponder::AgentStateResponder(LLPathfindingManager::agent_state_callback_t pAgentStateCB, const std::string &pCapabilityURL) + : mAgentStateCB(pAgentStateCB), + mCapabilityURL(pCapabilityURL) +{ +} + +AgentStateResponder::~AgentStateResponder() +{ +} + +void AgentStateResponder::result(const LLSD &pContent) +{ + LLPathfindingManager::getInstance()->handleAgentStateResult(pContent, mAgentStateCB); +} + +void AgentStateResponder::error(U32 pStatus, const std::string &pReason) +{ + LLPathfindingManager::getInstance()->handleAgentStateError(pStatus, pReason, mCapabilityURL, mAgentStateCB); +} -- cgit v1.3 From 1757f3967874a2885b45e3324bf19f677e76f6bc Mon Sep 17 00:00:00 2001 From: Todd Stinson Date: Tue, 21 Feb 2012 18:40:40 -0800 Subject: PATH-296: Refining the behavior of the freeze/unfreeze functionality to support both basic and edit/test pathfinding floaters open at the same time. --- indra/newview/llfloaterpathfindingbasic.cpp | 54 ++++++----- indra/newview/llfloaterpathfindingbasic.h | 15 +-- indra/newview/llpathfindingmanager.cpp | 104 ++++++++++++++++----- indra/newview/llpathfindingmanager.h | 37 +++++--- .../default/xui/en/floater_pathfinding_basic.xml | 7 +- 5 files changed, 150 insertions(+), 67 deletions(-) (limited to 'indra/newview/llpathfindingmanager.cpp') diff --git a/indra/newview/llfloaterpathfindingbasic.cpp b/indra/newview/llfloaterpathfindingbasic.cpp index af20a510c1..654189d4ef 100644 --- a/indra/newview/llfloaterpathfindingbasic.cpp +++ b/indra/newview/llfloaterpathfindingbasic.cpp @@ -25,8 +25,6 @@ * $/LicenseInfo$ */ -#include - #include "llviewerprecompiledheaders.h" #include "llfloaterpathfindingbasic.h" #include "llsd.h" @@ -34,6 +32,9 @@ #include "llbutton.h" #include "llpathfindingmanager.h" +#include +#include + //--------------------------------------------------------------------------- // LLFloaterPathfindingBasic //--------------------------------------------------------------------------- @@ -60,19 +61,25 @@ BOOL LLFloaterPathfindingBasic::postBuild() return LLFloater::postBuild(); } -void LLFloaterPathfindingBasic::onOpen(const LLSD& key) +void LLFloaterPathfindingBasic::onOpen(const LLSD& pKey) { - LLPathfindingManager *pathfindingManager = LLPathfindingManager::getInstance(); - if (pathfindingManager->isPathfindingEnabledForCurrentRegion()) + LLFloater::onOpen(pKey); + + if (!mAgentStateSlot.connected()) { - LLPathfindingManager::getInstance()->requestGetAgentState(boost::bind(&LLFloaterPathfindingBasic::onAgentStateCB, this, _1)); + mAgentStateSlot = LLPathfindingManager::getInstance()->registerAgentStateSignal(boost::bind(&LLFloaterPathfindingBasic::onAgentStateCB, this, _1)); } - else + setAgentState(LLPathfindingManager::getInstance()->getAgentState()); +} + +void LLFloaterPathfindingBasic::onClose(bool pIsAppQuitting) +{ + if (mAgentStateSlot.connected()) { - setAgentState(LLPathfindingManager::kAgentStateNotEnabled); + mAgentStateSlot.disconnect(); } - LLFloater::onOpen(key); + LLFloater::onClose(pIsAppQuitting); } LLFloaterPathfindingBasic::LLFloaterPathfindingBasic(const LLSD& pSeed) @@ -82,7 +89,7 @@ LLFloaterPathfindingBasic::LLFloaterPathfindingBasic(const LLSD& pSeed) mUnfreezeButton(NULL), mFreezeLabel(NULL), mFreezeButton(NULL), - mAgentState(LLPathfindingManager::kAgentStateInitialDefault) + mAgentStateSlot() { } @@ -93,13 +100,13 @@ LLFloaterPathfindingBasic::~LLFloaterPathfindingBasic() void LLFloaterPathfindingBasic::onUnfreezeClicked() { mUnfreezeButton->setEnabled(FALSE); - LLPathfindingManager::getInstance()->requestSetAgentState(LLPathfindingManager::kAgentStateUnfrozen, boost::bind(&LLFloaterPathfindingBasic::onAgentStateCB, this, _1)); + LLPathfindingManager::getInstance()->requestSetAgentState(LLPathfindingManager::kAgentStateUnfrozen); } void LLFloaterPathfindingBasic::onFreezeClicked() { mUnfreezeButton->setEnabled(FALSE); - LLPathfindingManager::getInstance()->requestSetAgentState(LLPathfindingManager::kAgentStateFrozen, boost::bind(&LLFloaterPathfindingBasic::onAgentStateCB, this, _1)); + LLPathfindingManager::getInstance()->requestSetAgentState(LLPathfindingManager::kAgentStateFrozen); } void LLFloaterPathfindingBasic::onAgentStateCB(LLPathfindingManager::EAgentState pAgentState) @@ -109,26 +116,33 @@ void LLFloaterPathfindingBasic::onAgentStateCB(LLPathfindingManager::EAgentState void LLFloaterPathfindingBasic::setAgentState(LLPathfindingManager::EAgentState pAgentState) { + static const LLColor4 warningColor = LLUIColorTable::instance().getColor("DrYellow"); + LLStyle::Params styleParams; + switch (pAgentState) { + case LLPathfindingManager::kAgentStateUnknown : + mStatusText->setVisible(TRUE); + mStatusText->setText((LLStringExplicit)getString("status_querying_state"), styleParams); + break; case LLPathfindingManager::kAgentStateNotEnabled : mStatusText->setVisible(TRUE); - mStatusText->setText((LLStringExplicit)getString("pathfinding_not_enabled")); - mAgentState = pAgentState; + styleParams.color = warningColor; + mStatusText->setText((LLStringExplicit)getString("status_pathfinding_not_enabled"), styleParams); break; case LLPathfindingManager::kAgentStateError : mStatusText->setVisible(TRUE); - mStatusText->setText((LLStringExplicit)getString("unable_to_change_state")); - // Do not actually change the current state in the error case allowing user to retry previous command + styleParams.color = warningColor; + mStatusText->setText((LLStringExplicit)getString("status_unable_to_change_state"), styleParams); break; default : mStatusText->setVisible(FALSE); - mAgentState = pAgentState; break; } - switch (mAgentState) + switch (LLPathfindingManager::getInstance()->getLastKnownNonErrorAgentState()) { + case LLPathfindingManager::kAgentStateUnknown : case LLPathfindingManager::kAgentStateNotEnabled : mUnfreezeLabel->setEnabled(FALSE); mUnfreezeButton->setEnabled(FALSE); @@ -147,12 +161,8 @@ void LLFloaterPathfindingBasic::setAgentState(LLPathfindingManager::EAgentState mFreezeLabel->setEnabled(TRUE); mFreezeButton->setEnabled(TRUE); break; - case LLPathfindingManager::kAgentStateError : - llassert(0); - break; default : llassert(0); break; } } - diff --git a/indra/newview/llfloaterpathfindingbasic.h b/indra/newview/llfloaterpathfindingbasic.h index 356a270ca0..f765917cd7 100644 --- a/indra/newview/llfloaterpathfindingbasic.h +++ b/indra/newview/llfloaterpathfindingbasic.h @@ -42,7 +42,8 @@ class LLFloaterPathfindingBasic public: virtual BOOL postBuild(); - virtual void onOpen(const LLSD& key); + virtual void onOpen(const LLSD& pKey); + virtual void onClose(bool pIsAppQuitting); protected: @@ -59,12 +60,12 @@ private: void setAgentState(LLPathfindingManager::EAgentState pAgentState); - LLTextBase *mStatusText; - LLTextBase *mUnfreezeLabel; - LLButton *mUnfreezeButton; - LLTextBase *mFreezeLabel; - LLButton *mFreezeButton; - LLPathfindingManager::EAgentState mAgentState; + LLTextBase *mStatusText; + LLTextBase *mUnfreezeLabel; + LLButton *mUnfreezeButton; + LLTextBase *mFreezeLabel; + LLButton *mFreezeButton; + LLPathfindingManager::agent_state_slot_t mAgentStateSlot; }; #endif // LL_LLFLOATERPATHFINDINGBASIC_H diff --git a/indra/newview/llpathfindingmanager.cpp b/indra/newview/llpathfindingmanager.cpp index e46ec0e171..3905e6d9f3 100644 --- a/indra/newview/llpathfindingmanager.cpp +++ b/indra/newview/llpathfindingmanager.cpp @@ -27,8 +27,6 @@ #include -#include - #include "llviewerprecompiledheaders.h" #include "llpathfindingmanager.h" #include "llsingleton.h" @@ -36,6 +34,9 @@ #include "llagent.h" #include "llviewerregion.h" +#include +#include + #define CAP_SERVICE_RETRIEVE_NAVMESH "RetrieveNavMeshSrc" #define CAP_SERVICE_AGENT_STATE "AgentPreferences" @@ -48,7 +49,7 @@ class AgentStateResponder : public LLHTTPClient::Responder { public: - AgentStateResponder(LLPathfindingManager::agent_state_callback_t pAgentStateCB, const std::string &pCapabilityURL); + AgentStateResponder(const std::string &pCapabilityURL, LLPathfindingManager::EAgentState pRequestedAgentState = LLPathfindingManager::kAgentStateUnknown); virtual ~AgentStateResponder(); virtual void result(const LLSD &pContent); @@ -57,8 +58,8 @@ public: protected: private: - LLPathfindingManager::agent_state_callback_t mAgentStateCB; - std::string mCapabilityURL; + std::string mCapabilityURL; + LLPathfindingManager::EAgentState mRequestedAgentState; }; //--------------------------------------------------------------------------- @@ -66,6 +67,10 @@ private: //--------------------------------------------------------------------------- LLPathfindingManager::LLPathfindingManager() + : LLSingleton(), + mAgentStateSignal(), + mAgentState(kAgentStateUnknown), + mLastKnownNonErrorAgentState(kAgentStateUnknown) { } @@ -79,52 +84,103 @@ bool LLPathfindingManager::isPathfindingEnabledForCurrentRegion() const return !retrieveNavMeshURL.empty(); } -void LLPathfindingManager::requestGetAgentState(agent_state_callback_t pAgentStateCB) const +LLPathfindingManager::agent_state_slot_t LLPathfindingManager::registerAgentStateSignal(agent_state_callback_t pAgentStateCallback) { - std::string agentStateURL = getAgentStateURLForCurrentRegion(); + return mAgentStateSignal.connect(pAgentStateCallback); +} - if (agentStateURL.empty()) +LLPathfindingManager::EAgentState LLPathfindingManager::getAgentState() +{ + if (!isPathfindingEnabledForCurrentRegion()) { - pAgentStateCB(kAgentStateError); + setAgentState(kAgentStateNotEnabled); } else { - LLHTTPClient::ResponderPtr responder = new AgentStateResponder(pAgentStateCB, agentStateURL); - LLHTTPClient::get(agentStateURL, responder); + if (!isValidAgentState(mAgentState)) + { + requestGetAgentState(); + } } + + return mAgentState; } -void LLPathfindingManager::requestSetAgentState(EAgentState pAgentState, agent_state_callback_t pAgentStateCB) const +LLPathfindingManager::EAgentState LLPathfindingManager::getLastKnownNonErrorAgentState() const { + return mLastKnownNonErrorAgentState; +} + +void LLPathfindingManager::requestSetAgentState(EAgentState pRequestedAgentState) +{ + llassert(isValidAgentState(pRequestedAgentState)); std::string agentStateURL = getAgentStateURLForCurrentRegion(); if (agentStateURL.empty()) { - pAgentStateCB(kAgentStateError); + setAgentState(kAgentStateNotEnabled); } else { LLSD request; - request[ALTER_PERMANENT_OBJECTS_FIELD] = static_cast(pAgentState == kAgentStateUnfrozen); + request[ALTER_PERMANENT_OBJECTS_FIELD] = static_cast(pRequestedAgentState == kAgentStateUnfrozen); - LLHTTPClient::ResponderPtr responder = new AgentStateResponder(pAgentStateCB, agentStateURL); + LLHTTPClient::ResponderPtr responder = new AgentStateResponder(agentStateURL, pRequestedAgentState); LLHTTPClient::post(agentStateURL, request, responder); } } -void LLPathfindingManager::handleAgentStateResult(const LLSD &pContent, agent_state_callback_t pAgentStateCB) const +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) { llassert(pContent.has(ALTER_PERMANENT_OBJECTS_FIELD)); llassert(pContent.get(ALTER_PERMANENT_OBJECTS_FIELD).isBoolean()); EAgentState agentState = (pContent.get(ALTER_PERMANENT_OBJECTS_FIELD).asBoolean() ? kAgentStateUnfrozen : kAgentStateFrozen); - pAgentStateCB(agentState); + if (isValidAgentState(pRequestedAgentState) && (agentState != pRequestedAgentState)) + { + agentState = kAgentStateError; + llassert(0); + } + + setAgentState(agentState); } -void LLPathfindingManager::handleAgentStateError(U32 pStatus, const std::string &pReason, const std::string &pURL, agent_state_callback_t pAgentStateCB) const +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; - pAgentStateCB(kAgentStateError); + setAgentState(kAgentStateError); } std::string LLPathfindingManager::getRetrieveNavMeshURLForCurrentRegion() const @@ -160,9 +216,9 @@ std::string LLPathfindingManager::getCapabilityURLForCurrentRegion(const std::st // AgentStateResponder //--------------------------------------------------------------------------- -AgentStateResponder::AgentStateResponder(LLPathfindingManager::agent_state_callback_t pAgentStateCB, const std::string &pCapabilityURL) - : mAgentStateCB(pAgentStateCB), - mCapabilityURL(pCapabilityURL) +AgentStateResponder::AgentStateResponder(const std::string &pCapabilityURL, LLPathfindingManager::EAgentState pRequestedAgentState) + : mCapabilityURL(pCapabilityURL), + mRequestedAgentState(pRequestedAgentState) { } @@ -172,10 +228,10 @@ AgentStateResponder::~AgentStateResponder() void AgentStateResponder::result(const LLSD &pContent) { - LLPathfindingManager::getInstance()->handleAgentStateResult(pContent, mAgentStateCB); + LLPathfindingManager::getInstance()->handleAgentStateResult(pContent, mRequestedAgentState); } void AgentStateResponder::error(U32 pStatus, const std::string &pReason) { - LLPathfindingManager::getInstance()->handleAgentStateError(pStatus, pReason, mCapabilityURL, mAgentStateCB); + LLPathfindingManager::getInstance()->handleAgentStateError(pStatus, pReason, mCapabilityURL); } diff --git a/indra/newview/llpathfindingmanager.h b/indra/newview/llpathfindingmanager.h index e8aa8385cf..a9432f9077 100644 --- a/indra/newview/llpathfindingmanager.h +++ b/indra/newview/llpathfindingmanager.h @@ -31,6 +31,7 @@ #include #include +#include #include "llsingleton.h" @@ -38,35 +39,49 @@ class LLFloater; class LLPathfindingManager : public LLSingleton { + friend class AgentStateResponder; public: typedef enum { - kAgentStateNotEnabled = 0, - kAgentStateFrozen = 1, - kAgentStateUnfrozen = 2, - kAgentStateError = 3, - kAgentStateInitialDefault = kAgentStateUnfrozen + kAgentStateUnknown, + kAgentStateFrozen, + kAgentStateUnfrozen, + kAgentStateNotEnabled, + kAgentStateError } EAgentState; - typedef boost::function agent_state_callback_t; + typedef boost::function agent_state_callback_t; + typedef boost::signals2::signal agent_state_signal_t; + typedef boost::signals2::connection agent_state_slot_t; LLPathfindingManager(); virtual ~LLPathfindingManager(); bool isPathfindingEnabledForCurrentRegion() const; - void requestGetAgentState(agent_state_callback_t pAgentStateCB) const; - void requestSetAgentState(EAgentState, agent_state_callback_t pAgentStateCB) const; - - void handleAgentStateResult(const LLSD &pContent, agent_state_callback_t pAgentStateCB) const; - void handleAgentStateError(U32 pStatus, const std::string &pReason, const std::string &pURL, agent_state_callback_t pAgentStateCB) const; + agent_state_slot_t registerAgentStateSignal(agent_state_callback_t pAgentStateCallback); + EAgentState getAgentState(); + EAgentState getLastKnownNonErrorAgentState() const; + void requestSetAgentState(EAgentState pAgentState); protected: private: + 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); + std::string getRetrieveNavMeshURLForCurrentRegion() const; std::string getAgentStateURLForCurrentRegion() const; std::string getCapabilityURLForCurrentRegion(const std::string &pCapabilityName) const; + + agent_state_signal_t mAgentStateSignal; + EAgentState mAgentState; + EAgentState mLastKnownNonErrorAgentState; }; #endif // LL_LLPATHFINDINGMANAGER_H diff --git a/indra/newview/skins/default/xui/en/floater_pathfinding_basic.xml b/indra/newview/skins/default/xui/en/floater_pathfinding_basic.xml index f53d11bb1d..7af40bbff6 100644 --- a/indra/newview/skins/default/xui/en/floater_pathfinding_basic.xml +++ b/indra/newview/skins/default/xui/en/floater_pathfinding_basic.xml @@ -11,14 +11,15 @@ single_instance="true" title="Basic pathfinding setup" width="312"> - This region is not enabled for pathfinding. - Unable to change modes successfully. + This region is not enabled for pathfinding. + Unable to change modes successfully. + Checking status ... Date: Wed, 22 Feb 2012 14:04:13 -0800 Subject: Adding a missing base constructor to the list. --- indra/newview/llpathfindingmanager.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'indra/newview/llpathfindingmanager.cpp') diff --git a/indra/newview/llpathfindingmanager.cpp b/indra/newview/llpathfindingmanager.cpp index 3905e6d9f3..76766c4e09 100644 --- a/indra/newview/llpathfindingmanager.cpp +++ b/indra/newview/llpathfindingmanager.cpp @@ -217,7 +217,8 @@ std::string LLPathfindingManager::getCapabilityURLForCurrentRegion(const std::st //--------------------------------------------------------------------------- AgentStateResponder::AgentStateResponder(const std::string &pCapabilityURL, LLPathfindingManager::EAgentState pRequestedAgentState) - : mCapabilityURL(pCapabilityURL), + : LLHTTPClient::Responder(), + mCapabilityURL(pCapabilityURL), mRequestedAgentState(pRequestedAgentState) { } -- cgit v1.3 From 73aa47f391341e6d6ef5136ef73302be689d3e9d Mon Sep 17 00:00:00 2001 From: Todd Stinson Date: Thu, 23 Feb 2012 16:51:06 -0800 Subject: PATH-292: Reworking how and where linksets are requested and managed. --- indra/newview/CMakeLists.txt | 2 + indra/newview/llfloaterpathfindinglinksets.cpp | 639 ++++++++------------- indra/newview/llfloaterpathfindinglinksets.h | 113 ++-- indra/newview/llpathfindinglinkset.cpp | 37 +- indra/newview/llpathfindinglinkset.h | 27 +- indra/newview/llpathfindinglinksetlist.cpp | 103 ++++ indra/newview/llpathfindinglinksetlist.h | 60 ++ indra/newview/llpathfindingmanager.cpp | 111 ++++ indra/newview/llpathfindingmanager.h | 28 +- .../xui/en/floater_pathfinding_linksets.xml | 16 +- 10 files changed, 635 insertions(+), 501 deletions(-) create mode 100644 indra/newview/llpathfindinglinksetlist.cpp create mode 100644 indra/newview/llpathfindinglinksetlist.h (limited to 'indra/newview/llpathfindingmanager.cpp') diff --git a/indra/newview/CMakeLists.txt b/indra/newview/CMakeLists.txt index 1b0cf19c5a..726f0d1e28 100644 --- a/indra/newview/CMakeLists.txt +++ b/indra/newview/CMakeLists.txt @@ -420,6 +420,7 @@ set(viewer_SOURCE_FILES llpatchvertexarray.cpp llpathfindingcharacter.cpp llpathfindinglinkset.cpp + llpathfindinglinksetlist.cpp llpathfindingmanager.cpp llphysicsmotion.cpp llphysicsshapebuilderutil.cpp @@ -974,6 +975,7 @@ set(viewer_HEADER_FILES llpatchvertexarray.h llpathfindingcharacter.h llpathfindinglinkset.h + llpathfindinglinksetlist.h llpathfindingmanager.h llphysicsmotion.h llphysicsshapebuilderutil.h diff --git a/indra/newview/llfloaterpathfindinglinksets.cpp b/indra/newview/llfloaterpathfindinglinksets.cpp index aa0c78527d..73ab01a89f 100644 --- a/indra/newview/llfloaterpathfindinglinksets.cpp +++ b/indra/newview/llfloaterpathfindinglinksets.cpp @@ -34,7 +34,6 @@ #include "v3math.h" #include "lltextvalidate.h" #include "llagent.h" -#include "llhandle.h" #include "lltextbase.h" #include "lllineeditor.h" #include "llscrolllistitem.h" @@ -48,9 +47,11 @@ #include "llviewermenu.h" #include "llviewerobject.h" #include "llviewerobjectlist.h" -#include "llhttpclient.h" #include "llpathfindinglinkset.h" -#include "llfilteredpathfindinglinksets.h" +#include "llpathfindinglinksetlist.h" +#include "llpathfindingmanager.h" + +#include #define XUI_LINKSET_USE_NONE 0 #define XUI_LINKSET_USE_WALKABLE 1 @@ -60,48 +61,6 @@ #define XUI_LINKSET_USE_EXCLUSION_VOLUME 5 #define XUI_LINKSET_USE_DYNAMIC_PHANTOM 6 -//--------------------------------------------------------------------------- -// NavMeshDataGetResponder -//--------------------------------------------------------------------------- - -class NavMeshDataGetResponder : public LLHTTPClient::Responder -{ -public: - NavMeshDataGetResponder(const std::string& pNavMeshDataGetURL, - const LLHandle &pLinksetsHandle); - virtual ~NavMeshDataGetResponder(); - - virtual void result(const LLSD& pContent); - virtual void error(U32 pStatus, const std::string& pReason); - -private: - NavMeshDataGetResponder(const NavMeshDataGetResponder& pOther); - - std::string mNavMeshDataGetURL; - LLHandle mLinksetsFloaterHandle; -}; - -//--------------------------------------------------------------------------- -// NavMeshDataPutResponder -//--------------------------------------------------------------------------- - -class NavMeshDataPutResponder : public LLHTTPClient::Responder -{ -public: - NavMeshDataPutResponder(const std::string& pNavMeshDataPutURL, - const LLHandle &pLinksetsHandle); - virtual ~NavMeshDataPutResponder(); - - virtual void result(const LLSD& pContent); - virtual void error(U32 pStatus, const std::string& pReason); - -private: - NavMeshDataPutResponder(const NavMeshDataPutResponder& pOther); - - std::string mNavMeshDataPutURL; - LLHandle mLinksetsFloaterHandle; -}; - //--------------------------------------------------------------------------- // LLFloaterPathfindingLinksets //--------------------------------------------------------------------------- @@ -208,44 +167,38 @@ BOOL LLFloaterPathfindingLinksets::postBuild() llassert(mApplyEditsButton != NULL); mApplyEditsButton->setCommitCallback(boost::bind(&LLFloaterPathfindingLinksets::onApplyChangesClicked, this)); - setEnableActionAndEditFields(false); - setMessagingState(kMessagingInitial); - return LLFloater::postBuild(); } void LLFloaterPathfindingLinksets::onOpen(const LLSD& pKey) { - sendNavMeshDataGetRequest(); + LLFloater::onOpen(pKey); + + requestGetLinksets(); selectNoneLinksets(); mLinksetsScrollList->setCommitOnSelectionChange(true); + + if (!mAgentStateSlot.connected()) + { + LLPathfindingManager::getInstance()->registerAgentStateSignal(boost::bind(&LLFloaterPathfindingLinksets::onAgentStateCB, this, _1)); + } } -void LLFloaterPathfindingLinksets::onClose(bool app_quitting) +void LLFloaterPathfindingLinksets::onClose(bool pAppQuitting) { + if (mAgentStateSlot.connected()) + { + mAgentStateSlot.disconnect(); + } + mLinksetsScrollList->setCommitOnSelectionChange(false); selectNoneLinksets(); if (mLinksetsSelection.notNull()) { - std::vector selectedObjects; - - LLObjectSelection *linksetsSelected = mLinksetsSelection.get(); - for (LLObjectSelection::valid_iterator linksetsIter = linksetsSelected->valid_begin(); - linksetsIter != linksetsSelected->valid_end(); ++linksetsIter) - { - LLSelectNode *linksetsNode = *linksetsIter; - selectedObjects.push_back(linksetsNode->getObject()); - } - - for (std::vector::const_iterator selectedObjectIter = selectedObjects.begin(); - selectedObjectIter != selectedObjects.end(); ++selectedObjectIter) - { - LLViewerObject *selectedObject = *selectedObjectIter; - LLSelectMgr::getInstance()->deselectObjectAndFamily(selectedObject); - } - mLinksetsSelection.clear(); } + + LLFloater::onClose(pAppQuitting); } void LLFloaterPathfindingLinksets::draw() @@ -289,31 +242,13 @@ LLFloaterPathfindingLinksets::EMessagingState LLFloaterPathfindingLinksets::getM return mMessagingState; } -BOOL LLFloaterPathfindingLinksets::isMessagingInProgress() const +bool LLFloaterPathfindingLinksets::isMessagingInProgress() const { - BOOL retVal; - switch (getMessagingState()) - { - case kMessagingFetchStarting : - case kMessagingFetchRequestSent : - case kMessagingFetchRequestSent_MultiRequested : - case kMessagingFetchReceived : - case kMessagingModifyStarting : - case kMessagingModifyRequestSent : - case kMessagingModifyReceived : - retVal = true; - break; - default : - retVal = false; - break; - } - - return retVal; + return ((mMessagingState == kMessagingGetRequestSent) || (mMessagingState == kMessagingSetRequestSent)); } LLFloaterPathfindingLinksets::LLFloaterPathfindingLinksets(const LLSD& pSeed) : LLFloater(pSeed), - mSelfHandle(), mFilterByName(NULL), mFilterByDescription(NULL), mFilterByLinksetUse(NULL), @@ -321,6 +256,8 @@ LLFloaterPathfindingLinksets::LLFloaterPathfindingLinksets(const LLSD& pSeed) mLinksetsStatus(NULL), mRefreshListButton(NULL), mSelectAllButton(NULL), + mSelectNoneButton(NULL), + mShowBeaconCheckBox(NULL), mTakeButton(NULL), mTakeCopyButton(NULL), mReturnButton(NULL), @@ -337,126 +274,89 @@ LLFloaterPathfindingLinksets::LLFloaterPathfindingLinksets(const LLSD& pSeed) mLabelEditD(NULL), mEditD(NULL), mApplyEditsButton(NULL), - mPathfindingLinksets(), - mMessagingState(kMessagingInitial), - mLinksetsSelection() + mMessagingState(kMessagingUnknown), + mLinksetsListPtr(), + mLinksetsSelection(), + mAgentStateSlot() { - mSelfHandle.bind(this); } LLFloaterPathfindingLinksets::~LLFloaterPathfindingLinksets() { } -void LLFloaterPathfindingLinksets::sendNavMeshDataGetRequest() +void LLFloaterPathfindingLinksets::setMessagingState(EMessagingState pMessagingState) { - if (isMessagingInProgress()) - { - if (getMessagingState() == kMessagingFetchRequestSent) - { - setMessagingState(kMessagingFetchRequestSent_MultiRequested); - } - } - else - { - setMessagingState(kMessagingFetchStarting); - mPathfindingLinksets.clearPathfindingLinksets(); - updateLinksetsList(); - - std::string navMeshDataURL = getCapabilityURL(); - if (navMeshDataURL.empty()) - { - setMessagingState(kMessagingServiceNotAvailable); - llwarns << "cannot query object navmesh properties from current region '" << getRegionName() << "'" << llendl; - } - else - { - setMessagingState(kMessagingFetchRequestSent); - LLHTTPClient::get(navMeshDataURL, new NavMeshDataGetResponder(navMeshDataURL, mSelfHandle)); - } - } + mMessagingState = pMessagingState; + updateControls(); } -void LLFloaterPathfindingLinksets::sendNavMeshDataPutRequest(const LLSD& pPostData) +void LLFloaterPathfindingLinksets::requestGetLinksets() { + llassert(!isMessagingInProgress()); if (!isMessagingInProgress()) { - setMessagingState(kMessagingModifyStarting); - std::string navMeshDataURL = getCapabilityURL(); - if (navMeshDataURL.empty()) + switch (LLPathfindingManager::getInstance()->requestGetLinksets(boost::bind(&LLFloaterPathfindingLinksets::handleNewLinksets, this, _1, _2))) { - setMessagingState(kMessagingServiceNotAvailable); - llwarns << "cannot put object navmesh properties for current region '" << getRegionName() << "'" << llendl; - } - else - { - setMessagingState(kMessagingModifyRequestSent); - LLHTTPClient::put(navMeshDataURL, pPostData, new NavMeshDataPutResponder(navMeshDataURL, mSelfHandle)); + case LLPathfindingManager::kLinksetsRequestStarted : + setMessagingState(kMessagingGetRequestSent); + break; + case LLPathfindingManager::kLinksetsRequestNotEnabled : + setMessagingState(kMessagingNotEnabled); + break; + case LLPathfindingManager::kLinksetsRequestError : + setMessagingState(kMessagingGetError); + break; + default : + setMessagingState(kMessagingGetError); + llassert(0); + break; } } } -void LLFloaterPathfindingLinksets::handleNavMeshDataGetReply(const LLSD& pNavMeshData) -{ - setMessagingState(kMessagingFetchReceived); - mPathfindingLinksets.setPathfindingLinksets(pNavMeshData); - updateLinksetsList(); - setMessagingState(kMessagingComplete); -} - -void LLFloaterPathfindingLinksets::handleNavMeshDataGetError(const std::string& pURL, const std::string& pErrorReason) -{ - setMessagingState(kMessagingFetchError); - mPathfindingLinksets.clearPathfindingLinksets(); - updateLinksetsList(); - llwarns << "Error fetching object navmesh properties from URL '" << pURL << "' because " << pErrorReason << llendl; -} - -void LLFloaterPathfindingLinksets::handleNavMeshDataPutReply(const LLSD& pModifiedData) -{ - setMessagingState(kMessagingModifyReceived); - mPathfindingLinksets.updatePathfindingLinksets(pModifiedData); - updateLinksetsList(); - setMessagingState(kMessagingComplete); -} - -void LLFloaterPathfindingLinksets::handleNavMeshDataPutError(const std::string& pURL, const std::string& pErrorReason) +void LLFloaterPathfindingLinksets::requestSetLinksets(LLPathfindingLinksetListPtr pLinksetList, LLPathfindingLinkset::ELinksetUse pLinksetUse, S32 pA, S32 pB, S32 pC, S32 pD) { - setMessagingState(kMessagingModifyError); - llwarns << "Error putting object navmesh properties to URL '" << pURL << "' because " << pErrorReason << llendl; -} - -std::string LLFloaterPathfindingLinksets::getRegionName() const -{ - std::string regionName(""); - - LLViewerRegion* region = gAgent.getRegion(); - if (region != NULL) + llassert(!isMessagingInProgress()); + if (!isMessagingInProgress()) { - regionName = region->getName(); + switch (LLPathfindingManager::getInstance()->requestSetLinksets(pLinksetList, pLinksetUse, pA, pB, pC, pD, boost::bind(&LLFloaterPathfindingLinksets::handleNewLinksets, this, _1, _2))) + { + case LLPathfindingManager::kLinksetsRequestStarted : + setMessagingState(kMessagingSetRequestSent); + break; + case LLPathfindingManager::kLinksetsRequestNotEnabled : + setMessagingState(kMessagingNotEnabled); + break; + case LLPathfindingManager::kLinksetsRequestError : + setMessagingState(kMessagingSetError); + break; + default : + setMessagingState(kMessagingSetError); + llassert(0); + break; + } } - - return regionName; } -std::string LLFloaterPathfindingLinksets::getCapabilityURL() const +void LLFloaterPathfindingLinksets::handleNewLinksets(LLPathfindingManager::ELinksetsRequestStatus pLinksetsRequestStatus, LLPathfindingLinksetListPtr pLinksetsListPtr) { - std::string navMeshDataURL(""); + mLinksetsListPtr = pLinksetsListPtr; + updateScrollList(); - LLViewerRegion* region = gAgent.getRegion(); - if (region != NULL) + switch (pLinksetsRequestStatus) { - navMeshDataURL = region->getCapability("ObjectNavMeshProperties"); + case LLPathfindingManager::kLinksetsRequestCompleted : + setMessagingState(kMessagingComplete); + break; + case LLPathfindingManager::kLinksetsRequestError : + setMessagingState(kMessagingGetError); + break; + default : + setMessagingState(kMessagingGetError); + llassert(0); + break; } - - return navMeshDataURL; -} - -void LLFloaterPathfindingLinksets::setMessagingState(EMessagingState pMessagingState) -{ - mMessagingState = pMessagingState; - updateLinksetsStatusMessage(); - updateActionAndEditFields(); } void LLFloaterPathfindingLinksets::onApplyAllFilters() @@ -500,13 +400,13 @@ void LLFloaterPathfindingLinksets::onLinksetsSelectionChange() } } - updateLinksetsStatusMessage(); - updateActionAndEditFields(); + updateEditFieldValues(); + updateControls(); } void LLFloaterPathfindingLinksets::onRefreshLinksetsClicked() { - sendNavMeshDataGetRequest(); + requestGetLinksets(); } void LLFloaterPathfindingLinksets::onSelectAllLinksetsClicked() @@ -547,9 +447,9 @@ void LLFloaterPathfindingLinksets::onTeleportClicked() { std::vector::const_reference selectedItemRef = selectedItems.front(); const LLScrollListItem *selectedItem = selectedItemRef; - LLFilteredPathfindingLinksets::PathfindingLinksetMap::const_iterator linksetIter = mPathfindingLinksets.getFilteredLinksets().find(selectedItem->getUUID().asString()); - const LLPathfindingLinkset &linkset = linksetIter->second; - LLVector3 linksetLocation = linkset.getLocation(); + LLPathfindingLinksetList::const_iterator linksetIter = mLinksetsListPtr->find(selectedItem->getUUID().asString()); + const LLPathfindingLinksetPtr linksetPtr = linksetIter->second; + const LLVector3 &linksetLocation = linksetPtr->getLocation(); LLViewerRegion* region = gAgent.getRegion(); if (region != NULL) @@ -561,27 +461,80 @@ void LLFloaterPathfindingLinksets::onTeleportClicked() void LLFloaterPathfindingLinksets::onApplyChangesClicked() { - applyEditFields(); + applyEdit(); +} + +void LLFloaterPathfindingLinksets::onAgentStateCB(LLPathfindingManager::EAgentState pAgentState) +{ + updateControls(); } void LLFloaterPathfindingLinksets::applyFilters() { - mPathfindingLinksets.setNameFilter(mFilterByName->getText()); - mPathfindingLinksets.setDescriptionFilter(mFilterByDescription->getText()); - mPathfindingLinksets.setLinksetUseFilter(getFilterLinksetUse()); - updateLinksetsList(); +#if 0 + mLinksetsListPtr.setNameFilter(mFilterByName->getText()); + mLinksetsListPtr.setDescriptionFilter(mFilterByDescription->getText()); + mLinksetsListPtr.setLinksetUseFilter(getFilterLinksetUse()); +#endif + updateScrollList(); } void LLFloaterPathfindingLinksets::clearFilters() { - mPathfindingLinksets.clearFilters(); - mFilterByName->setText(LLStringExplicit(mPathfindingLinksets.getNameFilter())); - mFilterByDescription->setText(LLStringExplicit(mPathfindingLinksets.getDescriptionFilter())); - setFilterLinksetUse(mPathfindingLinksets.getLinksetUseFilter()); - updateLinksetsList(); +#if 0 + mLinksetsListPtr.clearFilters(); + mFilterByName->setText(LLStringExplicit(mLinksetsListPtr.getNameFilter())); + mFilterByDescription->setText(LLStringExplicit(mLinksetsListPtr.getDescriptionFilter())); + setFilterLinksetUse(mLinksetsListPtr.getLinksetUseFilter()); +#endif + updateScrollList(); +} + +void LLFloaterPathfindingLinksets::selectAllLinksets() +{ + mLinksetsScrollList->selectAll(); +} + +void LLFloaterPathfindingLinksets::selectNoneLinksets() +{ + mLinksetsScrollList->deselectAllItems(); } -void LLFloaterPathfindingLinksets::updateLinksetsList() +void LLFloaterPathfindingLinksets::updateControls() +{ + updateStatusMessage(); + updateEnableStateOnListActions(); + updateEnableStateOnEditFields(); +} + +void LLFloaterPathfindingLinksets::updateEditFieldValues() +{ + std::vector selectedItems = mLinksetsScrollList->getAllSelected(); + int numSelectedItems = selectedItems.size(); + if (numSelectedItems <= 0) + { + mEditLinksetUse->clear(); + mEditA->clear(); + mEditB->clear(); + mEditC->clear(); + mEditD->clear(); + } + else + { + LLScrollListItem *firstItem = selectedItems.front(); + + LLPathfindingLinksetList::const_iterator linksetIter = mLinksetsListPtr->find(firstItem->getUUID().asString()); + const LLPathfindingLinksetPtr linksetPtr(linksetIter->second); + + setEditLinksetUse(linksetPtr->getLinksetUse()); + mEditA->setValue(LLSD(linksetPtr->getWalkabilityCoefficientA())); + mEditB->setValue(LLSD(linksetPtr->getWalkabilityCoefficientB())); + mEditC->setValue(LLSD(linksetPtr->getWalkabilityCoefficientC())); + mEditD->setValue(LLSD(linksetPtr->getWalkabilityCoefficientD())); + } +} + +void LLFloaterPathfindingLinksets::updateScrollList() { std::vector selectedItems = mLinksetsScrollList->getAllSelected(); int numSelectedItems = selectedItems.size(); @@ -598,102 +551,94 @@ void LLFloaterPathfindingLinksets::updateLinksetsList() } mLinksetsScrollList->deleteAllItems(); - updateLinksetsStatusMessage(); const LLVector3& avatarPosition = gAgent.getPositionAgent(); - const LLFilteredPathfindingLinksets::PathfindingLinksetMap& linksetMap = mPathfindingLinksets.getFilteredLinksets(); - - for (LLFilteredPathfindingLinksets::PathfindingLinksetMap::const_iterator linksetIter = linksetMap.begin(); - linksetIter != linksetMap.end(); ++linksetIter) + for (LLPathfindingLinksetList::const_iterator linksetIter = mLinksetsListPtr->begin(); + linksetIter != mLinksetsListPtr->end(); ++linksetIter) { - const LLPathfindingLinkset& linkset(linksetIter->second); + const LLPathfindingLinksetPtr linksetPtr(linksetIter->second); LLSD columns; columns[0]["column"] = "name"; - columns[0]["value"] = linkset.getName(); + columns[0]["value"] = linksetPtr->getName(); columns[0]["font"] = "SANSSERIF"; columns[1]["column"] = "description"; - columns[1]["value"] = linkset.getDescription(); + columns[1]["value"] = linksetPtr->getDescription(); columns[1]["font"] = "SANSSERIF"; columns[2]["column"] = "land_impact"; - columns[2]["value"] = llformat("%1d", linkset.getLandImpact()); + columns[2]["value"] = llformat("%1d", linksetPtr->getLandImpact()); columns[2]["font"] = "SANSSERIF"; columns[3]["column"] = "dist_from_you"; - columns[3]["value"] = llformat("%1.0f m", dist_vec(avatarPosition, linkset.getLocation())); + columns[3]["value"] = llformat("%1.0f m", dist_vec(avatarPosition, linksetPtr->getLocation())); columns[3]["font"] = "SANSSERIF"; columns[4]["column"] = "linkset_use"; - switch (linkset.getLinksetUse()) + std::string linksetUse; + switch (linksetPtr->getLinksetUse()) { case LLPathfindingLinkset::kWalkable : - columns[4]["value"] = getString("linkset_use_walkable"); + linksetUse = getString("linkset_use_walkable"); break; case LLPathfindingLinkset::kStaticObstacle : - columns[4]["value"] = getString("linkset_use_static_obstacle"); + linksetUse = getString("linkset_use_static_obstacle"); break; case LLPathfindingLinkset::kDynamicObstacle : - columns[4]["value"] = getString("linkset_use_dynamic_obstacle"); + linksetUse = getString("linkset_use_dynamic_obstacle"); break; case LLPathfindingLinkset::kMaterialVolume : - columns[4]["value"] = getString("linkset_use_material_volume"); + linksetUse = getString("linkset_use_material_volume"); break; case LLPathfindingLinkset::kExclusionVolume : - columns[4]["value"] = getString("linkset_use_exclusion_volume"); + linksetUse = getString("linkset_use_exclusion_volume"); break; case LLPathfindingLinkset::kDynamicPhantom : - columns[4]["value"] = getString("linkset_use_dynamic_phantom"); + linksetUse = getString("linkset_use_dynamic_phantom"); break; case LLPathfindingLinkset::kUnknown : default : - columns[4]["value"] = getString("linkset_use_dynamic_obstacle"); + linksetUse = getString("linkset_use_dynamic_obstacle"); llassert(0); break; } + if (linksetPtr->isLocked()) + { + linksetUse += (" " + getString("linkset_is_locked_state")); + } + columns[4]["value"] = linksetUse; columns[4]["font"] = "SANSSERIF"; columns[5]["column"] = "a_percent"; - columns[5]["value"] = llformat("%3d", linkset.getWalkabilityCoefficientA()); + columns[5]["value"] = llformat("%3d", linksetPtr->getWalkabilityCoefficientA()); columns[5]["font"] = "SANSSERIF"; columns[6]["column"] = "b_percent"; - columns[6]["value"] = llformat("%3d", linkset.getWalkabilityCoefficientB()); + columns[6]["value"] = llformat("%3d", linksetPtr->getWalkabilityCoefficientB()); columns[6]["font"] = "SANSSERIF"; columns[7]["column"] = "c_percent"; - columns[7]["value"] = llformat("%3d", linkset.getWalkabilityCoefficientC()); + columns[7]["value"] = llformat("%3d", linksetPtr->getWalkabilityCoefficientC()); columns[7]["font"] = "SANSSERIF"; columns[8]["column"] = "d_percent"; - columns[8]["value"] = llformat("%3d", linkset.getWalkabilityCoefficientD()); + columns[8]["value"] = llformat("%3d", linksetPtr->getWalkabilityCoefficientD()); columns[8]["font"] = "SANSSERIF"; LLSD element; - element["id"] = linkset.getUUID().asString(); + element["id"] = linksetPtr->getUUID().asString(); element["column"] = columns; mLinksetsScrollList->addElement(element); } mLinksetsScrollList->selectMultiple(selectedUUIDs); - updateLinksetsStatusMessage(); - updateActionAndEditFields(); -} - -void LLFloaterPathfindingLinksets::selectAllLinksets() -{ - mLinksetsScrollList->selectAll(); -} - -void LLFloaterPathfindingLinksets::selectNoneLinksets() -{ - mLinksetsScrollList->deselectAllItems(); + updateControls(); } -void LLFloaterPathfindingLinksets::updateLinksetsStatusMessage() +void LLFloaterPathfindingLinksets::updateStatusMessage() { static const LLColor4 warningColor = LLUIColorTable::instance().getColor("DrYellow"); @@ -702,36 +647,21 @@ void LLFloaterPathfindingLinksets::updateLinksetsStatusMessage() switch (getMessagingState()) { - case kMessagingInitial: + case kMessagingUnknown: statusText = getString("linksets_messaging_initial"); break; - case kMessagingFetchStarting : - statusText = getString("linksets_messaging_fetch_starting"); - break; - case kMessagingFetchRequestSent : - statusText = getString("linksets_messaging_fetch_inprogress"); - break; - case kMessagingFetchRequestSent_MultiRequested : - statusText = getString("linksets_messaging_fetch_inprogress_multi_request"); - break; - case kMessagingFetchReceived : - statusText = getString("linksets_messaging_fetch_received"); + case kMessagingGetRequestSent : + statusText = getString("linksets_messaging_get_inprogress"); break; - case kMessagingFetchError : - statusText = getString("linksets_messaging_fetch_error"); + case kMessagingGetError : + statusText = getString("linksets_messaging_get_error"); styleParams.color = warningColor; break; - case kMessagingModifyStarting : - statusText = getString("linksets_messaging_modify_starting"); + case kMessagingSetRequestSent : + statusText = getString("linksets_messaging_set_inprogress"); break; - case kMessagingModifyRequestSent : - statusText = getString("linksets_messaging_modify_inprogress"); - break; - case kMessagingModifyReceived : - statusText = getString("linksets_messaging_modify_received"); - break; - case kMessagingModifyError : - statusText = getString("linksets_messaging_modify_error"); + case kMessagingSetError : + statusText = getString("linksets_messaging_set_error"); styleParams.color = warningColor; break; case kMessagingComplete : @@ -757,8 +687,8 @@ void LLFloaterPathfindingLinksets::updateLinksetsStatusMessage() statusText = getString("linksets_messaging_complete_available", string_args); } break; - case kMessagingServiceNotAvailable : - statusText = getString("linksets_messaging_service_not_available"); + case kMessagingNotEnabled : + statusText = getString("linksets_messaging_not_enabled"); styleParams.color = warningColor; break; default: @@ -770,63 +700,72 @@ void LLFloaterPathfindingLinksets::updateLinksetsStatusMessage() mLinksetsStatus->setText((LLStringExplicit)statusText, styleParams); } -void LLFloaterPathfindingLinksets::updateActionAndEditFields() +void LLFloaterPathfindingLinksets::updateEnableStateOnListActions() { - std::vector selectedItems = mLinksetsScrollList->getAllSelected(); - if (selectedItems.empty()) + switch (getMessagingState()) { - mEditLinksetUse->clear(); - mEditA->clear(); - mEditB->clear(); - mEditC->clear(); - mEditD->clear(); - - setEnableActionAndEditFields(false); + case kMessagingUnknown: + case kMessagingGetRequestSent : + case kMessagingSetRequestSent : + mRefreshListButton->setEnabled(FALSE); + mSelectAllButton->setEnabled(FALSE); + mSelectNoneButton->setEnabled(FALSE); + break; + case kMessagingGetError : + case kMessagingSetError : + case kMessagingNotEnabled : + mRefreshListButton->setEnabled(TRUE); + mSelectAllButton->setEnabled(FALSE); + mSelectNoneButton->setEnabled(FALSE); + break; + case kMessagingComplete : + { + int numItems = mLinksetsScrollList->getItemCount(); + int numSelectedItems = mLinksetsScrollList->getNumSelected(); + mRefreshListButton->setEnabled(TRUE); + mSelectAllButton->setEnabled(numSelectedItems < numItems); + mSelectNoneButton->setEnabled(numSelectedItems > 0); + } + break; + default: + llassert(0); + break; } - else - { - LLScrollListItem *firstItem = selectedItems.front(); +} - const LLFilteredPathfindingLinksets::PathfindingLinksetMap &linksetsMap = mPathfindingLinksets.getAllLinksets(); - LLFilteredPathfindingLinksets::PathfindingLinksetMap::const_iterator linksetIter = linksetsMap.find(firstItem->getUUID().asString()); - const LLPathfindingLinkset &linkset(linksetIter->second); +void LLFloaterPathfindingLinksets::updateEnableStateOnEditFields() +{ + int numSelectedItems = mLinksetsScrollList->getNumSelected(); + bool isEditEnabled = ((numSelectedItems > 0) && LLPathfindingManager::getInstance()->isAllowAlterPermanent()); - setEditLinksetUse(linkset.getLinksetUse()); - mEditA->setValue(LLSD(linkset.getWalkabilityCoefficientA())); - mEditB->setValue(LLSD(linkset.getWalkabilityCoefficientB())); - mEditC->setValue(LLSD(linkset.getWalkabilityCoefficientC())); - mEditD->setValue(LLSD(linkset.getWalkabilityCoefficientD())); + mShowBeaconCheckBox->setEnabled(numSelectedItems > 0); + mTakeButton->setEnabled(isEditEnabled && tools_visible_take_object()); + mTakeCopyButton->setEnabled(isEditEnabled && enable_object_take_copy()); + mReturnButton->setEnabled(isEditEnabled && enable_object_return()); + mDeleteButton->setEnabled(isEditEnabled && enable_object_delete()); + mTeleportButton->setEnabled(numSelectedItems == 1); - setEnableActionAndEditFields(true); - } -} + mEditLinksetUse->setEnabled(isEditEnabled); -void LLFloaterPathfindingLinksets::setEnableActionAndEditFields(BOOL pEnabled) -{ - mTakeButton->setEnabled(pEnabled && tools_visible_take_object()); - mTakeCopyButton->setEnabled(pEnabled && enable_object_take_copy()); - mReturnButton->setEnabled(pEnabled && enable_object_return()); - mDeleteButton->setEnabled(pEnabled && enable_object_delete()); - mTeleportButton->setEnabled(pEnabled && (mLinksetsScrollList->getNumSelected() == 1)); - mEditLinksetUse->setEnabled(pEnabled); - mLabelWalkabilityCoefficients->setEnabled(pEnabled); - mLabelEditA->setEnabled(pEnabled); - mLabelEditB->setEnabled(pEnabled); - mLabelEditC->setEnabled(pEnabled); - mLabelEditD->setEnabled(pEnabled); - mEditA->setEnabled(pEnabled); - mEditB->setEnabled(pEnabled); - mEditC->setEnabled(pEnabled); - mEditD->setEnabled(pEnabled); - mApplyEditsButton->setEnabled(pEnabled); + mLabelWalkabilityCoefficients->setEnabled(isEditEnabled); + mLabelEditA->setEnabled(isEditEnabled); + mLabelEditB->setEnabled(isEditEnabled); + mLabelEditC->setEnabled(isEditEnabled); + mLabelEditD->setEnabled(isEditEnabled); + mEditA->setEnabled(isEditEnabled); + mEditB->setEnabled(isEditEnabled); + mEditC->setEnabled(isEditEnabled); + mEditD->setEnabled(isEditEnabled); + + mApplyEditsButton->setEnabled(isEditEnabled && (getMessagingState() == kMessagingComplete)); } -void LLFloaterPathfindingLinksets::applyEditFields() +void LLFloaterPathfindingLinksets::applyEdit() { std::vector selectedItems = mLinksetsScrollList->getAllSelected(); if (!selectedItems.empty()) { - LLPathfindingLinkset::ELinksetUse pathState = getEditLinksetUse(); // XXX this and pathState + LLPathfindingLinkset::ELinksetUse linksetUse = getEditLinksetUse(); const std::string &aString = mEditA->getText(); const std::string &bString = mEditB->getText(); const std::string &cString = mEditC->getText(); @@ -836,34 +775,20 @@ void LLFloaterPathfindingLinksets::applyEditFields() S32 cValue = static_cast(atoi(cString.c_str())); S32 dValue = static_cast(atoi(dString.c_str())); - const LLFilteredPathfindingLinksets::PathfindingLinksetMap &linksetsMap = mPathfindingLinksets.getAllLinksets(); - - LLSD editData; + LLPathfindingLinksetListPtr editListPtr(new LLPathfindingLinksetList()); for (std::vector::const_iterator itemIter = selectedItems.begin(); itemIter != selectedItems.end(); ++itemIter) { const LLScrollListItem *listItem = *itemIter; LLUUID uuid = listItem->getUUID(); - - const LLFilteredPathfindingLinksets::PathfindingLinksetMap::const_iterator linksetIter = linksetsMap.find(uuid.asString()); - const LLPathfindingLinkset &linkset = linksetIter->second; - - LLSD itemData = linkset.encodeAlteredFields(pathState, aValue, bValue, cValue, dValue); - - if (!itemData.isUndefined()) - { - editData[uuid.asString()] = itemData; - } + const std::string &uuidString = uuid.asString(); + LLPathfindingLinksetList::iterator linksetIter = mLinksetsListPtr->find(uuidString); + llassert(linksetIter != mLinksetsListPtr->end()); + LLPathfindingLinksetPtr linksetPtr = linksetIter->second; + editListPtr->insert(std::pair(uuidString, linksetPtr)); } - if (editData.isUndefined()) - { - llwarns << "No PUT data specified" << llendl; - } - else - { - sendNavMeshDataPutRequest(editData); - } + requestSetLinksets(editListPtr, linksetUse, aValue, bValue, cValue, dValue); } } @@ -958,69 +883,3 @@ LLSD LLFloaterPathfindingLinksets::convertToXuiValue(LLPathfindingLinkset::ELink return xuiValue; } - -//--------------------------------------------------------------------------- -// NavMeshDataGetResponder -//--------------------------------------------------------------------------- - -NavMeshDataGetResponder::NavMeshDataGetResponder(const std::string& pNavMeshDataGetURL, - const LLHandle &pLinksetsHandle) - : mNavMeshDataGetURL(pNavMeshDataGetURL), - mLinksetsFloaterHandle(pLinksetsHandle) -{ -} - -NavMeshDataGetResponder::~NavMeshDataGetResponder() -{ -} - -void NavMeshDataGetResponder::result(const LLSD& pContent) -{ - LLFloaterPathfindingLinksets *linksetsFloater = mLinksetsFloaterHandle.get(); - if (linksetsFloater != NULL) - { - linksetsFloater->handleNavMeshDataGetReply(pContent); - } -} - -void NavMeshDataGetResponder::error(U32 status, const std::string& reason) -{ - LLFloaterPathfindingLinksets *linksetsFloater = mLinksetsFloaterHandle.get(); - if (linksetsFloater != NULL) - { - linksetsFloater->handleNavMeshDataGetError(mNavMeshDataGetURL, reason); - } -} - -//--------------------------------------------------------------------------- -// NavMeshDataPutResponder -//--------------------------------------------------------------------------- - -NavMeshDataPutResponder::NavMeshDataPutResponder(const std::string& pNavMeshDataPutURL, - const LLHandle &pLinksetsHandle) - : mNavMeshDataPutURL(pNavMeshDataPutURL), - mLinksetsFloaterHandle(pLinksetsHandle) -{ -} - -NavMeshDataPutResponder::~NavMeshDataPutResponder() -{ -} - -void NavMeshDataPutResponder::result(const LLSD& pContent) -{ - LLFloaterPathfindingLinksets *linksetsFloater = mLinksetsFloaterHandle.get(); - if (linksetsFloater != NULL) - { - linksetsFloater->handleNavMeshDataPutReply(pContent); - } -} - -void NavMeshDataPutResponder::error(U32 status, const std::string& reason) -{ - LLFloaterPathfindingLinksets *linksetsFloater = mLinksetsFloaterHandle.get(); - if (linksetsFloater != NULL) - { - linksetsFloater->handleNavMeshDataPutError(mNavMeshDataPutURL, reason); - } -} diff --git a/indra/newview/llfloaterpathfindinglinksets.h b/indra/newview/llfloaterpathfindinglinksets.h index c47ad878cc..f4758e2335 100644 --- a/indra/newview/llfloaterpathfindinglinksets.h +++ b/indra/newview/llfloaterpathfindinglinksets.h @@ -28,12 +28,12 @@ #ifndef LL_LLFLOATERPATHFINDINGLINKSETS_H #define LL_LLFLOATERPATHFINDINGLINKSETS_H -#include "llhandle.h" #include "llfloater.h" #include "lluuid.h" #include "llselectmgr.h" #include "llpathfindinglinkset.h" -#include "llfilteredpathfindinglinksets.h" +#include "llpathfindinglinksetlist.h" +#include "llpathfindingmanager.h" class LLSD; class LLTextBase; @@ -47,85 +47,72 @@ class LLFloaterPathfindingLinksets : public LLFloater { friend class LLFloaterReg; - friend class NavMeshDataGetResponder; - friend class NavMeshDataPutResponder; public: typedef enum { - kMessagingInitial, - kMessagingFetchStarting, - kMessagingFetchRequestSent, - kMessagingFetchRequestSent_MultiRequested, - kMessagingFetchReceived, - kMessagingFetchError, - kMessagingModifyStarting, - kMessagingModifyRequestSent, - kMessagingModifyReceived, - kMessagingModifyError, + kMessagingUnknown, + kMessagingGetRequestSent, + kMessagingGetError, + kMessagingSetRequestSent, + kMessagingSetError, kMessagingComplete, - kMessagingServiceNotAvailable + kMessagingNotEnabled } EMessagingState; virtual BOOL postBuild(); virtual void onOpen(const LLSD& pKey); - virtual void onClose(bool app_quitting); + virtual void onClose(bool pAppQuitting); virtual void draw(); static void openLinksetsEditor(); EMessagingState getMessagingState() const; - BOOL isMessagingInProgress() const; + bool isMessagingInProgress() const; protected: private: - LLRootHandle mSelfHandle; - LLLineEditor *mFilterByName; - LLLineEditor *mFilterByDescription; - LLComboBox *mFilterByLinksetUse; - LLScrollListCtrl *mLinksetsScrollList; - LLTextBase *mLinksetsStatus; - LLButton *mRefreshListButton; - LLButton *mSelectAllButton; - LLButton *mSelectNoneButton; - LLCheckBoxCtrl *mShowBeaconCheckBox; - LLButton *mTakeButton; - LLButton *mTakeCopyButton; - LLButton *mReturnButton; - LLButton *mDeleteButton; - LLButton *mTeleportButton; - LLComboBox *mEditLinksetUse; - LLTextBase *mLabelWalkabilityCoefficients; - LLTextBase *mLabelEditA; - LLLineEditor *mEditA; - LLTextBase *mLabelEditB; - LLLineEditor *mEditB; - LLTextBase *mLabelEditC; - LLLineEditor *mEditC; - LLTextBase *mLabelEditD; - LLLineEditor *mEditD; - LLButton *mApplyEditsButton; - LLFilteredPathfindingLinksets mPathfindingLinksets; - EMessagingState mMessagingState; - LLObjectSelectionHandle mLinksetsSelection; + LLLineEditor *mFilterByName; + LLLineEditor *mFilterByDescription; + LLComboBox *mFilterByLinksetUse; + LLScrollListCtrl *mLinksetsScrollList; + LLTextBase *mLinksetsStatus; + LLButton *mRefreshListButton; + LLButton *mSelectAllButton; + LLButton *mSelectNoneButton; + LLCheckBoxCtrl *mShowBeaconCheckBox; + LLButton *mTakeButton; + LLButton *mTakeCopyButton; + LLButton *mReturnButton; + LLButton *mDeleteButton; + LLButton *mTeleportButton; + LLComboBox *mEditLinksetUse; + LLTextBase *mLabelWalkabilityCoefficients; + LLTextBase *mLabelEditA; + LLLineEditor *mEditA; + LLTextBase *mLabelEditB; + LLLineEditor *mEditB; + LLTextBase *mLabelEditC; + LLLineEditor *mEditC; + LLTextBase *mLabelEditD; + LLLineEditor *mEditD; + LLButton *mApplyEditsButton; + + EMessagingState mMessagingState; + LLPathfindingLinksetListPtr mLinksetsListPtr; + LLObjectSelectionHandle mLinksetsSelection; + LLPathfindingManager::agent_state_slot_t mAgentStateSlot; // Does its own instance management, so clients not allowed // to allocate or destroy. LLFloaterPathfindingLinksets(const LLSD& pSeed); virtual ~LLFloaterPathfindingLinksets(); - void sendNavMeshDataGetRequest(); - void sendNavMeshDataPutRequest(const LLSD& pPostData); - void handleNavMeshDataGetReply(const LLSD& pNavMeshData); - void handleNavMeshDataGetError(const std::string& pURL, const std::string& pErrorReason); - void handleNavMeshDataPutReply(const LLSD& pModifiedData); - void handleNavMeshDataPutError(const std::string& pURL, const std::string& pErrorReason); - - std::string getRegionName() const; - std::string getCapabilityURL() const; - void setMessagingState(EMessagingState pMessagingState); + void requestGetLinksets(); + void requestSetLinksets(LLPathfindingLinksetListPtr pLinksetList, LLPathfindingLinkset::ELinksetUse pLinksetUse, S32 pA, S32 pB, S32 pC, S32 pD); + void handleNewLinksets(LLPathfindingManager::ELinksetsRequestStatus pLinksetsRequestStatus, LLPathfindingLinksetListPtr pLinksetsListPtr); void onApplyAllFilters(); void onClearFiltersClicked(); @@ -139,19 +126,23 @@ private: void onDeleteClicked(); void onTeleportClicked(); void onApplyChangesClicked(); + void onAgentStateCB(LLPathfindingManager::EAgentState pAgentState); void applyFilters(); void clearFilters(); - void updateLinksetsList(); void selectAllLinksets(); void selectNoneLinksets(); - void updateLinksetsStatusMessage(); + void updateControls(); + void updateEditFieldValues(); + void updateScrollList(); + + void updateStatusMessage(); + void updateEnableStateOnListActions(); + void updateEnableStateOnEditFields(); - void updateActionAndEditFields(); - void setEnableActionAndEditFields(BOOL pEnabled); - void applyEditFields(); + void applyEdit(); LLPathfindingLinkset::ELinksetUse getFilterLinksetUse() const; void setFilterLinksetUse(LLPathfindingLinkset::ELinksetUse pLinksetUse); diff --git a/indra/newview/llpathfindinglinkset.cpp b/indra/newview/llpathfindinglinkset.cpp index de17edbf61..d775ec2fef 100644 --- a/indra/newview/llpathfindinglinkset.cpp +++ b/indra/newview/llpathfindinglinkset.cpp @@ -34,6 +34,7 @@ #define LINKSET_NAME_FIELD "name" #define LINKSET_DESCRIPTION_FIELD "description" #define LINKSET_LAND_IMPACT_FIELD "landimpact" +#define LINKSET_MODIFIABLE_FIELD "modifiable" #define LINKSET_PERMANENT_FIELD "permanent" #define LINKSET_WALKABLE_FIELD "walkable" #define LINKSET_PHANTOM_FIELD "phantom" @@ -55,7 +56,8 @@ LLPathfindingLinkset::LLPathfindingLinkset(const std::string &pUUID, const LLSD& mName(), mDescription(), mLandImpact(0U), - mLocation(), + mLocation(LLVector3::zero), + mIsLocked(FALSE), mLinksetUse(kUnknown), mWalkabilityCoefficientA(MIN_WALKABILITY_VALUE), mWalkabilityCoefficientB(MIN_WALKABILITY_VALUE), @@ -75,6 +77,12 @@ LLPathfindingLinkset::LLPathfindingLinkset(const std::string &pUUID, const LLSD& 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(); @@ -124,6 +132,7 @@ LLPathfindingLinkset::LLPathfindingLinkset(const LLPathfindingLinkset& pOther) mDescription(pOther.mDescription), mLandImpact(pOther.mLandImpact), mLocation(pOther.mLocation), + mIsLocked(pOther.mIsLocked), mLinksetUse(pOther.mLinksetUse), mWalkabilityCoefficientA(pOther.mWalkabilityCoefficientA), mWalkabilityCoefficientB(pOther.mWalkabilityCoefficientB), @@ -143,6 +152,7 @@ LLPathfindingLinkset& LLPathfindingLinkset::operator =(const LLPathfindingLinkse mDescription = pOther.mDescription; mLandImpact = pOther.mLandImpact; mLocation = pOther.mLocation; + // mIsLocked = pOther.mIsLocked; XXX stinson 02/23/2012 : disabling temporarily until all sim-service responses include the modifiable state mLinksetUse = pOther.mLinksetUse; mWalkabilityCoefficientA = pOther.mWalkabilityCoefficientA; mWalkabilityCoefficientB = pOther.mWalkabilityCoefficientB; @@ -152,33 +162,16 @@ LLPathfindingLinkset& LLPathfindingLinkset::operator =(const LLPathfindingLinkse return *this; } -void LLPathfindingLinkset::setWalkabilityCoefficientA(S32 pA) -{ - mWalkabilityCoefficientA = llclamp(pA, MIN_WALKABILITY_VALUE, MAX_WALKABILITY_VALUE); -} - -void LLPathfindingLinkset::setWalkabilityCoefficientB(S32 pB) -{ - mWalkabilityCoefficientB = llclamp(pB, MIN_WALKABILITY_VALUE, MAX_WALKABILITY_VALUE); -} - -void LLPathfindingLinkset::setWalkabilityCoefficientC(S32 pC) -{ - mWalkabilityCoefficientC = llclamp(pC, MIN_WALKABILITY_VALUE, MAX_WALKABILITY_VALUE); -} - -void LLPathfindingLinkset::setWalkabilityCoefficientD(S32 pD) -{ - mWalkabilityCoefficientD = llclamp(pD, MIN_WALKABILITY_VALUE, MAX_WALKABILITY_VALUE); -} - LLSD LLPathfindingLinkset::encodeAlteredFields(ELinksetUse pLinksetUse, S32 pA, S32 pB, S32 pC, S32 pD) const { LLSD itemData; if ((pLinksetUse != kUnknown) && (mLinksetUse != pLinksetUse)) { - itemData[LINKSET_PHANTOM_FIELD] = static_cast(LLPathfindingLinkset::isPhantom(pLinksetUse)); + if (!mIsLocked) + { + itemData[LINKSET_PHANTOM_FIELD] = static_cast(LLPathfindingLinkset::isPhantom(pLinksetUse)); + } itemData[LINKSET_PERMANENT_FIELD] = static_cast(LLPathfindingLinkset::isPermanent(pLinksetUse)); itemData[LINKSET_WALKABLE_FIELD] = static_cast(LLPathfindingLinkset::isWalkable(pLinksetUse)); } diff --git a/indra/newview/llpathfindinglinkset.h b/indra/newview/llpathfindinglinkset.h index 50bc07218b..ea6cf710b1 100644 --- a/indra/newview/llpathfindinglinkset.h +++ b/indra/newview/llpathfindinglinkset.h @@ -31,7 +31,12 @@ #include "v3math.h" #include "lluuid.h" +#include + class LLSD; +class LLPathfindingLinkset; + +typedef boost::shared_ptr LLPathfindingLinksetPtr; class LLPathfindingLinkset { @@ -53,26 +58,19 @@ public: LLPathfindingLinkset& operator = (const LLPathfindingLinkset& pOther); - inline const LLUUID& getUUID() const {return mUUID;}; - inline const std::string& getName() const {return mName;}; - inline const std::string& getDescription() const {return mDescription;}; - inline U32 getLandImpact() const {return mLandImpact;}; - inline const LLVector3& getLocation() const {return mLocation;}; + inline const LLUUID& getUUID() const {return mUUID;}; + inline const std::string& getName() const {return mName;}; + inline const std::string& getDescription() const {return mDescription;}; + inline U32 getLandImpact() const {return mLandImpact;}; + inline const LLVector3& getLocation() const {return mLocation;}; + BOOL isLocked() const {return mIsLocked;}; - inline ELinksetUse getLinksetUse() const {return mLinksetUse;}; - inline void setLinksetUse(ELinksetUse pLinksetUse) {mLinksetUse = pLinksetUse;}; + inline ELinksetUse getLinksetUse() const {return mLinksetUse;}; inline S32 getWalkabilityCoefficientA() const {return mWalkabilityCoefficientA;}; - void setWalkabilityCoefficientA(S32 pA); - inline S32 getWalkabilityCoefficientB() const {return mWalkabilityCoefficientB;}; - void setWalkabilityCoefficientB(S32 pB); - inline S32 getWalkabilityCoefficientC() const {return mWalkabilityCoefficientC;}; - void setWalkabilityCoefficientC(S32 pC); - inline S32 getWalkabilityCoefficientD() const {return mWalkabilityCoefficientD;}; - void setWalkabilityCoefficientD(S32 pD); LLSD encodeAlteredFields(ELinksetUse pLinksetUse, S32 pA, S32 pB, S32 pC, S32 pD) const; @@ -92,6 +90,7 @@ private: std::string mDescription; U32 mLandImpact; LLVector3 mLocation; + BOOL mIsLocked; ELinksetUse mLinksetUse; S32 mWalkabilityCoefficientA; S32 mWalkabilityCoefficientB; diff --git a/indra/newview/llpathfindinglinksetlist.cpp b/indra/newview/llpathfindinglinksetlist.cpp new file mode 100644 index 0000000000..e67b7b800c --- /dev/null +++ b/indra/newview/llpathfindinglinksetlist.cpp @@ -0,0 +1,103 @@ +/** + * @file llpathfindinglinksetlist.cpp + * @author William Todd Stinson + * @brief Class to implement the list of a set of pathfinding linksets + * + * $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 +#include + +#include "llsd.h" +#include "lluuid.h" +#include "llpathfindinglinkset.h" +#include "llpathfindinglinksetlist.h" + +//--------------------------------------------------------------------------- +// LLPathfindingLinksetList +//--------------------------------------------------------------------------- + +LLPathfindingLinksetList::LLPathfindingLinksetList() + : LLPathfindingLinksetMap() +{ +} + +LLPathfindingLinksetList::LLPathfindingLinksetList(const LLSD& pLinksetItems) + : LLPathfindingLinksetMap() +{ + for (LLSD::map_const_iterator linksetItemIter = pLinksetItems.beginMap(); + linksetItemIter != pLinksetItems.endMap(); ++linksetItemIter) + { + const std::string& uuid(linksetItemIter->first); + const LLSD& linksetData = linksetItemIter->second; + LLPathfindingLinksetPtr linkset(new LLPathfindingLinkset(uuid, linksetData)); + insert(std::pair(uuid, linkset)); + } +} + +LLPathfindingLinksetList::~LLPathfindingLinksetList() +{ + clear(); +} + +void LLPathfindingLinksetList::update(const LLSD& pLinksetItems) +{ + for (LLSD::map_const_iterator linksetItemIter = pLinksetItems.beginMap(); + linksetItemIter != pLinksetItems.endMap(); ++linksetItemIter) + { + const std::string& uuid(linksetItemIter->first); + const LLSD& linksetData = linksetItemIter->second; + LLPathfindingLinksetMap::iterator linksetIter = this->find(uuid); + if (linksetIter == end()) + { + LLPathfindingLinksetPtr linkset(new LLPathfindingLinkset(uuid, linksetData)); + insert(std::pair(uuid, linkset)); + } + else + { + LLPathfindingLinksetPtr linksetPtr = linksetIter->second; + const LLPathfindingLinkset newLinkset(uuid, linksetData); + *linksetPtr = newLinkset; + } + } +} + +LLSD LLPathfindingLinksetList::encodeAlteredFields(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()) + { + const std::string& uuid(linksetIter->first); + listData[uuid] = linksetData; + } + } + + return listData; +} diff --git a/indra/newview/llpathfindinglinksetlist.h b/indra/newview/llpathfindinglinksetlist.h new file mode 100644 index 0000000000..9ec36c2431 --- /dev/null +++ b/indra/newview/llpathfindinglinksetlist.h @@ -0,0 +1,60 @@ +/** + * @file llpathfindinglinksetlist.h + * @author William Todd Stinson + * @brief Class to implement the list of a set of pathfinding linksets + * + * $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_LLPATHFINDINGLINKSETLIST_H +#define LL_LLPATHFINDINGLINKSETLIST_H + +#include +#include +#include "llpathfindinglinkset.h" + +#include + +class LLSD; +class LLPathfindingLinksetList; + +typedef boost::shared_ptr LLPathfindingLinksetListPtr; +typedef std::map LLPathfindingLinksetMap; + +class LLPathfindingLinksetList : public LLPathfindingLinksetMap +{ +public: + LLPathfindingLinksetList(); + LLPathfindingLinksetList(const LLSD& pLinksetItems); + virtual ~LLPathfindingLinksetList(); + + void update(const LLSD& pLinksetItems); + + LLSD encodeAlteredFields(LLPathfindingLinkset::ELinksetUse pLinksetUse, S32 pA, S32 pB, S32 pC, S32 pD) const; + +protected: + +private: + +}; + +#endif // LL_LLPATHFINDINGLINKSETLIST_H diff --git a/indra/newview/llpathfindingmanager.cpp b/indra/newview/llpathfindingmanager.cpp index 76766c4e09..aafa2eaa10 100644 --- a/indra/newview/llpathfindingmanager.cpp +++ b/indra/newview/llpathfindingmanager.cpp @@ -33,6 +33,8 @@ #include "llhttpclient.h" #include "llagent.h" #include "llviewerregion.h" +#include "llpathfindinglinkset.h" +#include "llpathfindinglinksetlist.h" #include #include @@ -42,6 +44,8 @@ #define CAP_SERVICE_AGENT_STATE "AgentPreferences" #define ALTER_PERMANENT_OBJECTS_FIELD "alter_permanent_objects" +#define CAP_SERVICE_LINKSETS "ObjectNavMeshProperties" + //--------------------------------------------------------------------------- // AgentStateResponder //--------------------------------------------------------------------------- @@ -62,6 +66,26 @@ private: LLPathfindingManager::EAgentState mRequestedAgentState; }; +//--------------------------------------------------------------------------- +// LinksetsResponder +//--------------------------------------------------------------------------- + +class LinksetsResponder : public LLHTTPClient::Responder +{ +public: + LinksetsResponder(const std::string &pCapabilityURL, LLPathfindingManager::linksets_callback_t pLinksetsCallback); + virtual ~LinksetsResponder(); + + 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; +}; + //--------------------------------------------------------------------------- // LLPathfindingManager //--------------------------------------------------------------------------- @@ -84,6 +108,11 @@ bool LLPathfindingManager::isPathfindingEnabledForCurrentRegion() const return !retrieveNavMeshURL.empty(); } +bool LLPathfindingManager::isAllowAlterPermanent() +{ + return (!isPathfindingEnabledForCurrentRegion() || (getAgentState() == kAgentStateUnfrozen)); +} + LLPathfindingManager::agent_state_slot_t LLPathfindingManager::registerAgentStateSignal(agent_state_callback_t pAgentStateCallback) { return mAgentStateSignal.connect(pAgentStateCallback); @@ -130,6 +159,45 @@ void LLPathfindingManager::requestSetAgentState(EAgentState pRequestedAgentState } } +LLPathfindingManager::ELinksetsRequestStatus LLPathfindingManager::requestGetLinksets(linksets_callback_t pLinksetsCallback) const +{ + ELinksetsRequestStatus status; + + std::string linksetsURL = getLinksetsURLForCurrentRegion(); + if (linksetsURL.empty()) + {; + status = kLinksetsRequestNotEnabled; + } + else + { + LLHTTPClient::ResponderPtr responder = new LinksetsResponder(linksetsURL, pLinksetsCallback); + LLHTTPClient::get(linksetsURL, responder); + status = kLinksetsRequestStarted; + } + + return status; +} + +LLPathfindingManager::ELinksetsRequestStatus LLPathfindingManager::requestSetLinksets(LLPathfindingLinksetListPtr pLinksetList, LLPathfindingLinkset::ELinksetUse pLinksetUse, S32 pA, S32 pB, S32 pC, S32 pD, linksets_callback_t pLinksetsCallback) const +{ + ELinksetsRequestStatus status; + + std::string linksetsURL = getLinksetsURLForCurrentRegion(); + if (linksetsURL.empty()) + { + status = kLinksetsRequestNotEnabled; + } + else + { + LLHTTPClient::ResponderPtr responder = new LinksetsResponder(linksetsURL, pLinksetsCallback); + LLSD postData = pLinksetList->encodeAlteredFields(pLinksetUse, pA, pB, pC, pD); + LLHTTPClient::put(linksetsURL, postData, responder); + status = kLinksetsRequestStarted; + } + + return status; +} + bool LLPathfindingManager::isValidAgentState(EAgentState pAgentState) { return ((pAgentState == kAgentStateFrozen) || (pAgentState == kAgentStateUnfrozen)); @@ -183,6 +251,19 @@ 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); @@ -193,6 +274,11 @@ std::string LLPathfindingManager::getAgentStateURLForCurrentRegion() const return getCapabilityURLForCurrentRegion(CAP_SERVICE_AGENT_STATE); } +std::string LLPathfindingManager::getLinksetsURLForCurrentRegion() const +{ + return getCapabilityURLForCurrentRegion(CAP_SERVICE_LINKSETS); +} + std::string LLPathfindingManager::getCapabilityURLForCurrentRegion(const std::string &pCapabilityName) const { std::string capabilityURL(""); @@ -236,3 +322,28 @@ void AgentStateResponder::error(U32 pStatus, const std::string &pReason) { LLPathfindingManager::getInstance()->handleAgentStateError(pStatus, pReason, mCapabilityURL); } + +//--------------------------------------------------------------------------- +// LinksetsResponder +//--------------------------------------------------------------------------- + +LinksetsResponder::LinksetsResponder(const std::string &pCapabilityURL, LLPathfindingManager::linksets_callback_t pLinksetsCallback) + : LLHTTPClient::Responder(), + mCapabilityURL(pCapabilityURL), + mLinksetsCallback(pLinksetsCallback) +{ +} + +LinksetsResponder::~LinksetsResponder() +{ +} + +void LinksetsResponder::result(const LLSD &pContent) +{ + LLPathfindingManager::getInstance()->handleLinksetsResult(pContent, mLinksetsCallback); +} + +void LinksetsResponder::error(U32 pStatus, const std::string &pReason) +{ + LLPathfindingManager::getInstance()->handleLinksetsError(pStatus, pReason, mCapabilityURL, mLinksetsCallback); +} diff --git a/indra/newview/llpathfindingmanager.h b/indra/newview/llpathfindingmanager.h index a9432f9077..cef2b7c058 100644 --- a/indra/newview/llpathfindingmanager.h +++ b/indra/newview/llpathfindingmanager.h @@ -34,12 +34,15 @@ #include #include "llsingleton.h" +#include "llpathfindinglinkset.h" +#include "llpathfindinglinksetlist.h" class LLFloater; class LLPathfindingManager : public LLSingleton { friend class AgentStateResponder; + friend class LinksetsResponder; public: typedef enum { kAgentStateUnknown, @@ -49,20 +52,34 @@ public: kAgentStateError } EAgentState; - typedef boost::function agent_state_callback_t; - typedef boost::signals2::signal agent_state_signal_t; - typedef boost::signals2::connection agent_state_slot_t; + typedef boost::function agent_state_callback_t; + typedef boost::signals2::signal agent_state_signal_t; + typedef boost::signals2::connection agent_state_slot_t; + + typedef enum { + kLinksetsRequestStarted, + kLinksetsRequestCompleted, + kLinksetsRequestNotEnabled, + kLinksetsRequestError + } ELinksetsRequestStatus; + + typedef boost::function linksets_callback_t; LLPathfindingManager(); virtual ~LLPathfindingManager(); bool isPathfindingEnabledForCurrentRegion() const; + bool isAllowAlterPermanent(); + agent_state_slot_t registerAgentStateSignal(agent_state_callback_t pAgentStateCallback); EAgentState getAgentState(); EAgentState getLastKnownNonErrorAgentState() const; void requestSetAgentState(EAgentState pAgentState); + ELinksetsRequestStatus requestGetLinksets(linksets_callback_t pLinksetsCallback) const; + ELinksetsRequestStatus requestSetLinksets(LLPathfindingLinksetListPtr pLinksetList, LLPathfindingLinkset::ELinksetUse pLinksetUse, S32 pA, S32 pB, S32 pC, S32 pD, linksets_callback_t pLinksetsCallback) const; + protected: private: @@ -70,12 +87,15 @@ private: 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 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 getCapabilityURLForCurrentRegion(const std::string &pCapabilityName) const; 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 60d547c5f4..f7e78a91cc 100644 --- a/indra/newview/skins/default/xui/en/floater_pathfinding_linksets.xml +++ b/indra/newview/skins/default/xui/en/floater_pathfinding_linksets.xml @@ -15,24 +15,20 @@ single_instance="true" title="Pathfinding linksets"> - Building query for pathfinding linksets ... - Querying for pathfinding linksets ... - Querying for pathfinding linksets (already in progress) ... - Loading pathfinding linksets data from response ... - Error detected while querying for pathfinding linksets - Building modify message for selected pathfinding linksets ... - Modifying selected pathfinding linksets ... - Loading modified pathfinding linksets data from response ... - Error detected while modifying for pathfinding linksets + Querying for pathfinding linksets ... + Error detected while querying for pathfinding linksets + Modifying selected pathfinding linksets ... + Error detected while modifying selected pathfinding linksets No pathfinding linksets [NUM_SELECTED] linksets selected out of [NUM_TOTAL] - Required capability is not available in current region + This region is not enabled for pathfinding. Walkable Static obstacle Dynamic obstacle Material volume Exclusion volume Dynamic phantom + [locked] Date: Thu, 23 Feb 2012 18:41:23 -0800 Subject: PATH-292: Fixing an issue where clicking Apply Edits without any changes resulted in an usable floater state. --- indra/newview/llfloaterpathfindinglinksets.cpp | 168 +++++++++++++++---------- indra/newview/llfloaterpathfindinglinksets.h | 1 + indra/newview/llpathfindingmanager.cpp | 13 +- 3 files changed, 111 insertions(+), 71 deletions(-) (limited to 'indra/newview/llpathfindingmanager.cpp') diff --git a/indra/newview/llfloaterpathfindinglinksets.cpp b/indra/newview/llfloaterpathfindinglinksets.cpp index 2b3007b435..88328ee8a8 100644 --- a/indra/newview/llfloaterpathfindinglinksets.cpp +++ b/indra/newview/llfloaterpathfindinglinksets.cpp @@ -301,7 +301,12 @@ void LLFloaterPathfindingLinksets::requestGetLinksets() case LLPathfindingManager::kLinksetsRequestStarted : setMessagingState(kMessagingGetRequestSent); break; + case LLPathfindingManager::kLinksetsRequestCompleted : + clearLinksets(); + setMessagingState(kMessagingComplete); + break; case LLPathfindingManager::kLinksetsRequestNotEnabled : + clearLinksets(); setMessagingState(kMessagingNotEnabled); break; case LLPathfindingManager::kLinksetsRequestError : @@ -325,7 +330,11 @@ void LLFloaterPathfindingLinksets::requestSetLinksets(LLPathfindingLinksetListPt case LLPathfindingManager::kLinksetsRequestStarted : setMessagingState(kMessagingSetRequestSent); break; + case LLPathfindingManager::kLinksetsRequestCompleted : + setMessagingState(kMessagingComplete); + break; case LLPathfindingManager::kLinksetsRequestNotEnabled : + clearLinksets(); setMessagingState(kMessagingNotEnabled); break; case LLPathfindingManager::kLinksetsRequestError : @@ -361,7 +370,14 @@ void LLFloaterPathfindingLinksets::handleNewLinksets(LLPathfindingManager::ELink void LLFloaterPathfindingLinksets::handleUpdateLinksets(LLPathfindingManager::ELinksetsRequestStatus pLinksetsRequestStatus, LLPathfindingLinksetListPtr pLinksetsListPtr) { - mLinksetsListPtr->update(*pLinksetsListPtr); + if (mLinksetsListPtr == NULL) + { + mLinksetsListPtr = pLinksetsListPtr; + } + else + { + mLinksetsListPtr->update(*pLinksetsListPtr); + } updateScrollList(); switch (pLinksetsRequestStatus) @@ -467,6 +483,7 @@ void LLFloaterPathfindingLinksets::onTeleportClicked() { std::vector::const_reference selectedItemRef = selectedItems.front(); const LLScrollListItem *selectedItem = selectedItemRef; + llassert(mLinksetsListPtr != NULL); LLPathfindingLinksetList::const_iterator linksetIter = mLinksetsListPtr->find(selectedItem->getUUID().asString()); const LLPathfindingLinksetPtr linksetPtr = linksetIter->second; const LLVector3 &linksetLocation = linksetPtr->getLocation(); @@ -520,6 +537,15 @@ void LLFloaterPathfindingLinksets::selectNoneLinksets() mLinksetsScrollList->deselectAllItems(); } +void LLFloaterPathfindingLinksets::clearLinksets() +{ + if (mLinksetsListPtr != NULL) + { + mLinksetsListPtr->clear(); + } + updateScrollList(); +} + void LLFloaterPathfindingLinksets::updateControls() { updateStatusMessage(); @@ -543,6 +569,7 @@ void LLFloaterPathfindingLinksets::updateEditFieldValues() { LLScrollListItem *firstItem = selectedItems.front(); + llassert(mLinksetsListPtr != NULL); LLPathfindingLinksetList::const_iterator linksetIter = mLinksetsListPtr->find(firstItem->getUUID().asString()); const LLPathfindingLinksetPtr linksetPtr(linksetIter->second); @@ -572,89 +599,93 @@ void LLFloaterPathfindingLinksets::updateScrollList() mLinksetsScrollList->deleteAllItems(); - const LLVector3& avatarPosition = gAgent.getPositionAgent(); - for (LLPathfindingLinksetList::const_iterator linksetIter = mLinksetsListPtr->begin(); - linksetIter != mLinksetsListPtr->end(); ++linksetIter) + if (mLinksetsListPtr != NULL) { - const LLPathfindingLinksetPtr linksetPtr(linksetIter->second); + const LLVector3& avatarPosition = gAgent.getPositionAgent(); + for (LLPathfindingLinksetList::const_iterator linksetIter = mLinksetsListPtr->begin(); + linksetIter != mLinksetsListPtr->end(); ++linksetIter) + { + const LLPathfindingLinksetPtr linksetPtr(linksetIter->second); - LLSD columns; + LLSD columns; - columns[0]["column"] = "name"; - columns[0]["value"] = linksetPtr->getName(); - columns[0]["font"] = "SANSSERIF"; + columns[0]["column"] = "name"; + columns[0]["value"] = linksetPtr->getName(); + columns[0]["font"] = "SANSSERIF"; - columns[1]["column"] = "description"; - columns[1]["value"] = linksetPtr->getDescription(); - columns[1]["font"] = "SANSSERIF"; + columns[1]["column"] = "description"; + columns[1]["value"] = linksetPtr->getDescription(); + columns[1]["font"] = "SANSSERIF"; - columns[2]["column"] = "land_impact"; - columns[2]["value"] = llformat("%1d", linksetPtr->getLandImpact()); - columns[2]["font"] = "SANSSERIF"; + columns[2]["column"] = "land_impact"; + columns[2]["value"] = llformat("%1d", linksetPtr->getLandImpact()); + columns[2]["font"] = "SANSSERIF"; - columns[3]["column"] = "dist_from_you"; - columns[3]["value"] = llformat("%1.0f m", dist_vec(avatarPosition, linksetPtr->getLocation())); - columns[3]["font"] = "SANSSERIF"; + columns[3]["column"] = "dist_from_you"; + columns[3]["value"] = llformat("%1.0f m", dist_vec(avatarPosition, linksetPtr->getLocation())); + columns[3]["font"] = "SANSSERIF"; - columns[4]["column"] = "linkset_use"; - std::string linksetUse; - switch (linksetPtr->getLinksetUse()) - { - case LLPathfindingLinkset::kWalkable : - linksetUse = getString("linkset_use_walkable"); - break; - case LLPathfindingLinkset::kStaticObstacle : - linksetUse = getString("linkset_use_static_obstacle"); - break; - case LLPathfindingLinkset::kDynamicObstacle : - linksetUse = getString("linkset_use_dynamic_obstacle"); - break; - case LLPathfindingLinkset::kMaterialVolume : - linksetUse = getString("linkset_use_material_volume"); - break; - case LLPathfindingLinkset::kExclusionVolume : - linksetUse = getString("linkset_use_exclusion_volume"); - break; - case LLPathfindingLinkset::kDynamicPhantom : - linksetUse = getString("linkset_use_dynamic_phantom"); - break; - case LLPathfindingLinkset::kUnknown : - default : - linksetUse = getString("linkset_use_dynamic_obstacle"); - llassert(0); - break; - } - if (linksetPtr->isLocked()) - { - linksetUse += (" " + getString("linkset_is_locked_state")); - } - columns[4]["value"] = linksetUse; - columns[4]["font"] = "SANSSERIF"; + columns[4]["column"] = "linkset_use"; + std::string linksetUse; + switch (linksetPtr->getLinksetUse()) + { + case LLPathfindingLinkset::kWalkable : + linksetUse = getString("linkset_use_walkable"); + break; + case LLPathfindingLinkset::kStaticObstacle : + linksetUse = getString("linkset_use_static_obstacle"); + break; + case LLPathfindingLinkset::kDynamicObstacle : + linksetUse = getString("linkset_use_dynamic_obstacle"); + break; + case LLPathfindingLinkset::kMaterialVolume : + linksetUse = getString("linkset_use_material_volume"); + break; + case LLPathfindingLinkset::kExclusionVolume : + linksetUse = getString("linkset_use_exclusion_volume"); + break; + case LLPathfindingLinkset::kDynamicPhantom : + linksetUse = getString("linkset_use_dynamic_phantom"); + break; + case LLPathfindingLinkset::kUnknown : + default : + linksetUse = getString("linkset_use_dynamic_obstacle"); + llassert(0); + break; + } + if (linksetPtr->isLocked()) + { + linksetUse += (" " + getString("linkset_is_locked_state")); + } + columns[4]["value"] = linksetUse; + columns[4]["font"] = "SANSSERIF"; - columns[5]["column"] = "a_percent"; - columns[5]["value"] = llformat("%3d", linksetPtr->getWalkabilityCoefficientA()); - columns[5]["font"] = "SANSSERIF"; + columns[5]["column"] = "a_percent"; + columns[5]["value"] = llformat("%3d", linksetPtr->getWalkabilityCoefficientA()); + columns[5]["font"] = "SANSSERIF"; - columns[6]["column"] = "b_percent"; - columns[6]["value"] = llformat("%3d", linksetPtr->getWalkabilityCoefficientB()); - columns[6]["font"] = "SANSSERIF"; + columns[6]["column"] = "b_percent"; + columns[6]["value"] = llformat("%3d", linksetPtr->getWalkabilityCoefficientB()); + columns[6]["font"] = "SANSSERIF"; - columns[7]["column"] = "c_percent"; - columns[7]["value"] = llformat("%3d", linksetPtr->getWalkabilityCoefficientC()); - columns[7]["font"] = "SANSSERIF"; + columns[7]["column"] = "c_percent"; + columns[7]["value"] = llformat("%3d", linksetPtr->getWalkabilityCoefficientC()); + columns[7]["font"] = "SANSSERIF"; - columns[8]["column"] = "d_percent"; - columns[8]["value"] = llformat("%3d", linksetPtr->getWalkabilityCoefficientD()); - columns[8]["font"] = "SANSSERIF"; + columns[8]["column"] = "d_percent"; + columns[8]["value"] = llformat("%3d", linksetPtr->getWalkabilityCoefficientD()); + columns[8]["font"] = "SANSSERIF"; - LLSD element; - element["id"] = linksetPtr->getUUID().asString(); - element["column"] = columns; + LLSD element; + element["id"] = linksetPtr->getUUID().asString(); + element["column"] = columns; - mLinksetsScrollList->addElement(element); + mLinksetsScrollList->addElement(element); + } } mLinksetsScrollList->selectMultiple(selectedUUIDs); + updateEditFieldValues(); updateControls(); } @@ -802,6 +833,7 @@ void LLFloaterPathfindingLinksets::applyEdit() const LLScrollListItem *listItem = *itemIter; LLUUID uuid = listItem->getUUID(); const std::string &uuidString = uuid.asString(); + llassert(mLinksetsListPtr != NULL); LLPathfindingLinksetList::iterator linksetIter = mLinksetsListPtr->find(uuidString); llassert(linksetIter != mLinksetsListPtr->end()); LLPathfindingLinksetPtr linksetPtr = linksetIter->second; diff --git a/indra/newview/llfloaterpathfindinglinksets.h b/indra/newview/llfloaterpathfindinglinksets.h index abbc355f46..2a280cb4af 100644 --- a/indra/newview/llfloaterpathfindinglinksets.h +++ b/indra/newview/llfloaterpathfindinglinksets.h @@ -134,6 +134,7 @@ private: void selectAllLinksets(); void selectNoneLinksets(); + void clearLinksets(); void updateControls(); void updateEditFieldValues(); diff --git a/indra/newview/llpathfindingmanager.cpp b/indra/newview/llpathfindingmanager.cpp index aafa2eaa10..7cfa07718b 100644 --- a/indra/newview/llpathfindingmanager.cpp +++ b/indra/newview/llpathfindingmanager.cpp @@ -165,7 +165,7 @@ LLPathfindingManager::ELinksetsRequestStatus LLPathfindingManager::requestGetLin std::string linksetsURL = getLinksetsURLForCurrentRegion(); if (linksetsURL.empty()) - {; + { status = kLinksetsRequestNotEnabled; } else @@ -191,8 +191,15 @@ LLPathfindingManager::ELinksetsRequestStatus LLPathfindingManager::requestSetLin { LLHTTPClient::ResponderPtr responder = new LinksetsResponder(linksetsURL, pLinksetsCallback); LLSD postData = pLinksetList->encodeAlteredFields(pLinksetUse, pA, pB, pC, pD); - LLHTTPClient::put(linksetsURL, postData, responder); - status = kLinksetsRequestStarted; + if (postData.isUndefined()) + { + status = kLinksetsRequestCompleted; + } + else + { + LLHTTPClient::put(linksetsURL, postData, responder); + status = kLinksetsRequestStarted; + } } return status; -- cgit v1.3 From 9b06300e2c94eae83a29637073f65d4ffc73bf6d Mon Sep 17 00:00:00 2001 From: William Todd Stinson Date: Sat, 25 Feb 2012 22:27:06 -0800 Subject: PATH-292: Adding the ability to view and edit pathfinding attributes of the terrain. --- indra/newview/llfloaterpathfindinglinksets.cpp | 55 +++-- indra/newview/llpathfindinglinkset.cpp | 152 +++++++----- indra/newview/llpathfindinglinkset.h | 5 + indra/newview/llpathfindinglinksetlist.cpp | 30 ++- indra/newview/llpathfindinglinksetlist.h | 3 +- indra/newview/llpathfindingmanager.cpp | 255 +++++++++++++++++---- indra/newview/llpathfindingmanager.h | 9 +- indra/newview/llviewerregion.cpp | 1 + .../xui/en/floater_pathfinding_linksets.xml | 4 + 9 files changed, 384 insertions(+), 130 deletions(-) (limited to 'indra/newview/llpathfindingmanager.cpp') 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 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(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 { 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 @@ No pathfinding linksets [NUM_SELECTED] linksets selected out of [NUM_TOTAL] This region is not enabled for pathfinding. + [Terrain] + -- + -- + -- Walkable Static obstacle Dynamic obstacle -- cgit v1.3 From 1503338ddcd170871815d70d328cbbd1dfd40c82 Mon Sep 17 00:00:00 2001 From: Todd Stinson Date: Mon, 27 Feb 2012 16:15:16 -0800 Subject: PATH-292: Ensuring that the terrain linkset is not visible and/or editable to a non-estate non-god agent. --- indra/newview/llpathfindingmanager.cpp | 33 +++++++++++++++++++++++++++------ indra/newview/llpathfindingmanager.h | 3 +++ 2 files changed, 30 insertions(+), 6 deletions(-) (limited to 'indra/newview/llpathfindingmanager.cpp') diff --git a/indra/newview/llpathfindingmanager.cpp b/indra/newview/llpathfindingmanager.cpp index 3a96ed72e5..5c9293a28a 100644 --- a/indra/newview/llpathfindingmanager.cpp +++ b/indra/newview/llpathfindingmanager.cpp @@ -173,6 +173,12 @@ bool LLPathfindingManager::isAllowAlterPermanent() return (!isPathfindingEnabledForCurrentRegion() || (getAgentState() == kAgentStateUnfrozen)); } +bool LLPathfindingManager::isAllowViewTerrainProperties() const +{ + LLViewerRegion* region = getCurrentRegion(); + return (gAgent.isGodlike() || ((region != NULL) && region->canManageEstate())); +} + LLPathfindingManager::agent_state_slot_t LLPathfindingManager::registerAgentStateSignal(agent_state_callback_t pAgentStateCallback) { return mAgentStateSignal.connect(pAgentStateCallback); @@ -231,13 +237,18 @@ LLPathfindingManager::ELinksetsRequestStatus LLPathfindingManager::requestGetLin } else { - LinksetsResponderPtr linksetsResponderPtr(new LinksetsResponder(pLinksetsCallback, true, true)); + bool doRequestTerrain = isAllowViewTerrainProperties(); + LinksetsResponderPtr linksetsResponderPtr(new LinksetsResponder(pLinksetsCallback, true, doRequestTerrain)); LLHTTPClient::ResponderPtr objectLinksetsResponder = new ObjectLinksetsResponder(objectLinksetsURL, linksetsResponderPtr); - LLHTTPClient::ResponderPtr terrainLinksetsResponder = new TerrainLinksetsResponder(terrainLinksetsURL, linksetsResponderPtr); - LLHTTPClient::get(objectLinksetsURL, objectLinksetsResponder); - LLHTTPClient::get(terrainLinksetsURL, terrainLinksetsResponder); + + if (doRequestTerrain) + { + LLHTTPClient::ResponderPtr terrainLinksetsResponder = new TerrainLinksetsResponder(terrainLinksetsURL, linksetsResponderPtr); + LLHTTPClient::get(terrainLinksetsURL, terrainLinksetsResponder); + } + status = kLinksetsRequestStarted; } @@ -257,7 +268,12 @@ LLPathfindingManager::ELinksetsRequestStatus LLPathfindingManager::requestSetLin else { LLSD objectPostData = pLinksetList->encodeObjectFields(pLinksetUse, pA, pB, pC, pD); - LLSD terrainPostData = pLinksetList->encodeTerrainFields(pLinksetUse, pA, pB, pC, pD); + LLSD terrainPostData; + if (isAllowViewTerrainProperties()) + { + terrainPostData = pLinksetList->encodeTerrainFields(pLinksetUse, pA, pB, pC, pD); + } + if (objectPostData.isUndefined() && terrainPostData.isUndefined()) { status = kLinksetsRequestCompleted; @@ -362,7 +378,7 @@ std::string LLPathfindingManager::getCapabilityURLForCurrentRegion(const std::st { std::string capabilityURL(""); - LLViewerRegion* region = gAgent.getRegion(); + LLViewerRegion* region = getCurrentRegion(); if (region != NULL) { capabilityURL = region->getCapability(pCapabilityName); @@ -377,6 +393,11 @@ std::string LLPathfindingManager::getCapabilityURLForCurrentRegion(const std::st return capabilityURL; } +LLViewerRegion *LLPathfindingManager::getCurrentRegion() const +{ + return gAgent.getRegion(); +} + //--------------------------------------------------------------------------- // AgentStateResponder //--------------------------------------------------------------------------- diff --git a/indra/newview/llpathfindingmanager.h b/indra/newview/llpathfindingmanager.h index 4b6fd49640..9a6bbb81b9 100644 --- a/indra/newview/llpathfindingmanager.h +++ b/indra/newview/llpathfindingmanager.h @@ -38,6 +38,7 @@ #include "llpathfindinglinksetlist.h" class LLFloater; +class LLViewerRegion; class LLPathfindingManager : public LLSingleton { @@ -70,6 +71,7 @@ public: bool isPathfindingEnabledForCurrentRegion() const; bool isAllowAlterPermanent(); + bool isAllowViewTerrainProperties() const; agent_state_slot_t registerAgentStateSignal(agent_state_callback_t pAgentStateCallback); EAgentState getAgentState(); @@ -95,6 +97,7 @@ private: std::string getTerrainLinksetsURLForCurrentRegion() const; std::string getCapabilityURLForCurrentRegion(const std::string &pCapabilityName) const; + LLViewerRegion *getCurrentRegion() const; agent_state_signal_t mAgentStateSignal; EAgentState mAgentState; -- cgit v1.3 From a33e24413ea74aaad91d9eeaa685d1c523c5d210 Mon Sep 17 00:00:00 2001 From: Todd Stinson Date: Fri, 2 Mar 2012 19:17:16 -0800 Subject: PATH-304,PATH-205: Initial reworking of the navmesh download functionality. --- indra/newview/CMakeLists.txt | 4 +- indra/newview/llfloaterpathfindingbasic.cpp | 2 +- indra/newview/llfloaterpathfindingconsole.cpp | 281 ++++++++++++++++----- indra/newview/llfloaterpathfindingconsole.h | 37 ++- indra/newview/llfloaterpathfindinglinksets.cpp | 2 +- indra/newview/llnavmeshstation.cpp | 134 ---------- indra/newview/llnavmeshstation.h | 101 -------- indra/newview/llpathfindingmanager.cpp | 118 ++++++++- indra/newview/llpathfindingmanager.h | 25 +- indra/newview/llpathfindingnavmesh.cpp | 133 ++++++++++ indra/newview/llpathfindingnavmesh.h | 86 +++++++ .../default/xui/en/floater_pathfinding_console.xml | 14 +- 12 files changed, 615 insertions(+), 322 deletions(-) delete mode 100644 indra/newview/llnavmeshstation.cpp delete mode 100644 indra/newview/llnavmeshstation.h create mode 100644 indra/newview/llpathfindingnavmesh.cpp create mode 100644 indra/newview/llpathfindingnavmesh.h (limited to 'indra/newview/llpathfindingmanager.cpp') diff --git a/indra/newview/CMakeLists.txt b/indra/newview/CMakeLists.txt index 5223eead35..c5eac457fd 100644 --- a/indra/newview/CMakeLists.txt +++ b/indra/newview/CMakeLists.txt @@ -333,7 +333,6 @@ set(viewer_SOURCE_FILES llnameeditor.cpp llnamelistctrl.cpp llnavigationbar.cpp - llnavmeshstation.cpp llnearbychat.cpp llnearbychatbar.cpp llnearbychathandler.cpp @@ -421,6 +420,7 @@ set(viewer_SOURCE_FILES llpathfindinglinkset.cpp llpathfindinglinksetlist.cpp llpathfindingmanager.cpp + llpathfindingnavmesh.cpp llphysicsmotion.cpp llphysicsshapebuilderutil.cpp llplacesinventorybridge.cpp @@ -898,7 +898,6 @@ set(viewer_HEADER_FILES llnameeditor.h llnamelistctrl.h llnavigationbar.h - llnavmeshstation.h llnearbychat.h llnearbychatbar.h llnearbychathandler.h @@ -975,6 +974,7 @@ set(viewer_HEADER_FILES llpathfindinglinkset.h llpathfindinglinksetlist.h llpathfindingmanager.h + llpathfindingnavmesh.h llphysicsmotion.h llphysicsshapebuilderutil.h llplacesinventorybridge.h diff --git a/indra/newview/llfloaterpathfindingbasic.cpp b/indra/newview/llfloaterpathfindingbasic.cpp index 04d830632d..d1103088ab 100644 --- a/indra/newview/llfloaterpathfindingbasic.cpp +++ b/indra/newview/llfloaterpathfindingbasic.cpp @@ -66,7 +66,7 @@ void LLFloaterPathfindingBasic::onOpen(const LLSD& pKey) if (!mAgentStateSlot.connected()) { - mAgentStateSlot = LLPathfindingManager::getInstance()->registerAgentStateSignal(boost::bind(&LLFloaterPathfindingBasic::onAgentStateCB, this, _1)); + mAgentStateSlot = LLPathfindingManager::getInstance()->registerAgentStateListener(boost::bind(&LLFloaterPathfindingBasic::onAgentStateCB, this, _1)); } setAgentState(LLPathfindingManager::getInstance()->getAgentState()); } diff --git a/indra/newview/llfloaterpathfindingconsole.cpp b/indra/newview/llfloaterpathfindingconsole.cpp index 2bf46175ee..02f2bf8d72 100644 --- a/indra/newview/llfloaterpathfindingconsole.cpp +++ b/indra/newview/llfloaterpathfindingconsole.cpp @@ -33,6 +33,7 @@ #include "llsd.h" #include "llhandle.h" #include "llagent.h" +#include "llpanel.h" #include "llbutton.h" #include "llradiogroup.h" #include "llsliderctrl.h" @@ -40,12 +41,12 @@ #include "lltextbase.h" #include "lltabcontainer.h" #include "llcombobox.h" -#include "llnavmeshstation.h" #include "llfloaterreg.h" #include "llviewerregion.h" #include "llviewerwindow.h" #include "llviewercamera.h" #include "llviewercontrol.h" +#include "llpathfindingnavmesh.h" #include "llpathfindingmanager.h" #include "LLPathingLib.h" @@ -104,6 +105,12 @@ BOOL LLFloaterPathfindingConsole::postBuild() mEditTestTabContainer = findChild("edit_test_tab_container"); llassert(mEditTestTabContainer != NULL); + mEditTab = findChild("edit_panel"); + llassert(mEditTab != NULL); + + mTestTab = findChild("test_panel"); + llassert(mTestTab != NULL); + mUnfreezeLabel = findChild("unfreeze_label"); llassert(mUnfreezeLabel != NULL); @@ -157,14 +164,18 @@ void LLFloaterPathfindingConsole::onOpen(const LLSD& pKey) } if ( LLPathingLib::getInstance() == NULL ) { - std::string str = getString("navmesh_library_not_implemented"); - LLStyle::Params styleParams; - styleParams.color = LLUIColorTable::instance().getColor("DrYellow"); - mPathfindingStatus->setText((LLStringExplicit)str, styleParams); + setConsoleState(kConsoleStateLibraryNotImplemented); llwarns <<"Errror: cannout find pathing library implementation."<registerNavMeshListenerForCurrentRegion(boost::bind(&LLFloaterPathfindingConsole::onNavMeshDownloadCB, this, _1, _2, _3, _4)); + } + pathfindingManagerInstance->requestGetNavMeshForCurrentRegion(); +#if 0 LLPathingLib::getInstance()->cleanupResidual(); mCurrentMDO = 0; @@ -232,12 +243,14 @@ void LLFloaterPathfindingConsole::onOpen(const LLSD& pKey) llinfos<<"Region has does not required caps of type ["<registerAgentStateSignal(boost::bind(&LLFloaterPathfindingConsole::onAgentStateCB, this, _1)); + LLPathfindingManager::getInstance()->registerAgentStateListener(boost::bind(&LLFloaterPathfindingConsole::onAgentStateCB, this, _1)); } + setAgentState(LLPathfindingManager::getInstance()->getAgentState()); updatePathTestStatus(); } @@ -248,9 +261,16 @@ void LLFloaterPathfindingConsole::onClose(bool pIsAppQuitting) { mAgentStateSlot.disconnect(); } - LLPathingLib::getInstance()->cleanupResidual(); + + if (mNavMeshSlot.connected()) + { + mNavMeshSlot.disconnect(); + } + + clearNavMesh(); LLFloater::onClose(pIsAppQuitting); setHeartBeat( false ); + setConsoleState(kConsoleStateUnknown); } BOOL LLFloaterPathfindingConsole::handleAnyMouseClick(S32 x, S32 y, MASK mask, EClickType clicktype, BOOL down) @@ -496,6 +516,7 @@ void LLFloaterPathfindingConsole::setCharacterType(ECharacterType pCharacterType mCharacterTypeRadioGroup->setValue(radioGroupValue); } +#if 0 void LLFloaterPathfindingConsole::setHasNavMeshReceived() { std::string str = getString("navmesh_fetch_complete_available"); @@ -513,6 +534,7 @@ void LLFloaterPathfindingConsole::setHasNoNavMesh() std::string str = getString("navmesh_fetch_complete_none"); mPathfindingStatus->setText((LLStringExplicit)str); } +#endif LLFloaterPathfindingConsole::LLFloaterPathfindingConsole(const LLSD& pSeed) : LLFloater(pSeed), @@ -527,6 +549,8 @@ LLFloaterPathfindingConsole::LLFloaterPathfindingConsole(const LLSD& pSeed) mPathfindingStatus(NULL), mViewCharactersButton(NULL), mEditTestTabContainer(NULL), + mEditTab(NULL), + mTestTab(NULL), mUnfreezeLabel(NULL), mUnfreezeButton(NULL), mLinksetsLabel(NULL), @@ -537,38 +561,33 @@ LLFloaterPathfindingConsole::LLFloaterPathfindingConsole(const LLSD& pSeed) mCharacterTypeRadioGroup(NULL), mPathTestingStatus(NULL), mClearPathButton(NULL), + mNavMeshSlot(), mAgentStateSlot(), + mConsoleState(kConsoleStateUnknown), + mHasNavMesh(false), + mNavMeshRegionVersion(0U), + mNavMeshRegionUUID(), +#if 0 mNavMeshCnt(0), + mNeighboringRegion( CURRENT_REGION ), +#endif mHasStartPoint(false), mHasEndPoint(false), - mNeighboringRegion( CURRENT_REGION ), mHeartBeat( false ) { mSelfHandle.bind(this); - +#if 0 for (int i=0;igetCapability("RetrieveNavMeshSrc"); - } - - return capURL; -} - void LLFloaterPathfindingConsole::onShowWalkabilitySet() { switch (getRenderHeatmapType()) @@ -686,17 +705,76 @@ void LLFloaterPathfindingConsole::onClearPathClicked() updatePathTestStatus(); } +void LLFloaterPathfindingConsole::onNavMeshDownloadCB(LLPathfindingNavMesh::ENavMeshRequestStatus pNavMeshRequestStatus, const LLUUID &pRegionUUID, U32 pNavMeshVersion, const LLSD::Binary &pNavMeshData) +{ + + switch (pNavMeshRequestStatus) + { + case LLPathfindingNavMesh::kNavMeshRequestStarted : + setConsoleState(kConsoleStateDownloading); + break; + case LLPathfindingNavMesh::kNavMeshRequestCompleted : + updateNavMesh(pRegionUUID, pNavMeshVersion, pNavMeshData); + setConsoleState(kConsoleStateHasNavMesh); + break; + case LLPathfindingNavMesh::kNavMeshRequestNotEnabled : + clearNavMesh(); + setConsoleState(kConsoleStateRegionNotEnabled); + break; + case LLPathfindingNavMesh::kNavMeshRequestMessageError : + clearNavMesh(); + setConsoleState(kConsoleStateDownloadError); + break; + case LLPathfindingNavMesh::kNavMeshRequestFormatError : + clearNavMesh(); + setConsoleState(kConsoleStateNavMeshError); + break; + case LLPathfindingNavMesh::kNavMeshRequestUnknown : + default: + clearNavMesh(); + setConsoleState(kConsoleStateUnknown); + llassert(0); + break; + } +} + +void LLFloaterPathfindingConsole::updateNavMesh(const LLUUID &pRegionUUID, U32 pNavMeshVersion, const LLSD::Binary &pNavMeshData) +{ + if (!mHasNavMesh || (mNavMeshRegionUUID != pRegionUUID) || (mNavMeshRegionVersion != pNavMeshVersion)) + { + llassert(!pNavMeshData.empty()); + mHasNavMesh = true; + mNavMeshRegionUUID = pRegionUUID; + mNavMeshRegionVersion = pNavMeshVersion; + LLPathingLib::getInstance()->extractNavMeshSrcFromLLSD(pNavMeshData, CURRENT_REGION); + } +} + +void LLFloaterPathfindingConsole::clearNavMesh() +{ + mHasNavMesh = false; + LLPathingLib::getInstance()->cleanupResidual(); +} + void LLFloaterPathfindingConsole::onAgentStateCB(LLPathfindingManager::EAgentState pAgentState) { setAgentState(pAgentState); } -void LLFloaterPathfindingConsole::setAgentState(LLPathfindingManager::EAgentState pAgentState) +void LLFloaterPathfindingConsole::setConsoleState(EConsoleState pConsoleState) +{ + mConsoleState = pConsoleState; + updateControlsOnConsoleState(); + updateStatusOnConsoleState(); +} + +void LLFloaterPathfindingConsole::updateControlsOnConsoleState() { - switch (pAgentState) + switch (mConsoleState) { - case LLPathfindingManager::kAgentStateUnknown : - case LLPathfindingManager::kAgentStateNotEnabled : + case kConsoleStateUnknown : + case kConsoleStateLibraryNotImplemented : + case kConsoleStateRegionNotEnabled : mShowNavMeshCheckBox->setEnabled(FALSE); mShowNavMeshWalkabilityComboBox->setEnabled(FALSE); mShowWalkablesCheckBox->setEnabled(FALSE); @@ -705,16 +783,35 @@ void LLFloaterPathfindingConsole::setAgentState(LLPathfindingManager::EAgentStat mShowExclusionVolumesCheckBox->setEnabled(FALSE); mShowWorldCheckBox->setEnabled(FALSE); mViewCharactersButton->setEnabled(FALSE); - mEditTestTabContainer->setEnabled(FALSE); + mEditTestTabContainer->selectTab(0); + mTestTab->setEnabled(FALSE); mCharacterWidthSlider->setEnabled(FALSE); mCharacterTypeRadioGroup->setEnabled(FALSE); mClearPathButton->setEnabled(FALSE); - + mHasStartPoint = false; + mHasEndPoint = false; + break; + case kConsoleStateDownloading : + case kConsoleStateDownloadError : + case kConsoleStateNavMeshError : + mShowNavMeshCheckBox->setEnabled(FALSE); + mShowNavMeshWalkabilityComboBox->setEnabled(FALSE); + mShowWalkablesCheckBox->setEnabled(FALSE); + mShowStaticObstaclesCheckBox->setEnabled(FALSE); + mShowMaterialVolumesCheckBox->setEnabled(FALSE); + mShowExclusionVolumesCheckBox->setEnabled(FALSE); + mShowWorldCheckBox->setEnabled(FALSE); + mViewCharactersButton->setEnabled(TRUE); mEditTestTabContainer->selectTab(0); + mTestTab->setEnabled(FALSE); + mCharacterWidthSlider->setEnabled(FALSE); + mCharacterTypeRadioGroup->setEnabled(FALSE); + mClearPathButton->setEnabled(FALSE); mHasStartPoint = false; mHasEndPoint = false; break; - default : + case kConsoleStateHasNavMesh : + case kConsoleStateHasNavMeshDownloading : mShowNavMeshCheckBox->setEnabled(TRUE); mShowNavMeshWalkabilityComboBox->setEnabled(TRUE); mShowWalkablesCheckBox->setEnabled(TRUE); @@ -723,17 +820,71 @@ void LLFloaterPathfindingConsole::setAgentState(LLPathfindingManager::EAgentStat mShowExclusionVolumesCheckBox->setEnabled(TRUE); mShowWorldCheckBox->setEnabled(TRUE); mViewCharactersButton->setEnabled(TRUE); - mEditTestTabContainer->setEnabled(TRUE); + mTestTab->setEnabled(TRUE); mCharacterWidthSlider->setEnabled(TRUE); mCharacterTypeRadioGroup->setEnabled(TRUE); mClearPathButton->setEnabled(TRUE); + mTestTab->setEnabled(TRUE); + break; + default : + llassert(0); break; } +} +void LLFloaterPathfindingConsole::updateStatusOnConsoleState() +{ + static const LLColor4 warningColor = LLUIColorTable::instance().getColor("DrYellow"); + + std::string statusText(""); + LLStyle::Params styleParams; + + switch (mConsoleState) + { + case kConsoleStateUnknown : + statusText = getString("navmesh_status_unknown"); + break; + case kConsoleStateLibraryNotImplemented : + statusText = getString("navmesh_status_library_not_implemented"); + styleParams.color = warningColor; + break; + case kConsoleStateRegionNotEnabled : + statusText = getString("navmesh_status_region_not_enabled"); + styleParams.color = warningColor; + break; + case kConsoleStateDownloading : + statusText = getString("navmesh_status_downloading"); + break; + case kConsoleStateHasNavMesh : + statusText = getString("navmesh_status_has_navmesh"); + break; + case kConsoleStateHasNavMeshDownloading : + statusText = getString("navmesh_status_has_navmesh_downloading"); + break; + case kConsoleStateDownloadError : + statusText = getString("navmesh_status_download_error"); + styleParams.color = warningColor; + break; + case kConsoleStateNavMeshError : + statusText = getString("navmesh_status_navmesh_error"); + styleParams.color = warningColor; + break; + default : + statusText = getString("navmesh_status_unknown"); + llassert(0); + break; + } + + mPathfindingStatus->setText((LLStringExplicit)statusText, styleParams); +} + +void LLFloaterPathfindingConsole::setAgentState(LLPathfindingManager::EAgentState pAgentState) +{ switch (LLPathfindingManager::getInstance()->getLastKnownNonErrorAgentState()) { case LLPathfindingManager::kAgentStateUnknown : case LLPathfindingManager::kAgentStateNotEnabled : + mEditTab->setEnabled(FALSE); mUnfreezeLabel->setEnabled(FALSE); mUnfreezeButton->setEnabled(FALSE); mLinksetsLabel->setEnabled(FALSE); @@ -742,6 +893,7 @@ void LLFloaterPathfindingConsole::setAgentState(LLPathfindingManager::EAgentStat mFreezeButton->setEnabled(FALSE); break; case LLPathfindingManager::kAgentStateFrozen : + mEditTab->setEnabled(TRUE); mUnfreezeLabel->setEnabled(TRUE); mUnfreezeButton->setEnabled(TRUE); mLinksetsLabel->setEnabled(FALSE); @@ -750,6 +902,7 @@ void LLFloaterPathfindingConsole::setAgentState(LLPathfindingManager::EAgentStat mFreezeButton->setEnabled(FALSE); break; case LLPathfindingManager::kAgentStateUnfrozen : + mEditTab->setEnabled(TRUE); mUnfreezeLabel->setEnabled(FALSE); mUnfreezeButton->setEnabled(FALSE); mLinksetsLabel->setEnabled(TRUE); @@ -803,36 +956,36 @@ void LLFloaterPathfindingConsole::updatePathTestStatus() } -BOOL LLFloaterPathfindingConsole::isRenderAnyShapes() const -{ - if ( isRenderWalkables() || isRenderStaticObstacles() || - isRenderMaterialVolumes() || isRenderExclusionVolumes() ) - { - return true; - } - - return false; -} - -U32 LLFloaterPathfindingConsole::getRenderShapeFlags() -{ - resetShapeRenderFlags(); - - if ( isRenderWalkables() ) - { - setShapeRenderFlag( LLPathingLib::LLST_WalkableObjects ); - } - if ( isRenderStaticObstacles() ) - { - setShapeRenderFlag( LLPathingLib::LLST_ObstacleObjects ); - } - if ( isRenderMaterialVolumes() ) - { - setShapeRenderFlag( LLPathingLib::LLST_MaterialPhantoms ); - } - if ( isRenderExclusionVolumes() ) - { - setShapeRenderFlag( LLPathingLib::LLST_ExclusionPhantoms ); - } - return mShapeRenderFlags; -} +BOOL LLFloaterPathfindingConsole::isRenderAnyShapes() const +{ + if ( isRenderWalkables() || isRenderStaticObstacles() || + isRenderMaterialVolumes() || isRenderExclusionVolumes() ) + { + return true; + } + + return false; +} + +U32 LLFloaterPathfindingConsole::getRenderShapeFlags() +{ + resetShapeRenderFlags(); + + if ( isRenderWalkables() ) + { + setShapeRenderFlag( LLPathingLib::LLST_WalkableObjects ); + } + if ( isRenderStaticObstacles() ) + { + setShapeRenderFlag( LLPathingLib::LLST_ObstacleObjects ); + } + if ( isRenderMaterialVolumes() ) + { + setShapeRenderFlag( LLPathingLib::LLST_MaterialPhantoms ); + } + if ( isRenderExclusionVolumes() ) + { + setShapeRenderFlag( LLPathingLib::LLST_ExclusionPhantoms ); + } + return mShapeRenderFlags; +} diff --git a/indra/newview/llfloaterpathfindingconsole.h b/indra/newview/llfloaterpathfindingconsole.h index 34a68ebed1..237d4216bb 100644 --- a/indra/newview/llfloaterpathfindingconsole.h +++ b/indra/newview/llfloaterpathfindingconsole.h @@ -30,11 +30,12 @@ #include "llfloater.h" #include "llhandle.h" -#include "llnavmeshstation.h" #include "LLPathingLib.h" #include "llpathfindingmanager.h" +#include "llpathfindingnavmesh.h" class LLSD; +class LLPanel; class LLRadioGroup; class LLSliderCtrl; class LLLineEditor; @@ -108,22 +109,29 @@ public: ECharacterType getCharacterType() const; void setCharacterType(ECharacterType pCharacterType); - void setHasNavMeshReceived(); - void setHasNoNavMesh(); - bool getHeartBeat() const { return mHeartBeat;} void setHeartBeat( bool state ) { mHeartBeat=state; } protected: private: + typedef enum + { + kConsoleStateUnknown, + kConsoleStateLibraryNotImplemented, + kConsoleStateRegionNotEnabled, + kConsoleStateDownloading, + kConsoleStateHasNavMesh, + kConsoleStateHasNavMeshDownloading, + kConsoleStateDownloadError, + kConsoleStateNavMeshError + } EConsoleState; + // Does its own instance management, so clients not allowed // to allocate or destroy. LLFloaterPathfindingConsole(const LLSD& pSeed); virtual ~LLFloaterPathfindingConsole(); - std::string getCurrentRegionCapabilityURL() const; - void onShowWalkabilitySet(); void onShowWorldToggle(); void onCharacterWidthSet(); @@ -133,8 +141,16 @@ private: void onFreezeClicked(); void onViewEditLinksetClicked(); void onClearPathClicked(); + void onNavMeshDownloadCB(LLPathfindingNavMesh::ENavMeshRequestStatus pNavMeshRequestStatus, const LLUUID &pRegionUUID, U32 pNavMeshVersion, const LLSD::Binary &pNavMeshData); void onAgentStateCB(LLPathfindingManager::EAgentState pAgentState); + void setConsoleState(EConsoleState pConsoleState); + void updateNavMesh(const LLUUID &pRegionUUID, U32 pNavMeshVersion, const LLSD::Binary &pNavMeshData); + void clearNavMesh(); + + void updateControlsOnConsoleState(); + void updateStatusOnConsoleState(); + void setAgentState(LLPathfindingManager::EAgentState pAgentState); void generatePath(); @@ -153,6 +169,8 @@ private: LLTextBase *mPathfindingStatus; LLButton *mViewCharactersButton; LLTabContainer *mEditTestTabContainer; + LLPanel *mEditTab; + LLPanel *mTestTab; LLTextBase *mUnfreezeLabel; LLButton *mUnfreezeButton; LLTextBase *mLinksetsLabel; @@ -163,12 +181,19 @@ private: LLRadioGroup *mCharacterTypeRadioGroup; LLTextBase *mPathTestingStatus; LLButton *mClearPathButton; + LLPathfindingNavMesh::navmesh_slot_t mNavMeshSlot; LLPathfindingManager::agent_state_slot_t mAgentStateSlot; + EConsoleState mConsoleState; + bool mHasNavMesh; + U32 mNavMeshRegionVersion; + LLUUID mNavMeshRegionUUID; +#if 0 LLNavMeshDownloadObserver mNavMeshDownloadObserver[10]; int mCurrentMDO; int mNavMeshCnt; U32 mNeighboringRegion; +#endif //Container that is populated and subsequently submitted to the LLPathingSystem for processing LLPathingLib::PathingPacket mPathData; bool mHasStartPoint; diff --git a/indra/newview/llfloaterpathfindinglinksets.cpp b/indra/newview/llfloaterpathfindinglinksets.cpp index 27047b4fd9..8c4bbea128 100644 --- a/indra/newview/llfloaterpathfindinglinksets.cpp +++ b/indra/newview/llfloaterpathfindinglinksets.cpp @@ -211,7 +211,7 @@ void LLFloaterPathfindingLinksets::onOpen(const LLSD& pKey) if (!mAgentStateSlot.connected()) { - LLPathfindingManager::getInstance()->registerAgentStateSignal(boost::bind(&LLFloaterPathfindingLinksets::onAgentStateCB, this, _1)); + LLPathfindingManager::getInstance()->registerAgentStateListener(boost::bind(&LLFloaterPathfindingLinksets::onAgentStateCB, this, _1)); } if (!mSelectionUpdateSlot.connected()) diff --git a/indra/newview/llnavmeshstation.cpp b/indra/newview/llnavmeshstation.cpp deleted file mode 100644 index 54a945e562..0000000000 --- a/indra/newview/llnavmeshstation.cpp +++ /dev/null @@ -1,134 +0,0 @@ -/** - * @file llnavmeshstation.cpp - * @brief - * - * $LicenseInfo:firstyear=2005&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 "llnavmeshstation.h" -#include "llcurl.h" -#include "LLPathingLib.h" -#include "llagent.h" -#include "llviewerregion.h" -#include "llsdutil.h" -#include "llfloaterpathfindingconsole.h" -#include "llsdserialize.h" -//=============================================================================== -LLNavMeshStation::LLNavMeshStation() -{ -} -//=============================================================================== -class LLNavMeshDownloadResponder : public LLCurl::Responder -{ -public: - LLNavMeshDownloadResponder( const LLHandle& observer_handle, int dir ) - : mObserverHandle( observer_handle ) - , mDir( dir ) - { - } - - void error( U32 statusNum, const std::string& reason ) - { - llwarns << "Transport error "<& value = content["navmesh_data"].asBinary(); - unsigned int binSize = value.size(); - U8* pBinBuffer = new U8[binSize]; - memcpy( &pBinBuffer[0], &value[0], binSize ); - std::string newStr((char*) pBinBuffer, binSize ); - std::istringstream streamdecomp( newStr ); - unsigned int decompBinSize = 0; - bool valid = false; - if ( pBinBuffer ) - { - delete [] pBinBuffer ; - } - U8* pUncompressedNavMeshContainer = unzip_llsdNavMesh( valid, decompBinSize, streamdecomp, binSize ) ; - if ( !valid ) - { - if ( pUncompressedNavMeshContainer ) - { - free( pUncompressedNavMeshContainer ); - } - llwarns << "Unable to decompress the navmesh llsd." << llendl; - pObserver->getPathfindingConsole()->setHasNoNavMesh(); - return; - } - else - { - if ( pUncompressedNavMeshContainer ) - { - std::vector lsd; - lsd.resize( decompBinSize ); - memcpy( &lsd[0], &pUncompressedNavMeshContainer[0], decompBinSize ); - LLPathingLib::getInstance()->extractNavMeshSrcFromLLSD( lsd, mDir ); - pObserver->getPathfindingConsole()->setHasNavMeshReceived(); - free( pUncompressedNavMeshContainer ); - } - } - } - else - { - llwarns<<"No mesh data received"<getPathfindingConsole()->setHasNoNavMesh(); - } - } - } -} -private: - //Observer handle - LLHandle mObserverHandle; - int mDir; -}; -//=============================================================================== -void LLNavMeshStation::downloadNavMeshSrc( const LLHandle& observerHandle, int dir ) -{ - if ( mNavMeshDownloadURL.empty() ) - { - llinfos << "Unable to upload navmesh because of missing URL" << llendl; - } - else - { - LLSD data; - data["agent_id"] = gAgent.getID(); - data["region_id"] = gAgent.getRegion()->getRegionID(); - LLHTTPClient::post(mNavMeshDownloadURL, data, new LLNavMeshDownloadResponder( observerHandle, dir ) ); - } -} -//=============================================================================== diff --git a/indra/newview/llnavmeshstation.h b/indra/newview/llnavmeshstation.h deleted file mode 100644 index 72bf725688..0000000000 --- a/indra/newview/llnavmeshstation.h +++ /dev/null @@ -1,101 +0,0 @@ -/** - * @file llnavmeshstation.h - * @brief Client-side navmesh support - * - * $LicenseInfo:firstyear=2001&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_NAV_MESH_STATION_H -#define LL_NAV_MESH_STATION_H - -//=============================================================================== -#include "llhandle.h" -//=============================================================================== -class LLCurlRequest; -class LLFloaterPathfindingConsole; -//=============================================================================== -class LLNavMeshObserver -{ -public: - //Ctor - LLNavMeshObserver() - : mPathfindingConsole(NULL) - { mObserverHandle.bind(this); } - //Dtor - virtual ~LLNavMeshObserver() {} - //Accessor for the observers handle - const LLHandle& getObserverHandle() const { return mObserverHandle; } - LLFloaterPathfindingConsole *getPathfindingConsole() {return mPathfindingConsole;} - void setPathfindingConsole(LLFloaterPathfindingConsole *pPathfindingConsole) {mPathfindingConsole = pPathfindingConsole;} - -protected: - LLRootHandle mObserverHandle; - LLFloaterPathfindingConsole *mPathfindingConsole; -}; -//=============================================================================== -class LLNavMeshDownloadObserver -{ -public: - //Ctor - LLNavMeshDownloadObserver() { mObserverHandle.bind(this); } - //Dtor - virtual ~LLNavMeshDownloadObserver() {} - //Accessor for the observers handle - const LLHandle& getObserverHandle() const { return mObserverHandle; } - LLFloaterPathfindingConsole *getPathfindingConsole() {return mPathfindingConsole;} - void setPathfindingConsole(LLFloaterPathfindingConsole *pPathfindingConsole) {mPathfindingConsole = pPathfindingConsole;} - -protected: - LLRootHandle mObserverHandle; - LLFloaterPathfindingConsole *mPathfindingConsole; -}; -//=============================================================================== -class LLNavMeshStation : public LLSingleton -{ -public: - //Ctor - LLNavMeshStation(); - //Facilitates the posting of a prepopulated llsd block to an existing url - bool postNavMeshToServer( LLSD& data, const LLHandle& observerHandle ); - //Setter for the navmesh upload url - void setNavMeshUploadURL( std::string& url ) { mNavMeshUploadURL = url; } - //Setter for the navmesh download url - void setNavMeshDownloadURL( std::string& url ) { mNavMeshDownloadURL = url; } - //Callback to handle the requested src data for this regions navmesh src - static void processNavMeshSrc( LLMessageSystem* msg, void** ); - //Initiate download of the navmesh source from the server - void downloadNavMeshSrc( const LLHandle& observerHandle, int dir ); - -protected: - //Curl object to facilitate posts to server - LLCurlRequest* mCurlRequest; - //Maximum time in seconds to execute an uploading request. - S32 mMeshUploadTimeOut ; - //URL used for uploading viewer generated navmesh - std::string mNavMeshUploadURL; - //URL used for download the src data for a navmesh - std::string mNavMeshDownloadURL; - -}; -//=============================================================================== -#endif //LL_NAV_MESH_STATION_H - diff --git a/indra/newview/llpathfindingmanager.cpp b/indra/newview/llpathfindingmanager.cpp index 5c9293a28a..9a36923bd5 100644 --- a/indra/newview/llpathfindingmanager.cpp +++ b/indra/newview/llpathfindingmanager.cpp @@ -33,6 +33,7 @@ #include "llhttpclient.h" #include "llagent.h" #include "llviewerregion.h" +#include "llpathfindingnavmesh.h" #include "llpathfindinglinkset.h" #include "llpathfindinglinksetlist.h" @@ -47,6 +48,27 @@ #define CAP_SERVICE_OBJECT_LINKSETS "ObjectNavMeshProperties" #define CAP_SERVICE_TERRAIN_LINKSETS "TerrainNavMeshProperties" +//--------------------------------------------------------------------------- +// 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 //--------------------------------------------------------------------------- @@ -152,6 +174,8 @@ private: LLPathfindingManager::LLPathfindingManager() : LLSingleton(), + mNavMeshMap(), + mNavMeshVersionXXX(0), mAgentStateSignal(), mAgentState(kAgentStateUnknown), mLastKnownNonErrorAgentState(kAgentStateUnknown) @@ -179,7 +203,49 @@ bool LLPathfindingManager::isAllowViewTerrainProperties() const return (gAgent.isGodlike() || ((region != NULL) && region->canManageEstate())); } -LLPathfindingManager::agent_state_slot_t LLPathfindingManager::registerAgentStateSignal(agent_state_callback_t pAgentStateCallback) +LLPathfindingNavMesh::navmesh_slot_t LLPathfindingManager::registerNavMeshListenerForCurrentRegion(LLPathfindingNavMesh::navmesh_callback_t pNavMeshCallback) +{ + LLPathfindingNavMeshPtr navMeshPtr = getNavMeshForCurrentRegion(); + return navMeshPtr->registerNavMeshListener(pNavMeshCallback); +} + +void LLPathfindingManager::requestGetNavMeshForCurrentRegion() +{ + LLPathfindingNavMeshPtr navMeshPtr = getNavMeshForCurrentRegion(); + + if (navMeshPtr->hasNavMeshVersion(mNavMeshVersionXXX)) + { + navMeshPtr->handleRefresh(); + } + else + { + LLViewerRegion *region = getCurrentRegion(); + if (region == NULL) + { + navMeshPtr->handleNavMeshNotEnabled(); + } + else + { + std::string navMeshURL = getRetrieveNavMeshURLForCurrentRegion(); + if (navMeshURL.empty()) + { + navMeshPtr->handleNavMeshNotEnabled(); + } + else + { + navMeshPtr->handleNavMeshStart(mNavMeshVersionXXX); + LLHTTPClient::ResponderPtr responder = new NavMeshResponder(navMeshURL, mNavMeshVersionXXX, navMeshPtr); + + LLSD postData; + postData["agent_id"] = gAgent.getID(); + postData["region_id"] = region->getRegionID(); + LLHTTPClient::post(navMeshURL, postData, responder); + } + } + } +} + +LLPathfindingManager::agent_state_slot_t LLPathfindingManager::registerAgentStateListener(agent_state_callback_t pAgentStateCallback) { return mAgentStateSignal.connect(pAgentStateCallback); } @@ -301,6 +367,31 @@ LLPathfindingManager::ELinksetsRequestStatus LLPathfindingManager::requestSetLin return status; } +LLPathfindingNavMeshPtr LLPathfindingManager::getNavMeshForCurrentRegion() +{ + + LLUUID regionUUID; + LLViewerRegion *region = getCurrentRegion(); + if (region != NULL) + { + regionUUID = region->getRegionID(); + } + + LLPathfindingNavMeshPtr navMeshPtr; + NavMeshMap::iterator navMeshIter = mNavMeshMap.find(regionUUID); + if (navMeshIter == mNavMeshMap.end()) + { + navMeshPtr = LLPathfindingNavMeshPtr(new LLPathfindingNavMesh(regionUUID)); + mNavMeshMap.insert(std::pair(regionUUID, navMeshPtr)); + } + else + { + navMeshPtr = navMeshIter->second; + } + + return navMeshPtr; +} + bool LLPathfindingManager::isValidAgentState(EAgentState pAgentState) { return ((pAgentState == kAgentStateFrozen) || (pAgentState == kAgentStateUnfrozen)); @@ -398,6 +489,31 @@ LLViewerRegion *LLPathfindingManager::getCurrentRegion() const return gAgent.getRegion(); } +//--------------------------------------------------------------------------- +// NavMeshResponder +//--------------------------------------------------------------------------- + +NavMeshResponder::NavMeshResponder(const std::string &pCapabilityURL, U32 pNavMeshVersion, LLPathfindingNavMeshPtr pNavMeshPtr) + : 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 //--------------------------------------------------------------------------- diff --git a/indra/newview/llpathfindingmanager.h b/indra/newview/llpathfindingmanager.h index 9a6bbb81b9..f034ddb9ea 100644 --- a/indra/newview/llpathfindingmanager.h +++ b/indra/newview/llpathfindingmanager.h @@ -28,15 +28,18 @@ #ifndef LL_LLPATHFINDINGMANAGER_H #define LL_LLPATHFINDINGMANAGER_H +#include "llsingleton.h" +#include "lluuid.h" +#include "llpathfindingnavmesh.h" +#include "llpathfindinglinkset.h" +#include "llpathfindinglinksetlist.h" + #include +#include #include #include -#include "llsingleton.h" -#include "llpathfindinglinkset.h" -#include "llpathfindinglinksetlist.h" - class LLFloater; class LLViewerRegion; @@ -44,6 +47,8 @@ class LLPathfindingManager : public LLSingleton { friend class AgentStateResponder; public: + typedef std::map NavMeshMap; + typedef enum { kAgentStateUnknown, kAgentStateFrozen, @@ -73,7 +78,10 @@ public: bool isAllowAlterPermanent(); bool isAllowViewTerrainProperties() const; - agent_state_slot_t registerAgentStateSignal(agent_state_callback_t pAgentStateCallback); + LLPathfindingNavMesh::navmesh_slot_t registerNavMeshListenerForCurrentRegion(LLPathfindingNavMesh::navmesh_callback_t pNavMeshCallback); + void requestGetNavMeshForCurrentRegion(); + + agent_state_slot_t registerAgentStateListener(agent_state_callback_t pAgentStateCallback); EAgentState getAgentState(); EAgentState getLastKnownNonErrorAgentState() const; void requestSetAgentState(EAgentState pAgentState); @@ -84,6 +92,8 @@ public: protected: private: + LLPathfindingNavMeshPtr getNavMeshForCurrentRegion(); + static bool isValidAgentState(EAgentState pAgentState); void requestGetAgentState(); @@ -96,9 +106,12 @@ private: std::string getObjectLinksetsURLForCurrentRegion() const; std::string getTerrainLinksetsURLForCurrentRegion() const; - std::string getCapabilityURLForCurrentRegion(const std::string &pCapabilityName) const; + std::string getCapabilityURLForCurrentRegion(const std::string &pCapabilityName) const; LLViewerRegion *getCurrentRegion() const; + NavMeshMap mNavMeshMap; + U32 mNavMeshVersionXXX; // XXX stinson 03/02/2012 : a hacky way of doing versions for now + agent_state_signal_t mAgentStateSignal; EAgentState mAgentState; EAgentState mLastKnownNonErrorAgentState; diff --git a/indra/newview/llpathfindingnavmesh.cpp b/indra/newview/llpathfindingnavmesh.cpp new file mode 100644 index 0000000000..fd1a498e3b --- /dev/null +++ b/indra/newview/llpathfindingnavmesh.cpp @@ -0,0 +1,133 @@ +/** + * @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 "llsdserialize.h" + +#include + +//--------------------------------------------------------------------------- +// LLPathfindingNavMesh +//--------------------------------------------------------------------------- + +LLPathfindingNavMesh::LLPathfindingNavMesh(const LLUUID &pRegionUUID) + : mRegionUUID(pRegionUUID), + mNavMeshRequestStatus(kNavMeshRequestUnknown), + mNavMeshSignal(), + mNavMeshData(), + mNavMeshVersion(0U) +{ +} + +LLPathfindingNavMesh::~LLPathfindingNavMesh() +{ +} + +LLPathfindingNavMesh::navmesh_slot_t LLPathfindingNavMesh::registerNavMeshListener(navmesh_callback_t pNavMeshCallback) +{ + return mNavMeshSignal.connect(pNavMeshCallback); +} + +bool LLPathfindingNavMesh::hasNavMeshVersion(U32 pNavMeshVersion) const +{ + return (((mNavMeshRequestStatus == kNavMeshRequestStarted) || (mNavMeshRequestStatus == kNavMeshRequestCompleted)) && (mNavMeshVersion == pNavMeshVersion)); +} + +void LLPathfindingNavMesh::handleRefresh() +{ + mNavMeshSignal(mNavMeshRequestStatus, mRegionUUID, mNavMeshVersion, mNavMeshData); +} + +void LLPathfindingNavMesh::handleNavMeshStart(U32 pNavMeshVersion) +{ + mNavMeshVersion = pNavMeshVersion; + setRequestStatus(kNavMeshRequestStarted); +} + +void LLPathfindingNavMesh::handleNavMeshResult(const LLSD &pContent, U32 pNavMeshVersion) +{ + llassert(mNavMeshVersion == pNavMeshVersion); + if (mNavMeshVersion == pNavMeshVersion) + { + if ( pContent.has("navmesh_data") ) + { + const LLSD::Binary &value = pContent["navmesh_data"].asBinary(); + unsigned int binSize = value.size(); + std::string newStr(reinterpret_cast(&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; + setRequestStatus(kNavMeshRequestFormatError); + } + else + { + llassert(pUncompressedNavMeshContainer); + mNavMeshData.resize( decompBinSize ); + memcpy( &mNavMeshData[0], &pUncompressedNavMeshContainer[0], decompBinSize ); + setRequestStatus(kNavMeshRequestCompleted); + } + if ( pUncompressedNavMeshContainer ) + { + free( pUncompressedNavMeshContainer ); + } + } + else + { + llwarns << "No mesh data received" << llendl; + setRequestStatus(kNavMeshRequestMessageError); + } + } +} + +void LLPathfindingNavMesh::handleNavMeshNotEnabled() +{ + mNavMeshData.clear(); + setRequestStatus(kNavMeshRequestNotEnabled); +} + +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; + llassert(mNavMeshVersion == pNavMeshVersion); + mNavMeshData.clear(); + if (mNavMeshVersion == pNavMeshVersion) + { + setRequestStatus(kNavMeshRequestMessageError); + } +} + +void LLPathfindingNavMesh::setRequestStatus(ENavMeshRequestStatus pNavMeshRequestStatus) +{ + mNavMeshRequestStatus = pNavMeshRequestStatus; + mNavMeshSignal(mNavMeshRequestStatus, mRegionUUID, mNavMeshVersion, mNavMeshData); +} diff --git a/indra/newview/llpathfindingnavmesh.h b/indra/newview/llpathfindingnavmesh.h new file mode 100644 index 0000000000..1f033e15c7 --- /dev/null +++ b/indra/newview/llpathfindingnavmesh.h @@ -0,0 +1,86 @@ +/** + * @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 "lluuid.h" + +#include + +#include +#include +#include + +class LLSD; +class LLPathfindingNavMesh; + +typedef boost::shared_ptr LLPathfindingNavMeshPtr; + +class LLPathfindingNavMesh +{ +public: + typedef enum { + kNavMeshRequestUnknown, + kNavMeshRequestStarted, + kNavMeshRequestCompleted, + kNavMeshRequestNotEnabled, + kNavMeshRequestMessageError, + kNavMeshRequestFormatError + } ENavMeshRequestStatus; + + typedef boost::function navmesh_callback_t; + typedef boost::signals2::signal navmesh_signal_t; + typedef boost::signals2::connection navmesh_slot_t; + + LLPathfindingNavMesh(const LLUUID &pRegionUUID); + virtual ~LLPathfindingNavMesh(); + + navmesh_slot_t registerNavMeshListener(navmesh_callback_t pNavMeshCallback); + + bool hasNavMeshVersion(U32 pNavMeshVersion) const; + + void handleRefresh(); + void handleNavMeshStart(U32 pNavMeshVersion); + void handleNavMeshResult(const LLSD &pContent, U32 pNavMeshVersion); + void handleNavMeshNotEnabled(); + void handleNavMeshError(U32 pStatus, const std::string &pReason, const std::string &pURL, U32 pNavMeshVersion); + +protected: + +private: + void setRequestStatus(ENavMeshRequestStatus pNavMeshRequestStatus); + + LLUUID mRegionUUID; + ENavMeshRequestStatus mNavMeshRequestStatus; + navmesh_signal_t mNavMeshSignal; + LLSD::Binary mNavMeshData; + U32 mNavMeshVersion; +}; + +#endif // LL_LLPATHFINDINGNAVMESH_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 b608e513d5..5577083303 100644 --- a/indra/newview/skins/default/xui/en/floater_pathfinding_console.xml +++ b/indra/newview/skins/default/xui/en/floater_pathfinding_console.xml @@ -11,12 +11,14 @@ single_instance="true" title="Pathfinding edit / test" width="456"> - - Downloading the navmesh ... - Navmesh received. - No navmesh for region. - This region is not enabled for pathfinding. - Cannot find pathing library implementation. + + Cannot find pathing library implementation. + This region is not enabled for pathfinding. + Downloading the navmesh ... + Navmesh received. + Downloading the latest navmesh ... + Unable to download navmesh successfully. + Unable to understand data format of the navmesh. Please choose start and end points. Please choose start point. Please choose end point. -- cgit v1.3 From 49477cec951a658d2014afd7ac7c3920d6844a50 Mon Sep 17 00:00:00 2001 From: Todd Stinson Date: Tue, 6 Mar 2012 11:01:29 -0800 Subject: Updating the freeze/unfreeze service with the new field names. Also, still supporting the old field names until fully deprecated from all server builds. --- indra/newview/llpathfindingmanager.cpp | 29 ++++++++++++++++++++++++----- 1 file changed, 24 insertions(+), 5 deletions(-) (limited to 'indra/newview/llpathfindingmanager.cpp') diff --git a/indra/newview/llpathfindingmanager.cpp b/indra/newview/llpathfindingmanager.cpp index 5c9293a28a..a59dda74ac 100644 --- a/indra/newview/llpathfindingmanager.cpp +++ b/indra/newview/llpathfindingmanager.cpp @@ -42,7 +42,8 @@ #define CAP_SERVICE_RETRIEVE_NAVMESH "RetrieveNavMeshSrc" #define CAP_SERVICE_AGENT_STATE "AgentPreferences" -#define ALTER_PERMANENT_OBJECTS_FIELD "alter_permanent_objects" +#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" @@ -218,7 +219,10 @@ void LLPathfindingManager::requestSetAgentState(EAgentState pRequestedAgentState else { LLSD request; - request[ALTER_PERMANENT_OBJECTS_FIELD] = static_cast(pRequestedAgentState == kAgentStateUnfrozen); + request[ALTER_NAVMESH_OBJECTS_FIELD] = static_cast(pRequestedAgentState == kAgentStateUnfrozen); +#ifdef DEPRECATED_ALTER_NAVMESH_OBJECTS_FIELD + request[DEPRECATED_ALTER_NAVMESH_OBJECTS_FIELD] = static_cast(pRequestedAgentState == kAgentStateUnfrozen); +#endif // DEPRECATED_ALTER_NAVMESH_OBJECTS_FIELD LLHTTPClient::ResponderPtr responder = new AgentStateResponder(agentStateURL, pRequestedAgentState); LLHTTPClient::post(agentStateURL, request, responder); @@ -335,9 +339,24 @@ void LLPathfindingManager::setAgentState(EAgentState pAgentState) void LLPathfindingManager::handleAgentStateResult(const LLSD &pContent, EAgentState pRequestedAgentState) { - llassert(pContent.has(ALTER_PERMANENT_OBJECTS_FIELD)); - llassert(pContent.get(ALTER_PERMANENT_OBJECTS_FIELD).isBoolean()); - EAgentState agentState = (pContent.get(ALTER_PERMANENT_OBJECTS_FIELD).asBoolean() ? kAgentStateUnfrozen : kAgentStateFrozen); +#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)) { -- cgit v1.3 From a0c626fe411336871505c2c414143ae4b2f73259 Mon Sep 17 00:00:00 2001 From: Todd Stinson Date: Tue, 6 Mar 2012 18:40:37 -0800 Subject: PATH-205,PATH-304: More work to handle downloading of out-of-date navmeshes. --- indra/newview/llfloaterpathfindingconsole.cpp | 73 +--------- indra/newview/llpathfindingmanager.cpp | 39 +++--- indra/newview/llpathfindingmanager.h | 8 +- indra/newview/llpathfindingnavmeshzone.cpp | 194 ++++++++++++++++++-------- indra/newview/llpathfindingnavmeshzone.h | 40 ++++-- 5 files changed, 190 insertions(+), 164 deletions(-) (limited to 'indra/newview/llpathfindingmanager.cpp') diff --git a/indra/newview/llfloaterpathfindingconsole.cpp b/indra/newview/llfloaterpathfindingconsole.cpp index f2404dcb6b..fe5c6b8d44 100644 --- a/indra/newview/llfloaterpathfindingconsole.cpp +++ b/indra/newview/llfloaterpathfindingconsole.cpp @@ -171,77 +171,10 @@ void LLFloaterPathfindingConsole::onOpen(const LLSD& pKey) mNavMeshZoneSlot = mNavMeshZone.registerNavMeshZoneListener(boost::bind(&LLFloaterPathfindingConsole::onNavMeshZoneCB, this, _1)); } - mNavMeshZone.setCurrentRegionAsCenter(); - mNavMeshZone.refresh(); -#if 0 - LLPathingLib::getInstance()->cleanupResidual(); - - mCurrentMDO = 0; - mNavMeshCnt = 0; - - //make sure the region is essentially enabled for navmesh support - std::string capability = "RetrieveNavMeshSrc"; - - LLViewerRegion* pCurrentRegion = gAgent.getRegion(); - std::vector regions; - regions.push_back( pCurrentRegion ); - std::vector shiftDirections; - shiftDirections.push_back( CURRENT_REGION ); - - mNeighboringRegion = gSavedSettings.getU32("RetrieveNeighboringRegion"); - if ( mNeighboringRegion != CURRENT_REGION ) - { - //User wants to pull in a neighboring region - std::vector availableRegions; - pCurrentRegion->getNeighboringRegionsStatus( availableRegions ); - //Is the desired region in the available list - std::vector::iterator foundElem = std::find(availableRegions.begin(),availableRegions.end(),mNeighboringRegion); - if ( foundElem != availableRegions.end() ) - { - LLViewerRegion* pCurrentRegion = gAgent.getRegion(); - std::vector regionPtrs; - pCurrentRegion->getNeighboringRegions( regionPtrs ); - regions.push_back( regionPtrs[mNeighboringRegion] ); - shiftDirections.push_back( mNeighboringRegion ); - } - } - - - //If the navmesh shift ops and the total region counts do not match - use the current region, only. - if ( shiftDirections.size() != regions.size() ) - { - shiftDirections.clear();regions.clear(); - regions.push_back( pCurrentRegion ); - shiftDirections.push_back( CURRENT_REGION ); - } + mNavMeshZone.initialize(); - int regionCnt = regions.size(); - mNavMeshCnt = regionCnt; - - for ( int i=0; igetCapability( capability ); - - if ( !url.empty() ) - { - std::string str = getString("navmesh_fetch_inprogress"); - mPathfindingStatus->setText((LLStringExplicit)str); - LLNavMeshStation::getInstance()->setNavMeshDownloadURL( url ); - int dir = shiftDirections[i]; - LLNavMeshStation::getInstance()->downloadNavMeshSrc( mNavMeshDownloadObserver[mCurrentMDO].getObserverHandle(), dir ); - ++mCurrentMDO; - } - else - { - --mNavMeshCnt; - std::string str = getString("navmesh_region_not_enabled"); - LLStyle::Params styleParams; - styleParams.color = LLUIColorTable::instance().getColor("DrYellow"); - mPathfindingStatus->setText((LLStringExplicit)str, styleParams); - llinfos<<"Region has does not required caps of type ["<canManageEstate())); } -LLPathfindingNavMesh::navmesh_slot_t LLPathfindingManager::registerNavMeshListenerForCurrentRegion(LLPathfindingNavMesh::navmesh_callback_t pNavMeshCallback) +LLPathfindingNavMesh::navmesh_slot_t LLPathfindingManager::registerNavMeshListenerForRegion(LLViewerRegion *pRegion, LLPathfindingNavMesh::navmesh_callback_t pNavMeshCallback) { - LLPathfindingNavMeshPtr navMeshPtr = getNavMeshForCurrentRegion(); + LLPathfindingNavMeshPtr navMeshPtr = getNavMeshForRegion(pRegion); return navMeshPtr->registerNavMeshListener(pNavMeshCallback); } -void LLPathfindingManager::requestGetNavMeshForCurrentRegion() +void LLPathfindingManager::requestGetNavMeshForRegion(LLViewerRegion *pRegion) { - LLPathfindingNavMeshPtr navMeshPtr = getNavMeshForCurrentRegion(); + LLPathfindingNavMeshPtr navMeshPtr = getNavMeshForRegion(pRegion); if (navMeshPtr->hasNavMeshVersion(mNavMeshVersionXXX)) { @@ -220,14 +220,13 @@ void LLPathfindingManager::requestGetNavMeshForCurrentRegion() } else { - LLViewerRegion *region = getCurrentRegion(); - if (region == NULL) + if (pRegion == NULL) { navMeshPtr->handleNavMeshNotEnabled(); } else { - std::string navMeshURL = getRetrieveNavMeshURLForCurrentRegion(); + std::string navMeshURL = getRetrieveNavMeshURLForRegion(pRegion); if (navMeshURL.empty()) { navMeshPtr->handleNavMeshNotEnabled(); @@ -239,7 +238,7 @@ void LLPathfindingManager::requestGetNavMeshForCurrentRegion() LLSD postData; postData["agent_id"] = gAgent.getID(); - postData["region_id"] = region->getRegionID(); + postData["region_id"] = pRegion->getRegionID(); LLHTTPClient::post(navMeshURL, postData, responder); } } @@ -371,14 +370,13 @@ LLPathfindingManager::ELinksetsRequestStatus LLPathfindingManager::requestSetLin return status; } -LLPathfindingNavMeshPtr LLPathfindingManager::getNavMeshForCurrentRegion() +LLPathfindingNavMeshPtr LLPathfindingManager::getNavMeshForRegion(LLViewerRegion *pRegion) { LLUUID regionUUID; - LLViewerRegion *region = getCurrentRegion(); - if (region != NULL) + if (pRegion != NULL) { - regionUUID = region->getRegionID(); + regionUUID = pRegion->getRegionID(); } LLPathfindingNavMeshPtr navMeshPtr; @@ -469,6 +467,11 @@ std::string LLPathfindingManager::getRetrieveNavMeshURLForCurrentRegion() const return getCapabilityURLForCurrentRegion(CAP_SERVICE_RETRIEVE_NAVMESH); } +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); @@ -485,19 +488,23 @@ std::string LLPathfindingManager::getTerrainLinksetsURLForCurrentRegion() const } 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(""); - LLViewerRegion* region = getCurrentRegion(); - if (region != NULL) + if (pRegion != NULL) { - capabilityURL = region->getCapability(pCapabilityName); + capabilityURL = pRegion->getCapability(pCapabilityName); } if (capabilityURL.empty()) { llwarns << "cannot find capability '" << pCapabilityName << "' for current region '" - << ((region != NULL) ? region->getName() : "") << "'" << llendl; + << ((pRegion != NULL) ? pRegion->getName() : "") << "'" << llendl; } return capabilityURL; diff --git a/indra/newview/llpathfindingmanager.h b/indra/newview/llpathfindingmanager.h index f034ddb9ea..eb8704e308 100644 --- a/indra/newview/llpathfindingmanager.h +++ b/indra/newview/llpathfindingmanager.h @@ -78,8 +78,8 @@ public: bool isAllowAlterPermanent(); bool isAllowViewTerrainProperties() const; - LLPathfindingNavMesh::navmesh_slot_t registerNavMeshListenerForCurrentRegion(LLPathfindingNavMesh::navmesh_callback_t pNavMeshCallback); - void requestGetNavMeshForCurrentRegion(); + 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(); @@ -92,7 +92,7 @@ public: protected: private: - LLPathfindingNavMeshPtr getNavMeshForCurrentRegion(); + LLPathfindingNavMeshPtr getNavMeshForRegion(LLViewerRegion *pRegion); static bool isValidAgentState(EAgentState pAgentState); @@ -102,11 +102,13 @@ private: void handleAgentStateError(U32 pStatus, const std::string &pReason, const std::string &pURL); std::string getRetrieveNavMeshURLForCurrentRegion() const; + std::string getRetrieveNavMeshURLForRegion(LLViewerRegion *pRegion) const; std::string getAgentStateURLForCurrentRegion() const; std::string getObjectLinksetsURLForCurrentRegion() const; std::string getTerrainLinksetsURLForCurrentRegion() const; std::string getCapabilityURLForCurrentRegion(const std::string &pCapabilityName) const; + std::string getCapabilityURLForRegion(LLViewerRegion *pRegion, const std::string &pCapabilityName) const; LLViewerRegion *getCurrentRegion() const; NavMeshMap mNavMeshMap; diff --git a/indra/newview/llpathfindingnavmeshzone.cpp b/indra/newview/llpathfindingnavmeshzone.cpp index c6b9c6c338..7b9ac913c9 100644 --- a/indra/newview/llpathfindingnavmeshzone.cpp +++ b/indra/newview/llpathfindingnavmeshzone.cpp @@ -38,7 +38,9 @@ #include "LLPathingLib.h" #include -#include +#include + +#include #define CENTER_REGION 99 @@ -47,9 +49,8 @@ //--------------------------------------------------------------------------- LLPathfindingNavMeshZone::LLPathfindingNavMeshZone() - : mNavMeshLocations(), - mNavMeshZoneSignal(), - mNavMeshSlot() + : mNavMeshLocationPtrs(), + mNavMeshZoneSignal() { } @@ -62,56 +63,68 @@ LLPathfindingNavMeshZone::navmesh_zone_slot_t LLPathfindingNavMeshZone::register return mNavMeshZoneSignal.connect(pNavMeshZoneCallback); } -void LLPathfindingNavMeshZone::setCurrentRegionAsCenter() +void LLPathfindingNavMeshZone::initialize() { llassert(LLPathingLib::getInstance() != NULL); if (LLPathingLib::getInstance() != NULL) { LLPathingLib::getInstance()->cleanupResidual(); } - mNavMeshLocations.clear(); - LLViewerRegion *currentRegion = gAgent.getRegion(); - const LLUUID ¤tRegionUUID = currentRegion->getRegionID(); - NavMeshLocation centerNavMesh(currentRegionUUID, CENTER_REGION); - mNavMeshLocations.insert(std::pair(currentRegionUUID, centerNavMesh)); + mNavMeshLocationPtrs.clear(); + + NavMeshLocationPtr centerNavMeshPtr(new NavMeshLocation(CENTER_REGION, boost::bind(&LLPathfindingNavMeshZone::handleNavMeshLocation, this))); + mNavMeshLocationPtrs.push_back(centerNavMeshPtr); + + U32 neighborRegionDir = gSavedSettings.getU32("RetrieveNeighboringRegion"); + if (neighborRegionDir != CENTER_REGION) + { + NavMeshLocationPtr neighborNavMeshPtr(new NavMeshLocation(neighborRegionDir, boost::bind(&LLPathfindingNavMeshZone::handleNavMeshLocation, this))); + mNavMeshLocationPtrs.push_back(neighborNavMeshPtr); + } } -void LLPathfindingNavMeshZone::refresh() +void LLPathfindingNavMeshZone::enable() { - LLPathfindingManager *pathfindingManagerInstance = LLPathfindingManager::getInstance(); - if (!mNavMeshSlot.connected()) + for (NavMeshLocationPtrs::iterator navMeshLocationPtrIter = mNavMeshLocationPtrs.begin(); + navMeshLocationPtrIter != mNavMeshLocationPtrs.end(); ++navMeshLocationPtrIter) { - mNavMeshSlot = pathfindingManagerInstance->registerNavMeshListenerForCurrentRegion(boost::bind(&LLPathfindingNavMeshZone::handleNavMesh, this, _1, _2, _3, _4)); + NavMeshLocationPtr navMeshLocationPtr = *navMeshLocationPtrIter; + navMeshLocationPtr->enable(); } - - pathfindingManagerInstance->requestGetNavMeshForCurrentRegion(); } void LLPathfindingNavMeshZone::disable() { - if (mNavMeshSlot.connected()) + for (NavMeshLocationPtrs::iterator navMeshLocationPtrIter = mNavMeshLocationPtrs.begin(); + navMeshLocationPtrIter != mNavMeshLocationPtrs.end(); ++navMeshLocationPtrIter) { - mNavMeshSlot.disconnect(); + NavMeshLocationPtr navMeshLocationPtr = *navMeshLocationPtrIter; + navMeshLocationPtr->disable(); } - +#if 0 + llassert(LLPathingLib::getInstance() != NULL); if (LLPathingLib::getInstance() != NULL) { LLPathingLib::getInstance()->cleanupResidual(); } - - mNavMeshLocations.clear(); +#endif } -void LLPathfindingNavMeshZone::handleNavMesh(LLPathfindingNavMesh::ENavMeshRequestStatus pNavMeshRequestStatus, const LLUUID &pRegionUUID, U32 pNavMeshVersion, const LLSD::Binary &pNavMeshData) +void LLPathfindingNavMeshZone::refresh() { - NavMeshLocations::iterator navMeshIter = mNavMeshLocations.find(pRegionUUID); - if (navMeshIter != mNavMeshLocations.end()) + for (NavMeshLocationPtrs::iterator navMeshLocationPtrIter = mNavMeshLocationPtrs.begin(); + navMeshLocationPtrIter != mNavMeshLocationPtrs.end(); ++navMeshLocationPtrIter) { - navMeshIter->second.handleNavMesh(pNavMeshRequestStatus, pRegionUUID, pNavMeshVersion, pNavMeshData); - updateStatus(); + NavMeshLocationPtr navMeshLocationPtr = *navMeshLocationPtrIter; + navMeshLocationPtr->refresh(); } } +void LLPathfindingNavMeshZone::handleNavMeshLocation() +{ + updateStatus(); +} + void LLPathfindingNavMeshZone::updateStatus() { bool hasRequestUnknown = false; @@ -120,10 +133,11 @@ void LLPathfindingNavMeshZone::updateStatus() bool hasRequestNotEnabled = false; bool hasRequestError = false; - for (NavMeshLocations::iterator navMeshIter = mNavMeshLocations.begin(); - navMeshIter != mNavMeshLocations.end(); ++navMeshIter) + for (NavMeshLocationPtrs::iterator navMeshLocationPtrIter = mNavMeshLocationPtrs.begin(); + navMeshLocationPtrIter != mNavMeshLocationPtrs.end(); ++navMeshLocationPtrIter) { - switch (navMeshIter->second.getRequestStatus()) + NavMeshLocationPtr navMeshLocationPtr = *navMeshLocationPtrIter; + switch (navMeshLocationPtr->getRequestStatus()) { case LLPathfindingNavMesh::kNavMeshRequestUnknown : hasRequestUnknown = true; @@ -148,23 +162,14 @@ void LLPathfindingNavMeshZone::updateStatus() } ENavMeshZoneRequestStatus zoneRequestStatus = kNavMeshZoneRequestUnknown; - if (hasRequestNotEnabled) + if (hasRequestStarted) { - zoneRequestStatus = kNavMeshZoneRequestNotEnabled; + zoneRequestStatus = kNavMeshZoneRequestStarted; } else if (hasRequestError) { zoneRequestStatus = kNavMeshZoneRequestError; } - else if (hasRequestStarted) - { - zoneRequestStatus = kNavMeshZoneRequestStarted; - } - else if (hasRequestUnknown) - { - zoneRequestStatus = kNavMeshZoneRequestUnknown; - llassert(0); - } else if (hasRequestCompleted) { zoneRequestStatus = kNavMeshZoneRequestCompleted; @@ -174,6 +179,14 @@ void LLPathfindingNavMeshZone::updateStatus() LLPathingLib::getInstance()->stitchNavMeshes( gSavedSettings.getBOOL("EnableVBOForNavMeshVisualization") ); } } + else if (hasRequestNotEnabled) + { + zoneRequestStatus = kNavMeshZoneRequestNotEnabled; + } + else if (hasRequestUnknown) + { + zoneRequestStatus = kNavMeshZoneRequestUnknown; + } else { zoneRequestStatus = kNavMeshZoneRequestError; @@ -187,26 +200,62 @@ void LLPathfindingNavMeshZone::updateStatus() // LLPathfindingNavMeshZone::NavMeshLocation //--------------------------------------------------------------------------- -LLPathfindingNavMeshZone::NavMeshLocation::NavMeshLocation(const LLUUID &pRegionUUID, S32 pDirection) - : mRegionUUID(pRegionUUID), - mDirection(pDirection), +LLPathfindingNavMeshZone::NavMeshLocation::NavMeshLocation(S32 pDirection, navmesh_location_callback_t pLocationCallback) + : mDirection(pDirection), + mRegionUUID(), mHasNavMesh(false), mNavMeshVersion(0U), - mRequestStatus(LLPathfindingNavMesh::kNavMeshRequestUnknown) + mLocationCallback(pLocationCallback), + mRequestStatus(LLPathfindingNavMesh::kNavMeshRequestUnknown), + mNavMeshSlot() { } -LLPathfindingNavMeshZone::NavMeshLocation::NavMeshLocation(const NavMeshLocation &other) - : mRegionUUID(other.mRegionUUID), - mDirection(other.mDirection), - mHasNavMesh(other.mHasNavMesh), - mNavMeshVersion(other.mNavMeshVersion), - mRequestStatus(other.mRequestStatus) +LLPathfindingNavMeshZone::NavMeshLocation::~NavMeshLocation() { } -LLPathfindingNavMeshZone::NavMeshLocation::~NavMeshLocation() +void LLPathfindingNavMeshZone::NavMeshLocation::enable() { + clear(); + + LLViewerRegion *region = getRegion(); + if (region == NULL) + { + mRegionUUID.setNull(); + } + else + { + mRegionUUID = region->getRegionID(); + mNavMeshSlot = LLPathfindingManager::getInstance()->registerNavMeshListenerForRegion(region, boost::bind(&LLPathfindingNavMeshZone::NavMeshLocation::handleNavMesh, this, _1, _2, _3, _4)); + } +} + +void LLPathfindingNavMeshZone::NavMeshLocation::refresh() +{ + LLViewerRegion *region = getRegion(); + + if (region == NULL) + { + llassert(mRegionUUID.isNull()); + LLSD::Binary nullData; + handleNavMesh(LLPathfindingNavMesh::kNavMeshRequestUnknown, mRegionUUID, 0U, nullData); + } + else + { + llassert(mRegionUUID == region->getRegionID()); + LLPathfindingManager::getInstance()->requestGetNavMeshForRegion(region); + } +} + +void LLPathfindingNavMeshZone::NavMeshLocation::disable() +{ + clear(); +} + +LLPathfindingNavMesh::ENavMeshRequestStatus LLPathfindingNavMeshZone::NavMeshLocation::getRequestStatus() const +{ + return mRequestStatus; } void LLPathfindingNavMeshZone::NavMeshLocation::handleNavMesh(LLPathfindingNavMesh::ENavMeshRequestStatus pNavMeshRequestStatus, const LLUUID &pRegionUUID, U32 pNavMeshVersion, const LLSD::Binary &pNavMeshData) @@ -224,20 +273,45 @@ void LLPathfindingNavMeshZone::NavMeshLocation::handleNavMesh(LLPathfindingNavMe LLPathingLib::getInstance()->extractNavMeshSrcFromLLSD(pNavMeshData, mDirection); } } + mLocationCallback(); } -LLPathfindingNavMesh::ENavMeshRequestStatus LLPathfindingNavMeshZone::NavMeshLocation::getRequestStatus() const +void LLPathfindingNavMeshZone::NavMeshLocation::clear() { - return mRequestStatus; + mHasNavMesh = false; + mRequestStatus = LLPathfindingNavMesh::kNavMeshRequestUnknown; + if (mNavMeshSlot.connected()) + { + mNavMeshSlot.disconnect(); + } } -LLPathfindingNavMeshZone::NavMeshLocation &LLPathfindingNavMeshZone::NavMeshLocation::operator =(const NavMeshLocation &other) +LLViewerRegion *LLPathfindingNavMeshZone::NavMeshLocation::getRegion() const { - mRegionUUID = other.mRegionUUID; - mDirection = other.mDirection; - mHasNavMesh = other.mHasNavMesh; - mNavMeshVersion = other.mNavMeshVersion; - mRequestStatus = other.mRequestStatus; + LLViewerRegion *region = NULL; + + LLViewerRegion *currentRegion = gAgent.getRegion(); + if (currentRegion != NULL) + { + if (mDirection == CENTER_REGION) + { + region = currentRegion; + } + else + { + //User wants to pull in a neighboring region + std::vector availableRegions; + currentRegion->getNeighboringRegionsStatus( availableRegions ); + //Is the desired region in the available list + std::vector::iterator foundElem = std::find(availableRegions.begin(),availableRegions.end(),mDirection); + if ( foundElem != availableRegions.end() ) + { + std::vector neighborRegionsPtrs; + currentRegion->getNeighboringRegions( neighborRegionsPtrs ); + region = neighborRegionsPtrs[foundElem - availableRegions.begin()]; + } + } + } - return (*this); + return region; } diff --git a/indra/newview/llpathfindingnavmeshzone.h b/indra/newview/llpathfindingnavmeshzone.h index 9d1139de32..8489b5899b 100644 --- a/indra/newview/llpathfindingnavmeshzone.h +++ b/indra/newview/llpathfindingnavmeshzone.h @@ -32,8 +32,9 @@ #include "lluuid.h" #include "llpathfindingnavmesh.h" -#include +#include +#include #include #include @@ -56,44 +57,53 @@ public: virtual ~LLPathfindingNavMeshZone(); navmesh_zone_slot_t registerNavMeshZoneListener(navmesh_zone_callback_t pNavMeshZoneCallback); - void setCurrentRegionAsCenter(); - void refresh(); - void disable(); + void initialize(); - void handleNavMesh(LLPathfindingNavMesh::ENavMeshRequestStatus pNavMeshRequestStatus, const LLUUID &pRegionUUID, U32 pNavMeshVersion, const LLSD::Binary &pNavMeshData); + void enable(); + void disable(); + void refresh(); protected: private: + typedef boost::function navmesh_location_callback_t; class NavMeshLocation { public: - NavMeshLocation(const LLUUID &pRegionUUID, S32 pDirection); - NavMeshLocation(const NavMeshLocation &other); + NavMeshLocation(S32 pDirection, navmesh_location_callback_t pLocationCallback); virtual ~NavMeshLocation(); - void handleNavMesh(LLPathfindingNavMesh::ENavMeshRequestStatus pNavMeshRequestStatus, const LLUUID &pRegionUUID, U32 pNavMeshVersion, const LLSD::Binary &pNavMeshData); - LLPathfindingNavMesh::ENavMeshRequestStatus getRequestStatus() const; + void enable(); + void refresh(); + void disable(); - NavMeshLocation &operator =(const NavMeshLocation &other); + LLPathfindingNavMesh::ENavMeshRequestStatus getRequestStatus() const; protected: private: - LLUUID mRegionUUID; + void handleNavMesh(LLPathfindingNavMesh::ENavMeshRequestStatus pNavMeshRequestStatus, const LLUUID &pRegionUUID, U32 pNavMeshVersion, const LLSD::Binary &pNavMeshData); + + void clear(); + LLViewerRegion *getRegion() const; + S32 mDirection; + LLUUID mRegionUUID; bool mHasNavMesh; U32 mNavMeshVersion; + navmesh_location_callback_t mLocationCallback; LLPathfindingNavMesh::ENavMeshRequestStatus mRequestStatus; + LLPathfindingNavMesh::navmesh_slot_t mNavMeshSlot; }; - typedef std::map NavMeshLocations; + typedef boost::shared_ptr NavMeshLocationPtr; + typedef std::vector NavMeshLocationPtrs; + void handleNavMeshLocation(); void updateStatus(); - NavMeshLocations mNavMeshLocations; - navmesh_zone_signal_t mNavMeshZoneSignal; - LLPathfindingNavMesh::navmesh_slot_t mNavMeshSlot; + NavMeshLocationPtrs mNavMeshLocationPtrs; + navmesh_zone_signal_t mNavMeshZoneSignal; }; #endif // LL_LLPATHFINDINGNAVMESHZONE_H -- cgit v1.3 From 160a9532bad6d4d0112b888b3490d94ee34f5f13 Mon Sep 17 00:00:00 2001 From: Todd Stinson Date: Wed, 7 Mar 2012 15:08:35 -0800 Subject: Removing unreferenced parameters from the post data. --- indra/newview/llpathfindingmanager.cpp | 2 -- 1 file changed, 2 deletions(-) (limited to 'indra/newview/llpathfindingmanager.cpp') diff --git a/indra/newview/llpathfindingmanager.cpp b/indra/newview/llpathfindingmanager.cpp index 8597498a76..cba0501ad2 100644 --- a/indra/newview/llpathfindingmanager.cpp +++ b/indra/newview/llpathfindingmanager.cpp @@ -237,8 +237,6 @@ void LLPathfindingManager::requestGetNavMeshForRegion(LLViewerRegion *pRegion) LLHTTPClient::ResponderPtr responder = new NavMeshResponder(navMeshURL, mNavMeshVersionXXX, navMeshPtr); LLSD postData; - postData["agent_id"] = gAgent.getID(); - postData["region_id"] = pRegion->getRegionID(); LLHTTPClient::post(navMeshURL, postData, responder); } } -- cgit v1.3 From f578181af9cbe3277374578c27487e2e72956079 Mon Sep 17 00:00:00 2001 From: Todd Stinson Date: Thu, 8 Mar 2012 12:34:11 -0800 Subject: PATH-304: Adding functionality to handle the reloading of out-of-date navmeshes. --- etc/message.xml | 12 ++++- indra/newview/llfloaterpathfindingconsole.cpp | 20 ++++++-- indra/newview/llfloaterpathfindingconsole.h | 4 +- indra/newview/llpathfindingmanager.cpp | 60 ++++++++++++++++++---- indra/newview/llpathfindingmanager.h | 2 + indra/newview/llpathfindingnavmesh.cpp | 11 ++-- indra/newview/llpathfindingnavmesh.h | 2 + indra/newview/llpathfindingnavmeshzone.cpp | 58 ++++++++++++++++++++- indra/newview/llpathfindingnavmeshzone.h | 7 +++ .../default/xui/en/floater_pathfinding_console.xml | 2 +- 10 files changed, 153 insertions(+), 25 deletions(-) (limited to 'indra/newview/llpathfindingmanager.cpp') diff --git a/etc/message.xml b/etc/message.xml index 3445975545..9407888a92 100644 --- a/etc/message.xml +++ b/etc/message.xml @@ -546,8 +546,16 @@ trusted-sender true - - + + NavmeshStatusUpdate + + flavor + llsd + trusted-sender + true + + + ScriptRunningReply flavor diff --git a/indra/newview/llfloaterpathfindingconsole.cpp b/indra/newview/llfloaterpathfindingconsole.cpp index 6824e629c9..493b4617b5 100644 --- a/indra/newview/llfloaterpathfindingconsole.cpp +++ b/indra/newview/llfloaterpathfindingconsole.cpp @@ -171,6 +171,7 @@ void LLFloaterPathfindingConsole::onOpen(const LLSD& pKey) mNavMeshZoneSlot = mNavMeshZone.registerNavMeshZoneListener(boost::bind(&LLFloaterPathfindingConsole::onNavMeshZoneCB, this, _1)); } + mIsNavMeshUpdating = false; mNavMeshZone.initialize(); mNavMeshZone.enable(); @@ -478,6 +479,7 @@ LLFloaterPathfindingConsole::LLFloaterPathfindingConsole(const LLSD& pSeed) mClearPathButton(NULL), mNavMeshZoneSlot(), mNavMeshZone(), + mIsNavMeshUpdating(false), mAgentStateSlot(), mConsoleState(kConsoleStateUnknown), mPathData(), @@ -616,10 +618,15 @@ void LLFloaterPathfindingConsole::onNavMeshZoneCB(LLPathfindingNavMeshZone::ENav case LLPathfindingNavMeshZone::kNavMeshZoneRequestUnknown : setConsoleState(kConsoleStateUnknown); break; + case LLPathfindingNavMeshZone::kNavMeshZoneRequestNeedsUpdate : + mIsNavMeshUpdating = true; + mNavMeshZone.refresh(); + break; case LLPathfindingNavMeshZone::kNavMeshZoneRequestStarted : setConsoleState(kConsoleStateDownloading); break; case LLPathfindingNavMeshZone::kNavMeshZoneRequestCompleted : + mIsNavMeshUpdating = false; setConsoleState(kConsoleStateHasNavMesh); break; case LLPathfindingNavMeshZone::kNavMeshZoneRequestNotEnabled : @@ -689,7 +696,6 @@ void LLFloaterPathfindingConsole::updateControlsOnConsoleState() mHasEndPoint = false; break; case kConsoleStateHasNavMesh : - case kConsoleStateHasNavMeshDownloading : mShowNavMeshCheckBox->setEnabled(TRUE); mShowNavMeshWalkabilityComboBox->setEnabled(TRUE); mShowWalkablesCheckBox->setEnabled(TRUE); @@ -731,14 +737,18 @@ void LLFloaterPathfindingConsole::updateStatusOnConsoleState() styleParams.color = warningColor; break; case kConsoleStateDownloading : - statusText = getString("navmesh_status_downloading"); + if (mIsNavMeshUpdating) + { + statusText = getString("navmesh_status_updating"); + } + else + { + statusText = getString("navmesh_status_downloading"); + } break; case kConsoleStateHasNavMesh : statusText = getString("navmesh_status_has_navmesh"); break; - case kConsoleStateHasNavMeshDownloading : - statusText = getString("navmesh_status_has_navmesh_downloading"); - break; case kConsoleStateError : statusText = getString("navmesh_status_error"); styleParams.color = warningColor; diff --git a/indra/newview/llfloaterpathfindingconsole.h b/indra/newview/llfloaterpathfindingconsole.h index b1886fb716..8c29bf5909 100644 --- a/indra/newview/llfloaterpathfindingconsole.h +++ b/indra/newview/llfloaterpathfindingconsole.h @@ -122,7 +122,6 @@ private: kConsoleStateRegionNotEnabled, kConsoleStateDownloading, kConsoleStateHasNavMesh, - kConsoleStateHasNavMeshDownloading, kConsoleStateError } EConsoleState; @@ -179,9 +178,10 @@ private: LLTextBase *mPathTestingStatus; LLButton *mClearPathButton; - LLPathfindingNavMeshZone::navmesh_zone_slot_t mNavMeshZoneSlot; LLPathfindingNavMeshZone mNavMeshZone; + bool mIsNavMeshUpdating; + LLPathfindingManager::agent_state_slot_t mAgentStateSlot; EConsoleState mConsoleState; diff --git a/indra/newview/llpathfindingmanager.cpp b/indra/newview/llpathfindingmanager.cpp index cba0501ad2..ebefebbb64 100644 --- a/indra/newview/llpathfindingmanager.cpp +++ b/indra/newview/llpathfindingmanager.cpp @@ -26,8 +26,10 @@ */ #include +#include #include "llviewerprecompiledheaders.h" +#include "llsd.h" #include "llpathfindingmanager.h" #include "llsingleton.h" #include "llhttpclient.h" @@ -36,6 +38,7 @@ #include "llpathfindingnavmesh.h" #include "llpathfindinglinkset.h" #include "llpathfindinglinksetlist.h" +#include "llhttpnode.h" #include #include @@ -49,6 +52,20 @@ #define CAP_SERVICE_OBJECT_LINKSETS "ObjectNavMeshProperties" #define CAP_SERVICE_TERRAIN_LINKSETS "TerrainNavMeshProperties" +#define SIM_MESSAGE_NAVMESH_STATUS_UPDATE "/message/NavmeshStatusUpdate" + +//--------------------------------------------------------------------------- +// LLNavMeshSimStateChangeNode +//--------------------------------------------------------------------------- + +class LLNavMeshSimStateChangeNode : public LLHTTPNode +{ +public: + virtual void post(ResponsePtr pResponse, const LLSD &pContext, const LLSD &pInput) const; +}; + +LLHTTPRegistration gHTTPRegistrationNavMeshSimStateChangeNode(SIM_MESSAGE_NAVMESH_STATUS_UPDATE); + //--------------------------------------------------------------------------- // NavMeshResponder //--------------------------------------------------------------------------- @@ -243,6 +260,12 @@ void LLPathfindingManager::requestGetNavMeshForRegion(LLViewerRegion *pRegion) } } +void LLPathfindingManager::handleNavMeshUpdate(const LLUUID &pRegionUUID, U32 pNavMeshVersion) +{ + LLPathfindingNavMeshPtr navMeshPtr = getNavMeshForRegion(pRegionUUID); + navMeshPtr->handleNavMeshNewVersion(++mNavMeshVersionXXX); +} + LLPathfindingManager::agent_state_slot_t LLPathfindingManager::registerAgentStateListener(agent_state_callback_t pAgentStateCallback) { return mAgentStateSignal.connect(pAgentStateCallback); @@ -368,21 +391,14 @@ LLPathfindingManager::ELinksetsRequestStatus LLPathfindingManager::requestSetLin return status; } -LLPathfindingNavMeshPtr LLPathfindingManager::getNavMeshForRegion(LLViewerRegion *pRegion) +LLPathfindingNavMeshPtr LLPathfindingManager::getNavMeshForRegion(const LLUUID &pRegionUUID) { - - LLUUID regionUUID; - if (pRegion != NULL) - { - regionUUID = pRegion->getRegionID(); - } - LLPathfindingNavMeshPtr navMeshPtr; - NavMeshMap::iterator navMeshIter = mNavMeshMap.find(regionUUID); + NavMeshMap::iterator navMeshIter = mNavMeshMap.find(pRegionUUID); if (navMeshIter == mNavMeshMap.end()) { - navMeshPtr = LLPathfindingNavMeshPtr(new LLPathfindingNavMesh(regionUUID)); - mNavMeshMap.insert(std::pair(regionUUID, navMeshPtr)); + navMeshPtr = LLPathfindingNavMeshPtr(new LLPathfindingNavMesh(pRegionUUID)); + mNavMeshMap.insert(std::pair(pRegionUUID, navMeshPtr)); } else { @@ -392,6 +408,17 @@ LLPathfindingNavMeshPtr LLPathfindingManager::getNavMeshForRegion(LLViewerRegion 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)); @@ -513,6 +540,17 @@ LLViewerRegion *LLPathfindingManager::getCurrentRegion() const return gAgent.getRegion(); } +//--------------------------------------------------------------------------- +// LLNavMeshSimStateChangeNode +//--------------------------------------------------------------------------- + +void LLNavMeshSimStateChangeNode::post(ResponsePtr pResponse, const LLSD &pContext, const LLSD &pInput) const +{ + LLViewerRegion *region = gAgent.getRegion(); + U32 navMeshVersion = 0U; + LLPathfindingManager::getInstance()->handleNavMeshUpdate(region->getRegionID(), navMeshVersion); +} + //--------------------------------------------------------------------------- // NavMeshResponder //--------------------------------------------------------------------------- diff --git a/indra/newview/llpathfindingmanager.h b/indra/newview/llpathfindingmanager.h index eb8704e308..3e85cb1291 100644 --- a/indra/newview/llpathfindingmanager.h +++ b/indra/newview/llpathfindingmanager.h @@ -80,6 +80,7 @@ public: LLPathfindingNavMesh::navmesh_slot_t registerNavMeshListenerForRegion(LLViewerRegion *pRegion, LLPathfindingNavMesh::navmesh_callback_t pNavMeshCallback); void requestGetNavMeshForRegion(LLViewerRegion *pRegion); + void handleNavMeshUpdate(const LLUUID &pRegionUUID, U32 pNavMeshVersion); agent_state_slot_t registerAgentStateListener(agent_state_callback_t pAgentStateCallback); EAgentState getAgentState(); @@ -92,6 +93,7 @@ public: protected: private: + LLPathfindingNavMeshPtr getNavMeshForRegion(const LLUUID &pRegionUUID); LLPathfindingNavMeshPtr getNavMeshForRegion(LLViewerRegion *pRegion); static bool isValidAgentState(EAgentState pAgentState); diff --git a/indra/newview/llpathfindingnavmesh.cpp b/indra/newview/llpathfindingnavmesh.cpp index 469972efa9..84343cf31e 100644 --- a/indra/newview/llpathfindingnavmesh.cpp +++ b/indra/newview/llpathfindingnavmesh.cpp @@ -64,6 +64,13 @@ void LLPathfindingNavMesh::handleRefresh() mNavMeshSignal(mNavMeshRequestStatus, mRegionUUID, mNavMeshVersion, mNavMeshData); } +void LLPathfindingNavMesh::handleNavMeshNewVersion(U32 pNavMeshVersion) +{ + mNavMeshData.clear(); + mNavMeshVersion = pNavMeshVersion; + setRequestStatus(kNavMeshRequestNeedsUpdate); +} + void LLPathfindingNavMesh::handleNavMeshStart(U32 pNavMeshVersion) { mNavMeshVersion = pNavMeshVersion; @@ -72,7 +79,6 @@ void LLPathfindingNavMesh::handleNavMeshStart(U32 pNavMeshVersion) void LLPathfindingNavMesh::handleNavMeshResult(const LLSD &pContent, U32 pNavMeshVersion) { - llassert(mNavMeshVersion == pNavMeshVersion); if (mNavMeshVersion == pNavMeshVersion) { if ( pContent.has("navmesh_data") ) @@ -118,10 +124,9 @@ void LLPathfindingNavMesh::handleNavMeshNotEnabled() 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; - llassert(mNavMeshVersion == pNavMeshVersion); - mNavMeshData.clear(); if (mNavMeshVersion == pNavMeshVersion) { + mNavMeshData.clear(); setRequestStatus(kNavMeshRequestError); } } diff --git a/indra/newview/llpathfindingnavmesh.h b/indra/newview/llpathfindingnavmesh.h index 26ef21f90e..eb9ef9683d 100644 --- a/indra/newview/llpathfindingnavmesh.h +++ b/indra/newview/llpathfindingnavmesh.h @@ -47,6 +47,7 @@ class LLPathfindingNavMesh public: typedef enum { kNavMeshRequestUnknown, + kNavMeshRequestNeedsUpdate, kNavMeshRequestStarted, kNavMeshRequestCompleted, kNavMeshRequestNotEnabled, @@ -65,6 +66,7 @@ public: bool hasNavMeshVersion(U32 pNavMeshVersion) const; void handleRefresh(); + void handleNavMeshNewVersion(U32 pNavMeshVersion); void handleNavMeshStart(U32 pNavMeshVersion); void handleNavMeshResult(const LLSD &pContent, U32 pNavMeshVersion); void handleNavMeshNotEnabled(); diff --git a/indra/newview/llpathfindingnavmeshzone.cpp b/indra/newview/llpathfindingnavmeshzone.cpp index 983b88fe05..3767834655 100644 --- a/indra/newview/llpathfindingnavmeshzone.cpp +++ b/indra/newview/llpathfindingnavmeshzone.cpp @@ -67,6 +67,24 @@ void LLPathfindingNavMeshZone::initialize() { mNavMeshLocationPtrs.clear(); +#ifdef XXX_STINSON_DEBUG_NAVMESH_ZONE + LLViewerRegion *currentRegion = gAgent.getRegion(); + if (currentRegion != NULL) + { + llinfos << "STINSON DEBUG: currentRegion: '" << currentRegion->getName() << "' (" << currentRegion->getRegionID().asString() << ")" << llendl; + std::vector availableRegions; + currentRegion->getNeighboringRegionsStatus( availableRegions ); + std::vector neighborRegionsPtrs; + currentRegion->getNeighboringRegions( neighborRegionsPtrs ); + for (std::vector::const_iterator statusIter = availableRegions.begin(); + statusIter != availableRegions.end(); ++statusIter) + { + LLViewerRegion *region = neighborRegionsPtrs[statusIter - availableRegions.begin()]; + llinfos << "STINSON DEBUG: region #" << *statusIter << ": '" << region->getName() << "' (" << region->getRegionID().asString() << ")" << llendl; + } + } + +#endif // XXX_STINSON_DEBUG_NAVMESH_ZONE NavMeshLocationPtr centerNavMeshPtr(new NavMeshLocation(CENTER_REGION, boost::bind(&LLPathfindingNavMeshZone::handleNavMeshLocation, this))); mNavMeshLocationPtrs.push_back(centerNavMeshPtr); @@ -122,20 +140,30 @@ void LLPathfindingNavMeshZone::handleNavMeshLocation() void LLPathfindingNavMeshZone::updateStatus() { bool hasRequestUnknown = false; + bool hasRequestNeedsUpdate = false; bool hasRequestStarted = false; bool hasRequestCompleted = false; bool hasRequestNotEnabled = false; bool hasRequestError = false; +#ifdef XXX_STINSON_DEBUG_NAVMESH_ZONE + llinfos << "STINSON DEBUG: Navmesh zone update BEGIN" << llendl; +#endif // XXX_STINSON_DEBUG_NAVMESH_ZONE for (NavMeshLocationPtrs::iterator navMeshLocationPtrIter = mNavMeshLocationPtrs.begin(); navMeshLocationPtrIter != mNavMeshLocationPtrs.end(); ++navMeshLocationPtrIter) { NavMeshLocationPtr navMeshLocationPtr = *navMeshLocationPtrIter; +#ifdef XXX_STINSON_DEBUG_NAVMESH_ZONE + llinfos << "STINSON DEBUG: region #" << navMeshLocationPtr->getDirection() << ": region(" << navMeshLocationPtr->getRegionUUID().asString() << ") status:" << navMeshLocationPtr->getRequestStatus() << llendl; +#endif // XXX_STINSON_DEBUG_NAVMESH_ZONE switch (navMeshLocationPtr->getRequestStatus()) { case LLPathfindingNavMesh::kNavMeshRequestUnknown : hasRequestUnknown = true; break; + case LLPathfindingNavMesh::kNavMeshRequestNeedsUpdate : + hasRequestNeedsUpdate = true; + break; case LLPathfindingNavMesh::kNavMeshRequestStarted : hasRequestStarted = true; break; @@ -156,34 +184,62 @@ void LLPathfindingNavMeshZone::updateStatus() } ENavMeshZoneRequestStatus zoneRequestStatus = kNavMeshZoneRequestUnknown; - if (hasRequestStarted) + if (hasRequestNeedsUpdate) + { + zoneRequestStatus = kNavMeshZoneRequestNeedsUpdate; +#ifdef XXX_STINSON_DEBUG_NAVMESH_ZONE + llinfos << "STINSON DEBUG: Navmesh zone update is NEEDS UPDATE" << llendl; +#endif // XXX_STINSON_DEBUG_NAVMESH_ZONE + } + else if (hasRequestStarted) { zoneRequestStatus = kNavMeshZoneRequestStarted; +#ifdef XXX_STINSON_DEBUG_NAVMESH_ZONE + llinfos << "STINSON DEBUG: Navmesh zone update is STARTED" << llendl; +#endif // XXX_STINSON_DEBUG_NAVMESH_ZONE } else if (hasRequestError) { zoneRequestStatus = kNavMeshZoneRequestError; +#ifdef XXX_STINSON_DEBUG_NAVMESH_ZONE + llinfos << "STINSON DEBUG: Navmesh zone update is ERROR" << llendl; +#endif // XXX_STINSON_DEBUG_NAVMESH_ZONE } else if (hasRequestUnknown) { zoneRequestStatus = kNavMeshZoneRequestUnknown; +#ifdef XXX_STINSON_DEBUG_NAVMESH_ZONE + llinfos << "STINSON DEBUG: Navmesh zone update is UNKNOWN" << llendl; +#endif // XXX_STINSON_DEBUG_NAVMESH_ZONE } else if (hasRequestCompleted) { zoneRequestStatus = kNavMeshZoneRequestCompleted; +#ifdef XXX_STINSON_DEBUG_NAVMESH_ZONE + llinfos << "STINSON DEBUG: Navmesh zone update is stitching" << llendl; +#endif // XXX_STINSON_DEBUG_NAVMESH_ZONE llassert(LLPathingLib::getInstance() != NULL); if (LLPathingLib::getInstance() != NULL) { LLPathingLib::getInstance()->stitchNavMeshes( gSavedSettings.getBOOL("EnableVBOForNavMeshVisualization") ); } +#ifdef XXX_STINSON_DEBUG_NAVMESH_ZONE + llinfos << "STINSON DEBUG: Navmesh zone update is COMPLETED" << llendl; +#endif // XXX_STINSON_DEBUG_NAVMESH_ZONE } else if (hasRequestNotEnabled) { zoneRequestStatus = kNavMeshZoneRequestNotEnabled; +#ifdef XXX_STINSON_DEBUG_NAVMESH_ZONE + llinfos << "STINSON DEBUG: Navmesh zone update is NOT ENABLED" << llendl; +#endif // XXX_STINSON_DEBUG_NAVMESH_ZONE } else { zoneRequestStatus = kNavMeshZoneRequestError; +#ifdef XXX_STINSON_DEBUG_NAVMESH_ZONE + llinfos << "STINSON DEBUG: Navmesh zone update is BAD ERROR" << llendl; +#endif // XXX_STINSON_DEBUG_NAVMESH_ZONE llassert(0); } diff --git a/indra/newview/llpathfindingnavmeshzone.h b/indra/newview/llpathfindingnavmeshzone.h index 8489b5899b..7084869b33 100644 --- a/indra/newview/llpathfindingnavmeshzone.h +++ b/indra/newview/llpathfindingnavmeshzone.h @@ -38,11 +38,14 @@ #include #include +#define XXX_STINSON_DEBUG_NAVMESH_ZONE + class LLPathfindingNavMeshZone { public: typedef enum { kNavMeshZoneRequestUnknown, + kNavMeshZoneRequestNeedsUpdate, kNavMeshZoneRequestStarted, kNavMeshZoneRequestCompleted, kNavMeshZoneRequestNotEnabled, @@ -78,6 +81,10 @@ private: void disable(); LLPathfindingNavMesh::ENavMeshRequestStatus getRequestStatus() 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: 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 6c97af2878..75465f1aea 100644 --- a/indra/newview/skins/default/xui/en/floater_pathfinding_console.xml +++ b/indra/newview/skins/default/xui/en/floater_pathfinding_console.xml @@ -15,8 +15,8 @@ Cannot find pathing library implementation. This region is not enabled for pathfinding. Downloading the navmesh ... + The navmesh has changed on the server. Downloading the latest navmesh ... Navmesh received. - Downloading the latest navmesh ... Unable to download navmesh successfully. Please choose start and end points. Please choose start point. -- cgit v1.3 From b3197fc12e41bc60e3510d840c67ef98816c3ae8 Mon Sep 17 00:00:00 2001 From: Todd Stinson Date: Mon, 12 Mar 2012 18:48:40 -0700 Subject: PATH-304: Making the navmesh version information work for both Premium Wilderness regions (old pathfinding simulator build with missing capabilities) as well as the new pathfinding simulator builds with the version services. --- indra/newview/CMakeLists.txt | 2 + indra/newview/llpathfindingmanager.cpp | 170 ++++++++++++++++++++++----- indra/newview/llpathfindingmanager.h | 11 +- indra/newview/llpathfindingnavmesh.cpp | 18 ++- indra/newview/llpathfindingnavmesh.h | 8 ++ indra/newview/llpathfindingnavmeshstatus.cpp | 134 +++++++++++++++++++++ indra/newview/llpathfindingnavmeshstatus.h | 77 ++++++++++++ indra/newview/llpathfindingnavmeshzone.cpp | 11 +- indra/newview/llviewerregion.cpp | 1 + 9 files changed, 391 insertions(+), 41 deletions(-) create mode 100644 indra/newview/llpathfindingnavmeshstatus.cpp create mode 100644 indra/newview/llpathfindingnavmeshstatus.h (limited to 'indra/newview/llpathfindingmanager.cpp') diff --git a/indra/newview/CMakeLists.txt b/indra/newview/CMakeLists.txt index 44cb23b648..36b7e136d0 100644 --- a/indra/newview/CMakeLists.txt +++ b/indra/newview/CMakeLists.txt @@ -421,6 +421,7 @@ set(viewer_SOURCE_FILES llpathfindinglinksetlist.cpp llpathfindingmanager.cpp llpathfindingnavmesh.cpp + llpathfindingnavmeshstatus.cpp llpathfindingnavmeshzone.cpp llphysicsmotion.cpp llphysicsshapebuilderutil.cpp @@ -976,6 +977,7 @@ set(viewer_HEADER_FILES llpathfindinglinksetlist.h llpathfindingmanager.h llpathfindingnavmesh.h + llpathfindingnavmeshstatus.h llpathfindingnavmeshzone.h llphysicsmotion.h llphysicsshapebuilderutil.h diff --git a/indra/newview/llpathfindingmanager.cpp b/indra/newview/llpathfindingmanager.cpp index ebefebbb64..9cd3d5625c 100644 --- a/indra/newview/llpathfindingmanager.cpp +++ b/indra/newview/llpathfindingmanager.cpp @@ -30,12 +30,14 @@ #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 "llhttpnode.h" @@ -45,14 +47,16 @@ #define CAP_SERVICE_RETRIEVE_NAVMESH "RetrieveNavMeshSrc" -#define CAP_SERVICE_AGENT_STATE "AgentPreferences" +#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_OBJECT_LINKSETS "ObjectNavMeshProperties" +#define CAP_SERVICE_TERRAIN_LINKSETS "TerrainNavMeshProperties" -#define SIM_MESSAGE_NAVMESH_STATUS_UPDATE "/message/NavmeshStatusUpdate" +#define SIM_MESSAGE_NAVMESH_STATUS_UPDATE "/message/NavMeshStatusUpdate" //--------------------------------------------------------------------------- // LLNavMeshSimStateChangeNode @@ -66,6 +70,27 @@ public: LLHTTPRegistration gHTTPRegistrationNavMeshSimStateChangeNode(SIM_MESSAGE_NAVMESH_STATUS_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 //--------------------------------------------------------------------------- @@ -193,7 +218,6 @@ private: LLPathfindingManager::LLPathfindingManager() : LLSingleton(), mNavMeshMap(), - mNavMeshVersionXXX(0), mAgentStateSignal(), mAgentState(kAgentStateUnknown), mLastKnownNonErrorAgentState(kAgentStateUnknown) @@ -206,7 +230,12 @@ LLPathfindingManager::~LLPathfindingManager() bool LLPathfindingManager::isPathfindingEnabledForCurrentRegion() const { - std::string retrieveNavMeshURL = getRetrieveNavMeshURLForCurrentRegion(); + return isPathfindingEnabledForRegion(getCurrentRegion()); +} + +bool LLPathfindingManager::isPathfindingEnabledForRegion(LLViewerRegion *pRegion) const +{ + std::string retrieveNavMeshURL = getRetrieveNavMeshURLForRegion(pRegion); return !retrieveNavMeshURL.empty(); } @@ -231,39 +260,64 @@ void LLPathfindingManager::requestGetNavMeshForRegion(LLViewerRegion *pRegion) { LLPathfindingNavMeshPtr navMeshPtr = getNavMeshForRegion(pRegion); - if (navMeshPtr->hasNavMeshVersion(mNavMeshVersionXXX)) + if ((pRegion == NULL) || !isPathfindingEnabledForRegion(pRegion)) { - navMeshPtr->handleRefresh(); + navMeshPtr->handleNavMeshNotEnabled(); } else { - if (pRegion == NULL) + std::string navMeshStatusURL = getNavMeshStatusURLForRegion(pRegion); +#ifdef DEPRECATED_UNVERSIONED_NAVMESH + if (navMeshStatusURL.empty()) { - navMeshPtr->handleNavMeshNotEnabled(); + sendRequestGetNavMeshForRegion(navMeshPtr, pRegion, navMeshPtr->getNavMeshVersion() + 1U); } else { - std::string navMeshURL = getRetrieveNavMeshURLForRegion(pRegion); - if (navMeshURL.empty()) - { - navMeshPtr->handleNavMeshNotEnabled(); - } - else - { - navMeshPtr->handleNavMeshStart(mNavMeshVersionXXX); - LLHTTPClient::ResponderPtr responder = new NavMeshResponder(navMeshURL, mNavMeshVersionXXX, navMeshPtr); + LLHTTPClient::ResponderPtr navMeshStatusResponder = new NavMeshStatusResponder(navMeshStatusURL, pRegion); + LLHTTPClient::get(navMeshStatusURL, navMeshStatusResponder); + } +#else // DEPRECATED_UNVERSIONED_NAVMESH + llassert(!navMeshStatusURL.empty()); + LLHTTPClient::ResponderPtr navMeshStatusResponder = new NavMeshStatusResponder(navMeshStatusURL, pRegion); + LLHTTPClient::get(navMeshStatusURL, navMeshStatusResponder); +#endif // DEPRECATED_UNVERSIONED_NAVMESH + } +} - 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.getVersion())) + { + navMeshPtr->handleRefresh(); + } + else + { + sendRequestGetNavMeshForRegion(navMeshPtr, pRegion, pNavMeshStatus.getVersion()); } } } -void LLPathfindingManager::handleNavMeshUpdate(const LLUUID &pRegionUUID, U32 pNavMeshVersion) +void LLPathfindingManager::handleNavMeshStatusUpdate(const LLPathfindingNavMeshStatus &pNavMeshStatus) { - LLPathfindingNavMeshPtr navMeshPtr = getNavMeshForRegion(pRegionUUID); - navMeshPtr->handleNavMeshNewVersion(++mNavMeshVersionXXX); + LLPathfindingNavMeshPtr navMeshPtr = getNavMeshForRegion(pNavMeshStatus.getRegionUUID()); + + if (!pNavMeshStatus.isValid()) + { + navMeshPtr->handleNavMeshError(); + } + else + { + navMeshPtr->handleNavMeshNewVersion(pNavMeshStatus.getVersion()); + } } LLPathfindingManager::agent_state_slot_t LLPathfindingManager::registerAgentStateListener(agent_state_callback_t pAgentStateCallback) @@ -391,6 +445,31 @@ LLPathfindingManager::ELinksetsRequestStatus LLPathfindingManager::requestSetLin return status; } +void LLPathfindingManager::sendRequestGetNavMeshForRegion(LLPathfindingNavMeshPtr navMeshPtr, LLViewerRegion *pRegion, U32 pNavMeshVersion) +{ + if ((pRegion == NULL) || !pRegion->isAlive()) + { + navMeshPtr->handleNavMeshNotEnabled(); + } + else + { + std::string navMeshURL = getRetrieveNavMeshURLForRegion(pRegion); + + if (navMeshURL.empty()) + { + navMeshPtr->handleNavMeshNotEnabled(); + } + else + { + navMeshPtr->handleNavMeshStart(pNavMeshVersion); + LLHTTPClient::ResponderPtr responder = new NavMeshResponder(navMeshURL, pNavMeshVersion, navMeshPtr); + + LLSD postData; + LLHTTPClient::post(navMeshURL, postData, responder); + } + } +} + LLPathfindingNavMeshPtr LLPathfindingManager::getNavMeshForRegion(const LLUUID &pRegionUUID) { LLPathfindingNavMeshPtr navMeshPtr; @@ -487,9 +566,9 @@ void LLPathfindingManager::handleAgentStateError(U32 pStatus, const std::string setAgentState(kAgentStateError); } -std::string LLPathfindingManager::getRetrieveNavMeshURLForCurrentRegion() const +std::string LLPathfindingManager::getNavMeshStatusURLForRegion(LLViewerRegion *pRegion) const { - return getCapabilityURLForCurrentRegion(CAP_SERVICE_RETRIEVE_NAVMESH); + return getCapabilityURLForRegion(pRegion, CAP_SERVICE_NAVMESH_STATUS); } std::string LLPathfindingManager::getRetrieveNavMeshURLForRegion(LLViewerRegion *pRegion) const @@ -546,9 +625,40 @@ LLViewerRegion *LLPathfindingManager::getCurrentRegion() const void LLNavMeshSimStateChangeNode::post(ResponsePtr pResponse, const LLSD &pContext, const LLSD &pInput) const { - LLViewerRegion *region = gAgent.getRegion(); - U32 navMeshVersion = 0U; - LLPathfindingManager::getInstance()->handleNavMeshUpdate(region->getRegionID(), navMeshVersion); + LLPathfindingNavMeshStatus navMeshStatus(pContext); + LLPathfindingManager::getInstance()->handleNavMeshStatusUpdate(pContext); +} + +//--------------------------------------------------------------------------- +// NavMeshStatusResponder +//--------------------------------------------------------------------------- + +NavMeshStatusResponder::NavMeshStatusResponder(const std::string &pCapabilityURL, LLViewerRegion *pRegion) + : mCapabilityURL(pCapabilityURL), + mRegion(pRegion), + mRegionUUID() +{ + if (mRegion != NULL) + { + mRegionUUID = mRegion->getRegionID(); + } +} + +NavMeshStatusResponder::~NavMeshStatusResponder() +{ +} + +void NavMeshStatusResponder::result(const LLSD &pContent) +{ + 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); } //--------------------------------------------------------------------------- diff --git a/indra/newview/llpathfindingmanager.h b/indra/newview/llpathfindingmanager.h index 3e85cb1291..3a849d0290 100644 --- a/indra/newview/llpathfindingmanager.h +++ b/indra/newview/llpathfindingmanager.h @@ -42,6 +42,7 @@ class LLFloater; class LLViewerRegion; +class LLPathfindingNavMeshStatus; class LLPathfindingManager : public LLSingleton { @@ -74,13 +75,16 @@ public: virtual ~LLPathfindingManager(); bool isPathfindingEnabledForCurrentRegion() const; + bool isPathfindingEnabledForRegion(LLViewerRegion *pRegion) const; bool isAllowAlterPermanent(); bool isAllowViewTerrainProperties() const; LLPathfindingNavMesh::navmesh_slot_t registerNavMeshListenerForRegion(LLViewerRegion *pRegion, LLPathfindingNavMesh::navmesh_callback_t pNavMeshCallback); void requestGetNavMeshForRegion(LLViewerRegion *pRegion); - void handleNavMeshUpdate(const LLUUID &pRegionUUID, U32 pNavMeshVersion); + + void handleNavMeshStatusRequest(const LLPathfindingNavMeshStatus &pNavMeshStatus, LLViewerRegion *pRegion); + void handleNavMeshStatusUpdate(const LLPathfindingNavMeshStatus &pNavMeshStatus); agent_state_slot_t registerAgentStateListener(agent_state_callback_t pAgentStateCallback); EAgentState getAgentState(); @@ -93,6 +97,8 @@ public: protected: private: + void sendRequestGetNavMeshForRegion(LLPathfindingNavMeshPtr navMeshPtr, LLViewerRegion *pRegion, U32 pNavMeshVersion); + LLPathfindingNavMeshPtr getNavMeshForRegion(const LLUUID &pRegionUUID); LLPathfindingNavMeshPtr getNavMeshForRegion(LLViewerRegion *pRegion); @@ -103,7 +109,7 @@ private: void handleAgentStateResult(const LLSD &pContent, EAgentState pRequestedAgentState); void handleAgentStateError(U32 pStatus, const std::string &pReason, const std::string &pURL); - std::string getRetrieveNavMeshURLForCurrentRegion() const; + std::string getNavMeshStatusURLForRegion(LLViewerRegion *pRegion) const; std::string getRetrieveNavMeshURLForRegion(LLViewerRegion *pRegion) const; std::string getAgentStateURLForCurrentRegion() const; std::string getObjectLinksetsURLForCurrentRegion() const; @@ -114,7 +120,6 @@ private: LLViewerRegion *getCurrentRegion() const; NavMeshMap mNavMeshMap; - U32 mNavMeshVersionXXX; // XXX stinson 03/02/2012 : a hacky way of doing versions for now agent_state_signal_t mAgentStateSignal; EAgentState mAgentState; diff --git a/indra/newview/llpathfindingnavmesh.cpp b/indra/newview/llpathfindingnavmesh.cpp index 84343cf31e..81fa7b24db 100644 --- a/indra/newview/llpathfindingnavmesh.cpp +++ b/indra/newview/llpathfindingnavmesh.cpp @@ -66,9 +66,12 @@ void LLPathfindingNavMesh::handleRefresh() void LLPathfindingNavMesh::handleNavMeshNewVersion(U32 pNavMeshVersion) { - mNavMeshData.clear(); - mNavMeshVersion = pNavMeshVersion; - setRequestStatus(kNavMeshRequestNeedsUpdate); + if (mNavMeshVersion != pNavMeshVersion) + { + mNavMeshData.clear(); + mNavMeshVersion = pNavMeshVersion; + setRequestStatus(kNavMeshRequestNeedsUpdate); + } } void LLPathfindingNavMesh::handleNavMeshStart(U32 pNavMeshVersion) @@ -121,13 +124,18 @@ void LLPathfindingNavMesh::handleNavMeshNotEnabled() 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 (mNavMeshVersion == pNavMeshVersion) { - mNavMeshData.clear(); - setRequestStatus(kNavMeshRequestError); + handleNavMeshError(); } } diff --git a/indra/newview/llpathfindingnavmesh.h b/indra/newview/llpathfindingnavmesh.h index eb9ef9683d..3bdb485d37 100644 --- a/indra/newview/llpathfindingnavmesh.h +++ b/indra/newview/llpathfindingnavmesh.h @@ -42,6 +42,9 @@ class LLPathfindingNavMesh; typedef boost::shared_ptr LLPathfindingNavMeshPtr; +// XXX stinson 03/12/2012 : This definition is in place to support an older version of the pathfinding simulator that does not have versioned information +#define DEPRECATED_UNVERSIONED_NAVMESH + class LLPathfindingNavMesh { public: @@ -63,6 +66,10 @@ public: navmesh_slot_t registerNavMeshListener(navmesh_callback_t pNavMeshCallback); +#ifdef DEPRECATED_UNVERSIONED_NAVMESH + U32 getNavMeshVersion() const {return mNavMeshVersion;}; +#endif // DEPRECATED_UNVERSIONED_NAVMESH + bool hasNavMeshVersion(U32 pNavMeshVersion) const; void handleRefresh(); @@ -70,6 +77,7 @@ public: void handleNavMeshStart(U32 pNavMeshVersion); 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: diff --git a/indra/newview/llpathfindingnavmeshstatus.cpp b/indra/newview/llpathfindingnavmeshstatus.cpp new file mode 100644 index 0000000000..67be0459a5 --- /dev/null +++ b/indra/newview/llpathfindingnavmeshstatus.cpp @@ -0,0 +1,134 @@ +/** + * @file llpathfindingnavmeshstatus.cpp + * @author William Todd Stinson + * @brief A class for representing the navmesh status 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 "llsd.h" +#include "lluuid.h" +#include "llstring.h" +#include "llpathfindingnavmeshstatus.h" + +#include + +#define REGION_FIELD "region" +#define STATE_FIELD "state" +#define VERSION_FIELD "version" + +const std::string LLPathfindingNavMeshStatus::sStatusPending("pending"); +const std::string LLPathfindingNavMeshStatus::sStatusBuilding("building"); +const std::string LLPathfindingNavMeshStatus::sStatusComplete("complete"); +const std::string LLPathfindingNavMeshStatus::sStatusRepending("repending"); + + +//--------------------------------------------------------------------------- +// LLPathfindingNavMeshStatus +//--------------------------------------------------------------------------- + +LLPathfindingNavMeshStatus::LLPathfindingNavMeshStatus(const LLUUID &pRegionUUID) + : mIsValid(false), + mRegionUUID(pRegionUUID), + mVersion(0U), + mStatus(kComplete) +{ +} + +LLPathfindingNavMeshStatus::LLPathfindingNavMeshStatus(const LLUUID &pRegionUUID, const LLSD &pContent) + : mIsValid(true), + mRegionUUID(pRegionUUID), + mVersion(0U), + mStatus(kComplete) +{ + parseStatus(pContent); +} + +LLPathfindingNavMeshStatus::LLPathfindingNavMeshStatus(const LLSD &pContent) + : mIsValid(true), + mRegionUUID(), + mVersion(0U), + mStatus(kComplete) +{ + llassert(pContent.has(REGION_FIELD)); + llassert(pContent.get(REGION_FIELD).isUUID()); + mRegionUUID = pContent.get(REGION_FIELD).asUUID(); + + parseStatus(pContent); +} + +LLPathfindingNavMeshStatus::LLPathfindingNavMeshStatus(const LLPathfindingNavMeshStatus &pOther) + : mIsValid(pOther.mIsValid), + mRegionUUID(pOther.mRegionUUID), + mVersion(pOther.mVersion), + mStatus(pOther.mStatus) +{ +} + +LLPathfindingNavMeshStatus::~LLPathfindingNavMeshStatus() +{ +} + +LLPathfindingNavMeshStatus &LLPathfindingNavMeshStatus::operator =(const LLPathfindingNavMeshStatus &pOther) +{ + mIsValid = pOther.mIsValid; + mRegionUUID = pOther.mRegionUUID; + mVersion = pOther.mVersion; + mStatus = pOther.mStatus; + + return *this; +} + +void LLPathfindingNavMeshStatus::parseStatus(const LLSD &pContent) +{ + llassert(pContent.has(VERSION_FIELD)); + llassert(pContent.get(VERSION_FIELD).isInteger()); + llassert(pContent.get(VERSION_FIELD).asInteger() >= 0); + mVersion = static_cast(pContent.get(VERSION_FIELD).asInteger()); + + llassert(pContent.has(STATE_FIELD)); + llassert(pContent.get(STATE_FIELD).isString()); + std::string status = pContent.get(STATE_FIELD).asString(); + + if (LLStringUtil::compareStrings(status, sStatusPending)) + { + mStatus = kPending; + } + else if (LLStringUtil::compareStrings(status, sStatusBuilding)) + { + mStatus = kBuilding; + } + else if (LLStringUtil::compareStrings(status, sStatusComplete)) + { + mStatus = kComplete; + } + else if (LLStringUtil::compareStrings(status, sStatusRepending)) + { + mStatus = kRepending; + } + else + { + mStatus = kComplete; + llassert(0); + } +} diff --git a/indra/newview/llpathfindingnavmeshstatus.h b/indra/newview/llpathfindingnavmeshstatus.h new file mode 100644 index 0000000000..fcc876059d --- /dev/null +++ b/indra/newview/llpathfindingnavmeshstatus.h @@ -0,0 +1,77 @@ +/** + * @file llpathfindingnavmeshstatus.h + * @author William Todd Stinson + * @brief A class for representing the navmesh status 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_LLPATHFINDINGNAVMESHSTATUS_H +#define LL_LLPATHFINDINGNAVMESHSTATUS_H + +#include "lluuid.h" + +#include + +class LLSD; + +class LLPathfindingNavMeshStatus +{ +public: + typedef enum + { + kPending, + kBuilding, + kComplete, + kRepending + } ENavMeshStatus; + + LLPathfindingNavMeshStatus(const LLUUID &pRegionUUID); + LLPathfindingNavMeshStatus(const LLUUID &pRegionUUID, const LLSD &pContent); + LLPathfindingNavMeshStatus(const LLSD &pContent); + LLPathfindingNavMeshStatus(const LLPathfindingNavMeshStatus &pOther); + virtual ~LLPathfindingNavMeshStatus(); + + LLPathfindingNavMeshStatus &operator =(const LLPathfindingNavMeshStatus &pOther); + + bool isValid() const {return mIsValid;}; + const LLUUID &getRegionUUID() const {return mRegionUUID;}; + U32 getVersion() const {return mVersion;}; + ENavMeshStatus getStatus() const {return mStatus;}; + +protected: + +private: + void parseStatus(const LLSD &pContent); + + bool mIsValid; + LLUUID mRegionUUID; + U32 mVersion; + ENavMeshStatus mStatus; + + static const std::string sStatusPending; + static const std::string sStatusBuilding; + static const std::string sStatusComplete; + static const std::string sStatusRepending; +}; + +#endif // LL_LLPATHFINDINGNAVMESHSTATUS_H diff --git a/indra/newview/llpathfindingnavmeshzone.cpp b/indra/newview/llpathfindingnavmeshzone.cpp index 3767834655..83238ec869 100644 --- a/indra/newview/llpathfindingnavmeshzone.cpp +++ b/indra/newview/llpathfindingnavmeshzone.cpp @@ -311,10 +311,15 @@ LLPathfindingNavMesh::ENavMeshRequestStatus LLPathfindingNavMeshZone::NavMeshLoc void LLPathfindingNavMeshZone::NavMeshLocation::handleNavMesh(LLPathfindingNavMesh::ENavMeshRequestStatus pNavMeshRequestStatus, const LLUUID &pRegionUUID, U32 pNavMeshVersion, const LLSD::Binary &pNavMeshData) { llassert(mRegionUUID == pRegionUUID); - mRequestStatus = pNavMeshRequestStatus; - if ((pNavMeshRequestStatus == LLPathfindingNavMesh::kNavMeshRequestCompleted) && (!mHasNavMesh || (mNavMeshVersion != pNavMeshVersion))) + if (pNavMeshRequestStatus != LLPathfindingNavMesh::kNavMeshRequestCompleted) + { + mRequestStatus = pNavMeshRequestStatus; + mLocationCallback(); + } + else if (!mHasNavMesh || (mNavMeshVersion != pNavMeshVersion)) { llassert(!pNavMeshData.empty()); + mRequestStatus = pNavMeshRequestStatus; mHasNavMesh = true; mNavMeshVersion = pNavMeshVersion; llassert(LLPathingLib::getInstance() != NULL); @@ -322,8 +327,8 @@ void LLPathfindingNavMeshZone::NavMeshLocation::handleNavMesh(LLPathfindingNavMe { LLPathingLib::getInstance()->extractNavMeshSrcFromLLSD(pNavMeshData, mDirection); } + mLocationCallback(); } - mLocationCallback(); } void LLPathfindingNavMeshZone::NavMeshLocation::clear() diff --git a/indra/newview/llviewerregion.cpp b/indra/newview/llviewerregion.cpp index 6e422a5821..fc04546bb8 100644 --- a/indra/newview/llviewerregion.cpp +++ b/indra/newview/llviewerregion.cpp @@ -1522,6 +1522,7 @@ void LLViewerRegionImpl::buildCapabilityNames(LLSD& capabilityNames) capabilityNames.append("MapLayer"); capabilityNames.append("MapLayerGod"); capabilityNames.append("MeshUploadFlag"); + capabilityNames.append("NavMeshGenerationStatus"); capabilityNames.append("NavMeshUpload"); capabilityNames.append("NewFileAgentInventory"); capabilityNames.append("ObjectNavMeshProperties"); -- cgit v1.3 From c990cc71ce124059a072c7778ac962253bacb199 Mon Sep 17 00:00:00 2001 From: Todd Stinson Date: Mon, 12 Mar 2012 19:18:19 -0700 Subject: PATH-304: Adding an extra state for the pathfinding console to report that the status of the navmesh is being checked. --- indra/newview/llfloaterpathfindingconsole.cpp | 7 +++++++ indra/newview/llfloaterpathfindingconsole.h | 1 + indra/newview/llpathfindingmanager.cpp | 4 +++- indra/newview/llpathfindingnavmesh.cpp | 22 +++++++++++++++++++--- indra/newview/llpathfindingnavmesh.h | 4 +++- indra/newview/llpathfindingnavmeshzone.cpp | 11 +++++++++++ indra/newview/llpathfindingnavmeshzone.h | 1 + .../default/xui/en/floater_pathfinding_console.xml | 1 + 8 files changed, 46 insertions(+), 5 deletions(-) (limited to 'indra/newview/llpathfindingmanager.cpp') diff --git a/indra/newview/llfloaterpathfindingconsole.cpp b/indra/newview/llfloaterpathfindingconsole.cpp index 493b4617b5..487ef0933a 100644 --- a/indra/newview/llfloaterpathfindingconsole.cpp +++ b/indra/newview/llfloaterpathfindingconsole.cpp @@ -618,6 +618,9 @@ void LLFloaterPathfindingConsole::onNavMeshZoneCB(LLPathfindingNavMeshZone::ENav case LLPathfindingNavMeshZone::kNavMeshZoneRequestUnknown : setConsoleState(kConsoleStateUnknown); break; + case LLPathfindingNavMeshZone::kNavMeshZoneRequestChecking : + setConsoleState(kConsoleStateCheckingVersion); + break; case LLPathfindingNavMeshZone::kNavMeshZoneRequestNeedsUpdate : mIsNavMeshUpdating = true; mNavMeshZone.refresh(); @@ -677,6 +680,7 @@ void LLFloaterPathfindingConsole::updateControlsOnConsoleState() mHasStartPoint = false; mHasEndPoint = false; break; + case kConsoleStateCheckingVersion : case kConsoleStateDownloading : case kConsoleStateError : mShowNavMeshCheckBox->setEnabled(FALSE); @@ -736,6 +740,9 @@ void LLFloaterPathfindingConsole::updateStatusOnConsoleState() statusText = getString("navmesh_status_region_not_enabled"); styleParams.color = warningColor; break; + case kConsoleStateCheckingVersion : + statusText = getString("navmesh_status_checking_version"); + break; case kConsoleStateDownloading : if (mIsNavMeshUpdating) { diff --git a/indra/newview/llfloaterpathfindingconsole.h b/indra/newview/llfloaterpathfindingconsole.h index 8c29bf5909..c58dc83653 100644 --- a/indra/newview/llfloaterpathfindingconsole.h +++ b/indra/newview/llfloaterpathfindingconsole.h @@ -120,6 +120,7 @@ private: kConsoleStateUnknown, kConsoleStateLibraryNotImplemented, kConsoleStateRegionNotEnabled, + kConsoleStateCheckingVersion, kConsoleStateDownloading, kConsoleStateHasNavMesh, kConsoleStateError diff --git a/indra/newview/llpathfindingmanager.cpp b/indra/newview/llpathfindingmanager.cpp index 9cd3d5625c..9abd9fda1a 100644 --- a/indra/newview/llpathfindingmanager.cpp +++ b/indra/newview/llpathfindingmanager.cpp @@ -274,11 +274,13 @@ void LLPathfindingManager::requestGetNavMeshForRegion(LLViewerRegion *pRegion) } 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 @@ -297,7 +299,7 @@ void LLPathfindingManager::handleNavMeshStatusRequest(const LLPathfindingNavMesh { if (navMeshPtr->hasNavMeshVersion(pNavMeshStatus.getVersion())) { - navMeshPtr->handleRefresh(); + navMeshPtr->handleRefresh(pNavMeshStatus.getVersion()); } else { diff --git a/indra/newview/llpathfindingnavmesh.cpp b/indra/newview/llpathfindingnavmesh.cpp index 81fa7b24db..138295a8cf 100644 --- a/indra/newview/llpathfindingnavmesh.cpp +++ b/indra/newview/llpathfindingnavmesh.cpp @@ -56,12 +56,28 @@ LLPathfindingNavMesh::navmesh_slot_t LLPathfindingNavMesh::registerNavMeshListen bool LLPathfindingNavMesh::hasNavMeshVersion(U32 pNavMeshVersion) const { - return (((mNavMeshRequestStatus == kNavMeshRequestStarted) || (mNavMeshRequestStatus == kNavMeshRequestCompleted)) && (mNavMeshVersion == pNavMeshVersion)); + return ((mNavMeshVersion == pNavMeshVersion) && + ((mNavMeshRequestStatus == kNavMeshRequestStarted) || (mNavMeshRequestStatus == kNavMeshRequestCompleted) || + ((mNavMeshRequestStatus == kNavMeshRequestChecking) && !mNavMeshData.empty()))); } -void LLPathfindingNavMesh::handleRefresh() +void LLPathfindingNavMesh::handleRefresh(U32 pNavMeshVersion) { - mNavMeshSignal(mNavMeshRequestStatus, mRegionUUID, mNavMeshVersion, mNavMeshData); + llassert(pNavMeshVersion == mNavMeshVersion); + if (mNavMeshRequestStatus == kNavMeshRequestChecking) + { + llassert(!mNavMeshData.empty()); + setRequestStatus(kNavMeshRequestCompleted); + } + else + { + mNavMeshSignal(mNavMeshRequestStatus, mRegionUUID, mNavMeshVersion, mNavMeshData); + } +} + +void LLPathfindingNavMesh::handleNavMeshCheckVersion() +{ + setRequestStatus(kNavMeshRequestChecking); } void LLPathfindingNavMesh::handleNavMeshNewVersion(U32 pNavMeshVersion) diff --git a/indra/newview/llpathfindingnavmesh.h b/indra/newview/llpathfindingnavmesh.h index 3bdb485d37..46a114439a 100644 --- a/indra/newview/llpathfindingnavmesh.h +++ b/indra/newview/llpathfindingnavmesh.h @@ -50,6 +50,7 @@ class LLPathfindingNavMesh public: typedef enum { kNavMeshRequestUnknown, + kNavMeshRequestChecking, kNavMeshRequestNeedsUpdate, kNavMeshRequestStarted, kNavMeshRequestCompleted, @@ -72,7 +73,8 @@ public: bool hasNavMeshVersion(U32 pNavMeshVersion) const; - void handleRefresh(); + void handleNavMeshCheckVersion(); + void handleRefresh(U32 pNavMeshVersion); void handleNavMeshNewVersion(U32 pNavMeshVersion); void handleNavMeshStart(U32 pNavMeshVersion); void handleNavMeshResult(const LLSD &pContent, U32 pNavMeshVersion); diff --git a/indra/newview/llpathfindingnavmeshzone.cpp b/indra/newview/llpathfindingnavmeshzone.cpp index 83238ec869..8e558c3b00 100644 --- a/indra/newview/llpathfindingnavmeshzone.cpp +++ b/indra/newview/llpathfindingnavmeshzone.cpp @@ -140,6 +140,7 @@ void LLPathfindingNavMeshZone::handleNavMeshLocation() void LLPathfindingNavMeshZone::updateStatus() { bool hasRequestUnknown = false; + bool hasRequestChecking = false; bool hasRequestNeedsUpdate = false; bool hasRequestStarted = false; bool hasRequestCompleted = false; @@ -161,6 +162,9 @@ void LLPathfindingNavMeshZone::updateStatus() case LLPathfindingNavMesh::kNavMeshRequestUnknown : hasRequestUnknown = true; break; + case LLPathfindingNavMesh::kNavMeshRequestChecking : + hasRequestChecking = true; + break; case LLPathfindingNavMesh::kNavMeshRequestNeedsUpdate : hasRequestNeedsUpdate = true; break; @@ -189,6 +193,13 @@ void LLPathfindingNavMeshZone::updateStatus() zoneRequestStatus = kNavMeshZoneRequestNeedsUpdate; #ifdef XXX_STINSON_DEBUG_NAVMESH_ZONE llinfos << "STINSON DEBUG: Navmesh zone update is NEEDS UPDATE" << llendl; +#endif // XXX_STINSON_DEBUG_NAVMESH_ZONE + } + else if (hasRequestChecking) + { + zoneRequestStatus = kNavMeshZoneRequestChecking; +#ifdef XXX_STINSON_DEBUG_NAVMESH_ZONE + llinfos << "STINSON DEBUG: Navmesh zone update is CHECKING" << llendl; #endif // XXX_STINSON_DEBUG_NAVMESH_ZONE } else if (hasRequestStarted) diff --git a/indra/newview/llpathfindingnavmeshzone.h b/indra/newview/llpathfindingnavmeshzone.h index 833f3ebb05..7b6583a663 100644 --- a/indra/newview/llpathfindingnavmeshzone.h +++ b/indra/newview/llpathfindingnavmeshzone.h @@ -45,6 +45,7 @@ class LLPathfindingNavMeshZone public: typedef enum { kNavMeshZoneRequestUnknown, + kNavMeshZoneRequestChecking, kNavMeshZoneRequestNeedsUpdate, kNavMeshZoneRequestStarted, kNavMeshZoneRequestCompleted, 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 75465f1aea..d23d62674f 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 @@ Cannot find pathing library implementation. This region is not enabled for pathfinding. + Checking the status of the navmesh ... Downloading the navmesh ... The navmesh has changed on the server. Downloading the latest navmesh ... Navmesh received. -- cgit v1.3 From b84db8354d992cfddfd64eb80ebd80c4b6baf3f8 Mon Sep 17 00:00:00 2001 From: Todd Stinson Date: Tue, 13 Mar 2012 10:23:55 -0700 Subject: PATH-304: Adding more debug messaging and correcting the camel-case of the NavMesh update message. --- etc/message.xml | 2 +- indra/newview/llpathfindingmanager.cpp | 6 ++++++ 2 files changed, 7 insertions(+), 1 deletion(-) (limited to 'indra/newview/llpathfindingmanager.cpp') diff --git a/etc/message.xml b/etc/message.xml index 9407888a92..244bf7fb06 100644 --- a/etc/message.xml +++ b/etc/message.xml @@ -547,7 +547,7 @@ true - NavmeshStatusUpdate + NavMeshStatusUpdate flavor llsd diff --git a/indra/newview/llpathfindingmanager.cpp b/indra/newview/llpathfindingmanager.cpp index 9abd9fda1a..f3b9bc4b8a 100644 --- a/indra/newview/llpathfindingmanager.cpp +++ b/indra/newview/llpathfindingmanager.cpp @@ -627,6 +627,9 @@ LLViewerRegion *LLPathfindingManager::getCurrentRegion() const void LLNavMeshSimStateChangeNode::post(ResponsePtr pResponse, const LLSD &pContext, const LLSD &pInput) const { +#ifdef XXX_STINSON_DEBUG_NAVMESH_ZONE + llinfos << "Received NavMeshStatusUpdate: " << pContext << llendl; +#endif // XXX_STINSON_DEBUG_NAVMESH_ZONE LLPathfindingNavMeshStatus navMeshStatus(pContext); LLPathfindingManager::getInstance()->handleNavMeshStatusUpdate(pContext); } @@ -652,6 +655,9 @@ NavMeshStatusResponder::~NavMeshStatusResponder() void NavMeshStatusResponder::result(const LLSD &pContent) { +#ifdef XXX_STINSON_DEBUG_NAVMESH_ZONE + llinfos << "Received requested NavMeshStatus: " << pContent << llendl; +#endif // XXX_STINSON_DEBUG_NAVMESH_ZONE LLPathfindingNavMeshStatus navMeshStatus(mRegionUUID, pContent); LLPathfindingManager::getInstance()->handleNavMeshStatusRequest(navMeshStatus, mRegion); } -- cgit v1.3 From 66374e4d656ae07d4dddc010e6239267ffe94b05 Mon Sep 17 00:00:00 2001 From: Todd Stinson Date: Tue, 13 Mar 2012 11:59:44 -0700 Subject: PATH-304: Proper handling of the sim-to-viewer message. --- indra/newview/llpathfindingmanager.cpp | 12 ++++++++---- indra/newview/llpathfindingnavmeshstatus.cpp | 27 ++++++++++++++++++++++----- 2 files changed, 30 insertions(+), 9 deletions(-) (limited to 'indra/newview/llpathfindingmanager.cpp') diff --git a/indra/newview/llpathfindingmanager.cpp b/indra/newview/llpathfindingmanager.cpp index f3b9bc4b8a..251e330914 100644 --- a/indra/newview/llpathfindingmanager.cpp +++ b/indra/newview/llpathfindingmanager.cpp @@ -41,6 +41,7 @@ #include "llpathfindinglinkset.h" #include "llpathfindinglinksetlist.h" #include "llhttpnode.h" +//#include "llpathfindingnavmeshzone.h" // XXX #include #include @@ -57,6 +58,7 @@ #define CAP_SERVICE_TERRAIN_LINKSETS "TerrainNavMeshProperties" #define SIM_MESSAGE_NAVMESH_STATUS_UPDATE "/message/NavMeshStatusUpdate" +#define SIM_MESSAGE_BODY_FIELD "body" //--------------------------------------------------------------------------- // LLNavMeshSimStateChangeNode @@ -628,10 +630,12 @@ LLViewerRegion *LLPathfindingManager::getCurrentRegion() const void LLNavMeshSimStateChangeNode::post(ResponsePtr pResponse, const LLSD &pContext, const LLSD &pInput) const { #ifdef XXX_STINSON_DEBUG_NAVMESH_ZONE - llinfos << "Received NavMeshStatusUpdate: " << pContext << llendl; + llinfos << "STINSON DEBUG: Received NavMeshStatusUpdate: " << pInput << llendl; #endif // XXX_STINSON_DEBUG_NAVMESH_ZONE - LLPathfindingNavMeshStatus navMeshStatus(pContext); - LLPathfindingManager::getInstance()->handleNavMeshStatusUpdate(pContext); + 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); } //--------------------------------------------------------------------------- @@ -656,7 +660,7 @@ NavMeshStatusResponder::~NavMeshStatusResponder() void NavMeshStatusResponder::result(const LLSD &pContent) { #ifdef XXX_STINSON_DEBUG_NAVMESH_ZONE - llinfos << "Received requested NavMeshStatus: " << pContent << llendl; + llinfos << "STINSON DEBUG: Received requested NavMeshStatus: " << pContent << llendl; #endif // XXX_STINSON_DEBUG_NAVMESH_ZONE LLPathfindingNavMeshStatus navMeshStatus(mRegionUUID, pContent); LLPathfindingManager::getInstance()->handleNavMeshStatusRequest(navMeshStatus, mRegion); diff --git a/indra/newview/llpathfindingnavmeshstatus.cpp b/indra/newview/llpathfindingnavmeshstatus.cpp index 67be0459a5..2ef892c8cd 100644 --- a/indra/newview/llpathfindingnavmeshstatus.cpp +++ b/indra/newview/llpathfindingnavmeshstatus.cpp @@ -33,8 +33,9 @@ #include -#define REGION_FIELD "region" -#define STATE_FIELD "state" +#define REGION_FIELD "region_id" +#define DEPRECATED_STATE_FIELD "state" +#define STATUS_FIELD "status" #define VERSION_FIELD "version" const std::string LLPathfindingNavMeshStatus::sStatusPending("pending"); @@ -106,9 +107,25 @@ void LLPathfindingNavMeshStatus::parseStatus(const LLSD &pContent) llassert(pContent.get(VERSION_FIELD).asInteger() >= 0); mVersion = static_cast(pContent.get(VERSION_FIELD).asInteger()); - llassert(pContent.has(STATE_FIELD)); - llassert(pContent.get(STATE_FIELD).isString()); - std::string status = pContent.get(STATE_FIELD).asString(); +#ifdef DEPRECATED_STATE_FIELD + std::string status; + if (pContent.has(DEPRECATED_STATE_FIELD)) + { + llassert(pContent.has(DEPRECATED_STATE_FIELD)); + llassert(pContent.get(DEPRECATED_STATE_FIELD).isString()); + status = pContent.get(DEPRECATED_STATE_FIELD).asString(); + } + else + { + llassert(pContent.has(STATUS_FIELD)); + llassert(pContent.get(STATUS_FIELD).isString()); + status = pContent.get(STATUS_FIELD).asString(); + } +#else // DEPRECATED_STATE_FIELD + llassert(pContent.has(STATUS_FIELD)); + llassert(pContent.get(STATUS_FIELD).isString()); + std::string status = pContent.get(STATUS_FIELD).asString(); +#endif // DEPRECATED_STATE_FIELD if (LLStringUtil::compareStrings(status, sStatusPending)) { -- cgit v1.3 From e1aac3718192d7ce663f9134492b4a12dc1637d0 Mon Sep 17 00:00:00 2001 From: Todd Stinson Date: Tue, 13 Mar 2012 16:42:07 -0700 Subject: PATH-394: First pass at handling the sim-to-viewer message reporting the change from FROZEN to UNFROZEN state. --- etc/message.xml | 8 ++++++++ indra/newview/llpathfindingmanager.cpp | 36 ++++++++++++++++++++++++++++++++++ indra/newview/llpathfindingmanager.h | 2 ++ 3 files changed, 46 insertions(+) (limited to 'indra/newview/llpathfindingmanager.cpp') diff --git a/etc/message.xml b/etc/message.xml index 244bf7fb06..7dcf99f307 100644 --- a/etc/message.xml +++ b/etc/message.xml @@ -555,6 +555,14 @@ true + AgentPreferencesUpdate + + flavor + llsd + trusted-sender + true + + ScriptRunningReply diff --git a/indra/newview/llpathfindingmanager.cpp b/indra/newview/llpathfindingmanager.cpp index 251e330914..46bfbe0bb0 100644 --- a/indra/newview/llpathfindingmanager.cpp +++ b/indra/newview/llpathfindingmanager.cpp @@ -58,6 +58,7 @@ #define CAP_SERVICE_TERRAIN_LINKSETS "TerrainNavMeshProperties" #define SIM_MESSAGE_NAVMESH_STATUS_UPDATE "/message/NavMeshStatusUpdate" +#define SIM_MESSAGE_AGENT_STATE_UPDATE "/message/AgentPreferencesUpdate" #define SIM_MESSAGE_BODY_FIELD "body" //--------------------------------------------------------------------------- @@ -72,6 +73,18 @@ public: LLHTTPRegistration 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 gHTTPRegistrationAgentStateChangeNode(SIM_MESSAGE_AGENT_STATE_UPDATE); + //--------------------------------------------------------------------------- // NavMeshStatusResponder //--------------------------------------------------------------------------- @@ -570,6 +583,15 @@ void LLPathfindingManager::handleAgentStateError(U32 pStatus, const std::string 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); @@ -638,6 +660,20 @@ void LLNavMeshSimStateChangeNode::post(ResponsePtr pResponse, const LLSD &pConte 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 //--------------------------------------------------------------------------- diff --git a/indra/newview/llpathfindingmanager.h b/indra/newview/llpathfindingmanager.h index 3a849d0290..1cfd870897 100644 --- a/indra/newview/llpathfindingmanager.h +++ b/indra/newview/llpathfindingmanager.h @@ -47,6 +47,7 @@ class LLPathfindingNavMeshStatus; class LLPathfindingManager : public LLSingleton { friend class AgentStateResponder; + friend class LLAgentStateChangeNode; public: typedef std::map NavMeshMap; @@ -108,6 +109,7 @@ private: 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; -- cgit v1.3 From d4fb7c99febf07b4eb7f3a9d2eab485e356d1439 Mon Sep 17 00:00:00 2001 From: Todd Stinson Date: Wed, 14 Mar 2012 14:09:36 -0700 Subject: PATH-302: Adding in status reporting for the simulator navmesh status. Separating the viewer status messaging from the simulator status. --- indra/newview/llfloaterpathfindingconsole.cpp | 118 ++++++++++++++++--- indra/newview/llfloaterpathfindingconsole.h | 8 +- indra/newview/llpathfindingmanager.cpp | 27 +++-- indra/newview/llpathfindingmanager.h | 5 +- indra/newview/llpathfindingnavmesh.cpp | 65 +++++++---- indra/newview/llpathfindingnavmesh.h | 34 +++--- indra/newview/llpathfindingnavmeshstatus.cpp | 16 ++- indra/newview/llpathfindingnavmeshstatus.h | 8 ++ indra/newview/llpathfindingnavmeshzone.cpp | 130 +++++++++++++++++---- indra/newview/llpathfindingnavmeshzone.h | 25 +++- .../default/xui/en/floater_pathfinding_console.xml | 86 +++++++++++--- 11 files changed, 399 insertions(+), 123 deletions(-) (limited to 'indra/newview/llpathfindingmanager.cpp') diff --git a/indra/newview/llfloaterpathfindingconsole.cpp b/indra/newview/llfloaterpathfindingconsole.cpp index 7e86819568..65a558b778 100644 --- a/indra/newview/llfloaterpathfindingconsole.cpp +++ b/indra/newview/llfloaterpathfindingconsole.cpp @@ -129,8 +129,11 @@ BOOL LLFloaterPathfindingConsole::postBuild() llassert(mFreezeButton != NULL); mFreezeButton->setCommitCallback(boost::bind(&LLFloaterPathfindingConsole::onFreezeClicked, this)); - mPathfindingStatus = findChild("pathfinding_status"); - llassert(mPathfindingStatus != NULL); + mPathfindingViewerStatus = findChild("pathfinding_viewer_status"); + llassert(mPathfindingViewerStatus != NULL); + + mPathfindingSimulatorStatus = findChild("pathfinding_simulator_status"); + llassert(mPathfindingSimulatorStatus != NULL); mCharacterWidthSlider = findChild("character_width"); llassert(mCharacterWidthSlider != NULL); @@ -469,7 +472,8 @@ LLFloaterPathfindingConsole::LLFloaterPathfindingConsole(const LLSD& pSeed) mShowMaterialVolumesCheckBox(NULL), mShowExclusionVolumesCheckBox(NULL), mShowWorldCheckBox(NULL), - mPathfindingStatus(NULL), + mPathfindingViewerStatus(NULL), + mPathfindingSimulatorStatus(NULL), mViewCharactersButton(NULL), mEditTestTabContainer(NULL), mEditTab(NULL), @@ -731,50 +735,126 @@ void LLFloaterPathfindingConsole::updateStatusOnConsoleState() { static const LLColor4 warningColor = LLUIColorTable::instance().getColor("DrYellow"); - std::string statusText(""); - LLStyle::Params styleParams; + std::string simulatorStatusText(""); + std::string viewerStatusText(""); + LLStyle::Params viewerStyleParams; switch (mConsoleState) { case kConsoleStateUnknown : - statusText = getString("navmesh_status_unknown"); + simulatorStatusText = getString("navmesh_simulator_status_unknown"); + viewerStatusText = getString("navmesh_viewer_status_unknown"); break; case kConsoleStateLibraryNotImplemented : - statusText = getString("navmesh_status_library_not_implemented"); - styleParams.color = warningColor; + simulatorStatusText = getString("navmesh_simulator_status_unknown"); + viewerStatusText = getString("navmesh_viewer_status_library_not_implemented"); + viewerStyleParams.color = warningColor; break; case kConsoleStateRegionNotEnabled : - statusText = getString("navmesh_status_region_not_enabled"); - styleParams.color = warningColor; + simulatorStatusText = getString("navmesh_simulator_status_unknown"); + viewerStatusText = getString("navmesh_viewer_status_region_not_enabled"); + viewerStyleParams.color = warningColor; break; case kConsoleStateCheckingVersion : - statusText = getString("navmesh_status_checking_version"); + simulatorStatusText = getString("navmesh_simulator_status_unknown"); + viewerStatusText = getString("navmesh_viewer_status_checking_version"); break; case kConsoleStateDownloading : + simulatorStatusText = getSimulatorStatusText(); if (mIsNavMeshUpdating) { - statusText = getString("navmesh_status_updating"); + viewerStatusText = getString("navmesh_viewer_status_updating"); } else { - statusText = getString("navmesh_status_downloading"); + viewerStatusText = getString("navmesh_viewer_status_downloading"); } break; case kConsoleStateHasNavMesh : - statusText = getString("navmesh_status_has_navmesh"); + simulatorStatusText = getSimulatorStatusText(); + viewerStatusText = getString("navmesh_viewer_status_has_navmesh"); break; case kConsoleStateError : - statusText = getString("navmesh_status_error"); - styleParams.color = warningColor; + simulatorStatusText = getString("navmesh_simulator_status_unknown"); + viewerStatusText = getString("navmesh_viewer_status_error"); + viewerStyleParams.color = warningColor; break; default : - statusText = getString("navmesh_status_unknown"); + simulatorStatusText = getString("navmesh_simulator_status_unknown"); + viewerStatusText = getString("navmesh_viewer_status_unknown"); llassert(0); break; } - mPathfindingStatus->setText((LLStringExplicit)statusText, styleParams); + mPathfindingViewerStatus->setText((LLStringExplicit)viewerStatusText, viewerStyleParams); + mPathfindingSimulatorStatus->setText((LLStringExplicit)simulatorStatusText); } + +std::string LLFloaterPathfindingConsole::getSimulatorStatusText() const +{ + std::string simulatorStatusText(""); + +#ifdef DEPRECATED_UNVERSIONED_NAVMESH + if (LLPathfindingManager::getInstance()->isPathfindingNavMeshVersioningEnabledForCurrentRegionXXX()) + { + switch (mNavMeshZone.getNavMeshZoneStatus()) + { + case LLPathfindingNavMeshZone::kNavMeshZonePending : + simulatorStatusText = getString("navmesh_simulator_status_pending"); + break; + case LLPathfindingNavMeshZone::kNavMeshZoneBuilding : + simulatorStatusText = getString("navmesh_simulator_status_building"); + break; + case LLPathfindingNavMeshZone::kNavMeshZoneSomePending : + simulatorStatusText = getString("navmesh_simulator_status_some_pending"); + break; + case LLPathfindingNavMeshZone::kNavMeshZoneSomeBuilding : + simulatorStatusText = getString("navmesh_simulator_status_some_building"); + break; + case LLPathfindingNavMeshZone::kNavMeshZonePendingAndBuilding : + simulatorStatusText = getString("navmesh_simulator_status_pending_and_building"); + break; + case LLPathfindingNavMeshZone::kNavMeshZoneComplete : + simulatorStatusText = getString("navmesh_simulator_status_complete"); + break; + default : + simulatorStatusText = getString("navmesh_simulator_status_unknown"); + break; + } + } + else + { + simulatorStatusText = getString("navmesh_simulator_status_region_not_enabled"); + } +#else // DEPRECATED_UNVERSIONED_NAVMESH + switch (mNavMeshZone.getNavMeshZoneStatus()) + { + case LLPathfindingNavMeshZone::kNavMeshZonePending : + simulatorStatusText = getString("navmesh_simulator_status_pending"); + break; + case LLPathfindingNavMeshZone::kNavMeshZoneBuilding : + simulatorStatusText = getString("navmesh_simulator_status_building"); + break; + case LLPathfindingNavMeshZone::kNavMeshZoneSomePending : + simulatorStatusText = getString("navmesh_simulator_status_some_pending"); + break; + case LLPathfindingNavMeshZone::kNavMeshZoneSomeBuilding : + simulatorStatusText = getString("navmesh_simulator_status_some_building"); + break; + case LLPathfindingNavMeshZone::kNavMeshZonePendingAndBuilding : + simulatorStatusText = getString("navmesh_simulator_status_pending_and_building"); + break; + case LLPathfindingNavMeshZone::kNavMeshZoneComplete : + simulatorStatusText = getString("navmesh_simulator_status_complete"); + break; + default : + simulatorStatusText = getString("navmesh_simulator_status_unknown"); + break; + } +#endif // DEPRECATED_UNVERSIONED_NAVMESH + + return simulatorStatusText; +} void LLFloaterPathfindingConsole::setAgentState(LLPathfindingManager::EAgentState pAgentState) { @@ -894,5 +974,5 @@ void LLFloaterPathfindingConsole::regionCrossingOccured() LLStyle::Params styleParams; styleParams.color = LLUIColorTable::instance().getColor("DrYellow"); statusText = getString("navmesh_update_needed"); - mPathfindingStatus->setText((LLStringExplicit)statusText, styleParams); + mPathfindingViewerStatus->setText((LLStringExplicit)statusText, styleParams); } \ No newline at end of file diff --git a/indra/newview/llfloaterpathfindingconsole.h b/indra/newview/llfloaterpathfindingconsole.h index a1973e0985..8c22e5ead7 100644 --- a/indra/newview/llfloaterpathfindingconsole.h +++ b/indra/newview/llfloaterpathfindingconsole.h @@ -147,8 +147,9 @@ private: void setConsoleState(EConsoleState pConsoleState); - void updateControlsOnConsoleState(); - void updateStatusOnConsoleState(); + void updateControlsOnConsoleState(); + void updateStatusOnConsoleState(); + std::string getSimulatorStatusText() const; void setAgentState(LLPathfindingManager::EAgentState pAgentState); @@ -165,7 +166,8 @@ private: LLCheckBoxCtrl *mShowMaterialVolumesCheckBox; LLCheckBoxCtrl *mShowExclusionVolumesCheckBox; LLCheckBoxCtrl *mShowWorldCheckBox; - LLTextBase *mPathfindingStatus; + LLTextBase *mPathfindingViewerStatus; + LLTextBase *mPathfindingSimulatorStatus; LLButton *mViewCharactersButton; LLTabContainer *mEditTestTabContainer; LLPanel *mEditTab; diff --git a/indra/newview/llpathfindingmanager.cpp b/indra/newview/llpathfindingmanager.cpp index 46bfbe0bb0..e3242de812 100644 --- a/indra/newview/llpathfindingmanager.cpp +++ b/indra/newview/llpathfindingmanager.cpp @@ -41,7 +41,6 @@ #include "llpathfindinglinkset.h" #include "llpathfindinglinksetlist.h" #include "llhttpnode.h" -//#include "llpathfindingnavmeshzone.h" // XXX #include #include @@ -254,6 +253,14 @@ bool LLPathfindingManager::isPathfindingEnabledForRegion(LLViewerRegion *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)); @@ -285,7 +292,9 @@ void LLPathfindingManager::requestGetNavMeshForRegion(LLViewerRegion *pRegion) #ifdef DEPRECATED_UNVERSIONED_NAVMESH if (navMeshStatusURL.empty()) { - sendRequestGetNavMeshForRegion(navMeshPtr, pRegion, navMeshPtr->getNavMeshVersion() + 1U); + LLPathfindingNavMeshStatus navMeshStatus = navMeshPtr->getNavMeshStatusXXX(); + navMeshStatus.incrementNavMeshVersionXXX(); + sendRequestGetNavMeshForRegion(navMeshPtr, pRegion, navMeshStatus); } else { @@ -312,13 +321,13 @@ void LLPathfindingManager::handleNavMeshStatusRequest(const LLPathfindingNavMesh } else { - if (navMeshPtr->hasNavMeshVersion(pNavMeshStatus.getVersion())) + if (navMeshPtr->hasNavMeshVersion(pNavMeshStatus)) { - navMeshPtr->handleRefresh(pNavMeshStatus.getVersion()); + navMeshPtr->handleRefresh(pNavMeshStatus); } else { - sendRequestGetNavMeshForRegion(navMeshPtr, pRegion, pNavMeshStatus.getVersion()); + sendRequestGetNavMeshForRegion(navMeshPtr, pRegion, pNavMeshStatus); } } } @@ -333,7 +342,7 @@ void LLPathfindingManager::handleNavMeshStatusUpdate(const LLPathfindingNavMeshS } else { - navMeshPtr->handleNavMeshNewVersion(pNavMeshStatus.getVersion()); + navMeshPtr->handleNavMeshNewVersion(pNavMeshStatus); } } @@ -462,7 +471,7 @@ LLPathfindingManager::ELinksetsRequestStatus LLPathfindingManager::requestSetLin return status; } -void LLPathfindingManager::sendRequestGetNavMeshForRegion(LLPathfindingNavMeshPtr navMeshPtr, LLViewerRegion *pRegion, U32 pNavMeshVersion) +void LLPathfindingManager::sendRequestGetNavMeshForRegion(LLPathfindingNavMeshPtr navMeshPtr, LLViewerRegion *pRegion, const LLPathfindingNavMeshStatus &pNavMeshStatus) { if ((pRegion == NULL) || !pRegion->isAlive()) { @@ -478,8 +487,8 @@ void LLPathfindingManager::sendRequestGetNavMeshForRegion(LLPathfindingNavMeshPt } else { - navMeshPtr->handleNavMeshStart(pNavMeshVersion); - LLHTTPClient::ResponderPtr responder = new NavMeshResponder(navMeshURL, pNavMeshVersion, navMeshPtr); + navMeshPtr->handleNavMeshStart(pNavMeshStatus); + LLHTTPClient::ResponderPtr responder = new NavMeshResponder(navMeshURL, pNavMeshStatus.getVersion(), navMeshPtr); LLSD postData; LLHTTPClient::post(navMeshURL, postData, responder); diff --git a/indra/newview/llpathfindingmanager.h b/indra/newview/llpathfindingmanager.h index 1cfd870897..b458d6513a 100644 --- a/indra/newview/llpathfindingmanager.h +++ b/indra/newview/llpathfindingmanager.h @@ -77,6 +77,9 @@ public: bool isPathfindingEnabledForCurrentRegion() const; bool isPathfindingEnabledForRegion(LLViewerRegion *pRegion) const; +#ifdef DEPRECATED_UNVERSIONED_NAVMESH + bool isPathfindingNavMeshVersioningEnabledForCurrentRegionXXX() const; +#endif // DEPRECATED_UNVERSIONED_NAVMESH bool isAllowAlterPermanent(); bool isAllowViewTerrainProperties() const; @@ -98,7 +101,7 @@ public: protected: private: - void sendRequestGetNavMeshForRegion(LLPathfindingNavMeshPtr navMeshPtr, LLViewerRegion *pRegion, U32 pNavMeshVersion); + void sendRequestGetNavMeshForRegion(LLPathfindingNavMeshPtr navMeshPtr, LLViewerRegion *pRegion, const LLPathfindingNavMeshStatus &pNavMeshStatus); LLPathfindingNavMeshPtr getNavMeshForRegion(const LLUUID &pRegionUUID); LLPathfindingNavMeshPtr getNavMeshForRegion(LLViewerRegion *pRegion); diff --git a/indra/newview/llpathfindingnavmesh.cpp b/indra/newview/llpathfindingnavmesh.cpp index 740d1cde24..10e9abaf0c 100644 --- a/indra/newview/llpathfindingnavmesh.cpp +++ b/indra/newview/llpathfindingnavmesh.cpp @@ -28,6 +28,7 @@ #include "llviewerprecompiledheaders.h" #include "lluuid.h" #include "llpathfindingnavmesh.h" +#include "llpathfindingnavmeshstatus.h" #include "llsdserialize.h" #include @@ -40,11 +41,11 @@ //--------------------------------------------------------------------------- LLPathfindingNavMesh::LLPathfindingNavMesh(const LLUUID &pRegionUUID) - : mRegionUUID(pRegionUUID), + : mNavMeshStatus(pRegionUUID), mNavMeshRequestStatus(kNavMeshRequestUnknown), mNavMeshSignal(), - mNavMeshData(), - mNavMeshVersion(0U) + mNavMeshData() + { } @@ -57,16 +58,23 @@ LLPathfindingNavMesh::navmesh_slot_t LLPathfindingNavMesh::registerNavMeshListen return mNavMeshSignal.connect(pNavMeshCallback); } -bool LLPathfindingNavMesh::hasNavMeshVersion(U32 pNavMeshVersion) const +bool LLPathfindingNavMesh::hasNavMeshVersion(const LLPathfindingNavMeshStatus &pNavMeshStatus) const { - return ((mNavMeshVersion == pNavMeshVersion) && + return ((mNavMeshStatus.getVersion() == pNavMeshStatus.getVersion()) && ((mNavMeshRequestStatus == kNavMeshRequestStarted) || (mNavMeshRequestStatus == kNavMeshRequestCompleted) || ((mNavMeshRequestStatus == kNavMeshRequestChecking) && !mNavMeshData.empty()))); } -void LLPathfindingNavMesh::handleRefresh(U32 pNavMeshVersion) +void LLPathfindingNavMesh::handleNavMeshCheckVersion() +{ + setRequestStatus(kNavMeshRequestChecking); +} + +void LLPathfindingNavMesh::handleRefresh(const LLPathfindingNavMeshStatus &pNavMeshStatus) { - llassert(pNavMeshVersion == mNavMeshVersion); + llassert(mNavMeshStatus.getRegionUUID() == pNavMeshStatus.getRegionUUID()); + llassert(mNavMeshStatus.getVersion() == pNavMeshStatus.getVersion()); + mNavMeshStatus = pNavMeshStatus; if (mNavMeshRequestStatus == kNavMeshRequestChecking) { llassert(!mNavMeshData.empty()); @@ -74,28 +82,30 @@ void LLPathfindingNavMesh::handleRefresh(U32 pNavMeshVersion) } else { - mNavMeshSignal(mNavMeshRequestStatus, mRegionUUID, mNavMeshVersion, mNavMeshData); + sendStatus(); } } -void LLPathfindingNavMesh::handleNavMeshCheckVersion() -{ - setRequestStatus(kNavMeshRequestChecking); -} - -void LLPathfindingNavMesh::handleNavMeshNewVersion(U32 pNavMeshVersion) +void LLPathfindingNavMesh::handleNavMeshNewVersion(const LLPathfindingNavMeshStatus &pNavMeshStatus) { - if (mNavMeshVersion != pNavMeshVersion) + llassert(mNavMeshStatus.getRegionUUID() == pNavMeshStatus.getRegionUUID()); + if (mNavMeshStatus.getVersion() == pNavMeshStatus.getVersion()) + { + mNavMeshStatus = pNavMeshStatus; + sendStatus(); + } + else { mNavMeshData.clear(); - mNavMeshVersion = pNavMeshVersion; + mNavMeshStatus = pNavMeshStatus; setRequestStatus(kNavMeshRequestNeedsUpdate); } } -void LLPathfindingNavMesh::handleNavMeshStart(U32 pNavMeshVersion) +void LLPathfindingNavMesh::handleNavMeshStart(const LLPathfindingNavMeshStatus &pNavMeshStatus) { - mNavMeshVersion = pNavMeshVersion; + llassert(mNavMeshStatus.getRegionUUID() == pNavMeshStatus.getRegionUUID()); + mNavMeshStatus = pNavMeshStatus; setRequestStatus(kNavMeshRequestStarted); } @@ -114,8 +124,9 @@ void LLPathfindingNavMesh::handleNavMeshResult(const LLSD &pContent, U32 pNavMes } } - if (mNavMeshVersion == pNavMeshVersion) + if (mNavMeshStatus.getVersion() == pNavMeshVersion) { + ENavMeshRequestStatus status; if ( pContent.has(NAVMESH_DATA_FIELD) ) { const LLSD::Binary &value = pContent.get(NAVMESH_DATA_FIELD).asBinary(); @@ -128,14 +139,14 @@ void LLPathfindingNavMesh::handleNavMeshResult(const LLSD &pContent, U32 pNavMes if ( !valid ) { llwarns << "Unable to decompress the navmesh llsd." << llendl; - setRequestStatus(kNavMeshRequestError); + status = kNavMeshRequestError; } else { llassert(pUncompressedNavMeshContainer); mNavMeshData.resize( decompBinSize ); memcpy( &mNavMeshData[0], &pUncompressedNavMeshContainer[0], decompBinSize ); - setRequestStatus(kNavMeshRequestCompleted); + status = kNavMeshRequestCompleted; } if ( pUncompressedNavMeshContainer ) { @@ -145,8 +156,9 @@ void LLPathfindingNavMesh::handleNavMeshResult(const LLSD &pContent, U32 pNavMes else { llwarns << "No mesh data received" << llendl; - setRequestStatus(kNavMeshRequestError); + status = kNavMeshRequestError; } + setRequestStatus(status); } } @@ -165,7 +177,7 @@ void LLPathfindingNavMesh::handleNavMeshError() 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 (mNavMeshVersion == pNavMeshVersion) + if (mNavMeshStatus.getVersion() == pNavMeshVersion) { handleNavMeshError(); } @@ -174,5 +186,10 @@ void LLPathfindingNavMesh::handleNavMeshError(U32 pStatus, const std::string &pR void LLPathfindingNavMesh::setRequestStatus(ENavMeshRequestStatus pNavMeshRequestStatus) { mNavMeshRequestStatus = pNavMeshRequestStatus; - mNavMeshSignal(mNavMeshRequestStatus, mRegionUUID, mNavMeshVersion, mNavMeshData); + sendStatus(); +} + +void LLPathfindingNavMesh::sendStatus() +{ + mNavMeshSignal(mNavMeshRequestStatus, mNavMeshStatus, mNavMeshData); } diff --git a/indra/newview/llpathfindingnavmesh.h b/indra/newview/llpathfindingnavmesh.h index 46a114439a..290f7a2cdf 100644 --- a/indra/newview/llpathfindingnavmesh.h +++ b/indra/newview/llpathfindingnavmesh.h @@ -29,7 +29,6 @@ #define LL_LLPATHFINDINGNAVMESH_H #include "llsd.h" -#include "lluuid.h" #include @@ -37,14 +36,13 @@ #include #include -class LLSD; +#include "llpathfindingnavmeshstatus.h" + +class LLUUID; class LLPathfindingNavMesh; typedef boost::shared_ptr LLPathfindingNavMeshPtr; -// XXX stinson 03/12/2012 : This definition is in place to support an older version of the pathfinding simulator that does not have versioned information -#define DEPRECATED_UNVERSIONED_NAVMESH - class LLPathfindingNavMesh { public: @@ -58,9 +56,9 @@ public: kNavMeshRequestError } ENavMeshRequestStatus; - typedef boost::function navmesh_callback_t; - typedef boost::signals2::signal navmesh_signal_t; - typedef boost::signals2::connection navmesh_slot_t; + typedef boost::function navmesh_callback_t; + typedef boost::signals2::signal navmesh_signal_t; + typedef boost::signals2::connection navmesh_slot_t; LLPathfindingNavMesh(const LLUUID &pRegionUUID); virtual ~LLPathfindingNavMesh(); @@ -68,15 +66,15 @@ public: navmesh_slot_t registerNavMeshListener(navmesh_callback_t pNavMeshCallback); #ifdef DEPRECATED_UNVERSIONED_NAVMESH - U32 getNavMeshVersion() const {return mNavMeshVersion;}; + const LLPathfindingNavMeshStatus &getNavMeshStatusXXX() const {return mNavMeshStatus;}; #endif // DEPRECATED_UNVERSIONED_NAVMESH - bool hasNavMeshVersion(U32 pNavMeshVersion) const; + bool hasNavMeshVersion(const LLPathfindingNavMeshStatus &pNavMeshStatus) const; void handleNavMeshCheckVersion(); - void handleRefresh(U32 pNavMeshVersion); - void handleNavMeshNewVersion(U32 pNavMeshVersion); - void handleNavMeshStart(U32 pNavMeshVersion); + 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(); @@ -86,12 +84,12 @@ protected: private: void setRequestStatus(ENavMeshRequestStatus pNavMeshRequestStatus); + void sendStatus(); - LLUUID mRegionUUID; - ENavMeshRequestStatus mNavMeshRequestStatus; - navmesh_signal_t mNavMeshSignal; - LLSD::Binary mNavMeshData; - U32 mNavMeshVersion; + LLPathfindingNavMeshStatus mNavMeshStatus; + ENavMeshRequestStatus mNavMeshRequestStatus; + navmesh_signal_t mNavMeshSignal; + LLSD::Binary mNavMeshData; }; #endif // LL_LLPATHFINDINGNAVMESH_H diff --git a/indra/newview/llpathfindingnavmeshstatus.cpp b/indra/newview/llpathfindingnavmeshstatus.cpp index 2ef892c8cd..0ba28e0297 100644 --- a/indra/newview/llpathfindingnavmeshstatus.cpp +++ b/indra/newview/llpathfindingnavmeshstatus.cpp @@ -48,6 +48,14 @@ const std::string LLPathfindingNavMeshStatus::sStatusRepending("repending"); // LLPathfindingNavMeshStatus //--------------------------------------------------------------------------- +LLPathfindingNavMeshStatus::LLPathfindingNavMeshStatus() + : mIsValid(false), + mRegionUUID(), + mVersion(0U), + mStatus(kComplete) +{ +} + LLPathfindingNavMeshStatus::LLPathfindingNavMeshStatus(const LLUUID &pRegionUUID) : mIsValid(false), mRegionUUID(pRegionUUID), @@ -127,19 +135,19 @@ void LLPathfindingNavMeshStatus::parseStatus(const LLSD &pContent) std::string status = pContent.get(STATUS_FIELD).asString(); #endif // DEPRECATED_STATE_FIELD - if (LLStringUtil::compareStrings(status, sStatusPending)) + if (LLStringUtil::compareStrings(status, sStatusPending) == 0) { mStatus = kPending; } - else if (LLStringUtil::compareStrings(status, sStatusBuilding)) + else if (LLStringUtil::compareStrings(status, sStatusBuilding) == 0) { mStatus = kBuilding; } - else if (LLStringUtil::compareStrings(status, sStatusComplete)) + else if (LLStringUtil::compareStrings(status, sStatusComplete) == 0) { mStatus = kComplete; } - else if (LLStringUtil::compareStrings(status, sStatusRepending)) + else if (LLStringUtil::compareStrings(status, sStatusRepending) == 0) { mStatus = kRepending; } diff --git a/indra/newview/llpathfindingnavmeshstatus.h b/indra/newview/llpathfindingnavmeshstatus.h index fcc876059d..7147fcdf36 100644 --- a/indra/newview/llpathfindingnavmeshstatus.h +++ b/indra/newview/llpathfindingnavmeshstatus.h @@ -32,6 +32,9 @@ #include +// XXX stinson 03/12/2012 : This definition is in place to support an older version of the pathfinding simulator that does not have versioned information +#define DEPRECATED_UNVERSIONED_NAVMESH + class LLSD; class LLPathfindingNavMeshStatus @@ -45,6 +48,7 @@ public: kRepending } ENavMeshStatus; + LLPathfindingNavMeshStatus(); LLPathfindingNavMeshStatus(const LLUUID &pRegionUUID); LLPathfindingNavMeshStatus(const LLUUID &pRegionUUID, const LLSD &pContent); LLPathfindingNavMeshStatus(const LLSD &pContent); @@ -53,6 +57,10 @@ public: LLPathfindingNavMeshStatus &operator =(const LLPathfindingNavMeshStatus &pOther); +#ifdef DEPRECATED_UNVERSIONED_NAVMESH + void incrementNavMeshVersionXXX() {++mVersion;}; +#endif // DEPRECATED_UNVERSIONED_NAVMESH + bool isValid() const {return mIsValid;}; const LLUUID &getRegionUUID() const {return mRegionUUID;}; U32 getVersion() const {return mVersion;}; diff --git a/indra/newview/llpathfindingnavmeshzone.cpp b/indra/newview/llpathfindingnavmeshzone.cpp index 8e558c3b00..f871204454 100644 --- a/indra/newview/llpathfindingnavmeshzone.cpp +++ b/indra/newview/llpathfindingnavmeshzone.cpp @@ -50,6 +50,7 @@ LLPathfindingNavMeshZone::LLPathfindingNavMeshZone() : mNavMeshLocationPtrs(), + mNavMeshZoneRequestStatus(kNavMeshZoneRequestUnknown), mNavMeshZoneSignal() { } @@ -132,6 +133,71 @@ void LLPathfindingNavMeshZone::refresh() } } +LLPathfindingNavMeshZone::ENavMeshZoneStatus LLPathfindingNavMeshZone::getNavMeshZoneStatus() const +{ + bool hasPending = false; + bool hasBuilding = false; + bool hasComplete = false; + bool hasRepending = false; + + for (NavMeshLocationPtrs::const_iterator navMeshLocationPtrIter = mNavMeshLocationPtrs.begin(); + navMeshLocationPtrIter != mNavMeshLocationPtrs.end(); ++navMeshLocationPtrIter) + { + const NavMeshLocationPtr navMeshLocationPtr = *navMeshLocationPtrIter; + + switch (navMeshLocationPtr->getNavMeshStatus()) + { + case LLPathfindingNavMeshStatus::kPending : + hasPending = true; + break; + case LLPathfindingNavMeshStatus::kBuilding : + hasBuilding = true; + break; + case LLPathfindingNavMeshStatus::kComplete : + hasComplete = true; + break; + case LLPathfindingNavMeshStatus::kRepending : + hasRepending = true; + break; + default : + hasPending = true; + llassert(0); + break; + } + } + + ENavMeshZoneStatus zoneStatus = kNavMeshZoneComplete; + if (hasRepending || (hasPending && hasBuilding)) + { + zoneStatus = kNavMeshZonePendingAndBuilding; + } + else if (hasComplete) + { + if (hasPending) + { + zoneStatus = kNavMeshZoneSomePending; + } + else if (hasBuilding) + { + zoneStatus = kNavMeshZoneSomeBuilding; + } + else + { + zoneStatus = kNavMeshZoneComplete; + } + } + else if (hasPending) + { + zoneStatus = kNavMeshZonePending; + } + else if (hasBuilding) + { + zoneStatus = kNavMeshZoneBuilding; + } + + return zoneStatus; +} + void LLPathfindingNavMeshZone::handleNavMeshLocation() { updateStatus(); @@ -150,10 +216,10 @@ void LLPathfindingNavMeshZone::updateStatus() #ifdef XXX_STINSON_DEBUG_NAVMESH_ZONE llinfos << "STINSON DEBUG: Navmesh zone update BEGIN" << llendl; #endif // XXX_STINSON_DEBUG_NAVMESH_ZONE - for (NavMeshLocationPtrs::iterator navMeshLocationPtrIter = mNavMeshLocationPtrs.begin(); + for (NavMeshLocationPtrs::const_iterator navMeshLocationPtrIter = mNavMeshLocationPtrs.begin(); navMeshLocationPtrIter != mNavMeshLocationPtrs.end(); ++navMeshLocationPtrIter) { - NavMeshLocationPtr navMeshLocationPtr = *navMeshLocationPtrIter; + const NavMeshLocationPtr navMeshLocationPtr = *navMeshLocationPtrIter; #ifdef XXX_STINSON_DEBUG_NAVMESH_ZONE llinfos << "STINSON DEBUG: region #" << navMeshLocationPtr->getDirection() << ": region(" << navMeshLocationPtr->getRegionUUID().asString() << ") status:" << navMeshLocationPtr->getRequestStatus() << llendl; #endif // XXX_STINSON_DEBUG_NAVMESH_ZONE @@ -226,14 +292,6 @@ void LLPathfindingNavMeshZone::updateStatus() else if (hasRequestCompleted) { zoneRequestStatus = kNavMeshZoneRequestCompleted; -#ifdef XXX_STINSON_DEBUG_NAVMESH_ZONE - llinfos << "STINSON DEBUG: Navmesh zone update is stitching" << llendl; -#endif // XXX_STINSON_DEBUG_NAVMESH_ZONE - llassert(LLPathingLib::getInstance() != NULL); - if (LLPathingLib::getInstance() != NULL) - { - LLPathingLib::getInstance()->stitchNavMeshes( gSavedSettings.getBOOL("EnableVBOForNavMeshVisualization") ); - } #ifdef XXX_STINSON_DEBUG_NAVMESH_ZONE llinfos << "STINSON DEBUG: Navmesh zone update is COMPLETED" << llendl; #endif // XXX_STINSON_DEBUG_NAVMESH_ZONE @@ -254,7 +312,24 @@ void LLPathfindingNavMeshZone::updateStatus() llassert(0); } - mNavMeshZoneSignal(zoneRequestStatus); + if ((mNavMeshZoneRequestStatus != kNavMeshZoneRequestCompleted) && + (zoneRequestStatus == kNavMeshZoneRequestCompleted)) + { +#ifdef XXX_STINSON_DEBUG_NAVMESH_ZONE + llinfos << "STINSON DEBUG: Navmesh zone update is stitching" << llendl; +#endif // XXX_STINSON_DEBUG_NAVMESH_ZONE + llassert(LLPathingLib::getInstance() != NULL); + if (LLPathingLib::getInstance() != NULL) + { + LLPathingLib::getInstance()->stitchNavMeshes( gSavedSettings.getBOOL("EnableVBOForNavMeshVisualization") ); + } +#ifdef XXX_STINSON_DEBUG_NAVMESH_ZONE + llinfos << "STINSON DEBUG: Navmesh zone update stitching is done" << llendl; +#endif // XXX_STINSON_DEBUG_NAVMESH_ZONE + } + + mNavMeshZoneRequestStatus = zoneRequestStatus; + mNavMeshZoneSignal(mNavMeshZoneRequestStatus); } //--------------------------------------------------------------------------- @@ -266,6 +341,7 @@ LLPathfindingNavMeshZone::NavMeshLocation::NavMeshLocation(S32 pDirection, navme mRegionUUID(), mHasNavMesh(false), mNavMeshVersion(0U), + mNavMeshStatus(LLPathfindingNavMeshStatus::kComplete), mLocationCallback(pLocationCallback), mRequestStatus(LLPathfindingNavMesh::kNavMeshRequestUnknown), mNavMeshSlot() @@ -288,7 +364,7 @@ void LLPathfindingNavMeshZone::NavMeshLocation::enable() else { mRegionUUID = region->getRegionID(); - mNavMeshSlot = LLPathfindingManager::getInstance()->registerNavMeshListenerForRegion(region, boost::bind(&LLPathfindingNavMeshZone::NavMeshLocation::handleNavMesh, this, _1, _2, _3, _4)); + mNavMeshSlot = LLPathfindingManager::getInstance()->registerNavMeshListenerForRegion(region, boost::bind(&LLPathfindingNavMeshZone::NavMeshLocation::handleNavMesh, this, _1, _2, _3)); } } @@ -299,8 +375,9 @@ void LLPathfindingNavMeshZone::NavMeshLocation::refresh() if (region == NULL) { llassert(mRegionUUID.isNull()); + LLPathfindingNavMeshStatus newNavMeshStatus(mRegionUUID); LLSD::Binary nullData; - handleNavMesh(LLPathfindingNavMesh::kNavMeshRequestNotEnabled, mRegionUUID, 0U, nullData); + handleNavMesh(LLPathfindingNavMesh::kNavMeshRequestNotEnabled, newNavMeshStatus, nullData); } else { @@ -319,33 +396,38 @@ LLPathfindingNavMesh::ENavMeshRequestStatus LLPathfindingNavMeshZone::NavMeshLoc return mRequestStatus; } -void LLPathfindingNavMeshZone::NavMeshLocation::handleNavMesh(LLPathfindingNavMesh::ENavMeshRequestStatus pNavMeshRequestStatus, const LLUUID &pRegionUUID, U32 pNavMeshVersion, const LLSD::Binary &pNavMeshData) +LLPathfindingNavMeshStatus::ENavMeshStatus LLPathfindingNavMeshZone::NavMeshLocation::getNavMeshStatus() const { - llassert(mRegionUUID == pRegionUUID); - if (pNavMeshRequestStatus != LLPathfindingNavMesh::kNavMeshRequestCompleted) - { - mRequestStatus = pNavMeshRequestStatus; - mLocationCallback(); - } - else if (!mHasNavMesh || (mNavMeshVersion != pNavMeshVersion)) + return mNavMeshStatus; +} + +void LLPathfindingNavMeshZone::NavMeshLocation::handleNavMesh(LLPathfindingNavMesh::ENavMeshRequestStatus pNavMeshRequestStatus, const LLPathfindingNavMeshStatus &pNavMeshStatus, const LLSD::Binary &pNavMeshData) +{ + llassert(mRegionUUID == pNavMeshStatus.getRegionUUID()); + + if ((pNavMeshRequestStatus == LLPathfindingNavMesh::kNavMeshRequestCompleted) && + (!mHasNavMesh || (mNavMeshVersion != pNavMeshStatus.getVersion()))) { llassert(!pNavMeshData.empty()); - mRequestStatus = pNavMeshRequestStatus; mHasNavMesh = true; - mNavMeshVersion = pNavMeshVersion; + mNavMeshVersion = pNavMeshStatus.getVersion(); llassert(LLPathingLib::getInstance() != NULL); if (LLPathingLib::getInstance() != NULL) { LLPathingLib::getInstance()->extractNavMeshSrcFromLLSD(pNavMeshData, mDirection); } - mLocationCallback(); } + + mRequestStatus = pNavMeshRequestStatus; + mNavMeshStatus = pNavMeshStatus.getStatus(); + mLocationCallback(); } void LLPathfindingNavMeshZone::NavMeshLocation::clear() { mHasNavMesh = false; mRequestStatus = LLPathfindingNavMesh::kNavMeshRequestUnknown; + mNavMeshStatus = LLPathfindingNavMeshStatus::kComplete; if (mNavMeshSlot.connected()) { mNavMeshSlot.disconnect(); diff --git a/indra/newview/llpathfindingnavmeshzone.h b/indra/newview/llpathfindingnavmeshzone.h index 7b6583a663..7f83e9d37b 100644 --- a/indra/newview/llpathfindingnavmeshzone.h +++ b/indra/newview/llpathfindingnavmeshzone.h @@ -31,6 +31,7 @@ #include "llsd.h" #include "lluuid.h" #include "llpathfindingnavmesh.h" +#include "llpathfindingnavmeshstatus.h" #include @@ -38,6 +39,8 @@ #include #include +class LLPathfindingNavMeshStatus; + //#define XXX_STINSON_DEBUG_NAVMESH_ZONE class LLPathfindingNavMeshZone @@ -53,9 +56,18 @@ public: kNavMeshZoneRequestError } ENavMeshZoneRequestStatus; + typedef enum { + kNavMeshZonePending, + kNavMeshZoneBuilding, + kNavMeshZoneSomePending, + kNavMeshZoneSomeBuilding, + kNavMeshZonePendingAndBuilding, + kNavMeshZoneComplete + } ENavMeshZoneStatus; + typedef boost::function navmesh_zone_callback_t; typedef boost::signals2::signal navmesh_zone_signal_t; - typedef boost::signals2::connection navmesh_zone_slot_t; + typedef boost::signals2::connection navmesh_zone_slot_t; LLPathfindingNavMeshZone(); virtual ~LLPathfindingNavMeshZone(); @@ -67,6 +79,8 @@ public: void disable(); void refresh(); + ENavMeshZoneStatus getNavMeshZoneStatus() const; + protected: private: @@ -82,6 +96,7 @@ private: 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;}; @@ -90,7 +105,7 @@ private: protected: private: - void handleNavMesh(LLPathfindingNavMesh::ENavMeshRequestStatus pNavMeshRequestStatus, const LLUUID &pRegionUUID, U32 pNavMeshVersion, const LLSD::Binary &pNavMeshData); + void handleNavMesh(LLPathfindingNavMesh::ENavMeshRequestStatus pNavMeshRequestStatus, const LLPathfindingNavMeshStatus &pNavMeshStatus, const LLSD::Binary &pNavMeshData); void clear(); LLViewerRegion *getRegion() const; @@ -99,6 +114,7 @@ private: LLUUID mRegionUUID; bool mHasNavMesh; U32 mNavMeshVersion; + LLPathfindingNavMeshStatus::ENavMeshStatus mNavMeshStatus; navmesh_location_callback_t mLocationCallback; LLPathfindingNavMesh::ENavMeshRequestStatus mRequestStatus; LLPathfindingNavMesh::navmesh_slot_t mNavMeshSlot; @@ -110,8 +126,9 @@ private: void handleNavMeshLocation(); void updateStatus(); - NavMeshLocationPtrs mNavMeshLocationPtrs; - navmesh_zone_signal_t mNavMeshZoneSignal; + 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 aaf94483df..0373305941 100644 --- a/indra/newview/skins/default/xui/en/floater_pathfinding_console.xml +++ b/indra/newview/skins/default/xui/en/floater_pathfinding_console.xml @@ -2,7 +2,7 @@ - - Cannot find pathing library implementation. - This region is not enabled for pathfinding. - Checking the status of the navmesh ... - Downloading the navmesh ... - The navmesh has changed on the server. Downloading the latest navmesh ... - Navmesh received. - Unable to download navmesh successfully. + + Cannot find pathing library implementation. + This region is not enabled for pathfinding. + Checking the status of the navmesh. + Downloading the navmesh. + The navmesh has changed on the server. Downloading the latest navmesh. + Latest navmesh has been downloaded. + Unable to download navmesh successfully. + + This region does not expose the navmesh status. + Navmesh has pending changes. + Navmesh is building. + Some navmesh regions have pending changes. + Some navmesh regions are building. + Some navmesh regions have pending changes and others are building. + Navmesh is up-to-date. Please choose start and end points. Please choose start point. Please choose end point. Path is shown in blue. - Region boundary hit, navmesh may not be accurate. Update. + Region boundary hit, navmesh may not be accurate. + width="188"> Show walkability map: - Status + Viewer status + + + + + + + + Simulator status @@ -210,7 +262,7 @@ layout="topleft" left="230" top="35" - height="305" + height="373" width="214" visible="true" /> Prevent object / terrain changes and update the navmesh: @@ -306,7 +358,7 @@ label="Freeze" layout="topleft" name="enter_frozen_mode" - top_pad="9" + top_pad="3" width="116"/> Date: Tue, 27 Mar 2012 19:05:29 -0700 Subject: Refactoring the characters floater code. --- indra/newview/CMakeLists.txt | 2 + indra/newview/llfloaterpathfindingcharacters.cpp | 490 +++++++++------------ indra/newview/llfloaterpathfindingcharacters.h | 123 +++--- indra/newview/llfloaterpathfindinglinksets.cpp | 98 ++--- indra/newview/llfloaterpathfindinglinksets.h | 4 +- indra/newview/llpathfindingcharacter.cpp | 12 +- indra/newview/llpathfindingcharacter.h | 18 +- indra/newview/llpathfindingcharacterlist.cpp | 63 +++ indra/newview/llpathfindingcharacterlist.h | 56 +++ indra/newview/llpathfindingmanager.cpp | 183 +++++--- indra/newview/llpathfindingmanager.h | 31 +- .../xui/en/floater_pathfinding_characters.xml | 317 ++++++------- .../default/xui/en/floater_pathfinding_console.xml | 1 + .../xui/en/floater_pathfinding_linksets.xml | 13 +- 14 files changed, 777 insertions(+), 634 deletions(-) create mode 100644 indra/newview/llpathfindingcharacterlist.cpp create mode 100644 indra/newview/llpathfindingcharacterlist.h (limited to 'indra/newview/llpathfindingmanager.cpp') diff --git a/indra/newview/CMakeLists.txt b/indra/newview/CMakeLists.txt index 500163c030..dad8e8e97a 100644 --- a/indra/newview/CMakeLists.txt +++ b/indra/newview/CMakeLists.txt @@ -417,6 +417,7 @@ set(viewer_SOURCE_FILES llparticipantlist.cpp llpatchvertexarray.cpp llpathfindingcharacter.cpp + llpathfindingcharacterlist.cpp llpathfindinglinkset.cpp llpathfindinglinksetlist.cpp llpathfindingmanager.cpp @@ -973,6 +974,7 @@ set(viewer_HEADER_FILES llparticipantlist.h llpatchvertexarray.h llpathfindingcharacter.h + llpathfindingcharacterlist.h llpathfindinglinkset.h llpathfindinglinksetlist.h llpathfindingmanager.h diff --git a/indra/newview/llfloaterpathfindingcharacters.cpp b/indra/newview/llfloaterpathfindingcharacters.cpp index fd84af74e1..d174d822cd 100644 --- a/indra/newview/llfloaterpathfindingcharacters.cpp +++ b/indra/newview/llfloaterpathfindingcharacters.cpp @@ -1,7 +1,7 @@ /** * @file llfloaterpathfindingcharacters.cpp * @author William Todd Stinson - * @brief "Pathfinding linksets" floater, allowing manipulation of the Havok AI pathfinding settings. + * @brief "Pathfinding characters" floater, allowing for identification of pathfinding characters and their cpu usage. * * $LicenseInfo:firstyear=2002&license=viewerlgpl$ * Second Life Viewer Source Code @@ -28,7 +28,7 @@ #include "llviewerprecompiledheaders.h" #include "llfloater.h" #include "llfloaterpathfindingcharacters.h" -#include "llpathfindingcharacter.h" +#include "llpathfindingcharacterlist.h" #include "llsd.h" #include "llagent.h" #include "llhandle.h" @@ -48,37 +48,12 @@ #include "llviewermenu.h" #include "llselectmgr.h" -//--------------------------------------------------------------------------- -// CharactersGetResponder -//--------------------------------------------------------------------------- - -class CharactersGetResponder : public LLHTTPClient::Responder -{ -public: - CharactersGetResponder(const std::string& pCharactersDataGetURL, - const LLHandle &pCharactersFloaterHandle); - virtual ~CharactersGetResponder(); - - virtual void result(const LLSD& pContent); - virtual void error(U32 pStatus, const std::string& pReason); - -private: - CharactersGetResponder(const CharactersGetResponder& pOther); - - std::string mCharactersDataGetURL; - LLHandle mCharactersFloaterHandle; -}; - //--------------------------------------------------------------------------- // LLFloaterPathfindingCharacters //--------------------------------------------------------------------------- BOOL LLFloaterPathfindingCharacters::postBuild() { - childSetAction("refresh_characters_list", boost::bind(&LLFloaterPathfindingCharacters::onRefreshCharactersClicked, this)); - childSetAction("select_all_characters", boost::bind(&LLFloaterPathfindingCharacters::onSelectAllCharactersClicked, this)); - childSetAction("select_none_characters", boost::bind(&LLFloaterPathfindingCharacters::onSelectNoneCharactersClicked, this)); - mCharactersScrollList = findChild("pathfinding_characters"); llassert(mCharactersScrollList != NULL); mCharactersScrollList->setCommitCallback(boost::bind(&LLFloaterPathfindingCharacters::onCharactersSelectionChange, this)); @@ -87,82 +62,73 @@ BOOL LLFloaterPathfindingCharacters::postBuild() mCharactersStatus = findChild("characters_status"); llassert(mCharactersStatus != NULL); - mLabelActions = findChild("actions_label"); - llassert(mLabelActions != NULL); + mRefreshListButton = findChild("refresh_characters_list"); + llassert(mRefreshListButton != NULL); + mRefreshListButton->setCommitCallback(boost::bind(&LLFloaterPathfindingCharacters::onRefreshCharactersClicked, this)); + + mSelectAllButton = findChild("select_all_characters"); + llassert(mSelectAllButton != NULL); + mSelectAllButton->setCommitCallback(boost::bind(&LLFloaterPathfindingCharacters::onSelectAllCharactersClicked, this)); + + mSelectNoneButton = findChild("select_none_characters"); + llassert(mSelectNoneButton != NULL); + mSelectNoneButton->setCommitCallback(boost::bind(&LLFloaterPathfindingCharacters::onSelectNoneCharactersClicked, this)); mShowBeaconCheckBox = findChild("show_beacon"); llassert(mShowBeaconCheckBox != NULL); - mTakeBtn = findChild("take_characters"); - llassert(mTakeBtn != NULL) - mTakeBtn->setCommitCallback(boost::bind(&LLFloaterPathfindingCharacters::onTakeCharactersClicked, this)); - - mTakeCopyBtn = findChild("take_copy_characters"); - llassert(mTakeCopyBtn != NULL) - mTakeCopyBtn->setCommitCallback(boost::bind(&LLFloaterPathfindingCharacters::onTakeCopyCharactersClicked, this)); + mTakeButton = findChild("take_characters"); + llassert(mTakeButton != NULL) + mTakeButton->setCommitCallback(boost::bind(&LLFloaterPathfindingCharacters::onTakeCharactersClicked, this)); - mReturnBtn = findChild("return_characters"); - llassert(mReturnBtn != NULL) - mReturnBtn->setCommitCallback(boost::bind(&LLFloaterPathfindingCharacters::onReturnCharactersClicked, this)); + mTakeCopyButton = findChild("take_copy_characters"); + llassert(mTakeCopyButton != NULL) + mTakeCopyButton->setCommitCallback(boost::bind(&LLFloaterPathfindingCharacters::onTakeCopyCharactersClicked, this)); - mDeleteBtn = findChild("delete_characters"); - llassert(mDeleteBtn != NULL) - mDeleteBtn->setCommitCallback(boost::bind(&LLFloaterPathfindingCharacters::onDeleteCharactersClicked, this)); + mReturnButton = findChild("return_characters"); + llassert(mReturnButton != NULL) + mReturnButton->setCommitCallback(boost::bind(&LLFloaterPathfindingCharacters::onReturnCharactersClicked, this)); - mTeleportBtn = findChild("teleport_to_character"); - llassert(mTeleportBtn != NULL) - mTeleportBtn->setCommitCallback(boost::bind(&LLFloaterPathfindingCharacters::onTeleportCharacterToMeClicked, this)); + mDeleteButton = findChild("delete_characters"); + llassert(mDeleteButton != NULL) + mDeleteButton->setCommitCallback(boost::bind(&LLFloaterPathfindingCharacters::onDeleteCharactersClicked, this)); - setEnableActionFields(false); - setMessagingState(kMessagingInitial); + mTeleportButton = findChild("teleport_to_character"); + llassert(mTeleportButton != NULL) + mTeleportButton->setCommitCallback(boost::bind(&LLFloaterPathfindingCharacters::onTeleportCharacterToMeClicked, this)); return LLFloater::postBuild(); } void LLFloaterPathfindingCharacters::onOpen(const LLSD& pKey) { - sendCharactersDataGetRequest(); + LLFloater::onOpen(pKey); + + requestGetCharacters(); selectNoneCharacters(); + mCharactersScrollList->setCommitOnSelectionChange(true); if (!mSelectionUpdateSlot.connected()) { - mSelectionUpdateSlot = LLSelectMgr::getInstance()->mUpdateSignal.connect(boost::bind(&LLFloaterPathfindingCharacters::updateActionFields, this)); + mSelectionUpdateSlot = LLSelectMgr::getInstance()->mUpdateSignal.connect(boost::bind(&LLFloaterPathfindingCharacters::updateControls, this)); } - - mCharactersScrollList->setCommitOnSelectionChange(true); } -void LLFloaterPathfindingCharacters::onClose(bool app_quitting) +void LLFloaterPathfindingCharacters::onClose(bool pAppQuitting) { - mCharactersScrollList->setCommitOnSelectionChange(false); - if (mSelectionUpdateSlot.connected()) { mSelectionUpdateSlot.disconnect(); } + mCharactersScrollList->setCommitOnSelectionChange(false); selectNoneCharacters(); if (mCharacterSelection.notNull()) { - std::vector selectedObjects; - - LLObjectSelection *charactersSelected = mCharacterSelection.get(); - for (LLObjectSelection::valid_iterator characterIter = charactersSelected->valid_begin(); - characterIter != charactersSelected->valid_end(); ++characterIter) - { - LLSelectNode *characterNode = *characterIter; - selectedObjects.push_back(characterNode->getObject()); - } - - for (std::vector::const_iterator selectedObjectIter = selectedObjects.begin(); - selectedObjectIter != selectedObjects.end(); ++selectedObjectIter) - { - LLViewerObject *selectedObject = *selectedObjectIter; - LLSelectMgr::getInstance()->deselectObjectAndFamily(selectedObject); - } - mCharacterSelection.clear(); } + + LLFloater::onClose(pAppQuitting); } void LLFloaterPathfindingCharacters::draw() @@ -208,141 +174,88 @@ LLFloaterPathfindingCharacters::EMessagingState LLFloaterPathfindingCharacters:: BOOL LLFloaterPathfindingCharacters::isMessagingInProgress() const { - BOOL retVal; - switch (getMessagingState()) - { - case kMessagingFetchStarting : - case kMessagingFetchRequestSent : - case kMessagingFetchRequestSent_MultiRequested : - case kMessagingFetchReceived : - retVal = true; - break; - default : - retVal = false; - break; - } - - return retVal; + return (mMessagingState == kMessagingGetRequestSent); } LLFloaterPathfindingCharacters::LLFloaterPathfindingCharacters(const LLSD& pSeed) : LLFloater(pSeed), - mSelfHandle(), - mPathfindingCharacters(), - mMessagingState(kMessagingInitial), mCharactersScrollList(NULL), mCharactersStatus(NULL), - mLabelActions(NULL), + mRefreshListButton(NULL), + mSelectAllButton(NULL), + mSelectNoneButton(NULL), mShowBeaconCheckBox(NULL), - mTakeBtn(NULL), - mTakeCopyBtn(NULL), - mReturnBtn(NULL), - mDeleteBtn(NULL), - mTeleportBtn(NULL), + mTakeButton(NULL), + mTakeCopyButton(NULL), + mReturnButton(NULL), + mDeleteButton(NULL), + mTeleportButton(NULL), + mMessagingState(kMessagingUnknown), + mCharacterListPtr(), mCharacterSelection(), mSelectionUpdateSlot() { - mSelfHandle.bind(this); } LLFloaterPathfindingCharacters::~LLFloaterPathfindingCharacters() { - mPathfindingCharacters.clear(); - mCharacterSelection.clear(); -} - -void LLFloaterPathfindingCharacters::sendCharactersDataGetRequest() -{ - if (isMessagingInProgress()) - { - if (getMessagingState() == kMessagingFetchRequestSent) - { - setMessagingState(kMessagingFetchRequestSent_MultiRequested); - } - } - else - { - setMessagingState(kMessagingFetchStarting); - mPathfindingCharacters.clear(); - updateCharactersList(); - - std::string charactersDataURL = getCapabilityURL(); - if (charactersDataURL.empty()) - { - setMessagingState(kMessagingServiceNotAvailable); - llwarns << "cannot query pathfinding characters from current region '" << getRegionName() << "'" << llendl; - } - else - { - setMessagingState(kMessagingFetchRequestSent); - LLHTTPClient::get(charactersDataURL, new CharactersGetResponder(charactersDataURL, mSelfHandle)); - } - } -} - -void LLFloaterPathfindingCharacters::handleCharactersDataGetReply(const LLSD& pCharactersData) -{ - setMessagingState(kMessagingFetchReceived); - mPathfindingCharacters.clear(); - parseCharactersData(pCharactersData); - updateCharactersList(); - setMessagingState(kMessagingComplete); } -void LLFloaterPathfindingCharacters::handleCharactersDataGetError(const std::string& pURL, const std::string& pErrorReason) +void LLFloaterPathfindingCharacters::setMessagingState(EMessagingState pMessagingState) { - setMessagingState(kMessagingFetchError); - mPathfindingCharacters.clear(); - updateCharactersList(); - llwarns << "Error fetching pathfinding characters from URL '" << pURL << "' because " << pErrorReason << llendl; + mMessagingState = pMessagingState; + updateControls(); } -std::string LLFloaterPathfindingCharacters::getRegionName() const +void LLFloaterPathfindingCharacters::requestGetCharacters() { - std::string regionName(""); - - LLViewerRegion* region = gAgent.getRegion(); - if (region != NULL) + llassert(!isMessagingInProgress()); + if (!isMessagingInProgress()) { - regionName = region->getName(); + switch (LLPathfindingManager::getInstance()->requestGetCharacters(boost::bind(&LLFloaterPathfindingCharacters::handleNewCharacters, this, _1, _2))) + { + case LLPathfindingManager::kRequestStarted : + setMessagingState(kMessagingGetRequestSent); + break; + case LLPathfindingManager::kRequestCompleted : + clearCharacters(); + setMessagingState(kMessagingComplete); + break; + case LLPathfindingManager::kRequestNotEnabled : + clearCharacters(); + setMessagingState(kMessagingNotEnabled); + break; + case LLPathfindingManager::kRequestError : + setMessagingState(kMessagingGetError); + break; + default : + setMessagingState(kMessagingGetError); + llassert(0); + break; + } } - - return regionName; } -std::string LLFloaterPathfindingCharacters::getCapabilityURL() const +void LLFloaterPathfindingCharacters::handleNewCharacters(LLPathfindingManager::ERequestStatus pCharacterRequestStatus, LLPathfindingCharacterListPtr pCharacterListPtr) { - std::string charactersDataURL(""); - - LLViewerRegion* region = gAgent.getRegion(); - if (region != NULL) - { - charactersDataURL = region->getCapability("CharacterProperties"); - } - - return charactersDataURL; -} + mCharacterListPtr = pCharacterListPtr; + updateScrollList(); -void LLFloaterPathfindingCharacters::parseCharactersData(const LLSD &pCharactersData) -{ - for (LLSD::map_const_iterator characterItemIter = pCharactersData.beginMap(); - characterItemIter != pCharactersData.endMap(); ++characterItemIter) + switch (pCharacterRequestStatus) { - const std::string &uuid(characterItemIter->first); - const LLSD &characterData(characterItemIter->second); - LLPathfindingCharacter character(uuid, characterData); - - mPathfindingCharacters.insert(std::pair(uuid, character)); + case LLPathfindingManager::kRequestCompleted : + setMessagingState(kMessagingComplete); + break; + case LLPathfindingManager::kRequestError : + setMessagingState(kMessagingGetError); + break; + default : + setMessagingState(kMessagingGetError); + llassert(0); + break; } } -void LLFloaterPathfindingCharacters::setMessagingState(EMessagingState pMessagingState) -{ - mMessagingState = pMessagingState; - updateCharactersList(); - updateActionFields(); -} - void LLFloaterPathfindingCharacters::onCharactersSelectionChange() { mCharacterSelection.clear(); @@ -374,13 +287,12 @@ void LLFloaterPathfindingCharacters::onCharactersSelectionChange() } } - updateCharactersStatusMessage(); - updateActionFields(); + updateControls(); } void LLFloaterPathfindingCharacters::onRefreshCharactersClicked() { - sendCharactersDataGetRequest(); + requestGetCharacters(); } void LLFloaterPathfindingCharacters::onSelectAllCharactersClicked() @@ -421,9 +333,9 @@ void LLFloaterPathfindingCharacters::onTeleportCharacterToMeClicked() { std::vector::const_reference selectedItemRef = selectedItems.front(); const LLScrollListItem *selectedItem = selectedItemRef; - PathfindingCharacterMap::const_iterator characterIter = mPathfindingCharacters.find(selectedItem->getUUID().asString()); - const LLPathfindingCharacter &character = characterIter->second; - LLVector3 characterLocation = character.getLocation(); + LLPathfindingCharacterList::const_iterator characterIter = mCharacterListPtr->find(selectedItem->getUUID().asString()); + const LLPathfindingCharacterPtr &characterPtr = characterIter->second; + const LLVector3 &characterLocation = characterPtr->getLocation(); LLViewerRegion* region = gAgent.getRegion(); if (region != NULL) @@ -433,7 +345,33 @@ void LLFloaterPathfindingCharacters::onTeleportCharacterToMeClicked() } } -void LLFloaterPathfindingCharacters::updateCharactersList() +void LLFloaterPathfindingCharacters::selectAllCharacters() +{ + mCharactersScrollList->selectAll(); +} + +void LLFloaterPathfindingCharacters::selectNoneCharacters() +{ + mCharactersScrollList->deselectAllItems(); +} + +void LLFloaterPathfindingCharacters::clearCharacters() +{ + if (mCharacterListPtr != NULL) + { + mCharacterListPtr->clear(); + } + updateScrollList(); +} + +void LLFloaterPathfindingCharacters::updateControls() +{ + updateStatusMessage(); + updateEnableStateOnListActions(); + updateEnableStateOnEditFields(); +} + +void LLFloaterPathfindingCharacters::updateScrollList() { std::vector selectedItems = mCharactersScrollList->getAllSelected(); int numSelectedItems = selectedItems.size(); @@ -449,65 +387,62 @@ void LLFloaterPathfindingCharacters::updateCharactersList() } } + S32 origScrollPosition = mCharactersScrollList->getScrollPos(); mCharactersScrollList->deleteAllItems(); - updateCharactersStatusMessage(); - LLLocale locale(LLStringUtil::getLocale()); - for (PathfindingCharacterMap::const_iterator characterIter = mPathfindingCharacters.begin(); - characterIter != mPathfindingCharacters.end(); ++characterIter) + if (mCharacterListPtr != NULL) { - const LLPathfindingCharacter& character(characterIter->second); - - LLSD columns; - - columns[0]["column"] = "name"; - columns[0]["value"] = character.getName(); - columns[0]["font"] = "SANSSERIF"; + for (LLPathfindingCharacterList::const_iterator characterIter = mCharacterListPtr->begin(); + characterIter != mCharacterListPtr->end(); ++characterIter) + { + const LLPathfindingCharacterPtr& character(characterIter->second); + LLSD element = buildCharacterScrollListElement(character); + mCharactersScrollList->addElement(element); + } + } - columns[1]["column"] = "description"; - columns[1]["value"] = character.getDescription(); - columns[1]["font"] = "SANSSERIF"; + mCharactersScrollList->selectMultiple(selectedUUIDs); + mCharactersScrollList->setScrollPos(origScrollPosition); + updateControls(); +} - columns[2]["column"] = "owner"; - columns[2]["value"] = character.getOwnerName(); - columns[2]["font"] = "SANSSERIF"; +LLSD LLFloaterPathfindingCharacters::buildCharacterScrollListElement(const LLPathfindingCharacterPtr pCharacterPtr) const +{ + LLSD columns; - S32 cpuTime = llround(character.getCPUTime()); - std::string cpuTimeString = llformat("%d", cpuTime); - LLStringUtil::format_map_t string_args; - string_args["[CPU_TIME]"] = cpuTimeString; + columns[0]["column"] = "name"; + columns[0]["value"] = pCharacterPtr->getName(); + columns[0]["font"] = "SANSSERIF"; - columns[3]["column"] = "cpu_time"; - columns[3]["value"] = getString("character_cpu_time", string_args); - columns[3]["font"] = "SANSSERIF"; + columns[1]["column"] = "description"; + columns[1]["value"] = pCharacterPtr->getDescription(); + columns[1]["font"] = "SANSSERIF"; - columns[4]["column"] = "altitude"; - columns[4]["value"] = llformat("%1.0f m", character.getLocation()[2]); - columns[4]["font"] = "SANSSERIF"; + columns[2]["column"] = "owner"; + columns[2]["value"] = pCharacterPtr->getOwnerName(); + columns[2]["font"] = "SANSSERIF"; - LLSD element; - element["id"] = character.getUUID().asString(); - element["column"] = columns; + S32 cpuTime = llround(pCharacterPtr->getCPUTime()); + std::string cpuTimeString = llformat("%d", cpuTime); + LLStringUtil::format_map_t string_args; + string_args["[CPU_TIME]"] = cpuTimeString; - mCharactersScrollList->addElement(element); - } + columns[3]["column"] = "cpu_time"; + columns[3]["value"] = getString("character_cpu_time", string_args); + columns[3]["font"] = "SANSSERIF"; - mCharactersScrollList->selectMultiple(selectedUUIDs); - updateCharactersStatusMessage(); - updateActionFields(); -} + columns[4]["column"] = "altitude"; + columns[4]["value"] = llformat("%1.0f m", pCharacterPtr->getLocation()[2]); + columns[4]["font"] = "SANSSERIF"; -void LLFloaterPathfindingCharacters::selectAllCharacters() -{ - mCharactersScrollList->selectAll(); -} + LLSD element; + element["id"] = pCharacterPtr->getUUID().asString(); + element["column"] = columns; -void LLFloaterPathfindingCharacters::selectNoneCharacters() -{ - mCharactersScrollList->deselectAllItems(); + return element; } -void LLFloaterPathfindingCharacters::updateCharactersStatusMessage() +void LLFloaterPathfindingCharacters::updateStatusMessage() { static const LLColor4 warningColor = LLUIColorTable::instance().getColor("DrYellow"); @@ -516,23 +451,14 @@ void LLFloaterPathfindingCharacters::updateCharactersStatusMessage() switch (getMessagingState()) { - case kMessagingInitial: + case kMessagingUnknown: statusText = getString("characters_messaging_initial"); break; - case kMessagingFetchStarting : - statusText = getString("characters_messaging_fetch_starting"); - break; - case kMessagingFetchRequestSent : - statusText = getString("characters_messaging_fetch_inprogress"); + case kMessagingGetRequestSent : + statusText = getString("characters_messaging_get_inprogress"); break; - case kMessagingFetchRequestSent_MultiRequested : - statusText = getString("characters_messaging_fetch_inprogress_multi_request"); - break; - case kMessagingFetchReceived : - statusText = getString("characters_messaging_fetch_received"); - break; - case kMessagingFetchError : - statusText = getString("characters_messaging_fetch_error"); + case kMessagingGetError : + statusText = getString("characters_messaging_get_error"); styleParams.color = warningColor; break; case kMessagingComplete : @@ -558,8 +484,8 @@ void LLFloaterPathfindingCharacters::updateCharactersStatusMessage() statusText = getString("characters_messaging_complete_available", string_args); } break; - case kMessagingServiceNotAvailable: - statusText = getString("characters_messaging_service_not_available"); + case kMessagingNotEnabled: + statusText = getString("characters_messaging_not_enabled"); styleParams.color = warningColor; break; default: @@ -571,52 +497,46 @@ void LLFloaterPathfindingCharacters::updateCharactersStatusMessage() mCharactersStatus->setText((LLStringExplicit)statusText, styleParams); } -void LLFloaterPathfindingCharacters::updateActionFields() -{ - std::vector selectedItems = mCharactersScrollList->getAllSelected(); - setEnableActionFields(!selectedItems.empty()); -} - -void LLFloaterPathfindingCharacters::setEnableActionFields(BOOL pEnabled) -{ - mLabelActions->setEnabled(pEnabled); - mShowBeaconCheckBox->setEnabled(pEnabled); - mTakeBtn->setEnabled(pEnabled && visible_take_object()); - mTakeCopyBtn->setEnabled(pEnabled && enable_object_take_copy()); - mReturnBtn->setEnabled(pEnabled && enable_object_return()); - mDeleteBtn->setEnabled(pEnabled && enable_object_delete()); - mTeleportBtn->setEnabled(pEnabled && (mCharactersScrollList->getNumSelected() == 1)); -} - -//--------------------------------------------------------------------------- -// CharactersGetResponder -//--------------------------------------------------------------------------- - -CharactersGetResponder::CharactersGetResponder(const std::string& pCharactersDataGetURL, - const LLHandle &pCharactersFloaterHandle) - : mCharactersDataGetURL(pCharactersDataGetURL), - mCharactersFloaterHandle(pCharactersFloaterHandle) -{ -} - -CharactersGetResponder::~CharactersGetResponder() -{ -} - -void CharactersGetResponder::result(const LLSD& pContent) +void LLFloaterPathfindingCharacters::updateEnableStateOnListActions() { - LLFloaterPathfindingCharacters *charactersFloater = mCharactersFloaterHandle.get(); - if (charactersFloater != NULL) + switch (getMessagingState()) { - charactersFloater->handleCharactersDataGetReply(pContent); + case kMessagingUnknown: + case kMessagingGetRequestSent : + mRefreshListButton->setEnabled(FALSE); + mSelectAllButton->setEnabled(FALSE); + mSelectNoneButton->setEnabled(FALSE); + break; + case kMessagingGetError : + case kMessagingNotEnabled : + mRefreshListButton->setEnabled(TRUE); + mSelectAllButton->setEnabled(FALSE); + mSelectNoneButton->setEnabled(FALSE); + break; + case kMessagingComplete : + { + int numItems = mCharactersScrollList->getItemCount(); + int numSelectedItems = mCharactersScrollList->getNumSelected(); + mRefreshListButton->setEnabled(TRUE); + mSelectAllButton->setEnabled(numSelectedItems < numItems); + mSelectNoneButton->setEnabled(numSelectedItems > 0); + } + break; + default: + llassert(0); + break; } } -void CharactersGetResponder::error(U32 status, const std::string& reason) +void LLFloaterPathfindingCharacters::updateEnableStateOnEditFields() { - LLFloaterPathfindingCharacters *charactersFloater = mCharactersFloaterHandle.get(); - if (charactersFloater != NULL) - { - charactersFloater->handleCharactersDataGetError(mCharactersDataGetURL, reason); - } + int numSelectedItems = mCharactersScrollList->getNumSelected(); + bool isEditEnabled = (numSelectedItems > 0); + + mShowBeaconCheckBox->setEnabled(isEditEnabled); + mTakeButton->setEnabled(isEditEnabled && visible_take_object()); + mTakeCopyButton->setEnabled(isEditEnabled && enable_object_take_copy()); + mReturnButton->setEnabled(isEditEnabled && enable_object_return()); + mDeleteButton->setEnabled(isEditEnabled && enable_object_delete()); + mTeleportButton->setEnabled(numSelectedItems == 1); } diff --git a/indra/newview/llfloaterpathfindingcharacters.h b/indra/newview/llfloaterpathfindingcharacters.h index c381492784..a242a5503f 100644 --- a/indra/newview/llfloaterpathfindingcharacters.h +++ b/indra/newview/llfloaterpathfindingcharacters.h @@ -1,29 +1,29 @@ /** - * @file llfloaterpathfindingcharacters.h - * @author William Todd Stinson - * @brief "Pathfinding linksets" floater, allowing manipulation of the Havok AI pathfinding settings. - * - * $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$ - */ +* @file llfloaterpathfindingcharacters.h +* @author William Todd Stinson +* @brief "Pathfinding characters" floater, allowing for identification of pathfinding characters and their cpu usage. +* +* $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_LLFLOATERPATHFINDINGCHARACTERS_H #define LL_LLFLOATERPATHFINDINGCHARACTERS_H @@ -31,9 +31,10 @@ #include #include -#include "llhandle.h" #include "llfloater.h" #include "llpathfindingcharacter.h" +#include "llpathfindingcharacterlist.h" +#include "llpathfindingmanager.h" #include "llselectmgr.h" #include @@ -46,27 +47,23 @@ class LLRadioGroup; class LLButton; class LLFloaterPathfindingCharacters -: public LLFloater + : public LLFloater { friend class LLFloaterReg; - friend class CharactersGetResponder; public: typedef enum { - kMessagingInitial, - kMessagingFetchStarting, - kMessagingFetchRequestSent, - kMessagingFetchRequestSent_MultiRequested, - kMessagingFetchReceived, - kMessagingFetchError, + kMessagingUnknown, + kMessagingGetRequestSent, + kMessagingGetError, kMessagingComplete, - kMessagingServiceNotAvailable + kMessagingNotEnabled } EMessagingState; virtual BOOL postBuild(); virtual void onOpen(const LLSD& pKey); - virtual void onClose(bool app_quitting); + virtual void onClose(bool pAppQuitting); virtual void draw(); static void openCharactersViewer(); @@ -77,38 +74,31 @@ public: protected: private: - typedef std::map PathfindingCharacterMap; - - LLRootHandle mSelfHandle; - PathfindingCharacterMap mPathfindingCharacters; - EMessagingState mMessagingState; - LLScrollListCtrl *mCharactersScrollList; - LLTextBase *mCharactersStatus; - LLTextBase *mLabelActions; - LLCheckBoxCtrl *mShowBeaconCheckBox; - LLButton *mTakeBtn; - LLButton *mTakeCopyBtn; - LLButton *mReturnBtn; - LLButton *mDeleteBtn; - LLButton *mTeleportBtn; - LLObjectSelectionHandle mCharacterSelection; - boost::signals2::connection mSelectionUpdateSlot; + LLScrollListCtrl *mCharactersScrollList; + LLTextBase *mCharactersStatus; + LLButton *mRefreshListButton; + LLButton *mSelectAllButton; + LLButton *mSelectNoneButton; + LLCheckBoxCtrl *mShowBeaconCheckBox; + LLButton *mTakeButton; + LLButton *mTakeCopyButton; + LLButton *mReturnButton; + LLButton *mDeleteButton; + LLButton *mTeleportButton; + + EMessagingState mMessagingState; + LLPathfindingCharacterListPtr mCharacterListPtr; + LLObjectSelectionHandle mCharacterSelection; + boost::signals2::connection mSelectionUpdateSlot; // Does its own instance management, so clients not allowed // to allocate or destroy. LLFloaterPathfindingCharacters(const LLSD& pSeed); virtual ~LLFloaterPathfindingCharacters(); - void sendCharactersDataGetRequest(); - void handleCharactersDataGetReply(const LLSD& pCharactersData); - void handleCharactersDataGetError(const std::string& pURL, const std::string& pErrorReason); - - std::string getRegionName() const; - std::string getCapabilityURL() const; - - void parseCharactersData(const LLSD &pCharactersData); - void setMessagingState(EMessagingState pMessagingState); + void requestGetCharacters(); + void handleNewCharacters(LLPathfindingManager::ERequestStatus pCharacterRequestStatus, LLPathfindingCharacterListPtr pCharacterListPtr); void onCharactersSelectionChange(); void onRefreshCharactersClicked(); @@ -120,14 +110,17 @@ private: void onDeleteCharactersClicked(); void onTeleportCharacterToMeClicked(); - void updateCharactersList(); void selectAllCharacters(); void selectNoneCharacters(); + void clearCharacters(); - void updateCharactersStatusMessage(); + void updateControls(); + void updateScrollList(); + LLSD buildCharacterScrollListElement(const LLPathfindingCharacterPtr pCharacterPtr) const; - void updateActionFields(); - void setEnableActionFields(BOOL pEnabled); + void updateStatusMessage(); + void updateEnableStateOnListActions(); + void updateEnableStateOnEditFields(); }; #endif // LL_LLFLOATERPATHFINDINGCHARACTERS_H diff --git a/indra/newview/llfloaterpathfindinglinksets.cpp b/indra/newview/llfloaterpathfindinglinksets.cpp index 42a8f4e951..547db078b1 100644 --- a/indra/newview/llfloaterpathfindinglinksets.cpp +++ b/indra/newview/llfloaterpathfindinglinksets.cpp @@ -1,29 +1,29 @@ /** - * @file llfloaterpathfindinglinksets.cpp - * @author William Todd Stinson - * @brief "Pathfinding linksets" floater, allowing manipulation of the Havok AI pathfinding settings. - * - * $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$ - */ +* @file llfloaterpathfindinglinksets.cpp +* @author William Todd Stinson +* @brief "Pathfinding linksets" floater, allowing manipulation of the Havok AI pathfinding settings. +* +* $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 "llfloater.h" @@ -339,18 +339,18 @@ void LLFloaterPathfindingLinksets::requestGetLinksets() { switch (LLPathfindingManager::getInstance()->requestGetLinksets(boost::bind(&LLFloaterPathfindingLinksets::handleNewLinksets, this, _1, _2))) { - case LLPathfindingManager::kLinksetsRequestStarted : + case LLPathfindingManager::kRequestStarted : setMessagingState(kMessagingGetRequestSent); break; - case LLPathfindingManager::kLinksetsRequestCompleted : + case LLPathfindingManager::kRequestCompleted : clearLinksets(); setMessagingState(kMessagingComplete); break; - case LLPathfindingManager::kLinksetsRequestNotEnabled : + case LLPathfindingManager::kRequestNotEnabled : clearLinksets(); setMessagingState(kMessagingNotEnabled); break; - case LLPathfindingManager::kLinksetsRequestError : + case LLPathfindingManager::kRequestError : setMessagingState(kMessagingGetError); break; default : @@ -368,17 +368,17 @@ void LLFloaterPathfindingLinksets::requestSetLinksets(LLPathfindingLinksetListPt { switch (LLPathfindingManager::getInstance()->requestSetLinksets(pLinksetList, pLinksetUse, pA, pB, pC, pD, boost::bind(&LLFloaterPathfindingLinksets::handleUpdateLinksets, this, _1, _2))) { - case LLPathfindingManager::kLinksetsRequestStarted : + case LLPathfindingManager::kRequestStarted : setMessagingState(kMessagingSetRequestSent); break; - case LLPathfindingManager::kLinksetsRequestCompleted : + case LLPathfindingManager::kRequestCompleted : setMessagingState(kMessagingComplete); break; - case LLPathfindingManager::kLinksetsRequestNotEnabled : + case LLPathfindingManager::kRequestNotEnabled : clearLinksets(); setMessagingState(kMessagingNotEnabled); break; - case LLPathfindingManager::kLinksetsRequestError : + case LLPathfindingManager::kRequestError : setMessagingState(kMessagingSetError); break; default : @@ -389,17 +389,17 @@ void LLFloaterPathfindingLinksets::requestSetLinksets(LLPathfindingLinksetListPt } } -void LLFloaterPathfindingLinksets::handleNewLinksets(LLPathfindingManager::ELinksetsRequestStatus pLinksetsRequestStatus, LLPathfindingLinksetListPtr pLinksetsListPtr) +void LLFloaterPathfindingLinksets::handleNewLinksets(LLPathfindingManager::ERequestStatus pLinksetsRequestStatus, LLPathfindingLinksetListPtr pLinksetsListPtr) { mLinksetsListPtr = pLinksetsListPtr; updateScrollList(); switch (pLinksetsRequestStatus) { - case LLPathfindingManager::kLinksetsRequestCompleted : + case LLPathfindingManager::kRequestCompleted : setMessagingState(kMessagingComplete); break; - case LLPathfindingManager::kLinksetsRequestError : + case LLPathfindingManager::kRequestError : setMessagingState(kMessagingGetError); break; default : @@ -409,7 +409,7 @@ void LLFloaterPathfindingLinksets::handleNewLinksets(LLPathfindingManager::ELink } } -void LLFloaterPathfindingLinksets::handleUpdateLinksets(LLPathfindingManager::ELinksetsRequestStatus pLinksetsRequestStatus, LLPathfindingLinksetListPtr pLinksetsListPtr) +void LLFloaterPathfindingLinksets::handleUpdateLinksets(LLPathfindingManager::ERequestStatus pLinksetsRequestStatus, LLPathfindingLinksetListPtr pLinksetsListPtr) { if (mLinksetsListPtr == NULL) { @@ -423,10 +423,10 @@ void LLFloaterPathfindingLinksets::handleUpdateLinksets(LLPathfindingManager::EL switch (pLinksetsRequestStatus) { - case LLPathfindingManager::kLinksetsRequestCompleted : + case LLPathfindingManager::kRequestCompleted : setMessagingState(kMessagingComplete); break; - case LLPathfindingManager::kLinksetsRequestError : + case LLPathfindingManager::kRequestError : setMessagingState(kMessagingSetError); break; default : @@ -702,21 +702,21 @@ void LLFloaterPathfindingLinksets::updateScrollList() LLSD LLFloaterPathfindingLinksets::buildLinksetScrollListElement(const LLPathfindingLinksetPtr pLinksetPtr, const LLVector3 &pAvatarPosition) const { LLSD columns; - + 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"; @@ -726,15 +726,15 @@ LLSD LLFloaterPathfindingLinksets::buildLinksetScrollListElement(const LLPathfin 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"; @@ -787,12 +787,12 @@ LLSD LLFloaterPathfindingLinksets::buildLinksetScrollListElement(const LLPathfin LLSD LLFloaterPathfindingLinksets::buildLinksetUseScrollListElement(const std::string &label, S32 value) const { LLSD columns; - + columns[0]["column"] = "name"; columns[0]["relwidth"] = static_cast(100.0f); columns[0]["value"] = label; columns[0]["font"] = "SANSSERIF"; - + LLSD element; element["value"] = value; element["column"] = columns; @@ -1172,7 +1172,7 @@ void LLFloaterPathfindingLinksets::setEditLinksetUse(LLPathfindingLinkset::ELink LLPathfindingLinkset::ELinksetUse LLFloaterPathfindingLinksets::convertToLinksetUse(LLSD pXuiValue) const { LLPathfindingLinkset::ELinksetUse linkUse; - + switch (pXuiValue.asInteger()) { case XUI_LINKSET_USE_NONE : diff --git a/indra/newview/llfloaterpathfindinglinksets.h b/indra/newview/llfloaterpathfindinglinksets.h index fdc47e3d40..0cf9b2162b 100644 --- a/indra/newview/llfloaterpathfindinglinksets.h +++ b/indra/newview/llfloaterpathfindinglinksets.h @@ -124,8 +124,8 @@ private: void setMessagingState(EMessagingState pMessagingState); void requestGetLinksets(); void requestSetLinksets(LLPathfindingLinksetListPtr pLinksetList, LLPathfindingLinkset::ELinksetUse pLinksetUse, S32 pA, S32 pB, S32 pC, S32 pD); - void handleNewLinksets(LLPathfindingManager::ELinksetsRequestStatus pLinksetsRequestStatus, LLPathfindingLinksetListPtr pLinksetsListPtr); - void handleUpdateLinksets(LLPathfindingManager::ELinksetsRequestStatus pLinksetsRequestStatus, LLPathfindingLinksetListPtr pLinksetsListPtr); + void handleNewLinksets(LLPathfindingManager::ERequestStatus pLinksetsRequestStatus, LLPathfindingLinksetListPtr pLinksetsListPtr); + void handleUpdateLinksets(LLPathfindingManager::ERequestStatus pLinksetsRequestStatus, LLPathfindingLinksetListPtr pLinksetsListPtr); void onApplyAllFilters(); void onClearFiltersClicked(); diff --git a/indra/newview/llpathfindingcharacter.cpp b/indra/newview/llpathfindingcharacter.cpp index afa07457bc..4600f661f8 100644 --- a/indra/newview/llpathfindingcharacter.cpp +++ b/indra/newview/llpathfindingcharacter.cpp @@ -33,11 +33,11 @@ #include "llavatarname.h" #include "llavatarnamecache.h" -#define CHARACTER_NAME_FIELD "name" -#define CHARACTER_DESCRIPTION_FIELD "description" -#define CHARACTER_OWNER_FIELD "owner" -#define CHARACTER_CPU_TIME_FIELD "cpu_time" -#define CHARACTER_POSITION_FIELD "position" +#define CHARACTER_NAME_FIELD "name" +#define CHARACTER_DESCRIPTION_FIELD "description" +#define CHARACTER_OWNER_FIELD "owner" +#define CHARACTER_CPU_TIME_FIELD "cpu_time" +#define CHARACTER_POSITION_FIELD "position" //--------------------------------------------------------------------------- // LLPathfindingCharacter @@ -50,7 +50,7 @@ LLPathfindingCharacter::LLPathfindingCharacter(const std::string &pUUID, const L mOwnerUUID(), mOwnerName(), mCPUTime(0U), - mLocation() + mLocation(LLVector3::zero) { llassert(pCharacterItem.has(CHARACTER_NAME_FIELD)); llassert(pCharacterItem.get(CHARACTER_NAME_FIELD).isString()); diff --git a/indra/newview/llpathfindingcharacter.h b/indra/newview/llpathfindingcharacter.h index 9b0a7bae30..5be52ebc45 100644 --- a/indra/newview/llpathfindingcharacter.h +++ b/indra/newview/llpathfindingcharacter.h @@ -32,8 +32,12 @@ #include "lluuid.h" #include "llavatarname.h" +#include + class LLSD; -class LLAvatarName; +class LLPathfindingCharacter; + +typedef boost::shared_ptr LLPathfindingCharacterPtr; class LLPathfindingCharacter { @@ -44,12 +48,12 @@ public: LLPathfindingCharacter& operator = (const LLPathfindingCharacter& pOther); - inline const LLUUID& getUUID() const {return mUUID;}; - inline const std::string& getName() const {return mName;}; - inline const std::string& getDescription() const {return mDescription;}; - inline const std::string getOwnerName() const {return mOwnerName.getCompleteName();}; - inline F32 getCPUTime() const {return mCPUTime;}; - inline const LLVector3& getLocation() const {return mLocation;}; + inline const LLUUID& getUUID() const {return mUUID;}; + inline const std::string& getName() const {return mName;}; + inline const std::string& getDescription() const {return mDescription;}; + inline const std::string getOwnerName() const {return mOwnerName.getCompleteName();}; + inline F32 getCPUTime() const {return mCPUTime;}; + inline const LLVector3& getLocation() const {return mLocation;}; protected: diff --git a/indra/newview/llpathfindingcharacterlist.cpp b/indra/newview/llpathfindingcharacterlist.cpp new file mode 100644 index 0000000000..64fddd490c --- /dev/null +++ b/indra/newview/llpathfindingcharacterlist.cpp @@ -0,0 +1,63 @@ +/** + * @file llpathfindingcharacterlist.cpp + * @author William Todd Stinson + * @brief Class to implement the list of a set of pathfinding characters + * + * $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 +#include + +#include "llsd.h" +#include "lluuid.h" +#include "llpathfindingcharacter.h" +#include "llpathfindingcharacterlist.h" + +//--------------------------------------------------------------------------- +// LLPathfindingCharacterList +//--------------------------------------------------------------------------- + +LLPathfindingCharacterList::LLPathfindingCharacterList() + : LLPathfindingCharacterMap() +{ +} + +LLPathfindingCharacterList::LLPathfindingCharacterList(const LLSD& pCharacterItems) + : LLPathfindingCharacterMap() +{ + for (LLSD::map_const_iterator characterItemIter = pCharacterItems.beginMap(); + characterItemIter != pCharacterItems.endMap(); ++characterItemIter) + { + const std::string& uuid(characterItemIter->first); + const LLSD& characterData = characterItemIter->second; + LLPathfindingCharacterPtr character(new LLPathfindingCharacter(uuid, characterData)); + insert(std::pair(uuid, character)); + } +} + +LLPathfindingCharacterList::~LLPathfindingCharacterList() +{ + clear(); +} diff --git a/indra/newview/llpathfindingcharacterlist.h b/indra/newview/llpathfindingcharacterlist.h new file mode 100644 index 0000000000..ce6ec81615 --- /dev/null +++ b/indra/newview/llpathfindingcharacterlist.h @@ -0,0 +1,56 @@ +/** + * @file llpathfindingcharacterlist.h + * @author William Todd Stinson + * @brief Class to implement the list of a set of pathfinding characters + * + * $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_LLPATHFINDINGCHARACTERLIST_H +#define LL_LLPATHFINDINGCHARACTERLIST_H + +#include +#include +#include "llpathfindingcharacter.h" + +#include + +class LLSD; +class LLPathfindingCharacterList; + +typedef boost::shared_ptr LLPathfindingCharacterListPtr; +typedef std::map LLPathfindingCharacterMap; + +class LLPathfindingCharacterList : public LLPathfindingCharacterMap +{ +public: + LLPathfindingCharacterList(); + LLPathfindingCharacterList(const LLSD& pCharacterItems); + virtual ~LLPathfindingCharacterList(); + +protected: + +private: + +}; + +#endif // LL_LLPATHFINDINGCHARACTERLIST_H diff --git a/indra/newview/llpathfindingmanager.cpp b/indra/newview/llpathfindingmanager.cpp index e3242de812..fdff380050 100644 --- a/indra/newview/llpathfindingmanager.cpp +++ b/indra/newview/llpathfindingmanager.cpp @@ -40,6 +40,7 @@ #include "llpathfindingnavmeshstatus.h" #include "llpathfindinglinkset.h" #include "llpathfindinglinksetlist.h" +#include "llpathfindingcharacterlist.h" #include "llhttpnode.h" #include @@ -56,6 +57,8 @@ #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" @@ -225,6 +228,26 @@ private: LinksetsResponderPtr mLinksetsResponsderPtr; }; +//--------------------------------------------------------------------------- +// CharactersResponder +//--------------------------------------------------------------------------- + +class CharactersResponder : public LLHTTPClient::Responder +{ +public: + CharactersResponder(const std::string &pCapabilityURL, 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::characters_callback_t mCharactersCallback; +}; + //--------------------------------------------------------------------------- // LLPathfindingManager //--------------------------------------------------------------------------- @@ -311,41 +334,6 @@ void LLPathfindingManager::requestGetNavMeshForRegion(LLViewerRegion *pRegion) } } -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); - } -} - LLPathfindingManager::agent_state_slot_t LLPathfindingManager::registerAgentStateListener(agent_state_callback_t pAgentStateCallback) { return mAgentStateSignal.connect(pAgentStateCallback); @@ -395,15 +383,15 @@ void LLPathfindingManager::requestSetAgentState(EAgentState pRequestedAgentState } } -LLPathfindingManager::ELinksetsRequestStatus LLPathfindingManager::requestGetLinksets(linksets_callback_t pLinksetsCallback) const +LLPathfindingManager::ERequestStatus LLPathfindingManager::requestGetLinksets(linksets_callback_t pLinksetsCallback) const { - ELinksetsRequestStatus status; + ERequestStatus status; std::string objectLinksetsURL = getObjectLinksetsURLForCurrentRegion(); std::string terrainLinksetsURL = getTerrainLinksetsURLForCurrentRegion(); if (objectLinksetsURL.empty() || terrainLinksetsURL.empty()) { - status = kLinksetsRequestNotEnabled; + status = kRequestNotEnabled; } else { @@ -419,21 +407,21 @@ LLPathfindingManager::ELinksetsRequestStatus LLPathfindingManager::requestGetLin LLHTTPClient::get(terrainLinksetsURL, terrainLinksetsResponder); } - status = kLinksetsRequestStarted; + status = kRequestStarted; } return status; } -LLPathfindingManager::ELinksetsRequestStatus LLPathfindingManager::requestSetLinksets(LLPathfindingLinksetListPtr pLinksetList, LLPathfindingLinkset::ELinksetUse pLinksetUse, S32 pA, S32 pB, S32 pC, S32 pD, linksets_callback_t pLinksetsCallback) const +LLPathfindingManager::ERequestStatus LLPathfindingManager::requestSetLinksets(LLPathfindingLinksetListPtr pLinksetList, LLPathfindingLinkset::ELinksetUse pLinksetUse, S32 pA, S32 pB, S32 pC, S32 pD, linksets_callback_t pLinksetsCallback) const { - ELinksetsRequestStatus status = kLinksetsRequestNotEnabled; + ERequestStatus status = kRequestNotEnabled; std::string objectLinksetsURL = getObjectLinksetsURLForCurrentRegion(); std::string terrainLinksetsURL = getTerrainLinksetsURLForCurrentRegion(); if (objectLinksetsURL.empty() || terrainLinksetsURL.empty()) { - status = kLinksetsRequestNotEnabled; + status = kRequestNotEnabled; } else { @@ -446,7 +434,7 @@ LLPathfindingManager::ELinksetsRequestStatus LLPathfindingManager::requestSetLin if (objectPostData.isUndefined() && terrainPostData.isUndefined()) { - status = kLinksetsRequestCompleted; + status = kRequestCompleted; } else { @@ -464,13 +452,33 @@ LLPathfindingManager::ELinksetsRequestStatus LLPathfindingManager::requestSetLin LLHTTPClient::put(terrainLinksetsURL, terrainPostData, terrainLinksetsResponder); } - status = kLinksetsRequestStarted; + status = kRequestStarted; } } return status; } +LLPathfindingManager::ERequestStatus LLPathfindingManager::requestGetCharacters(characters_callback_t pCharactersCallback) const +{ + ERequestStatus status; + + std::string charactersURL = getCharactersURLForCurrentRegion(); + if (charactersURL.empty()) + { + status = kRequestNotEnabled; + } + else + { + LLHTTPClient::ResponderPtr charactersResponder = new CharactersResponder(charactersURL, pCharactersCallback); + LLHTTPClient::get(charactersURL, charactersResponder); + + status = kRequestStarted; + } + + return status; +} + void LLPathfindingManager::sendRequestGetNavMeshForRegion(LLPathfindingNavMeshPtr navMeshPtr, LLViewerRegion *pRegion, const LLPathfindingNavMeshStatus &pNavMeshStatus) { if ((pRegion == NULL) || !pRegion->isAlive()) @@ -496,6 +504,41 @@ void LLPathfindingManager::sendRequestGetNavMeshForRegion(LLPathfindingNavMeshPt } } +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; @@ -626,6 +669,11 @@ 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); @@ -688,7 +736,8 @@ void LLAgentStateChangeNode::post(ResponsePtr pResponse, const LLSD &pContext, c //--------------------------------------------------------------------------- NavMeshStatusResponder::NavMeshStatusResponder(const std::string &pCapabilityURL, LLViewerRegion *pRegion) - : mCapabilityURL(pCapabilityURL), + : LLHTTPClient::Responder(), + mCapabilityURL(pCapabilityURL), mRegion(pRegion), mRegionUUID() { @@ -723,7 +772,8 @@ void NavMeshStatusResponder::error(U32 pStatus, const std::string& pReason) //--------------------------------------------------------------------------- NavMeshResponder::NavMeshResponder(const std::string &pCapabilityURL, U32 pNavMeshVersion, LLPathfindingNavMeshPtr pNavMeshPtr) - : mCapabilityURL(pCapabilityURL), + : LLHTTPClient::Responder(), + mCapabilityURL(pCapabilityURL), mNavMeshVersion(pNavMeshVersion), mNavMeshPtr(pNavMeshPtr) { @@ -830,10 +880,10 @@ void LinksetsResponder::sendCallback() { llassert(mObjectMessagingState != kWaiting); llassert(mTerrainMessagingState != kWaiting); - LLPathfindingManager::ELinksetsRequestStatus requestStatus = + LLPathfindingManager::ERequestStatus requestStatus = ((((mObjectMessagingState == kReceivedGood) || (mObjectMessagingState == kNotRequested)) && ((mTerrainMessagingState == kReceivedGood) || (mTerrainMessagingState == kNotRequested))) ? - LLPathfindingManager::kLinksetsRequestCompleted : LLPathfindingManager::kLinksetsRequestError); + LLPathfindingManager::kRequestCompleted : LLPathfindingManager::kRequestError); if (mObjectMessagingState != kReceivedGood) { @@ -853,7 +903,8 @@ void LinksetsResponder::sendCallback() //--------------------------------------------------------------------------- ObjectLinksetsResponder::ObjectLinksetsResponder(const std::string &pCapabilityURL, LinksetsResponderPtr pLinksetsResponsderPtr) - : mCapabilityURL(pCapabilityURL), + : LLHTTPClient::Responder(), + mCapabilityURL(pCapabilityURL), mLinksetsResponsderPtr(pLinksetsResponsderPtr) { } @@ -877,8 +928,9 @@ void ObjectLinksetsResponder::error(U32 pStatus, const std::string &pReason) //--------------------------------------------------------------------------- TerrainLinksetsResponder::TerrainLinksetsResponder(const std::string &pCapabilityURL, LinksetsResponderPtr pLinksetsResponsderPtr) -: mCapabilityURL(pCapabilityURL), -mLinksetsResponsderPtr(pLinksetsResponsderPtr) + : LLHTTPClient::Responder(), + mCapabilityURL(pCapabilityURL), + mLinksetsResponsderPtr(pLinksetsResponsderPtr) { } @@ -895,3 +947,32 @@ void TerrainLinksetsResponder::error(U32 pStatus, const std::string &pReason) { mLinksetsResponsderPtr->handleTerrainLinksetsError(pStatus, pReason, mCapabilityURL); } + +//--------------------------------------------------------------------------- +// CharactersResponder +//--------------------------------------------------------------------------- + +CharactersResponder::CharactersResponder(const std::string &pCapabilityURL, LLPathfindingManager::characters_callback_t pCharactersCallback) + : LLHTTPClient::Responder(), + mCapabilityURL(pCapabilityURL), + mCharactersCallback(pCharactersCallback) +{ +} + +CharactersResponder::~CharactersResponder() +{ +} + +void CharactersResponder::result(const LLSD &pContent) +{ + LLPathfindingCharacterListPtr characterListPtr = LLPathfindingCharacterListPtr(new LLPathfindingCharacterList(pContent)); + mCharactersCallback(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(LLPathfindingManager::kRequestError, characterListPtr); +} diff --git a/indra/newview/llpathfindingmanager.h b/indra/newview/llpathfindingmanager.h index b458d6513a..d906a94d44 100644 --- a/indra/newview/llpathfindingmanager.h +++ b/indra/newview/llpathfindingmanager.h @@ -33,6 +33,7 @@ #include "llpathfindingnavmesh.h" #include "llpathfindinglinkset.h" #include "llpathfindinglinksetlist.h" +#include "llpathfindingcharacterlist.h" #include #include @@ -46,8 +47,10 @@ class LLPathfindingNavMeshStatus; class LLPathfindingManager : public LLSingleton { - friend class AgentStateResponder; + friend class LLNavMeshSimStateChangeNode; friend class LLAgentStateChangeNode; + friend class NavMeshStatusResponder; + friend class AgentStateResponder; public: typedef std::map NavMeshMap; @@ -64,13 +67,14 @@ public: typedef boost::signals2::connection agent_state_slot_t; typedef enum { - kLinksetsRequestStarted, - kLinksetsRequestCompleted, - kLinksetsRequestNotEnabled, - kLinksetsRequestError - } ELinksetsRequestStatus; + kRequestStarted, + kRequestCompleted, + kRequestNotEnabled, + kRequestError + } ERequestStatus; - typedef boost::function linksets_callback_t; + typedef boost::function linksets_callback_t; + typedef boost::function characters_callback_t; LLPathfindingManager(); virtual ~LLPathfindingManager(); @@ -87,22 +91,24 @@ public: LLPathfindingNavMesh::navmesh_slot_t registerNavMeshListenerForRegion(LLViewerRegion *pRegion, LLPathfindingNavMesh::navmesh_callback_t pNavMeshCallback); void requestGetNavMeshForRegion(LLViewerRegion *pRegion); - void handleNavMeshStatusRequest(const LLPathfindingNavMeshStatus &pNavMeshStatus, LLViewerRegion *pRegion); - void handleNavMeshStatusUpdate(const LLPathfindingNavMeshStatus &pNavMeshStatus); - agent_state_slot_t registerAgentStateListener(agent_state_callback_t pAgentStateCallback); EAgentState getAgentState(); EAgentState getLastKnownNonErrorAgentState() const; void requestSetAgentState(EAgentState pAgentState); - ELinksetsRequestStatus requestGetLinksets(linksets_callback_t pLinksetsCallback) const; - ELinksetsRequestStatus requestSetLinksets(LLPathfindingLinksetListPtr pLinksetList, LLPathfindingLinkset::ELinksetUse pLinksetUse, S32 pA, S32 pB, S32 pC, S32 pD, linksets_callback_t pLinksetsCallback) const; + ERequestStatus requestGetLinksets(linksets_callback_t pLinksetsCallback) const; + ERequestStatus requestSetLinksets(LLPathfindingLinksetListPtr pLinksetList, LLPathfindingLinkset::ELinksetUse pLinksetUse, S32 pA, S32 pB, S32 pC, S32 pD, linksets_callback_t pLinksetsCallback) const; + + ERequestStatus requestGetCharacters(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); @@ -119,6 +125,7 @@ private: 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; diff --git a/indra/newview/skins/default/xui/en/floater_pathfinding_characters.xml b/indra/newview/skins/default/xui/en/floater_pathfinding_characters.xml index e9d58c7a33..f643913b6d 100644 --- a/indra/newview/skins/default/xui/en/floater_pathfinding_characters.xml +++ b/indra/newview/skins/default/xui/en/floater_pathfinding_characters.xml @@ -15,165 +15,180 @@ single_instance="true" title="Pathfinding characters"> - Building query for pathfinding characters ... - Querying for pathfinding characters ... - Querying for pathfinding characters (already in progress) ... - Loading pathfinding characters data from response ... - Error detected while querying for pathfinding characters - No pathfinding characters - [NUM_SELECTED] characters selected out of [NUM_TOTAL] - Required capability is not available in current region + Querying for pathfinding characters ... + Error detected while querying for pathfinding characters. + No pathfinding characters. + [NUM_SELECTED] characters selected out of [NUM_TOTAL]. + This region is not enabled for pathfinding. [CPU_TIME] µs - - - - - - - - - Characters: - -